2 * Copyright (c) 2013 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
8 package org.opendaylight.controller.sal.binding.generator.impl;
10 import org.opendaylight.controller.binding.generator.util.ReferencedTypeImpl;
11 import org.opendaylight.controller.binding.generator.util.Types;
12 import org.opendaylight.controller.binding.generator.util.generated.type.builder.GeneratedTypeBuilderImpl;
13 import org.opendaylight.controller.sal.binding.generator.api.BindingGenerator;
14 import org.opendaylight.controller.sal.binding.generator.spi.TypeProvider;
15 import org.opendaylight.controller.sal.binding.model.api.*;
16 import org.opendaylight.controller.sal.binding.model.api.type.builder.*;
17 import org.opendaylight.controller.sal.binding.yang.types.TypeProviderImpl;
18 import org.opendaylight.controller.yang.common.QName;
19 import org.opendaylight.controller.yang.model.api.*;
20 import org.opendaylight.controller.yang.model.api.type.EnumTypeDefinition;
21 import org.opendaylight.controller.yang.model.api.type.EnumTypeDefinition.EnumPair;
22 import org.opendaylight.controller.yang.model.util.DataNodeIterator;
23 import org.opendaylight.controller.yang.model.util.ExtendedType;
27 import static org.opendaylight.controller.binding.generator.util.BindingGeneratorUtil.*;
28 import static org.opendaylight.controller.yang.model.util.SchemaContextUtil.findDataSchemaNode;
29 import static org.opendaylight.controller.yang.model.util.SchemaContextUtil.findParentModule;
31 public final class BindingGeneratorImpl implements BindingGenerator {
33 private Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders;
34 private TypeProvider typeProvider;
35 private SchemaContext schemaContext;
37 public BindingGeneratorImpl() {
42 public List<Type> generateTypes(final SchemaContext context) {
43 if (context == null) {
44 throw new IllegalArgumentException("Schema Context reference " +
47 if (context.getModules() == null) {
48 throw new IllegalStateException("Schema Context does not contain " +
52 final List<Type> generatedTypes = new ArrayList<>();
53 schemaContext = context;
54 typeProvider = new TypeProviderImpl(context);
55 final Set<Module> modules = context.getModules();
56 genTypeBuilders = new HashMap<>();
57 for (final Module module : modules) {
58 generatedTypes.add(moduleToDataType(module));
59 generatedTypes.addAll(allTypeDefinitionsToGenTypes(module));
60 generatedTypes.addAll(allContainersToGenTypes(module));
61 generatedTypes.addAll(allListsToGenTypes(module));
62 generatedTypes.addAll(allAugmentsToGenTypes(module));
63 generatedTypes.addAll(allRPCMethodsToGenType(module));
64 generatedTypes.addAll(allNotifycationsToGenType(module));
66 return generatedTypes;
70 public List<Type> generateTypes(final SchemaContext context,
71 final Set<Module> modules) {
72 if (context == null) {
73 throw new IllegalArgumentException("Schema Context reference " +
76 if (context.getModules() == null) {
77 throw new IllegalStateException("Schema Context does not contain " +
80 if (modules == null) {
81 throw new IllegalArgumentException("Sef of Modules cannot be " +
85 final List<Type> filteredGenTypes = new ArrayList<>();
86 schemaContext = context;
87 typeProvider = new TypeProviderImpl(context);
88 final Set<Module> contextModules = context.getModules();
89 genTypeBuilders = new HashMap<>();
90 for (final Module contextModule : contextModules) {
91 final List<Type> generatedTypes = new ArrayList<>();
93 generatedTypes.add(moduleToDataType(contextModule));
94 generatedTypes.addAll(allTypeDefinitionsToGenTypes(contextModule));
95 generatedTypes.addAll(allContainersToGenTypes(contextModule));
96 generatedTypes.addAll(allListsToGenTypes(contextModule));
97 generatedTypes.addAll(allAugmentsToGenTypes(contextModule));
98 generatedTypes.addAll(allRPCMethodsToGenType(contextModule));
99 generatedTypes.addAll(allNotifycationsToGenType(contextModule));
101 if (modules.contains(contextModule)) {
102 filteredGenTypes.addAll(generatedTypes);
105 return filteredGenTypes;
108 private List<Type> allTypeDefinitionsToGenTypes(final Module module) {
109 if (module == null) {
110 throw new IllegalArgumentException("Module reference cannot be NULL!");
112 if (module.getName() == null) {
113 throw new IllegalArgumentException("Module name cannot be NULL!");
115 if (module.getTypeDefinitions() == null) {
116 throw new IllegalArgumentException("Type Definitions for module " +
117 module.getName() + " cannot be NULL!");
120 final Set<TypeDefinition<?>> typeDefinitions = module
121 .getTypeDefinitions();
122 final List<Type> generatedTypes = new ArrayList<>();
123 for (final TypeDefinition<?> typedef : typeDefinitions) {
124 if (typedef != null) {
125 final Type type = ((TypeProviderImpl)typeProvider)
126 .generatedTypeForExtendedDefinitionType(typedef);
127 if ((type != null) && !generatedTypes.contains(type)) {
128 generatedTypes.add(type);
132 return generatedTypes;
135 private List<Type> allContainersToGenTypes(final Module module) {
136 if (module == null) {
137 throw new IllegalArgumentException("Module reference cannot be NULL!");
140 if (module.getName() == null) {
141 throw new IllegalArgumentException("Module name cannot be NULL!");
144 if (module.getChildNodes() == null) {
145 throw new IllegalArgumentException("Reference to Set of Child " +
146 "Nodes in module " + module.getName() + " cannot be " +
150 final List<Type> generatedTypes = new ArrayList<>();
151 final DataNodeIterator it = new DataNodeIterator(
153 final List<ContainerSchemaNode> schemaContainers = it.allContainers();
154 final String basePackageName = moduleNamespaceToPackageName(module);
155 for (final ContainerSchemaNode container : schemaContainers) {
156 generatedTypes.add(containerToGenType(basePackageName,
159 return generatedTypes;
162 private List<Type> allListsToGenTypes(final Module module) {
163 if (module == null) {
164 throw new IllegalArgumentException("Module reference cannot be NULL!");
167 if (module.getName() == null) {
168 throw new IllegalArgumentException("Module name cannot be NULL!");
171 if (module.getChildNodes() == null) {
172 throw new IllegalArgumentException("Reference to Set of Child " +
173 "Nodes in module " + module.getName() + " cannot be " +
177 final List<Type> generatedTypes = new ArrayList<>();
178 final DataNodeIterator it = new DataNodeIterator(
180 final List<ListSchemaNode> schemaLists = it.allLists();
181 final String basePackageName = moduleNamespaceToPackageName(module);
182 if (schemaLists != null) {
183 for (final ListSchemaNode list : schemaLists) {
184 generatedTypes.addAll(listToGenType(basePackageName, list));
187 return generatedTypes;
190 private List<Type> allAugmentsToGenTypes(final Module module) {
191 if (module == null) {
192 throw new IllegalArgumentException("Module reference cannot be NULL!");
195 if (module.getName() == null) {
196 throw new IllegalArgumentException("Module name cannot be NULL!");
199 if (module.getChildNodes() == null) {
200 throw new IllegalArgumentException("Reference to Set of " +
201 "Augmentation Definitions in module " + module.getName()
202 + " cannot be NULL!");
205 final List<Type> generatedTypes = new ArrayList<>();
206 final String basePackageName = moduleNamespaceToPackageName(module);
207 final List<AugmentationSchema> augmentations = resolveAugmentations(module);
208 for (final AugmentationSchema augment : augmentations) {
209 generatedTypes.addAll(augmentationToGenTypes(basePackageName, augment));
211 return generatedTypes;
214 private List<AugmentationSchema> resolveAugmentations(final Module module) {
215 if (module == null) {
216 throw new IllegalArgumentException("Module reference cannot be NULL!");
218 if (module.getAugmentations() == null) {
219 throw new IllegalStateException("Augmentations Set cannot be NULL!");
222 final Set<AugmentationSchema> augmentations = module
224 final List<AugmentationSchema> sortedAugmentations = new ArrayList<>(
226 Collections.sort(sortedAugmentations,
227 new Comparator<AugmentationSchema>() {
231 AugmentationSchema augSchema1,
232 AugmentationSchema augSchema2) {
234 if (augSchema1.getTargetPath().getPath()
236 .getTargetPath().getPath().size()) {
238 } else if (augSchema1.getTargetPath()
239 .getPath().size() < augSchema2
240 .getTargetPath().getPath().size()) {
248 return sortedAugmentations;
251 private GeneratedType moduleToDataType(final Module module) {
252 if (module == null) {
253 throw new IllegalArgumentException("Module reference cannot be NULL!");
256 final GeneratedTypeBuilder moduleDataTypeBuilder = moduleTypeBuilder(
259 final String basePackageName = moduleNamespaceToPackageName(module);
260 if (moduleDataTypeBuilder != null) {
261 final Set<DataSchemaNode> dataNodes = module.getChildNodes();
262 resolveDataSchemaNodes(basePackageName, moduleDataTypeBuilder, dataNodes);
264 return moduleDataTypeBuilder.toInstance();
267 private List<GeneratedType> allRPCMethodsToGenType(final Module module) {
268 if (module == null) {
269 throw new IllegalArgumentException("Module reference cannot be NULL!");
272 if (module.getName() == null) {
273 throw new IllegalArgumentException("Module name cannot be NULL!");
276 if (module.getChildNodes() == null) {
277 throw new IllegalArgumentException("Reference to Set of " +
278 "RPC Method Definitions in module " + module.getName()
279 + " cannot be NULL!");
282 final String basePackageName = moduleNamespaceToPackageName(module);
283 final Set<RpcDefinition> rpcDefinitions = module.getRpcs();
284 final List<GeneratedType> genRPCTypes = new ArrayList<>();
286 for (final RpcDefinition rpc : rpcDefinitions) {
288 final List<DataNodeIterator> rpcInOut = new ArrayList<>();
289 rpcInOut.add(new DataNodeIterator(rpc.getInput()));
290 rpcInOut.add(new DataNodeIterator(rpc.getOutput()));
292 for (DataNodeIterator it : rpcInOut) {
293 List<ContainerSchemaNode> nContainers = it.allContainers();
294 if ((nContainers != null) && !nContainers.isEmpty()) {
295 for (final ContainerSchemaNode container : nContainers) {
296 genRPCTypes.add(containerToGenType(basePackageName, container));
305 private List<Type> allNotifycationsToGenType(final Module module) {
306 if (module == null) {
307 throw new IllegalArgumentException("Module reference cannot be NULL!");
310 if (module.getName() == null) {
311 throw new IllegalArgumentException("Module name cannot be NULL!");
314 if (module.getChildNodes() == null) {
315 throw new IllegalArgumentException("Reference to Set of " +
316 "Notification Definitions in module " + module.getName()
317 + " cannot be NULL!");
320 final String basePackageName = moduleNamespaceToPackageName(module);
321 final List<Type> genNotifyTypes = new ArrayList<>();
322 final Set<NotificationDefinition> notifications = module
325 for (final NotificationDefinition notification : notifications) {
326 if (notification != null) {
327 final List<DataNodeIterator> notifyChildren = new ArrayList<>();
329 for (DataSchemaNode childNode : notification.getChildNodes()) {
330 if (childNode instanceof DataNodeContainer) {
331 notifyChildren.add(new DataNodeIterator((DataNodeContainer) childNode));
335 for (DataNodeIterator it : notifyChildren) {
336 List<ContainerSchemaNode> nContainers = it.allContainers();
337 List<ListSchemaNode> nLists = it.allLists();
338 if ((nContainers != null) && !nContainers.isEmpty()) {
339 for (final ContainerSchemaNode container : nContainers) {
340 genNotifyTypes.add(containerToGenType(basePackageName, container));
343 if ((nLists != null) && !nLists.isEmpty()) {
344 for (final ListSchemaNode list : nLists) {
345 genNotifyTypes.addAll(listToGenType(basePackageName, list));
351 return genNotifyTypes;
354 private EnumTypeDefinition enumTypeDefFromExtendedType(
355 final TypeDefinition<?> typeDefinition) {
356 if (typeDefinition != null) {
357 if (typeDefinition.getBaseType() instanceof EnumTypeDefinition) {
358 return (EnumTypeDefinition) typeDefinition.getBaseType();
359 } else if (typeDefinition.getBaseType() instanceof ExtendedType) {
360 return enumTypeDefFromExtendedType(typeDefinition.getBaseType());
366 private EnumBuilder resolveInnerEnumFromTypeDefinition(
367 final EnumTypeDefinition enumTypeDef, final String enumName,
368 final GeneratedTypeBuilder typeBuilder) {
369 if ((enumTypeDef != null) && (typeBuilder != null)
370 && (enumTypeDef.getQName() != null)
371 && (enumTypeDef.getQName().getLocalName() != null)) {
373 final String enumerationName = parseToClassName(enumName);
374 final EnumBuilder enumBuilder = typeBuilder
375 .addEnumeration(enumerationName);
377 if (enumBuilder != null) {
378 final List<EnumPair> enums = enumTypeDef.getValues();
381 for (final EnumPair enumPair : enums) {
382 if (enumPair != null) {
383 final String enumPairName = parseToClassName(enumPair
385 Integer enumPairValue = enumPair.getValue();
387 if (enumPairValue == null) {
388 enumPairValue = listIndex;
390 enumBuilder.addValue(enumPairName, enumPairValue);
401 private GeneratedTypeBuilder moduleTypeBuilder(final Module module,
402 final String postfix) {
403 if (module == null) {
404 throw new IllegalArgumentException("Module reference cannot be NULL!");
406 String packageName = moduleNamespaceToPackageName(module);
407 final String moduleName = parseToClassName(module.getName())
410 return new GeneratedTypeBuilderImpl(packageName, moduleName);
414 private List<Type> augmentationToGenTypes(final String augmentPackageName,
415 final AugmentationSchema augSchema) {
416 if (augmentPackageName == null) {
417 throw new IllegalArgumentException("Package Name cannot be NULL!");
419 if (augSchema == null) {
420 throw new IllegalArgumentException(
421 "Augmentation Schema cannot be NULL!");
423 if (augSchema.getTargetPath() == null) {
424 throw new IllegalStateException(
425 "Augmentation Schema does not contain Target Path (Target Path is NULL).");
428 final List<Type> genTypes = new ArrayList<>();
430 // EVERY augmented interface will extends Augmentation<T> interface
431 // and DataObject interface!!!
432 final SchemaPath targetPath = augSchema.getTargetPath();
433 final DataSchemaNode targetSchemaNode = findDataSchemaNode(schemaContext,
435 if ((targetSchemaNode != null) &&
436 (targetSchemaNode.getQName() != null) &&
437 (targetSchemaNode.getQName().getLocalName() != null)) {
438 final Module targetModule = findParentModule(schemaContext,
441 final String targetBasePackage = moduleNamespaceToPackageName(targetModule);
442 final String targetPackageName = packageNameForGeneratedType(targetBasePackage,
443 targetSchemaNode.getPath());
445 final String targetSchemaNodeName = targetSchemaNode.getQName().getLocalName();
446 final Set<DataSchemaNode> augChildNodes = augSchema
448 final GeneratedTypeBuilder augTypeBuilder = addRawAugmentGenTypeDefinition(
449 augmentPackageName, targetPackageName, targetSchemaNodeName, augSchema);
450 if (augTypeBuilder != null) {
451 genTypes.add(augTypeBuilder.toInstance());
453 genTypes.addAll(augmentationBodyToGenTypes(augmentPackageName,
460 private GeneratedTypeBuilder addRawAugmentGenTypeDefinition(
461 final String augmentPackageName, final String targetPackageName,
462 final String targetSchemaNodeName,
463 final AugmentationSchema augSchema) {
464 final String targetTypeName = parseToClassName(targetSchemaNodeName);
465 Map<String, GeneratedTypeBuilder> augmentBuilders = genTypeBuilders
466 .get(augmentPackageName);
467 if (augmentBuilders == null) {
468 augmentBuilders = new HashMap<>();
469 genTypeBuilders.put(augmentPackageName, augmentBuilders);
472 final String augTypeName = augGenTypeName(augmentBuilders, targetTypeName);
473 final Type targetTypeRef = new ReferencedTypeImpl(targetPackageName, targetTypeName);
474 final Set<DataSchemaNode> augChildNodes = augSchema
477 final GeneratedTypeBuilder augTypeBuilder = new GeneratedTypeBuilderImpl(
478 augmentPackageName, augTypeName);
480 augTypeBuilder.addImplementsType(Types.DATA_OBJECT);
481 augTypeBuilder.addImplementsType(Types
482 .augmentationTypeFor(targetTypeRef));
484 augSchemaNodeToMethods(augmentPackageName, augTypeBuilder, augChildNodes);
485 augmentBuilders.put(augTypeName, augTypeBuilder);
486 return augTypeBuilder;
489 private List<Type> augmentationBodyToGenTypes(final String augBasePackageName,
490 final Set<DataSchemaNode> augChildNodes) {
491 final List<Type> genTypes = new ArrayList<>();
492 final List<DataNodeIterator> augSchemaIts = new ArrayList<>();
493 for (final DataSchemaNode childNode : augChildNodes) {
494 if (childNode instanceof DataNodeContainer) {
495 augSchemaIts.add(new DataNodeIterator(
496 (DataNodeContainer) childNode));
498 if (childNode instanceof ContainerSchemaNode) {
499 genTypes.add(containerToGenType(augBasePackageName,
500 (ContainerSchemaNode) childNode));
501 } else if (childNode instanceof ListSchemaNode) {
502 genTypes.addAll(listToGenType(augBasePackageName,
503 (ListSchemaNode) childNode));
508 for (final DataNodeIterator it : augSchemaIts) {
509 final List<ContainerSchemaNode> augContainers = it.allContainers();
510 final List<ListSchemaNode> augLists = it.allLists();
512 if ((augContainers != null) && !augContainers.isEmpty()) {
513 for (final ContainerSchemaNode container : augContainers) {
514 genTypes.add(containerToGenType(augBasePackageName, container));
517 if ((augLists != null) && !augLists.isEmpty()) {
518 for (final ListSchemaNode list : augLists) {
519 genTypes.addAll(listToGenType(augBasePackageName, list));
526 private String augGenTypeName(
527 final Map<String, GeneratedTypeBuilder> builders,
528 final String genTypeName) {
529 String augTypeName = genTypeName;
532 while ((builders != null) && builders.containsKey(genTypeName + index)) {
535 augTypeName += index;
539 private GeneratedType containerToGenType(final String basePackageName,
540 ContainerSchemaNode containerNode) {
541 if (containerNode == null) {
545 final String packageName = packageNameForGeneratedType(
546 basePackageName, containerNode.getPath());
547 final Set<DataSchemaNode> schemaNodes = containerNode.getChildNodes();
548 final GeneratedTypeBuilder typeBuilder = addRawInterfaceDefinition(
549 packageName, containerNode);
551 resolveDataSchemaNodes(basePackageName, typeBuilder, schemaNodes);
552 return typeBuilder.toInstance();
555 private GeneratedTypeBuilder resolveDataSchemaNodes(
556 final String basePackageName,
557 final GeneratedTypeBuilder typeBuilder,
558 final Set<DataSchemaNode> schemaNodes) {
560 if ((schemaNodes != null) && (typeBuilder != null)) {
561 for (final DataSchemaNode schemaNode : schemaNodes) {
562 if (schemaNode.isAugmenting()) {
565 addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode, typeBuilder);
571 private GeneratedTypeBuilder augSchemaNodeToMethods(
572 final String basePackageName,
573 final GeneratedTypeBuilder typeBuilder,
574 final Set<DataSchemaNode> schemaNodes) {
576 if ((schemaNodes != null) && (typeBuilder != null)) {
577 for (final DataSchemaNode schemaNode : schemaNodes) {
578 if (schemaNode.isAugmenting()) {
579 addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode, typeBuilder);
586 private void addSchemaNodeToBuilderAsMethod(
587 final String basePackageName,
588 final DataSchemaNode schemaNode,
589 final GeneratedTypeBuilder typeBuilder) {
590 if (schemaNode != null && typeBuilder != null) {
591 if (schemaNode instanceof LeafSchemaNode) {
592 resolveLeafSchemaNodeAsMethod(typeBuilder,
593 (LeafSchemaNode) schemaNode);
594 } else if (schemaNode instanceof LeafListSchemaNode) {
595 resolveLeafListSchemaNode(typeBuilder,
596 (LeafListSchemaNode) schemaNode);
597 } else if (schemaNode instanceof ContainerSchemaNode) {
598 resolveContainerSchemaNode(basePackageName, typeBuilder,
599 (ContainerSchemaNode) schemaNode);
600 } else if (schemaNode instanceof ListSchemaNode) {
601 resolveListSchemaNode(basePackageName, typeBuilder,
602 (ListSchemaNode) schemaNode);
607 private boolean resolveLeafSchemaNodeAsMethod(
608 final GeneratedTypeBuilder typeBuilder, final LeafSchemaNode leaf) {
609 if ((leaf != null) && (typeBuilder != null)) {
610 final String leafName = leaf.getQName().getLocalName();
611 String leafDesc = leaf.getDescription();
612 if (leafDesc == null) {
616 if (leafName != null) {
617 final TypeDefinition<?> typeDef = leaf.getType();
619 Type returnType = null;
620 if (!(typeDef instanceof EnumTypeDefinition)) {
621 returnType = typeProvider
622 .javaTypeForSchemaDefinitionType(typeDef);
624 final EnumTypeDefinition enumTypeDef = enumTypeDefFromExtendedType(typeDef);
625 final EnumBuilder enumBuilder = resolveInnerEnumFromTypeDefinition(
626 enumTypeDef, leafName, typeBuilder);
628 if (enumBuilder != null) {
629 returnType = new ReferencedTypeImpl(
630 enumBuilder.getPackageName(),
631 enumBuilder.getName());
633 ((TypeProviderImpl)typeProvider).putReferencedType(leaf
634 .getPath(), returnType);
636 if (returnType != null) {
637 constructGetter(typeBuilder, leafName, leafDesc, returnType);
638 if (!leaf.isConfiguration()) {
639 constructSetter(typeBuilder, leafName, leafDesc, returnType);
648 private boolean resolveLeafSchemaNodeAsProperty(
649 final GeneratedTOBuilder toBuilder, final LeafSchemaNode leaf,
650 boolean isReadOnly) {
651 if ((leaf != null) && (toBuilder != null)) {
652 final String leafName = leaf.getQName().getLocalName();
653 String leafDesc = leaf.getDescription();
654 if (leafDesc == null) {
658 if (leafName != null) {
659 final TypeDefinition<?> typeDef = leaf.getType();
661 // TODO: properly resolve enum types
662 final Type returnType = typeProvider
663 .javaTypeForSchemaDefinitionType(typeDef);
665 if (returnType != null) {
666 final GeneratedPropertyBuilder propBuilder = toBuilder
667 .addProperty(parseToClassName(leafName));
669 propBuilder.setReadOnly(isReadOnly);
670 propBuilder.addReturnType(returnType);
671 propBuilder.addComment(leafDesc);
673 toBuilder.addEqualsIdentity(propBuilder);
674 toBuilder.addHashIdentity(propBuilder);
675 toBuilder.addToStringProperty(propBuilder);
684 private boolean resolveLeafListSchemaNode(
685 final GeneratedTypeBuilder typeBuilder,
686 final LeafListSchemaNode node) {
687 if ((node != null) && (typeBuilder != null)) {
688 final String nodeName = node.getQName().getLocalName();
689 String nodeDesc = node.getDescription();
690 if (nodeDesc == null) {
694 if (nodeName != null) {
695 final TypeDefinition<?> type = node.getType();
696 final Type listType = Types.listTypeFor(typeProvider
697 .javaTypeForSchemaDefinitionType(type));
699 constructGetter(typeBuilder, nodeName, nodeDesc, listType);
700 if (!node.isConfiguration()) {
701 constructSetter(typeBuilder, nodeName, nodeDesc, listType);
709 private boolean resolveContainerSchemaNode(final String basePackageName,
710 final GeneratedTypeBuilder typeBuilder,
711 final ContainerSchemaNode containerNode) {
712 if ((containerNode != null) && (typeBuilder != null)) {
713 final String nodeName = containerNode.getQName().getLocalName();
715 if (nodeName != null) {
716 final String packageName = packageNameForGeneratedType(
717 basePackageName, containerNode.getPath());
719 final GeneratedTypeBuilder rawGenType = addRawInterfaceDefinition(
720 packageName, containerNode);
721 constructGetter(typeBuilder, nodeName, "", rawGenType);
729 private boolean resolveListSchemaNode(final String basePackageName,
730 final GeneratedTypeBuilder typeBuilder,
731 final ListSchemaNode schemaNode) {
732 if ((schemaNode != null) && (typeBuilder != null)) {
733 final String listName = schemaNode.getQName().getLocalName();
735 if (listName != null) {
736 final String packageName = packageNameForGeneratedType(
737 basePackageName, schemaNode.getPath());
738 final GeneratedTypeBuilder rawGenType = addRawInterfaceDefinition(
739 packageName, schemaNode);
740 constructGetter(typeBuilder, listName, "",
741 Types.listTypeFor(rawGenType));
742 if (!schemaNode.isConfiguration()) {
743 constructSetter(typeBuilder, listName, "",
744 Types.listTypeFor(rawGenType));
752 private GeneratedTypeBuilder addRawInterfaceDefinition(
753 final String packageName, final DataSchemaNode schemaNode) {
754 if (schemaNode == null) {
758 final String schemaNodeName = schemaNode.getQName().getLocalName();
760 if ((packageName != null) && (schemaNodeName != null)) {
761 final String genTypeName = parseToClassName(schemaNodeName);
762 final GeneratedTypeBuilder newType = new GeneratedTypeBuilderImpl(
763 packageName, genTypeName);
765 newType.addImplementsType(Types.DATA_OBJECT);
766 newType.addImplementsType(Types.augmentableTypeFor(newType));
768 if (!genTypeBuilders.containsKey(packageName)) {
769 final Map<String, GeneratedTypeBuilder> builders = new HashMap<>();
770 builders.put(genTypeName, newType);
771 genTypeBuilders.put(packageName, builders);
773 final Map<String, GeneratedTypeBuilder> builders = genTypeBuilders
775 if (!builders.containsKey(genTypeName)) {
776 builders.put(genTypeName, newType);
784 private String getterMethodName(final String methodName) {
785 final StringBuilder method = new StringBuilder();
786 method.append("get");
787 method.append(parseToClassName(methodName));
788 return method.toString();
791 private String setterMethodName(final String methodName) {
792 final StringBuilder method = new StringBuilder();
793 method.append("set");
794 method.append(parseToClassName(methodName));
795 return method.toString();
798 private MethodSignatureBuilder constructGetter(
799 final GeneratedTypeBuilder interfaceBuilder,
800 final String schemaNodeName, final String comment,
801 final Type returnType) {
802 final MethodSignatureBuilder getMethod = interfaceBuilder
803 .addMethod(getterMethodName(schemaNodeName));
805 getMethod.addComment(comment);
806 getMethod.addReturnType(returnType);
811 private MethodSignatureBuilder constructSetter(
812 final GeneratedTypeBuilder interfaceBuilder,
813 final String schemaNodeName, final String comment,
814 final Type parameterType) {
815 final MethodSignatureBuilder setMethod = interfaceBuilder
816 .addMethod(setterMethodName(schemaNodeName));
818 setMethod.addComment(comment);
819 setMethod.addParameter(parameterType,
820 parseToValidParamName(schemaNodeName));
821 setMethod.addReturnType(Types.voidType());
827 private List<Type> listToGenType(final String basePackageName,
828 final ListSchemaNode list) {
829 if (basePackageName == null) {
830 throw new IllegalArgumentException(
831 "Package Name for Generated Type cannot be NULL!");
834 throw new IllegalArgumentException(
835 "List Schema Node cannot be NULL!");
838 final String packageName = packageNameForGeneratedType(
839 basePackageName, list.getPath());
840 final GeneratedTypeBuilder typeBuilder = resolveListTypeBuilder(
842 final List<String> listKeys = listKeys(list);
843 GeneratedTOBuilder genTOBuilder = resolveListKeyTOBuilder(packageName,
846 final Set<DataSchemaNode> schemaNodes = list.getChildNodes();
848 for (final DataSchemaNode schemaNode : schemaNodes) {
849 if (schemaNode.isAugmenting()) {
852 addSchemaNodeToListBuilders(basePackageName, schemaNode, typeBuilder,
853 genTOBuilder, listKeys);
855 return typeBuildersToGenTypes(typeBuilder, genTOBuilder);
858 private void addSchemaNodeToListBuilders(final String basePackageName,
859 final DataSchemaNode schemaNode,
860 final GeneratedTypeBuilder typeBuilder,
861 final GeneratedTOBuilder genTOBuilder,
862 final List<String> listKeys) {
863 if (schemaNode == null) {
864 throw new IllegalArgumentException(
865 "Data Schema Node cannot be NULL!");
868 if (typeBuilder == null) {
869 throw new IllegalArgumentException(
870 "Generated Type Builder cannot be NULL!");
873 if (schemaNode instanceof LeafSchemaNode) {
874 final LeafSchemaNode leaf = (LeafSchemaNode) schemaNode;
875 if (!isPartOfListKey(leaf, listKeys)) {
876 resolveLeafSchemaNodeAsMethod(typeBuilder, leaf);
878 resolveLeafSchemaNodeAsProperty(genTOBuilder, leaf, true);
880 } else if (schemaNode instanceof LeafListSchemaNode) {
881 resolveLeafListSchemaNode(typeBuilder,
882 (LeafListSchemaNode) schemaNode);
883 } else if (schemaNode instanceof ContainerSchemaNode) {
884 resolveContainerSchemaNode(basePackageName, typeBuilder,
885 (ContainerSchemaNode) schemaNode);
886 } else if (schemaNode instanceof ListSchemaNode) {
887 resolveListSchemaNode(basePackageName, typeBuilder, (ListSchemaNode) schemaNode);
891 private List<Type> typeBuildersToGenTypes(
892 final GeneratedTypeBuilder typeBuilder,
893 GeneratedTOBuilder genTOBuilder) {
894 final List<Type> genTypes = new ArrayList<>();
895 if (typeBuilder == null) {
896 throw new IllegalArgumentException(
897 "Generated Type Builder cannot be NULL!");
900 if (genTOBuilder != null) {
901 final GeneratedTransferObject genTO = genTOBuilder.toInstance();
902 constructGetter(typeBuilder, genTO.getName(),
903 "Returns Primary Key of Yang List Type", genTO);
906 genTypes.add(typeBuilder.toInstance());
914 private GeneratedTOBuilder resolveListKey(final String packageName,
915 final ListSchemaNode list) {
916 final String listName = list.getQName().getLocalName() + "Key";
917 return schemaNodeToTransferObjectBuilder(packageName, list, listName);
920 private boolean isPartOfListKey(final LeafSchemaNode leaf,
921 final List<String> keys) {
922 if ((leaf != null) && (keys != null) && (leaf.getQName() != null)) {
923 final String leafName = leaf.getQName().getLocalName();
924 if (keys.contains(leafName)) {
931 private List<String> listKeys(final ListSchemaNode list) {
932 final List<String> listKeys = new ArrayList<>();
934 if (list.getKeyDefinition() != null) {
935 final List<QName> keyDefinitions = list.getKeyDefinition();
937 for (final QName keyDefinition : keyDefinitions) {
938 listKeys.add(keyDefinition.getLocalName());
944 private GeneratedTypeBuilder resolveListTypeBuilder(
945 final String packageName, final ListSchemaNode list) {
946 if (packageName == null) {
947 throw new IllegalArgumentException(
948 "Package Name for Generated Type cannot be NULL!");
951 throw new IllegalArgumentException(
952 "List Schema Node cannot be NULL!");
955 final String schemaNodeName = list.getQName().getLocalName();
956 final String genTypeName = parseToClassName(schemaNodeName);
958 GeneratedTypeBuilder typeBuilder = null;
959 final Map<String, GeneratedTypeBuilder> builders = genTypeBuilders.get(packageName);
960 if (builders != null) {
961 typeBuilder = builders.get(genTypeName);
963 if (typeBuilder == null) {
964 typeBuilder = addRawInterfaceDefinition(packageName, list);
969 private GeneratedTOBuilder resolveListKeyTOBuilder(
970 final String packageName, final ListSchemaNode list,
971 final List<String> listKeys) {
972 GeneratedTOBuilder genTOBuilder = null;
973 if (listKeys.size() > 0) {
974 genTOBuilder = resolveListKey(packageName, list);