2 * Copyright (c) 2017 Cisco Systems, Inc. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
9 package org.opendaylight.mdsal.binding.javav2.generator.impl;
11 import static com.google.common.base.Preconditions.checkArgument;
12 import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.createDescription;
13 import static org.opendaylight.mdsal.binding.javav2.generator.impl.GenHelperUtil.groupingsToGenTypes;
14 import static org.opendaylight.mdsal.binding.javav2.generator.impl.GenHelperUtil.moduleTypeBuilder;
15 import static org.opendaylight.mdsal.binding.javav2.generator.impl.GenHelperUtil.processUsesImplements;
16 import static org.opendaylight.mdsal.binding.javav2.generator.impl.GenHelperUtil.resolveNotification;
17 import static org.opendaylight.mdsal.binding.javav2.generator.util.BindingTypes.NOTIFICATION_LISTENER;
19 import com.google.common.annotations.Beta;
20 import com.google.common.base.Preconditions;
21 import com.google.common.collect.ImmutableSet;
22 import java.util.Collection;
23 import java.util.HashMap;
24 import java.util.List;
27 import org.opendaylight.mdsal.binding.javav2.generator.spi.TypeProvider;
28 import org.opendaylight.mdsal.binding.javav2.generator.util.generated.type.builder.GeneratedTOBuilderImpl;
29 import org.opendaylight.mdsal.binding.javav2.generator.yang.types.TypeProviderImpl;
30 import org.opendaylight.mdsal.binding.javav2.model.api.Type;
31 import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedTypeBuilder;
32 import org.opendaylight.mdsal.binding.javav2.spec.runtime.BindingNamespaceType;
33 import org.opendaylight.mdsal.binding.javav2.util.BindingMapping;
34 import org.opendaylight.yangtools.yang.common.QName;
35 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
36 import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
37 import org.opendaylight.yangtools.yang.model.api.Module;
38 import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
39 import org.opendaylight.yangtools.yang.model.api.NotificationNodeContainer;
40 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
41 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
42 import org.opendaylight.yangtools.yang.model.util.DataNodeIterator;
45 final class ModuleToGenType {
47 private ModuleToGenType() {
48 throw new UnsupportedOperationException("Utility class");
51 static Map<Module, ModuleContext> generate(final Module module, final Map<String, Map<String, GeneratedTypeBuilder>>
52 genTypeBuilders, final SchemaContext schemaContext, final TypeProvider typeProvider, Map<Module,
53 ModuleContext> genCtx, final boolean verboseClassComments) {
55 genCtx.put(module, new ModuleContext());
56 genCtx = allTypeDefinitionsToGenTypes(module, genCtx, typeProvider);
57 genCtx = groupingsToGenTypes(module, module.getGroupings(), genCtx, schemaContext, verboseClassComments,
58 genTypeBuilders, typeProvider);
59 genCtx = allIdentitiesToGenTypes(module, schemaContext, genCtx, verboseClassComments, genTypeBuilders, typeProvider);
60 genCtx = notificationsToGenType(module, genCtx, schemaContext, genTypeBuilders, verboseClassComments, typeProvider);
62 if (!module.getChildNodes().isEmpty()) {
63 final GeneratedTypeBuilder moduleType = GenHelperUtil.moduleToDataType(module, genCtx, verboseClassComments);
64 genCtx.get(module).addModuleNode(moduleType);
65 final String basePackageName = BindingMapping.getRootPackageName(module);
66 GenHelperUtil.resolveDataSchemaNodes(module, basePackageName, moduleType, moduleType, module
67 .getChildNodes(), genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider,
68 BindingNamespaceType.Data);
71 //after potential parent data schema nodes
72 genCtx = actionsAndRPCMethodsToGenType(module, genCtx, schemaContext, verboseClassComments,
73 genTypeBuilders, typeProvider);
79 * Converts all extended type definitions of module to the list of
80 * <code>Type</code> objects.
83 * module from which is obtained set of type definitions
84 * @throws IllegalArgumentException
86 * <li>if module is null</li>
87 * <li>if name of module is null</li>
89 * @throws IllegalStateException
90 * if set of type definitions from module is null
92 private static Map<Module, ModuleContext> allTypeDefinitionsToGenTypes(final Module module, final Map<Module, ModuleContext> genCtx,
93 final TypeProvider typeProvider) {
94 Preconditions.checkArgument(module != null, "Module reference cannot be NULL.");
95 Preconditions.checkArgument(module.getName() != null, "Module name cannot be NULL.");
96 final DataNodeIterator it = new DataNodeIterator(module);
97 final List<TypeDefinition<?>> typeDefinitions = it.allTypedefs();
98 Preconditions.checkState(typeDefinitions != null, "Type Definitions for module «module.name» cannot be NULL.");
100 typeDefinitions.stream().filter(typedef -> typedef != null).forEach(typedef -> {
101 final Type type = ((TypeProviderImpl) typeProvider).generatedTypeForExtendedDefinitionType(typedef,
104 final ModuleContext ctx = genCtx.get(module);
105 ctx.addTypedefType(typedef.getPath(), type);
106 ctx.addTypeToSchema(type, typedef);
112 private static Map<Module, ModuleContext> actionsAndRPCMethodsToGenType(final Module module, Map<Module,
113 ModuleContext> genCtx, final SchemaContext schemaContext, final boolean verboseClassComments,
114 final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider) {
116 genCtx = RpcActionGenHelper.rpcMethodsToGenType(module, genCtx, schemaContext, verboseClassComments,
117 genTypeBuilders, typeProvider);
118 genCtx = RpcActionGenHelper.actionMethodsToGenType(module, genCtx, schemaContext, verboseClassComments,
119 genTypeBuilders, typeProvider);
125 * Converts all <b>identities</b> of the module to the list of
126 * <code>Type</code> objects.
129 * module from which is obtained set of all identity objects to
131 * @param schemaContext
132 * schema context only used as input parameter for method
133 * {@link GenHelperUtil#identityToGenType(Module, String, IdentitySchemaNode, SchemaContext, Map, boolean, Map, TypeProvider, Map)}
134 * @param genCtx generated context
135 * @return returns generated context
138 private static Map<Module, ModuleContext> allIdentitiesToGenTypes(final Module module,
139 final SchemaContext schemaContext, Map<Module, ModuleContext> genCtx, boolean verboseClassComments,
140 final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider) {
142 final Set<IdentitySchemaNode> schemaIdentities = module.getIdentities();
143 final String basePackageName = BindingMapping.getRootPackageName(module);
145 if (schemaIdentities != null && !schemaIdentities.isEmpty()) {
146 for (final IdentitySchemaNode identity : schemaIdentities) {
147 GenHelperUtil.identityToGenType(module, basePackageName, identity, schemaContext, genCtx,
148 verboseClassComments);
156 * Converts all <b>notifications</b> of the module to the list of
157 * <code>Type</code> objects. In addition are to this list added containers
158 * and lists which are part of this notification.
161 * module from which is obtained set of all notification objects
162 * to iterate over them
163 * @throws IllegalArgumentException
165 * <li>if the module equals null</li>
166 * <li>if the name of module equals null</li>
168 * @throws IllegalStateException
169 * if set of notifications from module is null
171 private static Map<Module, ModuleContext> notificationsToGenType(final Module module, final Map<Module, ModuleContext> genCtx,
172 final SchemaContext schemaContext, final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders,
173 final boolean verboseClassComments, final TypeProvider typeProvider) {
174 checkArgument(module != null, "Module reference cannot be NULL.");
175 checkArgument(module.getName() != null, "Module name cannot be NULL.");
176 final Set<NotificationDefinition> notifications = module.getNotifications();
177 if (notifications.isEmpty()) {
181 final GeneratedTypeBuilder listenerInterface = moduleTypeBuilder(module, "Listener", verboseClassComments);
182 listenerInterface.addImplementsType(NOTIFICATION_LISTENER);
183 final String basePackageName = BindingMapping.getRootPackageName(module);
185 for (final NotificationDefinition notification : notifications) {
186 if (notification != null) {
187 resolveNotification(listenerInterface, null, basePackageName, notification, module, schemaContext,
188 verboseClassComments, genTypeBuilders, typeProvider, genCtx);
189 processUsesImplements(notification, module, schemaContext, genCtx, BindingNamespaceType.Data);
193 //YANG 1.1 allows notifications be tied to containers and lists
194 final Collection<DataSchemaNode> potentials = module.getChildNodes();
195 Set<NotificationDefinition> tiedNotifications = null;
197 for (final DataSchemaNode potential : potentials) {
198 if (potential instanceof NotificationNodeContainer) {
199 tiedNotifications = ((NotificationNodeContainer) potential)
201 for (final NotificationDefinition tiedNotification: tiedNotifications) {
202 if (tiedNotification != null) {
203 resolveNotification(listenerInterface, potential.getQName().getLocalName(), basePackageName,
204 tiedNotification, module, schemaContext, verboseClassComments, genTypeBuilders,
205 typeProvider, genCtx);
206 processUsesImplements(tiedNotification, module, schemaContext, genCtx, BindingNamespaceType.Data);
212 if (tiedNotifications != null) {
213 listenerInterface.setDescription(createDescription(ImmutableSet.<NotificationDefinition>builder()
214 .addAll(notifications).addAll(tiedNotifications).build(), module, verboseClassComments));
216 listenerInterface.setDescription(createDescription(notifications, module, verboseClassComments));
219 genCtx.get(module).addTopLevelNodeType(listenerInterface);