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.GeneratedTransferObject;
16 import org.opendaylight.controller.sal.binding.model.api.GeneratedType;
17 import org.opendaylight.controller.sal.binding.model.api.Type;
18 import org.opendaylight.controller.sal.binding.model.api.type.builder.*;
19 import org.opendaylight.controller.sal.binding.yang.types.TypeProviderImpl;
20 import org.opendaylight.controller.yang.common.QName;
21 import org.opendaylight.controller.yang.model.api.*;
22 import org.opendaylight.controller.yang.model.api.type.EnumTypeDefinition;
23 import org.opendaylight.controller.yang.model.api.type.EnumTypeDefinition.EnumPair;
24 import org.opendaylight.controller.yang.model.util.DataNodeIterator;
25 import org.opendaylight.controller.yang.model.util.ExtendedType;
29 import static org.opendaylight.controller.binding.generator.util.BindingGeneratorUtil.*;
30 import static org.opendaylight.controller.yang.model.util.SchemaContextUtil.findDataSchemaNode;
31 import static org.opendaylight.controller.yang.model.util.SchemaContextUtil.findParentModule;
33 public class BindingGeneratorImpl implements BindingGenerator {
35 private Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders;
36 private TypeProvider typeProvider;
37 private SchemaContext schemaContext;
39 public BindingGeneratorImpl() {
44 public List<Type> generateTypes(final SchemaContext context) {
45 if (context == null) {
46 throw new IllegalArgumentException("Schema Context reference cannot be NULL");
48 if (context.getModules() == null) {
49 throw new IllegalStateException("Schema Context does not contain defined modules!");
52 final List<Type> genTypes = 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 final DataNodeIterator moduleIterator = new DataNodeIterator(
61 final List<AugmentationSchema> sortedAugmentations = provideSortedAugmentations(module);
62 final List<ContainerSchemaNode> schemaContainers = moduleIterator
64 final List<ListSchemaNode> schemaLists = moduleIterator
67 final String basePackageName = moduleNamespaceToPackageName(module);
68 if ((schemaContainers != null)
69 && !schemaContainers.isEmpty()) {
70 for (final ContainerSchemaNode container : schemaContainers) {
71 genTypes.add(containerToGenType(basePackageName,
75 if ((schemaLists != null) && !schemaLists.isEmpty()) {
76 for (final ListSchemaNode list : schemaLists) {
77 genTypes.addAll(listToGenType(basePackageName, list));
81 if ((sortedAugmentations != null)
82 && !sortedAugmentations.isEmpty()) {
83 for (final AugmentationSchema augment : sortedAugmentations) {
84 genTypes.addAll(augmentationToGenTypes(basePackageName, augment));
88 final GeneratedType genDataType = moduleToDataType(basePackageName, module);
89 final List<GeneratedType> genRpcType = rpcMethodsToGenType(basePackageName, module);
90 final List<Type> genNotifyType = notifycationsToGenType(basePackageName, module);
92 if (genDataType != null) {
93 genTypes.add(genDataType);
95 if (genRpcType != null) {
96 genTypes.addAll(genRpcType);
98 if (genNotifyType != null) {
99 genTypes.addAll(genNotifyType);
102 genTypes.addAll(((TypeProviderImpl) typeProvider)
103 .getGeneratedTypeDefs());
108 private List<AugmentationSchema> provideSortedAugmentations(final Module module) {
109 if (module == null) {
110 throw new IllegalArgumentException("Module reference cannot be NULL!");
112 if (module.getAugmentations() == null) {
113 throw new IllegalStateException("Augmentations Set cannot be NULL!");
116 final Set<AugmentationSchema> augmentations = module
118 final List<AugmentationSchema> sortedAugmentations = new ArrayList<>(
120 Collections.sort(sortedAugmentations,
121 new Comparator<AugmentationSchema>() {
125 AugmentationSchema augSchema1,
126 AugmentationSchema augSchema2) {
128 if (augSchema1.getTargetPath().getPath()
130 .getTargetPath().getPath().size()) {
132 } else if (augSchema1.getTargetPath()
133 .getPath().size() < augSchema2
134 .getTargetPath().getPath().size()) {
142 return sortedAugmentations;
145 private GeneratedType moduleToDataType(final String basePackageName, final Module module) {
146 if (module == null) {
147 throw new IllegalArgumentException("Module reference cannot be NULL!");
150 final GeneratedTypeBuilder moduleDataTypeBuilder = moduleTypeBuilder(
153 if (moduleDataTypeBuilder != null) {
154 final Set<DataSchemaNode> dataNodes = module.getChildNodes();
155 resolveDataSchemaNodes(basePackageName, moduleDataTypeBuilder, dataNodes);
157 return moduleDataTypeBuilder.toInstance();
160 private boolean isDerivedFromEnumerationType(
161 final TypeDefinition<?> typeDefinition) {
162 if (typeDefinition != null) {
163 if (typeDefinition.getBaseType() instanceof EnumTypeDefinition) {
165 } else if (typeDefinition.getBaseType() instanceof ExtendedType) {
166 return isDerivedFromEnumerationType(typeDefinition
173 private EnumTypeDefinition enumTypeDefFromExtendedType(
174 final TypeDefinition<?> typeDefinition) {
175 if (typeDefinition != null) {
176 if (typeDefinition.getBaseType() instanceof EnumTypeDefinition) {
177 return (EnumTypeDefinition) typeDefinition.getBaseType();
178 } else if (typeDefinition.getBaseType() instanceof ExtendedType) {
179 return enumTypeDefFromExtendedType(typeDefinition.getBaseType());
185 private EnumBuilder resolveEnumFromTypeDefinition(
186 final EnumTypeDefinition enumTypeDef, final String enumName,
187 final GeneratedTypeBuilder typeBuilder) {
188 if ((enumTypeDef != null) && (typeBuilder != null)
189 && (enumTypeDef.getQName() != null)
190 && (enumTypeDef.getQName().getLocalName() != null)) {
192 final String enumerationName = parseToClassName(enumName);
193 final EnumBuilder enumBuilder = typeBuilder
194 .addEnumeration(enumerationName);
196 if (enumBuilder != null) {
197 final List<EnumPair> enums = enumTypeDef.getValues();
200 for (final EnumPair enumPair : enums) {
201 if (enumPair != null) {
202 final String enumPairName = parseToClassName(enumPair
204 Integer enumPairValue = enumPair.getValue();
206 if (enumPairValue == null) {
207 enumPairValue = listIndex;
209 enumBuilder.addValue(enumPairName, enumPairValue);
220 private GeneratedTypeBuilder moduleTypeBuilder(final Module module,
221 final String postfix) {
222 if (module == null) {
223 throw new IllegalArgumentException("Module reference cannot be NULL!");
225 String packageName = moduleNamespaceToPackageName(module);
226 final String moduleName = parseToClassName(module.getName())
229 return new GeneratedTypeBuilderImpl(packageName, moduleName);
233 private List<GeneratedType> rpcMethodsToGenType(final String basePackageName, final Module module) {
234 if (module == null) {
235 throw new IllegalArgumentException("Module reference cannot be NULL!");
238 final Set<RpcDefinition> rpcDefinitions = module.getRpcs();
239 final List<GeneratedType> rpcTypes = new ArrayList<>();
241 if ((rpcDefinitions != null) && !rpcDefinitions.isEmpty()) {
242 for (final RpcDefinition rpc : rpcDefinitions) {
244 final List<DataNodeIterator> rpcInOut = new ArrayList<>();
245 rpcInOut.add(new DataNodeIterator(rpc.getInput()));
246 rpcInOut.add(new DataNodeIterator(rpc.getOutput()));
248 for (DataNodeIterator it : rpcInOut) {
249 List<ContainerSchemaNode> nContainers = it.allContainers();
250 if ((nContainers != null) && !nContainers.isEmpty()) {
251 for (final ContainerSchemaNode container : nContainers) {
252 rpcTypes.add(containerToGenType(basePackageName, container));
262 private List<Type> notifycationsToGenType(final String basePackageName, final Module module) {
263 if (module == null) {
264 throw new IllegalArgumentException("Module reference cannot be NULL!");
266 final List<Type> notificationTypes = new ArrayList<>();
267 final Set<NotificationDefinition> notifications = module
270 if ((notifications != null) && !notifications.isEmpty()) {
271 for (final NotificationDefinition notification : notifications) {
272 if (notification != null) {
273 final List<DataNodeIterator> notifyChildren = new ArrayList<>();
275 for (DataSchemaNode childNode : notification.getChildNodes()) {
276 if (childNode instanceof DataNodeContainer) {
277 notifyChildren.add(new DataNodeIterator((DataNodeContainer) childNode));
281 for (DataNodeIterator it : notifyChildren) {
282 List<ContainerSchemaNode> nContainers = it.allContainers();
283 List<ListSchemaNode> nLists = it.allLists();
284 if ((nContainers != null) && !nContainers.isEmpty()) {
285 for (final ContainerSchemaNode container : nContainers) {
286 notificationTypes.add(containerToGenType(basePackageName, container));
289 if ((nLists != null) && !nLists.isEmpty()) {
290 for (final ListSchemaNode list : nLists) {
292 notificationTypes.addAll(listToGenType(basePackageName, list));
299 return notificationTypes;
302 private List<Type> augmentationToGenTypes(final String augmentPackageName,
303 final AugmentationSchema augSchema) {
304 if (augmentPackageName == null) {
305 throw new IllegalArgumentException("Package Name cannot be NULL!");
307 if (augSchema == null) {
308 throw new IllegalArgumentException(
309 "Augmentation Schema cannot be NULL!");
311 if (augSchema.getTargetPath() == null) {
312 throw new IllegalStateException(
313 "Augmentation Schema does not contain Target Path (Target Path is NULL).");
316 final List<Type> genTypes = new ArrayList<>();
318 // EVERY augmented interface will extends Augmentation<T> interface
319 // and DataObject interface!!!
320 final SchemaPath targetPath = augSchema.getTargetPath();
321 final DataSchemaNode targetSchemaNode = findDataSchemaNode(schemaContext,
323 if ((targetSchemaNode != null) &&
324 (targetSchemaNode.getQName() != null) &&
325 (targetSchemaNode.getQName().getLocalName() != null)) {
326 final Module targetModule = findParentModule(schemaContext,
329 final String targetBasePackage = moduleNamespaceToPackageName(targetModule);
330 final String targetPackageName = packageNameForGeneratedType(targetBasePackage,
331 targetSchemaNode.getPath());
333 final String targetSchemaNodeName = targetSchemaNode.getQName().getLocalName();
334 final Set<DataSchemaNode> augChildNodes = augSchema
336 final GeneratedTypeBuilder augTypeBuilder = addRawAugmentGenTypeDefinition(
337 augmentPackageName, targetPackageName, targetSchemaNodeName, augSchema);
338 if (augTypeBuilder != null) {
339 genTypes.add(augTypeBuilder.toInstance());
341 genTypes.addAll(augmentationBodyToGenTypes(augmentPackageName,
348 private GeneratedTypeBuilder addRawAugmentGenTypeDefinition(
349 final String augmentPackageName, final String targetPackageName,
350 final String targetSchemaNodeName,
351 final AugmentationSchema augSchema) {
352 final String targetTypeName = parseToClassName(targetSchemaNodeName);
353 Map<String, GeneratedTypeBuilder> augmentBuilders = genTypeBuilders
354 .get(augmentPackageName);
355 if (augmentBuilders == null) {
356 augmentBuilders = new HashMap<>();
357 genTypeBuilders.put(augmentPackageName, augmentBuilders);
360 final String augTypeName = augGenTypeName(augmentBuilders, targetTypeName);
361 final Type targetTypeRef = new ReferencedTypeImpl(targetPackageName, targetTypeName);
362 final Set<DataSchemaNode> augChildNodes = augSchema
365 final GeneratedTypeBuilder augTypeBuilder = new GeneratedTypeBuilderImpl(
366 augmentPackageName, augTypeName);
368 augTypeBuilder.addImplementsType(Types.DATA_OBJECT);
369 augTypeBuilder.addImplementsType(Types
370 .augmentationTypeFor(targetTypeRef));
372 augSchemaNodeToMethods(augmentPackageName, augTypeBuilder, augChildNodes);
373 augmentBuilders.put(augTypeName, augTypeBuilder);
374 return augTypeBuilder;
377 private List<Type> augmentationBodyToGenTypes(final String augBasePackageName,
378 final Set<DataSchemaNode> augChildNodes) {
379 final List<Type> genTypes = new ArrayList<>();
380 final List<DataNodeIterator> augSchemaIts = new ArrayList<>();
381 for (final DataSchemaNode childNode : augChildNodes) {
382 if (childNode instanceof DataNodeContainer) {
383 augSchemaIts.add(new DataNodeIterator(
384 (DataNodeContainer) childNode));
386 if (childNode instanceof ContainerSchemaNode) {
387 genTypes.add(containerToGenType(augBasePackageName,
388 (ContainerSchemaNode) childNode));
389 } else if (childNode instanceof ListSchemaNode) {
390 genTypes.addAll(listToGenType(augBasePackageName,
391 (ListSchemaNode) childNode));
396 for (final DataNodeIterator it : augSchemaIts) {
397 final List<ContainerSchemaNode> augContainers = it.allContainers();
398 final List<ListSchemaNode> augLists = it.allLists();
400 if ((augContainers != null) && !augContainers.isEmpty()) {
401 for (final ContainerSchemaNode container : augContainers) {
402 genTypes.add(containerToGenType(augBasePackageName, container));
405 if ((augLists != null) && !augLists.isEmpty()) {
406 for (final ListSchemaNode list : augLists) {
407 // final String listPackageName = packageNameForAugmentedType(
408 // augBasePackageName, list.getPath());
409 genTypes.addAll(listToGenType(augBasePackageName, list));
416 private String augGenTypeName(
417 final Map<String, GeneratedTypeBuilder> builders,
418 final String genTypeName) {
419 String augTypeName = genTypeName;
422 while ((builders != null) && builders.containsKey(genTypeName + index)) {
425 augTypeName += index;
429 private GeneratedType containerToGenType(final String basePackageName,
430 ContainerSchemaNode containerNode) {
431 if (containerNode == null) {
435 final String packageName = packageNameForGeneratedType(
436 basePackageName, containerNode.getPath());
437 final Set<DataSchemaNode> schemaNodes = containerNode.getChildNodes();
438 final GeneratedTypeBuilder typeBuilder = addRawInterfaceDefinition(
439 packageName, containerNode);
441 resolveDataSchemaNodes(basePackageName, typeBuilder, schemaNodes);
442 return typeBuilder.toInstance();
445 private GeneratedTypeBuilder resolveDataSchemaNodes(
446 final String basePackageName,
447 final GeneratedTypeBuilder typeBuilder,
448 final Set<DataSchemaNode> schemaNodes) {
450 if ((schemaNodes != null) && (typeBuilder != null)) {
451 for (final DataSchemaNode schemaNode : schemaNodes) {
452 if (schemaNode.isAugmenting()) {
455 addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode, typeBuilder);
461 private GeneratedTypeBuilder augSchemaNodeToMethods(
462 final String basePackageName,
463 final GeneratedTypeBuilder typeBuilder,
464 final Set<DataSchemaNode> schemaNodes) {
466 if ((schemaNodes != null) && (typeBuilder != null)) {
467 for (final DataSchemaNode schemaNode : schemaNodes) {
468 if (schemaNode.isAugmenting()) {
469 addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode, typeBuilder);
476 private void addSchemaNodeToBuilderAsMethod(
477 final String basePackageName,
478 final DataSchemaNode schemaNode,
479 final GeneratedTypeBuilder typeBuilder) {
480 if (schemaNode != null && typeBuilder != null) {
481 if (schemaNode instanceof LeafSchemaNode) {
482 resolveLeafSchemaNodeAsMethod(typeBuilder,
483 (LeafSchemaNode) schemaNode);
484 } else if (schemaNode instanceof LeafListSchemaNode) {
485 resolveLeafListSchemaNode(typeBuilder,
486 (LeafListSchemaNode) schemaNode);
487 } else if (schemaNode instanceof ContainerSchemaNode) {
488 resolveContainerSchemaNode(basePackageName, typeBuilder,
489 (ContainerSchemaNode) schemaNode);
490 } else if (schemaNode instanceof ListSchemaNode) {
491 resolveListSchemaNode(basePackageName, typeBuilder,
492 (ListSchemaNode) schemaNode);
497 private boolean resolveLeafSchemaNodeAsMethod(
498 final GeneratedTypeBuilder typeBuilder, final LeafSchemaNode leaf) {
499 if ((leaf != null) && (typeBuilder != null)) {
500 final String leafName = leaf.getQName().getLocalName();
501 String leafDesc = leaf.getDescription();
502 if (leafDesc == null) {
506 if (leafName != null) {
507 final TypeDefinition<?> typeDef = leaf.getType();
509 Type returnType = null;
510 if (!(typeDef instanceof EnumTypeDefinition)
511 && !isDerivedFromEnumerationType(typeDef)) {
512 returnType = typeProvider
513 .javaTypeForSchemaDefinitionType(typeDef);
515 if (isImported(leaf.getPath(), typeDef.getPath())) {
516 // TODO: resolving of imported enums as references to
517 // GeneratedTypeData interface
519 final EnumTypeDefinition enumTypeDef = enumTypeDefFromExtendedType(typeDef);
520 final EnumBuilder enumBuilder = resolveEnumFromTypeDefinition(
521 enumTypeDef, leafName, typeBuilder);
523 if (enumBuilder != null) {
524 returnType = new ReferencedTypeImpl(
525 enumBuilder.getPackageName(),
526 enumBuilder.getName());
531 if (returnType != null) {
532 constructGetter(typeBuilder, leafName, leafDesc, returnType);
533 if (!leaf.isConfiguration()) {
534 constructSetter(typeBuilder, leafName, leafDesc, returnType);
543 private boolean isImported(final SchemaPath leafPath,
544 final SchemaPath typeDefPath) {
545 if ((leafPath != null) && (leafPath.getPath() != null)
546 && (typeDefPath != null) && (typeDefPath.getPath() != null)) {
548 final QName leafPathQName = leafPath.getPath().get(0);
549 final QName typePathQName = typeDefPath.getPath().get(0);
551 if ((leafPathQName != null)
552 && (leafPathQName.getNamespace() != null)
553 && (typePathQName != null)
554 && (typePathQName.getNamespace() != null)) {
556 return !leafPathQName.getNamespace().equals(
557 typePathQName.getNamespace());
563 private boolean resolveLeafSchemaNodeAsProperty(
564 final GeneratedTOBuilder toBuilder, final LeafSchemaNode leaf,
565 boolean isReadOnly) {
566 if ((leaf != null) && (toBuilder != null)) {
567 final String leafName = leaf.getQName().getLocalName();
568 String leafDesc = leaf.getDescription();
569 if (leafDesc == null) {
573 if (leafName != null) {
574 final TypeDefinition<?> typeDef = leaf.getType();
576 // TODO: properly resolve enum types
577 final Type returnType = typeProvider
578 .javaTypeForSchemaDefinitionType(typeDef);
580 if (returnType != null) {
581 final GeneratedPropertyBuilder propBuilder = toBuilder
582 .addProperty(parseToClassName(leafName));
584 propBuilder.setReadOnly(isReadOnly);
585 propBuilder.addReturnType(returnType);
586 propBuilder.addComment(leafDesc);
588 toBuilder.addEqualsIdentity(propBuilder);
589 toBuilder.addHashIdentity(propBuilder);
590 toBuilder.addToStringProperty(propBuilder);
599 private boolean resolveLeafListSchemaNode(
600 final GeneratedTypeBuilder typeBuilder,
601 final LeafListSchemaNode node) {
602 if ((node != null) && (typeBuilder != null)) {
603 final String nodeName = node.getQName().getLocalName();
604 String nodeDesc = node.getDescription();
605 if (nodeDesc == null) {
609 if (nodeName != null) {
610 final TypeDefinition<?> type = node.getType();
611 final Type listType = Types.listTypeFor(typeProvider
612 .javaTypeForSchemaDefinitionType(type));
614 constructGetter(typeBuilder, nodeName, nodeDesc, listType);
615 if (!node.isConfiguration()) {
616 constructSetter(typeBuilder, nodeName, nodeDesc, listType);
624 private boolean resolveContainerSchemaNode(final String basePackageName,
625 final GeneratedTypeBuilder typeBuilder,
626 final ContainerSchemaNode containerNode) {
627 if ((containerNode != null) && (typeBuilder != null)) {
628 final String nodeName = containerNode.getQName().getLocalName();
630 if (nodeName != null) {
631 final String packageName = packageNameForGeneratedType(
632 basePackageName, containerNode.getPath());
634 final GeneratedTypeBuilder rawGenType = addRawInterfaceDefinition(
635 packageName, containerNode);
636 constructGetter(typeBuilder, nodeName, "", rawGenType);
644 private boolean resolveListSchemaNode(final String basePackageName,
645 final GeneratedTypeBuilder typeBuilder,
646 final ListSchemaNode schemaNode) {
647 if ((schemaNode != null) && (typeBuilder != null)) {
648 final String listName = schemaNode.getQName().getLocalName();
650 if (listName != null) {
651 final String packageName = packageNameForGeneratedType(
652 basePackageName, schemaNode.getPath());
653 final GeneratedTypeBuilder rawGenType = addRawInterfaceDefinition(
654 packageName, schemaNode);
655 constructGetter(typeBuilder, listName, "",
656 Types.listTypeFor(rawGenType));
657 if (!schemaNode.isConfiguration()) {
658 constructSetter(typeBuilder, listName, "",
659 Types.listTypeFor(rawGenType));
667 private GeneratedTypeBuilder addRawInterfaceDefinition(
668 final String packageName, final DataSchemaNode schemaNode) {
669 if (schemaNode == null) {
673 final String schemaNodeName = schemaNode.getQName().getLocalName();
675 if ((packageName != null) && (schemaNodeName != null)) {
676 final String genTypeName = parseToClassName(schemaNodeName);
677 final GeneratedTypeBuilder newType = new GeneratedTypeBuilderImpl(
678 packageName, genTypeName);
680 newType.addImplementsType(Types.DATA_OBJECT);
681 newType.addImplementsType(Types.augmentableTypeFor(newType));
683 if (!genTypeBuilders.containsKey(packageName)) {
684 final Map<String, GeneratedTypeBuilder> builders = new HashMap<>();
685 builders.put(genTypeName, newType);
686 genTypeBuilders.put(packageName, builders);
688 final Map<String, GeneratedTypeBuilder> builders = genTypeBuilders
690 if (!builders.containsKey(genTypeName)) {
691 builders.put(genTypeName, newType);
699 private String getterMethodName(final String methodName) {
700 final StringBuilder method = new StringBuilder();
701 method.append("get");
702 method.append(parseToClassName(methodName));
703 return method.toString();
706 private String setterMethodName(final String methodName) {
707 final StringBuilder method = new StringBuilder();
708 method.append("set");
709 method.append(parseToClassName(methodName));
710 return method.toString();
713 private MethodSignatureBuilder constructGetter(
714 final GeneratedTypeBuilder interfaceBuilder,
715 final String schemaNodeName, final String comment,
716 final Type returnType) {
717 final MethodSignatureBuilder getMethod = interfaceBuilder
718 .addMethod(getterMethodName(schemaNodeName));
720 getMethod.addComment(comment);
721 getMethod.addReturnType(returnType);
726 private MethodSignatureBuilder constructSetter(
727 final GeneratedTypeBuilder interfaceBuilder,
728 final String schemaNodeName, final String comment,
729 final Type parameterType) {
730 final MethodSignatureBuilder setMethod = interfaceBuilder
731 .addMethod(setterMethodName(schemaNodeName));
733 setMethod.addComment(comment);
734 setMethod.addParameter(parameterType,
735 parseToValidParamName(schemaNodeName));
736 setMethod.addReturnType(Types.voidType());
742 private List<Type> listToGenType(final String basePackageName,
743 final ListSchemaNode list) {
744 if (basePackageName == null) {
745 throw new IllegalArgumentException(
746 "Package Name for Generated Type cannot be NULL!");
749 throw new IllegalArgumentException(
750 "List Schema Node cannot be NULL!");
753 final String packageName = packageNameForGeneratedType(
754 basePackageName, list.getPath());
755 final GeneratedTypeBuilder typeBuilder = resolveListTypeBuilder(
757 final List<String> listKeys = listKeys(list);
758 GeneratedTOBuilder genTOBuilder = resolveListKeyTOBuilder(packageName,
761 final Set<DataSchemaNode> schemaNodes = list.getChildNodes();
763 for (final DataSchemaNode schemaNode : schemaNodes) {
764 if (schemaNode.isAugmenting()) {
767 addSchemaNodeToListBuilders(basePackageName, schemaNode, typeBuilder,
768 genTOBuilder, listKeys);
771 // if (list.isAugmenting()) {
772 // for (final DataSchemaNode schemaNode : schemaNodes) {
773 // if (schemaNode.isAugmenting()) {
774 // addSchemaNodeToListBuilders(basePackageName, schemaNode, typeBuilder,
775 // genTOBuilder, listKeys);
779 // for (final DataSchemaNode schemaNode : schemaNodes) {
780 // if (schemaNode.isAugmenting()) {
783 // addSchemaNodeToListBuilders(basePackageName, schemaNode, typeBuilder,
784 // genTOBuilder, listKeys);
787 return typeBuildersToGenTypes(typeBuilder, genTOBuilder);
790 private void addSchemaNodeToListBuilders(final String basePackageName,
791 final DataSchemaNode schemaNode,
792 final GeneratedTypeBuilder typeBuilder,
793 final GeneratedTOBuilder genTOBuilder,
794 final List<String> listKeys) {
795 if (schemaNode == null) {
796 throw new IllegalArgumentException(
797 "Data Schema Node cannot be NULL!");
800 if (typeBuilder == null) {
801 throw new IllegalArgumentException(
802 "Generated Type Builder cannot be NULL!");
805 if (schemaNode instanceof LeafSchemaNode) {
806 final LeafSchemaNode leaf = (LeafSchemaNode) schemaNode;
807 if (!isPartOfListKey(leaf, listKeys)) {
808 resolveLeafSchemaNodeAsMethod(typeBuilder, leaf);
810 resolveLeafSchemaNodeAsProperty(genTOBuilder, leaf, true);
812 } else if (schemaNode instanceof LeafListSchemaNode) {
813 resolveLeafListSchemaNode(typeBuilder,
814 (LeafListSchemaNode) schemaNode);
815 } else if (schemaNode instanceof ContainerSchemaNode) {
816 resolveContainerSchemaNode(basePackageName, typeBuilder,
817 (ContainerSchemaNode) schemaNode);
818 } else if (schemaNode instanceof ListSchemaNode) {
819 resolveListSchemaNode(basePackageName, typeBuilder, (ListSchemaNode) schemaNode);
824 private List<Type> typeBuildersToGenTypes(
825 final GeneratedTypeBuilder typeBuilder,
826 GeneratedTOBuilder genTOBuilder) {
827 final List<Type> genTypes = new ArrayList<>();
828 if (typeBuilder == null) {
829 throw new IllegalArgumentException(
830 "Generated Type Builder cannot be NULL!");
833 if (genTOBuilder != null) {
834 final GeneratedTransferObject genTO = genTOBuilder.toInstance();
835 constructGetter(typeBuilder, genTO.getName(),
836 "Returns Primary Key of Yang List Type", genTO);
839 genTypes.add(typeBuilder.toInstance());
847 private GeneratedTOBuilder resolveListKey(final String packageName,
848 final ListSchemaNode list) {
849 final String listName = list.getQName().getLocalName() + "Key";
850 return schemaNodeToTransferObjectBuilder(packageName, list, listName);
853 private boolean isPartOfListKey(final LeafSchemaNode leaf,
854 final List<String> keys) {
855 if ((leaf != null) && (keys != null) && (leaf.getQName() != null)) {
856 final String leafName = leaf.getQName().getLocalName();
857 if (keys.contains(leafName)) {
864 private List<String> listKeys(final ListSchemaNode list) {
865 final List<String> listKeys = new ArrayList<>();
867 if (list.getKeyDefinition() != null) {
868 final List<QName> keyDefinitions = list.getKeyDefinition();
870 for (final QName keyDefinition : keyDefinitions) {
871 listKeys.add(keyDefinition.getLocalName());
877 private GeneratedTypeBuilder resolveListTypeBuilder(
878 final String packageName, final ListSchemaNode list) {
879 if (packageName == null) {
880 throw new IllegalArgumentException(
881 "Package Name for Generated Type cannot be NULL!");
884 throw new IllegalArgumentException(
885 "List Schema Node cannot be NULL!");
888 final String schemaNodeName = list.getQName().getLocalName();
889 final String genTypeName = parseToClassName(schemaNodeName);
891 GeneratedTypeBuilder typeBuilder = null;
892 final Map<String, GeneratedTypeBuilder> builders = genTypeBuilders.get(packageName);
893 if (builders != null) {
894 typeBuilder = builders.get(genTypeName);
896 if (typeBuilder == null) {
897 typeBuilder = addRawInterfaceDefinition(packageName, list);
902 private GeneratedTOBuilder resolveListKeyTOBuilder(
903 final String packageName, final ListSchemaNode list,
904 final List<String> listKeys) {
905 GeneratedTOBuilder genTOBuilder = null;
906 if (listKeys.size() > 0) {
907 genTOBuilder = resolveListKey(packageName, list);