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 static org.opendaylight.controller.binding.generator.util.BindingGeneratorUtil.moduleNamespaceToPackageName;
11 import static org.opendaylight.controller.binding.generator.util.BindingGeneratorUtil.packageNameForGeneratedType;
12 import static org.opendaylight.controller.binding.generator.util.BindingGeneratorUtil.parseToClassName;
13 import static org.opendaylight.controller.binding.generator.util.BindingGeneratorUtil.parseToValidParamName;
14 import static org.opendaylight.controller.binding.generator.util.BindingGeneratorUtil.schemaNodeToTransferObjectBuilder;
15 import static org.opendaylight.controller.yang.model.util.SchemaContextUtil.findDataSchemaNode;
16 import static org.opendaylight.controller.yang.model.util.SchemaContextUtil.findParentModule;
18 import java.util.ArrayList;
19 import java.util.Collections;
20 import java.util.Comparator;
21 import java.util.HashMap;
22 import java.util.List;
25 import java.util.concurrent.Future;
27 import org.opendaylight.controller.binding.generator.util.ReferencedTypeImpl;
28 import org.opendaylight.controller.binding.generator.util.Types;
29 import org.opendaylight.controller.binding.generator.util.generated.type.builder.GeneratedTOBuilderImpl;
30 import org.opendaylight.controller.binding.generator.util.generated.type.builder.GeneratedTypeBuilderImpl;
31 import org.opendaylight.controller.sal.binding.generator.api.BindingGenerator;
32 import org.opendaylight.controller.sal.binding.generator.spi.TypeProvider;
33 import org.opendaylight.controller.sal.binding.model.api.GeneratedTransferObject;
34 import org.opendaylight.controller.sal.binding.model.api.GeneratedType;
35 import org.opendaylight.controller.sal.binding.model.api.Type;
36 import org.opendaylight.controller.sal.binding.model.api.type.builder.EnumBuilder;
37 import org.opendaylight.controller.sal.binding.model.api.type.builder.GeneratedPropertyBuilder;
38 import org.opendaylight.controller.sal.binding.model.api.type.builder.GeneratedTOBuilder;
39 import org.opendaylight.controller.sal.binding.model.api.type.builder.GeneratedTypeBuilder;
40 import org.opendaylight.controller.sal.binding.model.api.type.builder.MethodSignatureBuilder;
41 import org.opendaylight.controller.sal.binding.yang.types.GroupingDefinitionDependencySort;
42 import org.opendaylight.controller.sal.binding.yang.types.TypeProviderImpl;
43 import org.opendaylight.controller.yang.binding.Notification;
44 import org.opendaylight.controller.yang.common.QName;
45 import org.opendaylight.controller.yang.common.RpcResult;
46 import org.opendaylight.controller.yang.model.api.AugmentationSchema;
47 import org.opendaylight.controller.yang.model.api.ChoiceCaseNode;
48 import org.opendaylight.controller.yang.model.api.ChoiceNode;
49 import org.opendaylight.controller.yang.model.api.ContainerSchemaNode;
50 import org.opendaylight.controller.yang.model.api.DataNodeContainer;
51 import org.opendaylight.controller.yang.model.api.DataSchemaNode;
52 import org.opendaylight.controller.yang.model.api.GroupingDefinition;
53 import org.opendaylight.controller.yang.model.api.IdentitySchemaNode;
54 import org.opendaylight.controller.yang.model.api.LeafListSchemaNode;
55 import org.opendaylight.controller.yang.model.api.LeafSchemaNode;
56 import org.opendaylight.controller.yang.model.api.ListSchemaNode;
57 import org.opendaylight.controller.yang.model.api.Module;
58 import org.opendaylight.controller.yang.model.api.NotificationDefinition;
59 import org.opendaylight.controller.yang.model.api.RpcDefinition;
60 import org.opendaylight.controller.yang.model.api.SchemaContext;
61 import org.opendaylight.controller.yang.model.api.SchemaNode;
62 import org.opendaylight.controller.yang.model.api.SchemaPath;
63 import org.opendaylight.controller.yang.model.api.TypeDefinition;
64 import org.opendaylight.controller.yang.model.api.UsesNode;
65 import org.opendaylight.controller.yang.model.api.type.BitsTypeDefinition;
66 import org.opendaylight.controller.yang.model.api.type.EnumTypeDefinition;
67 import org.opendaylight.controller.yang.model.api.type.EnumTypeDefinition.EnumPair;
68 import org.opendaylight.controller.yang.model.util.DataNodeIterator;
69 import org.opendaylight.controller.yang.model.util.ExtendedType;
70 import org.opendaylight.controller.yang.model.util.SchemaContextUtil;
71 import org.opendaylight.controller.yang.model.util.UnionType;
73 public final class BindingGeneratorImpl implements BindingGenerator {
75 private Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders;
76 private TypeProvider typeProvider;
77 private SchemaContext schemaContext;
78 private final Map<SchemaPath, GeneratedType> allGroupings = new HashMap<SchemaPath, GeneratedType>();
80 public BindingGeneratorImpl() {
85 public List<Type> generateTypes(final SchemaContext context) {
86 if (context == null) {
87 throw new IllegalArgumentException("Schema Context reference cannot be NULL!");
89 if (context.getModules() == null) {
90 throw new IllegalStateException("Schema Context does not contain defined modules!");
93 final List<Type> generatedTypes = new ArrayList<>();
94 schemaContext = context;
95 typeProvider = new TypeProviderImpl(context);
96 final Set<Module> modules = context.getModules();
97 genTypeBuilders = new HashMap<>();
98 for (final Module module : modules) {
99 generatedTypes.addAll(allGroupingsToGenTypes(module));
100 generatedTypes.add(moduleToDataType(module));
101 generatedTypes.addAll(allTypeDefinitionsToGenTypes(module));
102 generatedTypes.addAll(allContainersToGenTypes(module));
103 generatedTypes.addAll(allListsToGenTypes(module));
104 generatedTypes.addAll(allChoicesToGenTypes(module));
105 generatedTypes.addAll(allAugmentsToGenTypes(module));
106 generatedTypes.addAll(allRPCMethodsToGenType(module));
107 generatedTypes.addAll(allNotificationsToGenType(module));
108 generatedTypes.addAll(allIdentitiesToGenTypes(module, context));
111 return generatedTypes;
115 public List<Type> generateTypes(final SchemaContext context, final Set<Module> modules) {
116 if (context == null) {
117 throw new IllegalArgumentException("Schema Context reference cannot be NULL!");
119 if (context.getModules() == null) {
120 throw new IllegalStateException("Schema Context does not contain defined modules!");
122 if (modules == null) {
123 throw new IllegalArgumentException("Sef of Modules cannot be NULL!");
126 final List<Type> filteredGenTypes = new ArrayList<>();
127 schemaContext = context;
128 typeProvider = new TypeProviderImpl(context);
129 final Set<Module> contextModules = context.getModules();
130 genTypeBuilders = new HashMap<>();
131 for (final Module contextModule : contextModules) {
132 final List<Type> generatedTypes = new ArrayList<>();
134 generatedTypes.addAll(allGroupingsToGenTypes(contextModule));
135 generatedTypes.add(moduleToDataType(contextModule));
136 generatedTypes.addAll(allTypeDefinitionsToGenTypes(contextModule));
137 generatedTypes.addAll(allContainersToGenTypes(contextModule));
138 generatedTypes.addAll(allListsToGenTypes(contextModule));
139 generatedTypes.addAll(allChoicesToGenTypes(contextModule));
140 generatedTypes.addAll(allAugmentsToGenTypes(contextModule));
141 generatedTypes.addAll(allRPCMethodsToGenType(contextModule));
142 generatedTypes.addAll(allNotificationsToGenType(contextModule));
143 generatedTypes.addAll(allIdentitiesToGenTypes(contextModule, context));
145 if (modules.contains(contextModule)) {
146 filteredGenTypes.addAll(generatedTypes);
149 return filteredGenTypes;
152 private List<Type> allTypeDefinitionsToGenTypes(final Module module) {
153 if (module == null) {
154 throw new IllegalArgumentException("Module reference cannot be NULL!");
156 if (module.getName() == null) {
157 throw new IllegalArgumentException("Module name cannot be NULL!");
159 if (module.getTypeDefinitions() == null) {
160 throw new IllegalArgumentException("Type Definitions for module " + module.getName() + " cannot be NULL!");
163 final Set<TypeDefinition<?>> typeDefinitions = module.getTypeDefinitions();
164 final List<Type> generatedTypes = new ArrayList<>();
165 for (final TypeDefinition<?> typedef : typeDefinitions) {
166 if (typedef != null) {
167 final Type type = ((TypeProviderImpl) typeProvider).generatedTypeForExtendedDefinitionType(typedef);
168 if ((type != null) && !generatedTypes.contains(type)) {
169 generatedTypes.add(type);
173 return generatedTypes;
176 private List<Type> allContainersToGenTypes(final Module module) {
177 if (module == null) {
178 throw new IllegalArgumentException("Module reference cannot be NULL!");
181 if (module.getName() == null) {
182 throw new IllegalArgumentException("Module name cannot be NULL!");
185 if (module.getChildNodes() == null) {
186 throw new IllegalArgumentException("Reference to Set of Child Nodes in module " + module.getName()
187 + " cannot be NULL!");
190 final List<Type> generatedTypes = new ArrayList<>();
191 final DataNodeIterator it = new DataNodeIterator(module);
192 final List<ContainerSchemaNode> schemaContainers = it.allContainers();
193 final String basePackageName = moduleNamespaceToPackageName(module);
194 for (final ContainerSchemaNode container : schemaContainers) {
195 if (!container.isAddedByUses()) {
196 generatedTypes.add(containerToGenType(basePackageName, container));
199 return generatedTypes;
202 private List<Type> allListsToGenTypes(final Module module) {
203 if (module == null) {
204 throw new IllegalArgumentException("Module reference cannot be NULL!");
207 if (module.getName() == null) {
208 throw new IllegalArgumentException("Module name cannot be NULL!");
211 if (module.getChildNodes() == null) {
212 throw new IllegalArgumentException("Reference to Set of Child Nodes in module " + module.getName()
213 + " cannot be NULL!");
216 final List<Type> generatedTypes = new ArrayList<>();
217 final DataNodeIterator it = new DataNodeIterator(module);
218 final List<ListSchemaNode> schemaLists = it.allLists();
219 final String basePackageName = moduleNamespaceToPackageName(module);
220 if (schemaLists != null) {
221 for (final ListSchemaNode list : schemaLists) {
222 if (!list.isAddedByUses()) {
223 generatedTypes.addAll(listToGenType(basePackageName, list));
227 return generatedTypes;
230 private List<GeneratedType> allChoicesToGenTypes(final Module module) {
231 if (module == null) {
232 throw new IllegalArgumentException("Module reference cannot be NULL!");
234 if (module.getName() == null) {
235 throw new IllegalArgumentException("Module name cannot be NULL!");
238 final DataNodeIterator it = new DataNodeIterator(module);
239 final List<ChoiceNode> choiceNodes = it.allChoices();
240 final String basePackageName = moduleNamespaceToPackageName(module);
242 final List<GeneratedType> generatedTypes = new ArrayList<>();
243 for (final ChoiceNode choice : choiceNodes) {
244 if ((choice != null) && !choice.isAddedByUses()) {
245 generatedTypes.addAll(choiceToGeneratedType(basePackageName, choice));
248 return generatedTypes;
251 private List<Type> allAugmentsToGenTypes(final Module module) {
252 if (module == null) {
253 throw new IllegalArgumentException("Module reference cannot be NULL!");
255 if (module.getName() == null) {
256 throw new IllegalArgumentException("Module name cannot be NULL!");
258 if (module.getChildNodes() == null) {
259 throw new IllegalArgumentException("Reference to Set of Augmentation Definitions in module "
260 + module.getName() + " cannot be NULL!");
263 final List<Type> generatedTypes = new ArrayList<>();
264 final String basePackageName = moduleNamespaceToPackageName(module);
265 final List<AugmentationSchema> augmentations = resolveAugmentations(module);
266 for (final AugmentationSchema augment : augmentations) {
267 generatedTypes.addAll(augmentationToGenTypes(basePackageName, augment));
269 return generatedTypes;
272 private List<AugmentationSchema> resolveAugmentations(final Module module) {
273 if (module == null) {
274 throw new IllegalArgumentException("Module reference cannot be NULL!");
276 if (module.getAugmentations() == null) {
277 throw new IllegalStateException("Augmentations Set cannot be NULL!");
280 final Set<AugmentationSchema> augmentations = module.getAugmentations();
281 final List<AugmentationSchema> sortedAugmentations = new ArrayList<>(augmentations);
282 Collections.sort(sortedAugmentations, new Comparator<AugmentationSchema>() {
285 public int compare(AugmentationSchema augSchema1, AugmentationSchema augSchema2) {
287 if (augSchema1.getTargetPath().getPath().size() > augSchema2.getTargetPath().getPath().size()) {
289 } else if (augSchema1.getTargetPath().getPath().size() < augSchema2.getTargetPath().getPath().size()) {
297 return sortedAugmentations;
300 private GeneratedType moduleToDataType(final Module module) {
301 if (module == null) {
302 throw new IllegalArgumentException("Module reference cannot be NULL!");
305 final GeneratedTypeBuilder moduleDataTypeBuilder = moduleTypeBuilder(module, "Data");
306 addInterfaceDefinition(module, moduleDataTypeBuilder);
308 final String basePackageName = moduleNamespaceToPackageName(module);
309 if (moduleDataTypeBuilder != null) {
310 final Set<DataSchemaNode> dataNodes = module.getChildNodes();
311 resolveDataSchemaNodes(basePackageName, moduleDataTypeBuilder, dataNodes);
313 return moduleDataTypeBuilder.toInstance();
316 private List<Type> allRPCMethodsToGenType(final Module module) {
317 if (module == null) {
318 throw new IllegalArgumentException("Module reference cannot be NULL!");
321 if (module.getName() == null) {
322 throw new IllegalArgumentException("Module name cannot be NULL!");
325 if (module.getChildNodes() == null) {
326 throw new IllegalArgumentException("Reference to Set of RPC Method Definitions in module "
327 + module.getName() + " cannot be NULL!");
330 final String basePackageName = moduleNamespaceToPackageName(module);
331 final Set<RpcDefinition> rpcDefinitions = module.getRpcs();
332 final List<Type> genRPCTypes = new ArrayList<>();
333 final GeneratedTypeBuilder interfaceBuilder = moduleTypeBuilder(module, "Service");
334 final Type future = Types.typeForClass(Future.class);
335 for (final RpcDefinition rpc : rpcDefinitions) {
338 String rpcName = parseToClassName(rpc.getQName().getLocalName());
339 String rpcMethodName = parseToValidParamName(rpcName);
340 MethodSignatureBuilder method = interfaceBuilder.addMethod(rpcMethodName);
342 final List<DataNodeIterator> rpcInOut = new ArrayList<>();
344 ContainerSchemaNode input = rpc.getInput();
345 ContainerSchemaNode output = rpc.getOutput();
348 rpcInOut.add(new DataNodeIterator(input));
349 GeneratedTypeBuilder inType = addRawInterfaceDefinition(basePackageName, input, rpcName);
350 addInterfaceDefinition(input, inType);
351 resolveDataSchemaNodes(basePackageName, inType, input.getChildNodes());
352 Type inTypeInstance = inType.toInstance();
353 genRPCTypes.add(inTypeInstance);
354 method.addParameter(inTypeInstance, "input");
357 Type outTypeInstance = Types.typeForClass(Void.class);
358 if (output != null) {
359 rpcInOut.add(new DataNodeIterator(output));
360 GeneratedTypeBuilder outType = addRawInterfaceDefinition(basePackageName, output, rpcName);
361 addInterfaceDefinition(output, outType);
362 resolveDataSchemaNodes(basePackageName, outType, output.getChildNodes());
363 outTypeInstance = outType.toInstance();
364 genRPCTypes.add(outTypeInstance);
368 final Type rpcRes = Types.parameterizedTypeFor(Types.typeForClass(RpcResult.class), outTypeInstance);
369 method.setReturnType(Types.parameterizedTypeFor(future, rpcRes));
370 for (DataNodeIterator it : rpcInOut) {
371 List<ContainerSchemaNode> nContainers = it.allContainers();
372 if ((nContainers != null) && !nContainers.isEmpty()) {
373 for (final ContainerSchemaNode container : nContainers) {
374 if (!container.isAddedByUses()) {
375 genRPCTypes.add(containerToGenType(basePackageName, container));
379 List<ListSchemaNode> nLists = it.allLists();
380 if ((nLists != null) && !nLists.isEmpty()) {
381 for (final ListSchemaNode list : nLists) {
382 if (!list.isAddedByUses()) {
383 genRPCTypes.addAll(listToGenType(basePackageName, list));
390 genRPCTypes.add(interfaceBuilder.toInstance());
394 private List<Type> allNotificationsToGenType(final Module module) {
395 if (module == null) {
396 throw new IllegalArgumentException("Module reference cannot be NULL!");
399 if (module.getName() == null) {
400 throw new IllegalArgumentException("Module name cannot be NULL!");
403 if (module.getChildNodes() == null) {
404 throw new IllegalArgumentException("Reference to Set of Notification Definitions in module "
405 + module.getName() + " cannot be NULL!");
408 final String basePackageName = moduleNamespaceToPackageName(module);
409 final List<Type> genNotifyTypes = new ArrayList<>();
410 final Set<NotificationDefinition> notifications = module.getNotifications();
412 for (final NotificationDefinition notification : notifications) {
413 if (notification != null) {
414 DataNodeIterator it = new DataNodeIterator(notification);
417 for (ContainerSchemaNode node : it.allContainers()) {
418 if (!node.isAddedByUses()) {
419 genNotifyTypes.add(containerToGenType(basePackageName, node));
423 for (ListSchemaNode node : it.allLists()) {
424 if (!node.isAddedByUses()) {
425 genNotifyTypes.addAll(listToGenType(basePackageName, node));
428 final GeneratedTypeBuilder notificationTypeBuilder = addDefaultInterfaceDefinition(basePackageName,
430 notificationTypeBuilder.addImplementsType(Types.typeForClass(Notification.class));
431 // Notification object
432 resolveDataSchemaNodes(basePackageName, notificationTypeBuilder, notification.getChildNodes());
433 genNotifyTypes.add(notificationTypeBuilder.toInstance());
436 return genNotifyTypes;
439 private List<Type> allIdentitiesToGenTypes(final Module module, final SchemaContext context) {
440 List<Type> genTypes = new ArrayList<>();
442 final Set<IdentitySchemaNode> schemaIdentities = module.getIdentities();
444 final String basePackageName = moduleNamespaceToPackageName(module);
446 if (schemaIdentities != null && !schemaIdentities.isEmpty()) {
447 for (final IdentitySchemaNode identity : schemaIdentities) {
448 genTypes.add(identityToGenType(basePackageName, identity, context));
454 private GeneratedType identityToGenType(final String basePackageName, final IdentitySchemaNode identity,
455 final SchemaContext context) {
456 if (identity == null) {
460 final String packageName = packageNameForGeneratedType(basePackageName, identity.getPath());
461 final String genTypeName = parseToClassName(identity.getQName().getLocalName());
462 final GeneratedTOBuilderImpl newType = new GeneratedTOBuilderImpl(packageName, genTypeName);
464 IdentitySchemaNode baseIdentity = identity.getBaseIdentity();
465 if (baseIdentity != null) {
466 Module baseIdentityParentModule = SchemaContextUtil.findParentModule(context, baseIdentity);
468 final String returnTypePkgName = moduleNamespaceToPackageName(baseIdentityParentModule);
469 final String returnTypeName = parseToClassName(baseIdentity.getQName().getLocalName());
471 GeneratedTransferObject gto = new GeneratedTOBuilderImpl(returnTypePkgName, returnTypeName).toInstance();
472 newType.setExtendsType(gto);
474 newType.setExtendsType(Types.getBaseIdentityTO());
476 newType.setAbstract(true);
477 return newType.toInstance();
480 private List<Type> allGroupingsToGenTypes(final Module module) {
481 final List<Type> genTypes = new ArrayList<>();
482 final String basePackageName = moduleNamespaceToPackageName(module);
483 final Set<GroupingDefinition> groupings = module.getGroupings();
484 List<GroupingDefinition> groupingsSortedByDependencies;
485 // groupingsSortedByDependencies =
486 // sortGroupingDefinitionsByUses(groupings);
487 groupingsSortedByDependencies = GroupingDefinitionDependencySort.sort(groupings);
489 for (final GroupingDefinition grouping : groupingsSortedByDependencies) {
490 GeneratedType genType = groupingToGenType(basePackageName, grouping);
491 genTypes.add(genType);
492 SchemaPath schemaPath = grouping.getPath();
493 allGroupings.put(schemaPath, genType);
498 private GeneratedType groupingToGenType(final String basePackageName, GroupingDefinition grouping) {
499 if (grouping == null) {
503 final String packageName = packageNameForGeneratedType(basePackageName, grouping.getPath());
504 final Set<DataSchemaNode> schemaNodes = grouping.getChildNodes();
505 final GeneratedTypeBuilder typeBuilder = addDefaultInterfaceDefinition(packageName, grouping);
507 resolveDataSchemaNodes(basePackageName, typeBuilder, schemaNodes);
508 return typeBuilder.toInstance();
511 private EnumTypeDefinition enumTypeDefFromExtendedType(final TypeDefinition<?> typeDefinition) {
512 if (typeDefinition != null) {
513 if (typeDefinition.getBaseType() instanceof EnumTypeDefinition) {
514 return (EnumTypeDefinition) typeDefinition.getBaseType();
515 } else if (typeDefinition.getBaseType() instanceof ExtendedType) {
516 return enumTypeDefFromExtendedType(typeDefinition.getBaseType());
522 private EnumBuilder resolveInnerEnumFromTypeDefinition(final EnumTypeDefinition enumTypeDef, final String enumName,
523 final GeneratedTypeBuilder typeBuilder) {
524 if ((enumTypeDef != null) && (typeBuilder != null) && (enumTypeDef.getQName() != null)
525 && (enumTypeDef.getQName().getLocalName() != null)) {
527 final String enumerationName = parseToClassName(enumName);
528 final EnumBuilder enumBuilder = typeBuilder.addEnumeration(enumerationName);
530 if (enumBuilder != null) {
531 final List<EnumPair> enums = enumTypeDef.getValues();
534 for (final EnumPair enumPair : enums) {
535 if (enumPair != null) {
536 final String enumPairName = parseToClassName(enumPair.getName());
537 Integer enumPairValue = enumPair.getValue();
539 if (enumPairValue == null) {
540 enumPairValue = listIndex;
542 enumBuilder.addValue(enumPairName, enumPairValue);
553 private GeneratedTypeBuilder moduleTypeBuilder(final Module module, final String postfix) {
554 if (module == null) {
555 throw new IllegalArgumentException("Module reference cannot be NULL!");
557 String packageName = moduleNamespaceToPackageName(module);
558 final String moduleName = parseToClassName(module.getName()) + postfix;
560 return new GeneratedTypeBuilderImpl(packageName, moduleName);
564 private List<Type> augmentationToGenTypes(final String augmentPackageName, final AugmentationSchema augSchema) {
565 if (augmentPackageName == null) {
566 throw new IllegalArgumentException("Package Name cannot be NULL!");
568 if (augSchema == null) {
569 throw new IllegalArgumentException("Augmentation Schema cannot be NULL!");
571 if (augSchema.getTargetPath() == null) {
572 throw new IllegalStateException("Augmentation Schema does not contain Target Path (Target Path is NULL).");
575 final List<Type> genTypes = new ArrayList<>();
577 // EVERY augmented interface will extends Augmentation<T> interface
578 // and DataObject interface!!!
579 final SchemaPath targetPath = augSchema.getTargetPath();
580 final DataSchemaNode targetSchemaNode = findDataSchemaNode(schemaContext, targetPath);
581 if ((targetSchemaNode != null) && (targetSchemaNode.getQName() != null)
582 && (targetSchemaNode.getQName().getLocalName() != null)) {
583 final Module targetModule = findParentModule(schemaContext, targetSchemaNode);
584 final String targetBasePackage = moduleNamespaceToPackageName(targetModule);
585 final String targetPackageName = packageNameForGeneratedType(targetBasePackage, targetSchemaNode.getPath());
586 final String targetSchemaNodeName = targetSchemaNode.getQName().getLocalName();
587 final Set<DataSchemaNode> augChildNodes = augSchema.getChildNodes();
589 if (!(targetSchemaNode instanceof ChoiceNode)) {
590 final GeneratedTypeBuilder augTypeBuilder = addRawAugmentGenTypeDefinition(augmentPackageName,
591 targetPackageName, targetSchemaNodeName, augSchema);
592 addInterfaceDefinition(augSchema, augTypeBuilder);
594 final GeneratedType augType = augTypeBuilder.toInstance();
595 genTypes.add(augType);
597 final Type refChoiceType = new ReferencedTypeImpl(targetPackageName,
598 parseToClassName(targetSchemaNodeName));
599 final ChoiceNode choiceTarget = (ChoiceNode) targetSchemaNode;
600 final Set<ChoiceCaseNode> choiceCaseNodes = choiceTarget.getCases();
601 genTypes.addAll(augmentCasesToGenTypes(augmentPackageName, refChoiceType, choiceCaseNodes));
603 genTypes.addAll(augmentationBodyToGenTypes(augmentPackageName, augChildNodes));
608 private List<GeneratedType> augmentCasesToGenTypes(final String augmentPackageName, final Type refChoiceType,
609 final Set<ChoiceCaseNode> choiceCaseNodes) {
610 if (augmentPackageName == null) {
611 throw new IllegalArgumentException("Augment Package Name string cannot be NULL!");
613 if (choiceCaseNodes == null) {
614 throw new IllegalArgumentException("Set of Choice Case Nodes cannot be NULL!");
616 final List<GeneratedType> genTypes = generateTypesFromAugmentedChoiceCases(augmentPackageName, refChoiceType,
621 private GeneratedTypeBuilder addRawAugmentGenTypeDefinition(final String augmentPackageName,
622 final String targetPackageName, final String targetSchemaNodeName, final AugmentationSchema augSchema) {
623 final String targetTypeName = parseToClassName(targetSchemaNodeName);
624 Map<String, GeneratedTypeBuilder> augmentBuilders = genTypeBuilders.get(augmentPackageName);
625 if (augmentBuilders == null) {
626 augmentBuilders = new HashMap<>();
627 genTypeBuilders.put(augmentPackageName, augmentBuilders);
630 final String augTypeName = augGenTypeName(augmentBuilders, targetTypeName);
631 final Type targetTypeRef = new ReferencedTypeImpl(targetPackageName, targetTypeName);
632 final Set<DataSchemaNode> augChildNodes = augSchema.getChildNodes();
634 final GeneratedTypeBuilder augTypeBuilder = new GeneratedTypeBuilderImpl(augmentPackageName, augTypeName);
636 augTypeBuilder.addImplementsType(Types.DATA_OBJECT);
637 augTypeBuilder.addImplementsType(Types.augmentationTypeFor(targetTypeRef));
639 augSchemaNodeToMethods(augmentPackageName, augTypeBuilder, augChildNodes);
640 augmentBuilders.put(augTypeName, augTypeBuilder);
641 return augTypeBuilder;
644 private List<Type> augmentationBodyToGenTypes(final String augBasePackageName,
645 final Set<DataSchemaNode> augChildNodes) {
646 final List<Type> genTypes = new ArrayList<>();
647 final List<DataNodeIterator> augSchemaIts = new ArrayList<>();
648 for (final DataSchemaNode childNode : augChildNodes) {
649 if (childNode instanceof DataNodeContainer) {
650 augSchemaIts.add(new DataNodeIterator((DataNodeContainer) childNode));
652 if (childNode instanceof ContainerSchemaNode) {
653 genTypes.add(containerToGenType(augBasePackageName, (ContainerSchemaNode) childNode));
654 } else if (childNode instanceof ListSchemaNode) {
655 genTypes.addAll(listToGenType(augBasePackageName, (ListSchemaNode) childNode));
657 } else if (childNode instanceof ChoiceNode) {
658 final ChoiceNode choice = (ChoiceNode) childNode;
659 for (final ChoiceCaseNode caseNode : choice.getCases()) {
660 augSchemaIts.add(new DataNodeIterator(caseNode));
662 genTypes.addAll(choiceToGeneratedType(augBasePackageName, (ChoiceNode) childNode));
666 for (final DataNodeIterator it : augSchemaIts) {
667 final List<ContainerSchemaNode> augContainers = it.allContainers();
668 final List<ListSchemaNode> augLists = it.allLists();
669 final List<ChoiceNode> augChoices = it.allChoices();
671 if (augContainers != null) {
672 for (final ContainerSchemaNode container : augContainers) {
673 genTypes.add(containerToGenType(augBasePackageName, container));
676 if (augLists != null) {
677 for (final ListSchemaNode list : augLists) {
678 genTypes.addAll(listToGenType(augBasePackageName, list));
681 if (augChoices != null) {
682 for (final ChoiceNode choice : augChoices) {
683 genTypes.addAll(choiceToGeneratedType(augBasePackageName, choice));
690 private String augGenTypeName(final Map<String, GeneratedTypeBuilder> builders, final String genTypeName) {
691 String augTypeName = genTypeName;
694 while ((builders != null) && builders.containsKey(genTypeName + index)) {
697 augTypeName += index;
701 private GeneratedType containerToGenType(final String basePackageName, ContainerSchemaNode containerNode) {
702 if (containerNode == null) {
706 final String packageName = packageNameForGeneratedType(basePackageName, containerNode.getPath());
707 final Set<DataSchemaNode> schemaNodes = containerNode.getChildNodes();
708 final GeneratedTypeBuilder typeBuilder = addDefaultInterfaceDefinition(packageName, containerNode);
710 resolveDataSchemaNodes(basePackageName, typeBuilder, schemaNodes);
711 return typeBuilder.toInstance();
714 private GeneratedTypeBuilder resolveDataSchemaNodes(final String basePackageName,
715 final GeneratedTypeBuilder typeBuilder, final Set<DataSchemaNode> schemaNodes) {
716 if ((schemaNodes != null) && (typeBuilder != null)) {
717 for (final DataSchemaNode schemaNode : schemaNodes) {
718 if (schemaNode.isAugmenting() || schemaNode.isAddedByUses()) {
721 addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode, typeBuilder);
727 private GeneratedTypeBuilder augSchemaNodeToMethods(final String basePackageName,
728 final GeneratedTypeBuilder typeBuilder, final Set<DataSchemaNode> schemaNodes) {
729 if ((schemaNodes != null) && (typeBuilder != null)) {
730 for (final DataSchemaNode schemaNode : schemaNodes) {
731 if (schemaNode.isAugmenting()) {
732 addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode, typeBuilder);
739 private void addSchemaNodeToBuilderAsMethod(final String basePackageName, final DataSchemaNode schemaNode,
740 final GeneratedTypeBuilder typeBuilder) {
741 if (schemaNode != null && typeBuilder != null) {
742 if (schemaNode instanceof LeafSchemaNode) {
743 resolveLeafSchemaNodeAsMethod(typeBuilder, (LeafSchemaNode) schemaNode);
744 } else if (schemaNode instanceof LeafListSchemaNode) {
745 resolveLeafListSchemaNode(typeBuilder, (LeafListSchemaNode) schemaNode);
746 } else if (schemaNode instanceof ContainerSchemaNode) {
747 resolveContainerSchemaNode(basePackageName, typeBuilder, (ContainerSchemaNode) schemaNode);
748 } else if (schemaNode instanceof ListSchemaNode) {
749 resolveListSchemaNode(basePackageName, typeBuilder, (ListSchemaNode) schemaNode);
750 } else if (schemaNode instanceof ChoiceNode) {
751 resolveChoiceSchemaNode(basePackageName, typeBuilder, (ChoiceNode) schemaNode);
756 private void resolveChoiceSchemaNode(final String basePackageName, final GeneratedTypeBuilder typeBuilder,
757 final ChoiceNode choiceNode) {
758 if (basePackageName == null) {
759 throw new IllegalArgumentException("Base Package Name cannot be NULL!");
761 if (typeBuilder == null) {
762 throw new IllegalArgumentException("Generated Type Builder cannot be NULL!");
764 if (choiceNode == null) {
765 throw new IllegalArgumentException("Choice Schema Node cannot be NULL!");
768 final String choiceName = choiceNode.getQName().getLocalName();
769 if (choiceName != null && !choiceNode.isAddedByUses()) {
770 final String packageName = packageNameForGeneratedType(basePackageName, choiceNode.getPath());
771 final GeneratedTypeBuilder choiceType = addDefaultInterfaceDefinition(packageName, choiceNode);
772 constructGetter(typeBuilder, choiceName, choiceNode.getDescription(), choiceType);
776 private List<GeneratedType> choiceToGeneratedType(final String basePackageName, final ChoiceNode choiceNode) {
777 if (basePackageName == null) {
778 throw new IllegalArgumentException("Base Package Name cannot be NULL!");
780 if (choiceNode == null) {
781 throw new IllegalArgumentException("Choice Schema Node cannot be NULL!");
784 final List<GeneratedType> generatedTypes = new ArrayList<>();
785 final String packageName = packageNameForGeneratedType(basePackageName, choiceNode.getPath());
786 final GeneratedTypeBuilder choiceTypeBuilder = addRawInterfaceDefinition(packageName, choiceNode);
787 choiceTypeBuilder.addImplementsType(Types.DATA_OBJECT);
788 final GeneratedType choiceType = choiceTypeBuilder.toInstance();
790 generatedTypes.add(choiceType);
791 final Set<ChoiceCaseNode> caseNodes = choiceNode.getCases();
792 if ((caseNodes != null) && !caseNodes.isEmpty()) {
793 generatedTypes.addAll(generateTypesFromChoiceCases(basePackageName, choiceType, caseNodes));
795 return generatedTypes;
798 private List<GeneratedType> generateTypesFromChoiceCases(final String basePackageName, final Type refChoiceType,
799 final Set<ChoiceCaseNode> caseNodes) {
800 if (basePackageName == null) {
801 throw new IllegalArgumentException("Base Package Name cannot be NULL!");
803 if (refChoiceType == null) {
804 throw new IllegalArgumentException("Referenced Choice Type cannot be NULL!");
806 if (caseNodes == null) {
807 throw new IllegalArgumentException("Set of Choice Case Nodes cannot be NULL!");
810 final List<GeneratedType> generatedTypes = new ArrayList<>();
811 for (final ChoiceCaseNode caseNode : caseNodes) {
812 if (caseNode != null && !caseNode.isAddedByUses()) {
813 final String packageName = packageNameForGeneratedType(basePackageName, caseNode.getPath());
814 final GeneratedTypeBuilder caseTypeBuilder = addDefaultInterfaceDefinition(packageName, caseNode);
815 caseTypeBuilder.addImplementsType(refChoiceType);
817 final Set<DataSchemaNode> childNodes = caseNode.getChildNodes();
818 if (childNodes != null) {
819 resolveDataSchemaNodes(basePackageName, caseTypeBuilder, childNodes);
821 generatedTypes.add(caseTypeBuilder.toInstance());
825 return generatedTypes;
828 private List<GeneratedType> generateTypesFromAugmentedChoiceCases(final String basePackageName,
829 final Type refChoiceType, final Set<ChoiceCaseNode> caseNodes) {
830 if (basePackageName == null) {
831 throw new IllegalArgumentException("Base Package Name cannot be NULL!");
833 if (refChoiceType == null) {
834 throw new IllegalArgumentException("Referenced Choice Type cannot be NULL!");
836 if (caseNodes == null) {
837 throw new IllegalArgumentException("Set of Choice Case Nodes cannot be NULL!");
840 final List<GeneratedType> generatedTypes = new ArrayList<>();
841 for (final ChoiceCaseNode caseNode : caseNodes) {
842 if (caseNode != null && caseNode.isAugmenting()) {
843 final String packageName = packageNameForGeneratedType(basePackageName, caseNode.getPath());
844 final GeneratedTypeBuilder caseTypeBuilder = addDefaultInterfaceDefinition(packageName, caseNode);
845 caseTypeBuilder.addImplementsType(refChoiceType);
847 final Set<DataSchemaNode> childNodes = caseNode.getChildNodes();
848 if (childNodes != null) {
849 resolveDataSchemaNodes(basePackageName, caseTypeBuilder, childNodes);
851 generatedTypes.add(caseTypeBuilder.toInstance());
855 return generatedTypes;
858 private boolean resolveLeafSchemaNodeAsMethod(final GeneratedTypeBuilder typeBuilder, final LeafSchemaNode leaf) {
859 if ((leaf != null) && (typeBuilder != null)) {
860 final String leafName = leaf.getQName().getLocalName();
861 String leafDesc = leaf.getDescription();
862 if (leafDesc == null) {
866 if (leafName != null && !leaf.isAddedByUses()) {
867 final TypeDefinition<?> typeDef = leaf.getType();
869 Type returnType = null;
870 if (typeDef instanceof EnumTypeDefinition) {
871 returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef);
872 final EnumTypeDefinition enumTypeDef = enumTypeDefFromExtendedType(typeDef);
873 final EnumBuilder enumBuilder = resolveInnerEnumFromTypeDefinition(enumTypeDef, leafName,
876 if (enumBuilder != null) {
877 returnType = new ReferencedTypeImpl(enumBuilder.getPackageName(), enumBuilder.getName());
879 ((TypeProviderImpl) typeProvider).putReferencedType(leaf.getPath(), returnType);
880 } else if (typeDef instanceof UnionType) {
881 GeneratedTOBuilder genTOBuilder = addEnclosedTOToTypeBuilder(typeDef, typeBuilder, leafName);
882 if (genTOBuilder != null) {
883 returnType = new ReferencedTypeImpl(genTOBuilder.getPackageName(), genTOBuilder.getName());
885 } else if (typeDef instanceof BitsTypeDefinition) {
886 GeneratedTOBuilder genTOBuilder = addEnclosedTOToTypeBuilder(typeDef, typeBuilder, leafName);
887 if (genTOBuilder != null) {
888 returnType = new ReferencedTypeImpl(genTOBuilder.getPackageName(), genTOBuilder.getName());
891 returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef);
893 if (returnType != null) {
894 constructGetter(typeBuilder, leafName, leafDesc, returnType);
902 private boolean resolveLeafSchemaNodeAsProperty(final GeneratedTOBuilder toBuilder, final LeafSchemaNode leaf,
903 boolean isReadOnly) {
904 if ((leaf != null) && (toBuilder != null)) {
905 final String leafName = leaf.getQName().getLocalName();
906 String leafDesc = leaf.getDescription();
907 if (leafDesc == null) {
911 if (leafName != null && !leaf.isAddedByUses()) {
912 final TypeDefinition<?> typeDef = leaf.getType();
914 // TODO: properly resolve enum types
915 final Type returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef);
917 if (returnType != null) {
918 final GeneratedPropertyBuilder propBuilder = toBuilder.addProperty(parseToClassName(leafName));
920 propBuilder.setReadOnly(isReadOnly);
921 propBuilder.setReturnType(returnType);
922 propBuilder.setComment(leafDesc);
924 toBuilder.addEqualsIdentity(propBuilder);
925 toBuilder.addHashIdentity(propBuilder);
926 toBuilder.addToStringProperty(propBuilder);
935 private boolean resolveLeafListSchemaNode(final GeneratedTypeBuilder typeBuilder, final LeafListSchemaNode node) {
936 if ((node != null) && (typeBuilder != null)) {
937 final String nodeName = node.getQName().getLocalName();
938 String nodeDesc = node.getDescription();
939 if (nodeDesc == null) {
943 if (nodeName != null && !node.isAddedByUses()) {
944 final TypeDefinition<?> type = node.getType();
945 final Type listType = Types.listTypeFor(typeProvider.javaTypeForSchemaDefinitionType(type));
947 constructGetter(typeBuilder, nodeName, nodeDesc, listType);
954 private boolean resolveContainerSchemaNode(final String basePackageName, final GeneratedTypeBuilder typeBuilder,
955 final ContainerSchemaNode containerNode) {
956 if ((containerNode != null) && (typeBuilder != null)) {
957 final String nodeName = containerNode.getQName().getLocalName();
959 if (nodeName != null && !containerNode.isAddedByUses()) {
960 final String packageName = packageNameForGeneratedType(basePackageName, containerNode.getPath());
962 final GeneratedTypeBuilder rawGenType = addDefaultInterfaceDefinition(packageName, containerNode);
963 constructGetter(typeBuilder, nodeName, containerNode.getDescription(), rawGenType);
971 private boolean resolveListSchemaNode(final String basePackageName, final GeneratedTypeBuilder typeBuilder,
972 final ListSchemaNode schemaNode) {
973 if ((schemaNode != null) && (typeBuilder != null)) {
974 final String listName = schemaNode.getQName().getLocalName();
976 if (listName != null && !schemaNode.isAddedByUses()) {
977 final String packageName = packageNameForGeneratedType(basePackageName, schemaNode.getPath());
978 final GeneratedTypeBuilder rawGenType = addDefaultInterfaceDefinition(packageName, schemaNode);
979 constructGetter(typeBuilder, listName, schemaNode.getDescription(), Types.listTypeFor(rawGenType));
987 * Method instantiates new Generated Type Builder and sets the implements
988 * definitions of Data Object and Augmentable.
991 * Generated Type Package Name
993 * Schema Node definition
994 * @return Generated Type Builder instance for Schema Node definition
996 private GeneratedTypeBuilder addDefaultInterfaceDefinition(final String packageName, final SchemaNode schemaNode) {
997 final GeneratedTypeBuilder builder = addRawInterfaceDefinition(packageName, schemaNode, "");
998 builder.addImplementsType(Types.DATA_OBJECT);
999 if (!(schemaNode instanceof GroupingDefinition)) {
1000 builder.addImplementsType(Types.augmentableTypeFor(builder));
1003 if (schemaNode instanceof DataNodeContainer) {
1004 addInterfaceDefinition((DataNodeContainer) schemaNode, builder);
1012 * @param packageName
1016 private GeneratedTypeBuilder addRawInterfaceDefinition(final String packageName, final SchemaNode schemaNode) {
1017 return addRawInterfaceDefinition(packageName, schemaNode, "");
1020 private GeneratedTypeBuilder addRawInterfaceDefinition(final String packageName, final SchemaNode schemaNode,
1021 final String prefix) {
1022 if (schemaNode == null) {
1023 throw new IllegalArgumentException("Data Schema Node cannot be NULL!");
1025 if (packageName == null) {
1026 throw new IllegalArgumentException("Package Name for Generated Type cannot be NULL!");
1028 if (schemaNode.getQName() == null) {
1029 throw new IllegalArgumentException("QName for Data Schema Node cannot be NULL!");
1031 final String schemaNodeName = schemaNode.getQName().getLocalName();
1032 if (schemaNodeName == null) {
1033 throw new IllegalArgumentException("Local Name of QName for Data Schema Node cannot be NULL!");
1036 final String genTypeName;
1037 if (prefix == null) {
1038 genTypeName = parseToClassName(schemaNodeName);
1040 genTypeName = prefix + parseToClassName(schemaNodeName);
1043 final GeneratedTypeBuilder newType = new GeneratedTypeBuilderImpl(packageName, genTypeName);
1044 if (!genTypeBuilders.containsKey(packageName)) {
1045 final Map<String, GeneratedTypeBuilder> builders = new HashMap<>();
1046 builders.put(genTypeName, newType);
1047 genTypeBuilders.put(packageName, builders);
1049 final Map<String, GeneratedTypeBuilder> builders = genTypeBuilders.get(packageName);
1050 if (!builders.containsKey(genTypeName)) {
1051 builders.put(genTypeName, newType);
1057 private String getterMethodName(final String methodName) {
1058 final StringBuilder method = new StringBuilder();
1059 method.append("get");
1060 method.append(parseToClassName(methodName));
1061 return method.toString();
1064 private String setterMethodName(final String methodName) {
1065 final StringBuilder method = new StringBuilder();
1066 method.append("set");
1067 method.append(parseToClassName(methodName));
1068 return method.toString();
1071 private MethodSignatureBuilder constructGetter(final GeneratedTypeBuilder interfaceBuilder,
1072 final String schemaNodeName, final String comment, final Type returnType) {
1073 final MethodSignatureBuilder getMethod = interfaceBuilder.addMethod(getterMethodName(schemaNodeName));
1075 getMethod.setComment(comment);
1076 getMethod.setReturnType(returnType);
1081 private MethodSignatureBuilder constructSetter(final GeneratedTypeBuilder interfaceBuilder,
1082 final String schemaNodeName, final String comment, final Type parameterType) {
1083 final MethodSignatureBuilder setMethod = interfaceBuilder.addMethod(setterMethodName(schemaNodeName));
1085 setMethod.setComment(comment);
1086 setMethod.addParameter(parameterType, parseToValidParamName(schemaNodeName));
1087 setMethod.setReturnType(Types.voidType());
1092 private List<Type> listToGenType(final String basePackageName, final ListSchemaNode list) {
1093 if (basePackageName == null) {
1094 throw new IllegalArgumentException("Package Name for Generated Type cannot be NULL!");
1097 throw new IllegalArgumentException("List Schema Node cannot be NULL!");
1100 final String packageName = packageNameForGeneratedType(basePackageName, list.getPath());
1101 final GeneratedTypeBuilder typeBuilder = resolveListTypeBuilder(packageName, list);
1102 final List<String> listKeys = listKeys(list);
1103 GeneratedTOBuilder genTOBuilder = resolveListKeyTOBuilder(packageName, list, listKeys);
1105 final Set<DataSchemaNode> schemaNodes = list.getChildNodes();
1107 for (final DataSchemaNode schemaNode : schemaNodes) {
1108 if (schemaNode.isAugmenting()) {
1111 addSchemaNodeToListBuilders(basePackageName, schemaNode, typeBuilder, genTOBuilder, listKeys);
1113 return typeBuildersToGenTypes(typeBuilder, genTOBuilder);
1116 private void addSchemaNodeToListBuilders(final String basePackageName, final DataSchemaNode schemaNode,
1117 final GeneratedTypeBuilder typeBuilder, final GeneratedTOBuilder genTOBuilder, final List<String> listKeys) {
1118 if (schemaNode == null) {
1119 throw new IllegalArgumentException("Data Schema Node cannot be NULL!");
1122 if (typeBuilder == null) {
1123 throw new IllegalArgumentException("Generated Type Builder cannot be NULL!");
1126 if (schemaNode instanceof LeafSchemaNode) {
1127 final LeafSchemaNode leaf = (LeafSchemaNode) schemaNode;
1128 if (!isPartOfListKey(leaf, listKeys)) {
1129 resolveLeafSchemaNodeAsMethod(typeBuilder, leaf);
1131 resolveLeafSchemaNodeAsProperty(genTOBuilder, leaf, true);
1133 } else if (schemaNode instanceof LeafListSchemaNode) {
1134 resolveLeafListSchemaNode(typeBuilder, (LeafListSchemaNode) schemaNode);
1135 } else if (schemaNode instanceof ContainerSchemaNode) {
1136 resolveContainerSchemaNode(basePackageName, typeBuilder, (ContainerSchemaNode) schemaNode);
1137 } else if (schemaNode instanceof ListSchemaNode) {
1138 resolveListSchemaNode(basePackageName, typeBuilder, (ListSchemaNode) schemaNode);
1142 private List<Type> typeBuildersToGenTypes(final GeneratedTypeBuilder typeBuilder, GeneratedTOBuilder genTOBuilder) {
1143 final List<Type> genTypes = new ArrayList<>();
1144 if (typeBuilder == null) {
1145 throw new IllegalArgumentException("Generated Type Builder cannot be NULL!");
1148 if (genTOBuilder != null) {
1149 final GeneratedTransferObject genTO = genTOBuilder.toInstance();
1150 constructGetter(typeBuilder, genTO.getName(), "Returns Primary Key of Yang List Type", genTO);
1151 genTypes.add(genTO);
1153 genTypes.add(typeBuilder.toInstance());
1161 private GeneratedTOBuilder resolveListKey(final String packageName, final ListSchemaNode list) {
1162 final String listName = list.getQName().getLocalName() + "Key";
1163 return schemaNodeToTransferObjectBuilder(packageName, list, listName);
1166 private boolean isPartOfListKey(final LeafSchemaNode leaf, final List<String> keys) {
1167 if ((leaf != null) && (keys != null) && (leaf.getQName() != null)) {
1168 final String leafName = leaf.getQName().getLocalName();
1169 if (keys.contains(leafName)) {
1176 private List<String> listKeys(final ListSchemaNode list) {
1177 final List<String> listKeys = new ArrayList<>();
1179 if (list.getKeyDefinition() != null) {
1180 final List<QName> keyDefinitions = list.getKeyDefinition();
1182 for (final QName keyDefinition : keyDefinitions) {
1183 listKeys.add(keyDefinition.getLocalName());
1189 private GeneratedTypeBuilder resolveListTypeBuilder(final String packageName, final ListSchemaNode list) {
1190 if (packageName == null) {
1191 throw new IllegalArgumentException("Package Name for Generated Type cannot be NULL!");
1194 throw new IllegalArgumentException("List Schema Node cannot be NULL!");
1197 final String schemaNodeName = list.getQName().getLocalName();
1198 final String genTypeName = parseToClassName(schemaNodeName);
1200 GeneratedTypeBuilder typeBuilder = null;
1201 final Map<String, GeneratedTypeBuilder> builders = genTypeBuilders.get(packageName);
1202 if (builders != null) {
1203 typeBuilder = builders.get(genTypeName);
1205 if (typeBuilder == null) {
1206 typeBuilder = addDefaultInterfaceDefinition(packageName, list);
1211 private GeneratedTOBuilder resolveListKeyTOBuilder(final String packageName, final ListSchemaNode list,
1212 final List<String> listKeys) {
1213 GeneratedTOBuilder genTOBuilder = null;
1214 if (listKeys.size() > 0) {
1215 genTOBuilder = resolveListKey(packageName, list);
1217 return genTOBuilder;
1220 private GeneratedTOBuilder addEnclosedTOToTypeBuilder(TypeDefinition<?> typeDef, GeneratedTypeBuilder typeBuilder,
1222 String className = parseToClassName(leafName);
1223 GeneratedTOBuilder genTOBuilder = null;
1224 if (typeDef instanceof UnionType) {
1225 genTOBuilder = ((TypeProviderImpl) typeProvider).addUnionGeneratedTypeDefinition(
1226 typeBuilder.getFullyQualifiedName(), typeDef, className);
1227 } else if (typeDef instanceof BitsTypeDefinition) {
1228 genTOBuilder = ((TypeProviderImpl) typeProvider).bitsTypedefToTransferObject(
1229 typeBuilder.getFullyQualifiedName(), typeDef, className);
1231 if (genTOBuilder != null) {
1232 typeBuilder.addEnclosingTransferObject(genTOBuilder);
1233 return genTOBuilder;
1240 * Adds the implemented types to type builder. The method passes through the
1241 * list of elements which contains {@code dataNodeContainer} and adds them
1242 * as <i>implements type</i> to <code>builder</code>
1244 * @param dataNodeContainer
1245 * element which contains the list of used YANG groupings
1247 * builder to which are added implemented types according to
1248 * <code>dataNodeContainer</code>
1249 * @return generated type builder which contains implemented types
1251 private GeneratedTypeBuilder addInterfaceDefinition(final DataNodeContainer dataNodeContainer,
1252 final GeneratedTypeBuilder builder) {
1253 for (UsesNode usesNode : dataNodeContainer.getUses()) {
1254 if (usesNode.getGroupingPath() != null) {
1255 GeneratedType genType = allGroupings.get(usesNode.getGroupingPath());
1256 builder.addImplementsType(new ReferencedTypeImpl(genType.getPackageName(), genType.getName()));