import java.util.Iterator;
import java.util.List;
import java.util.Map;
+import java.util.Map.Entry;
import java.util.Set;
-import org.opendaylight.mdsal.binding2.generator.util.BindingGeneratorUtil;
-import org.opendaylight.mdsal.binding2.generator.util.ReferencedTypeImpl;
+import java.util.stream.Collectors;
+import org.opendaylight.mdsal.binding.javav2.generator.spi.TypeProvider;
+import org.opendaylight.mdsal.binding.javav2.generator.util.BindingGeneratorUtil;
import org.opendaylight.mdsal.binding.javav2.model.api.Type;
import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedTypeBuilder;
-import org.opendaylight.mdsal.binding2.util.BindingMapping;
+import org.opendaylight.mdsal.binding.javav2.spec.runtime.BindingNamespaceType;
+import org.opendaylight.mdsal.binding.javav2.util.BindingMapping;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
return otherIt.hasNext() ? -1 : 0;
};
+ /**
+ * Comparator based on augment target path.
+ */
+ private static final Comparator<Map.Entry<SchemaPath, List<AugmentationSchema>>> AUGMENTS_COMP = (o1, o2) -> {
+ final Iterator<QName> thisIt = o1.getKey().getPathFromRoot().iterator();
+ final Iterator<QName> otherIt = o2.getKey().getPathFromRoot().iterator();
+
+ while (thisIt.hasNext()) {
+ if (!otherIt.hasNext()) {
+ return 1;
+ }
+
+ final int comp = thisIt.next().compareTo(otherIt.next());
+ if (comp != 0) {
+ return comp;
+ }
+ }
+
+ return otherIt.hasNext() ? -1 : 0;
+ };
+
private AugmentToGenType() {
throw new UnsupportedOperationException("Utility class");
}
* @param module
* module from which is obtained list of all augmentation objects
* to iterate over them
- * @param schemaContext
- * @param genCtx
- * @param genTypeBuilders
+ * @param schemaContext actual schema context
+ * @param typeProvider actual type provider instance
+ * @param genCtx generated input context
+ * @param genTypeBuilders auxiliary type builders map
+ * @param verboseClassComments verbosity switch
*
* @throws IllegalArgumentException
* <ul>
* if set of augmentations from module is null
*/
static Map<Module, ModuleContext> generate(final Module module, final SchemaContext schemaContext,
- final Map<Module, ModuleContext> genCtx, Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders,
- final boolean verboseClassComments) {
+ final TypeProvider typeProvider, final Map<Module, ModuleContext> genCtx,
+ Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final boolean verboseClassComments) {
Preconditions.checkArgument(module != null, "Module reference cannot be NULL.");
Preconditions.checkArgument(module.getName() != null, "Module name cannot be NULL.");
Preconditions.checkState(module.getAugmentations() != null, "Augmentations Set cannot be NULL.");
final String basePackageName = BindingMapping.getRootPackageName(module);
- final List<AugmentationSchema> augmentations = resolveAugmentations(module);
+ final List<AugmentationSchema> augmentations = resolveAugmentations(module, schemaContext);
Map<Module, ModuleContext> resultCtx = genCtx;
- for (final AugmentationSchema augment : augmentations) {
- resultCtx = augmentationToGenTypes(basePackageName, augment, module, schemaContext, verboseClassComments,
- resultCtx, genTypeBuilders);
+
+ //let's group augments by target path
+ Map<SchemaPath, List<AugmentationSchema>> augmentationsGrouped =
+ augmentations.stream().collect(Collectors.groupingBy(AugmentationSchema::getTargetPath));
+
+ List<Map.Entry<SchemaPath, List<AugmentationSchema>>> sortedAugmentationsGrouped =
+ new ArrayList<>(augmentationsGrouped.entrySet());
+ Collections.sort(sortedAugmentationsGrouped, AUGMENTS_COMP);
+
+ //process child nodes of grouped augment entries
+ for (Map.Entry<SchemaPath, List<AugmentationSchema>> schemaPathAugmentListEntry : sortedAugmentationsGrouped) {
+ resultCtx = augmentationToGenTypes(basePackageName, schemaPathAugmentListEntry, module, schemaContext,
+ verboseClassComments, resultCtx, genTypeBuilders, typeProvider);
+
+ for (AugmentationSchema augSchema : schemaPathAugmentListEntry.getValue()) {
+ GenHelperUtil.processUsesImplements(augSchema, module, schemaContext, genCtx, BindingNamespaceType.Data);
+ }
+
}
+
return resultCtx;
}
* @throws IllegalStateException
* if set of module augmentations is null
*/
- private static List<AugmentationSchema> resolveAugmentations(final Module module) {
+ private static List<AugmentationSchema> resolveAugmentations(final Module module, final SchemaContext schemaContext) {
Preconditions.checkArgument(module != null, "Module reference cannot be NULL.");
Preconditions.checkState(module.getAugmentations() != null, "Augmentations Set cannot be NULL.");
final Set<AugmentationSchema> augmentations = module.getAugmentations();
- final List<AugmentationSchema> sortedAugmentations = new ArrayList<>(augmentations);
+ final List<AugmentationSchema> sortedAugmentations = new ArrayList<>(augmentations).stream()
+ .filter(aug -> !module.equals(findAugmentTargetModule(schemaContext, aug)))
+ .collect(Collectors.toList());
Collections.sort(sortedAugmentations, AUGMENT_COMP);
return sortedAugmentations;
}
+ public static Module findAugmentTargetModule(final SchemaContext schemaContext , final AugmentationSchema aug) {
+ Preconditions.checkNotNull(aug, "Augmentation schema can not be null.");
+ final QName first = aug.getTargetPath().getPathFromRoot().iterator().next();
+ return schemaContext.findModuleByNamespaceAndRevision(first.getNamespace(), first.getRevision());
+ }
+
/**
* Converts <code>augSchema</code> to list of <code>Type</code> which
* contains generated type for augmentation. In addition there are also
* <code>augSchema</code> node or a generated types for cases are added if
* augmented node is choice.
*
- * @param augmentPackageName
+ * @param basePackageName
* string with the name of the package to which the augmentation
* belongs
- * @param augSchema
- * AugmentationSchema which is contains data about augmentation
- * (target path, childs...)
- * @param module
- * current module
- * @param schemaContext
- * @param genCtx
- * @param genTypeBuilders
+ * @param schemaPathAugmentListEntry
+ * list of AugmentationSchema nodes grouped by target path
+ * @param module current module
+ * @param schemaContext actual schema context
+ * @param verboseClassComments verbosity switch
+ * @param genCtx generated input context
+ * @param genTypeBuilders auxiliary type builders map
+ * @param typeProvider actual type provider instance
* @throws IllegalArgumentException
- * <ul>
- * <li>if <code>augmentPackageName</code> equals null</li>
- * <li>if <code>augSchema</code> equals null</li>
- * </ul>
+ * if <code>augmentPackageName</code> equals null
* @throws IllegalStateException
* if augment target path is null
- * @return
+ * @return generated context
*/
- private static Map<Module, ModuleContext> augmentationToGenTypes(final String augmentPackageName, final AugmentationSchema augSchema,
- final Module module, final SchemaContext schemaContext, final boolean verboseClassComments,
- Map<Module, ModuleContext> genCtx, Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders) {
-
- Map<Module, ModuleContext> generatedCtx;
- Preconditions.checkArgument(augmentPackageName != null, "Package Name cannot be NULL.");
- Preconditions.checkArgument(augSchema != null, "Augmentation Schema cannot be NULL.");
- Preconditions.checkState(augSchema.getTargetPath() != null,
- "Augmentation Schema does not contain Target Path (Target Path is NULL).");
-
- generatedCtx = GenHelperUtil.processUsesAugments(schemaContext, augSchema, module, genCtx, genTypeBuilders,
- verboseClassComments);
- final SchemaPath targetPath = augSchema.getTargetPath();
- SchemaNode targetSchemaNode;
-
- targetSchemaNode = SchemaContextUtil.findDataSchemaNode(schemaContext, targetPath);
+ private static Map<Module, ModuleContext> augmentationToGenTypes(final String basePackageName,
+ final Entry<SchemaPath, List<AugmentationSchema>> schemaPathAugmentListEntry, final Module module,
+ final SchemaContext schemaContext, final boolean verboseClassComments,
+ Map<Module, ModuleContext> genCtx, Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders,
+ final TypeProvider typeProvider) {
+ Preconditions.checkArgument(basePackageName != null, "Package Name cannot be NULL.");
+ Preconditions.checkArgument(schemaPathAugmentListEntry != null, "Augmentation List Entry cannot be NULL.");
+ final SchemaPath targetPath = schemaPathAugmentListEntry.getKey();
+ Preconditions.checkState(targetPath != null,
+ "Augmentation List Entry does not contain Target Path (Target Path is NULL).");
+
+ final List<AugmentationSchema> augmentationSchemaList = schemaPathAugmentListEntry.getValue();
+ Preconditions.checkState(augmentationSchemaList.size() > 0,
+ "Augmentation List cannot be empty.");
+
+ SchemaNode targetSchemaNode = SchemaContextUtil.findDataSchemaNode(schemaContext, targetPath);
if (targetSchemaNode instanceof DataSchemaNode && ((DataSchemaNode) targetSchemaNode).isAddedByUses()) {
if (targetSchemaNode instanceof DerivableSchemaNode) {
targetSchemaNode = ((DerivableSchemaNode) targetSchemaNode).getOriginal().orNull();
}
if (targetSchemaNode == null) {
- throw new IllegalStateException("Failed to find target node from grouping in augmentation " + augSchema
+ throw new IllegalStateException("Failed to find target node from grouping in augmentation " +
+ schemaPathAugmentListEntry.getValue().get(0)
+ " in module " + module.getName());
}
}
}
GeneratedTypeBuilder targetTypeBuilder = GenHelperUtil.findChildNodeByPath(targetSchemaNode.getPath(),
- generatedCtx);
+ genCtx);
if (targetTypeBuilder == null) {
- targetTypeBuilder = GenHelperUtil.findCaseByPath(targetSchemaNode.getPath(), generatedCtx);
+ targetTypeBuilder = GenHelperUtil.findCaseByPath(targetSchemaNode.getPath(), genCtx);
}
if (targetTypeBuilder == null) {
throw new NullPointerException("Target type not yet generated: " + targetSchemaNode);
}
- if (!(targetSchemaNode instanceof ChoiceSchemaNode)) {
- final String packageName = augmentPackageName;
- final Type targetType = new ReferencedTypeImpl(targetTypeBuilder.getPackageName(),
- targetTypeBuilder.getName());
- generatedCtx = GenHelperUtil.addRawAugmentGenTypeDefinition(module, packageName, augmentPackageName, targetType,
- augSchema, genTypeBuilders, generatedCtx);
- return generatedCtx;
+ final String augmentPackageName =
+ BindingGeneratorUtil.packageNameWithNamespacePrefix(basePackageName, BindingNamespaceType.Data);
+ if (!(targetSchemaNode instanceof ChoiceSchemaNode)) {
+ genCtx = GenHelperUtil.addRawAugmentGenTypeDefinition(module, augmentPackageName,
+ targetTypeBuilder.toInstance(), targetSchemaNode, schemaPathAugmentListEntry.getValue(), genTypeBuilders, genCtx,
+ schemaContext, verboseClassComments, typeProvider, BindingNamespaceType.Data);
} else {
- generatedCtx = generateTypesFromAugmentedChoiceCases(schemaContext, module, augmentPackageName,
- targetTypeBuilder.toInstance(), (ChoiceSchemaNode) targetSchemaNode, augSchema.getChildNodes(),
- null, generatedCtx, verboseClassComments, genTypeBuilders);
- return generatedCtx;
+ genCtx = generateTypesFromAugmentedChoiceCases(schemaContext, module, basePackageName,
+ targetTypeBuilder.toInstance(), (ChoiceSchemaNode) targetSchemaNode,
+ schemaPathAugmentListEntry.getValue(),
+ null, genCtx, verboseClassComments, genTypeBuilders, typeProvider,
+ BindingNamespaceType.Data);
}
+ return genCtx;
}
- public static Map<Module, ModuleContext> usesAugmentationToGenTypes(final SchemaContext schemaContext, final String
- augmentPackageName, final AugmentationSchema augSchema, final Module module, final UsesNode usesNode, final DataNodeContainer
- usesNodeParent, Map<Module, ModuleContext> genCtx,
- Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders,
- final boolean verboseClassComments) {
+ @Deprecated
+ static Map<Module, ModuleContext> usesAugmentationToGenTypes(final SchemaContext schemaContext,
+ final String augmentPackageName, final List<AugmentationSchema> schemaPathAugmentListEntry, final Module module,
+ final UsesNode usesNode, final DataNodeContainer usesNodeParent, Map<Module, ModuleContext> genCtx,
+ Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final boolean verboseClassComments,
+ final TypeProvider typeProvider, final BindingNamespaceType namespaceType) {
- Map<Module, ModuleContext> generatedCtx;
Preconditions.checkArgument(augmentPackageName != null, "Package Name cannot be NULL.");
- Preconditions.checkArgument(augSchema != null, "Augmentation Schema cannot be NULL.");
- Preconditions.checkState(augSchema.getTargetPath() != null,
+ Preconditions.checkArgument(schemaPathAugmentListEntry != null,
+ "Augmentation Schema List Entry cannot be NULL.");
+ Preconditions.checkState(schemaPathAugmentListEntry.size() > 0,
+ "Augmentation Schema List cannot be empty");
+
+ final SchemaPath targetPath = schemaPathAugmentListEntry.get(0).getTargetPath();
+ Preconditions.checkState(targetPath != null,
"Augmentation Schema does not contain Target Path (Target Path is NULL).");
- generatedCtx = GenHelperUtil.processUsesAugments(schemaContext, augSchema, module, genCtx, genTypeBuilders,
- verboseClassComments);
- final SchemaPath targetPath = augSchema.getTargetPath();
final SchemaNode targetSchemaNode = findOriginalTargetFromGrouping(schemaContext, targetPath, usesNode);
if (targetSchemaNode == null) {
throw new IllegalArgumentException("augment target not found: " + targetPath);
}
GeneratedTypeBuilder targetTypeBuilder = GenHelperUtil.findChildNodeByPath(targetSchemaNode.getPath(),
- generatedCtx);
+ genCtx);
if (targetTypeBuilder == null) {
- targetTypeBuilder = GenHelperUtil.findCaseByPath(targetSchemaNode.getPath(), generatedCtx);
+ targetTypeBuilder = GenHelperUtil.findCaseByPath(targetSchemaNode.getPath(), genCtx);
}
if (targetTypeBuilder == null) {
throw new NullPointerException("Target type not yet generated: " + targetSchemaNode);
if (usesNodeParent instanceof SchemaNode) {
packageName = BindingGeneratorUtil.packageNameForAugmentedGeneratedType(augmentPackageName,
((SchemaNode) usesNodeParent).getPath());
+ } else if (usesNodeParent instanceof AugmentationSchema) {
+ Type parentTypeBuilder = genCtx.get(module).getTargetToAugmentation()
+ .get(((AugmentationSchema) usesNodeParent).getTargetPath());
+ packageName = BindingGeneratorUtil.packageNameForAugmentedGeneratedType(parentTypeBuilder.getPackageName(),
+ (AugmentationSchema)usesNodeParent);
}
- generatedCtx = GenHelperUtil.addRawAugmentGenTypeDefinition(module, packageName, augmentPackageName,
- targetTypeBuilder.toInstance(), augSchema, genTypeBuilders, generatedCtx);
- return generatedCtx;
+ genCtx = GenHelperUtil.addRawAugmentGenTypeDefinition(module, packageName,
+ targetTypeBuilder.toInstance(), targetSchemaNode, schemaPathAugmentListEntry, genTypeBuilders, genCtx,
+ schemaContext, verboseClassComments, typeProvider, namespaceType);
+ return genCtx;
} else {
- generatedCtx = generateTypesFromAugmentedChoiceCases(schemaContext, module, augmentPackageName,
- targetTypeBuilder.toInstance(), (ChoiceSchemaNode) targetSchemaNode, augSchema.getChildNodes(),
- usesNodeParent, generatedCtx, verboseClassComments, genTypeBuilders);
- return generatedCtx;
+ genCtx = generateTypesFromAugmentedChoiceCases(schemaContext, module, augmentPackageName,
+ targetTypeBuilder.toInstance(), (ChoiceSchemaNode) targetSchemaNode,
+ schemaPathAugmentListEntry,
+ usesNodeParent, genCtx, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
+ return genCtx;
}
}
*/
private static DataSchemaNode findOriginalTargetFromGrouping(final SchemaContext schemaContext, final SchemaPath targetPath,
final UsesNode parentUsesNode) {
- final SchemaNode targetGrouping = SchemaContextUtil.findNodeInSchemaContext(schemaContext, parentUsesNode
- .getGroupingPath()
- .getPathFromRoot());
- if (!(targetGrouping instanceof GroupingDefinition)) {
+ SchemaNode targetGrouping = null;
+ QName current = parentUsesNode.getGroupingPath().getPathFromRoot().iterator().next();
+ Module module = schemaContext.findModuleByNamespaceAndRevision(current.getNamespace(), current.getRevision());
+ if (module == null) {
+ throw new IllegalArgumentException("Fialed to find module for grouping in: " + parentUsesNode);
+ } else {
+ for (GroupingDefinition group : module.getGroupings()) {
+ if (group.getQName().equals(current)) {
+ targetGrouping = group;
+ break;
+ }
+ }
+ }
+
+ if (targetGrouping == null) {
throw new IllegalArgumentException("Failed to generate code for augment in " + parentUsesNode);
}
- final GroupingDefinition grouping = (GroupingDefinition) targetGrouping;
- SchemaNode result = grouping;
+ SchemaNode result = targetGrouping;
for (final QName node : targetPath.getPathFromRoot()) {
if (result instanceof DataNodeContainer) {
final QName resultNode = QName.create(result.getQName().getModule(), node.getLocalName());
* Type which represents target choice
* @param targetNode
* node which represents target choice
- * @param augmentedNodes
- * set of choice case nodes for which is checked if are/aren't
- * added to choice through augmentation
+ * @param schemaPathAugmentListEntry
+ * list of AugmentationSchema nodes grouped by target path
* @return list of generated types which represents augmented cases of
* choice <code>refChoiceType</code>
* @throws IllegalArgumentException
* <li>if <code>augmentedNodes</code> is null</li>
* </ul>
*/
- private static Map<Module, ModuleContext> generateTypesFromAugmentedChoiceCases(final SchemaContext schemaContext, final Module module,
- final String basePackageName, final Type targetType, final ChoiceSchemaNode targetNode,
- final Iterable<DataSchemaNode> augmentedNodes, final DataNodeContainer usesNodeParent,
- Map<Module, ModuleContext> genCtx, final boolean verboseClassComments,
- Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders) {
+ private static Map<Module, ModuleContext> generateTypesFromAugmentedChoiceCases(
+ final SchemaContext schemaContext, final Module module,
+ final String basePackageName, final Type targetType, final ChoiceSchemaNode targetNode,
+ final List<AugmentationSchema> schemaPathAugmentListEntry,
+ final DataNodeContainer usesNodeParent,
+ Map<Module, ModuleContext> genCtx, final boolean verboseClassComments,
+ Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider,
+ final BindingNamespaceType namespaceType) {
Preconditions.checkArgument(basePackageName != null, "Base Package Name cannot be NULL.");
Preconditions.checkArgument(targetType != null, "Referenced Choice Type cannot be NULL.");
- Preconditions.checkArgument(augmentedNodes != null, "Set of Choice Case Nodes cannot be NULL.");
-
- for (final DataSchemaNode caseNode : augmentedNodes) {
- if (caseNode != null) {
- final String packageName = BindingGeneratorUtil.packageNameForGeneratedType(basePackageName,
- caseNode.getPath());
- final GeneratedTypeBuilder caseTypeBuilder = GenHelperUtil.addDefaultInterfaceDefinition(packageName,
- caseNode, module, genCtx, schemaContext, verboseClassComments, genTypeBuilders);
- caseTypeBuilder.addImplementsType(targetType);
-
- SchemaNode parent;
- final SchemaPath nodeSp = targetNode.getPath();
- parent = SchemaContextUtil.findDataSchemaNode(schemaContext, nodeSp.getParent());
-
- GeneratedTypeBuilder childOfType = null;
- if (parent instanceof Module) {
- childOfType = genCtx.get(parent).getModuleNode();
- } else if (parent instanceof ChoiceCaseNode) {
- childOfType = GenHelperUtil.findCaseByPath(parent.getPath(), genCtx);
- } else if (parent instanceof DataSchemaNode || parent instanceof NotificationDefinition) {
- childOfType = GenHelperUtil.findChildNodeByPath(parent.getPath(), genCtx);
- } else if (parent instanceof GroupingDefinition) {
- childOfType = GenHelperUtil.findGroupingByPath(parent.getPath(), genCtx);
- }
+ Preconditions.checkArgument(schemaPathAugmentListEntry != null, "Set of Choice Case Nodes cannot be NULL.");
+
+
+ for (final AugmentationSchema augmentationSchema : schemaPathAugmentListEntry) {
+ for (final DataSchemaNode caseNode : augmentationSchema.getChildNodes()) {
+ if (caseNode != null) {
+ final GeneratedTypeBuilder caseTypeBuilder = GenHelperUtil.addDefaultInterfaceDefinition(basePackageName,
+ caseNode, module, genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider,
+ namespaceType);
+ caseTypeBuilder.addImplementsType(targetType);
+
+ SchemaNode parent;
+ final SchemaPath nodeSp = targetNode.getPath();
+ parent = SchemaContextUtil.findDataSchemaNode(schemaContext, nodeSp.getParent());
+
+ GeneratedTypeBuilder childOfType = null;
+ if (parent instanceof Module) {
+ childOfType = genCtx.get(parent).getModuleNode();
+ } else if (parent instanceof ChoiceCaseNode) {
+ childOfType = GenHelperUtil.findCaseByPath(parent.getPath(), genCtx);
+ } else if (parent instanceof DataSchemaNode || parent instanceof NotificationDefinition) {
+ childOfType = GenHelperUtil.findChildNodeByPath(parent.getPath(), genCtx);
+ } else if (parent instanceof GroupingDefinition) {
+ childOfType = GenHelperUtil.findGroupingByPath(parent.getPath(), genCtx);
+ }
- if (childOfType == null) {
- throw new IllegalArgumentException("Failed to find parent type of choice " + targetNode);
- }
+ if (childOfType == null) {
+ throw new IllegalArgumentException("Failed to find parent type of choice " + targetNode);
+ }
- ChoiceCaseNode node = null;
- final String caseLocalName = caseNode.getQName().getLocalName();
- if (caseNode instanceof ChoiceCaseNode) {
- node = (ChoiceCaseNode) caseNode;
- } else if (targetNode.getCaseNodeByName(caseLocalName) == null) {
- final String targetNodeLocalName = targetNode.getQName().getLocalName();
- for (DataSchemaNode dataSchemaNode : usesNodeParent.getChildNodes()) {
- if (dataSchemaNode instanceof ChoiceSchemaNode && targetNodeLocalName.equals(dataSchemaNode.getQName
- ().getLocalName())) {
- node = ((ChoiceSchemaNode) dataSchemaNode).getCaseNodeByName(caseLocalName);
- break;
+ ChoiceCaseNode node = null;
+ final String caseLocalName = caseNode.getQName().getLocalName();
+ if (caseNode instanceof ChoiceCaseNode) {
+ node = (ChoiceCaseNode) caseNode;
+ } else if (targetNode.getCaseNodeByName(caseLocalName) == null) {
+ final String targetNodeLocalName = targetNode.getQName().getLocalName();
+ for (DataSchemaNode dataSchemaNode : usesNodeParent.getChildNodes()) {
+ if (dataSchemaNode instanceof ChoiceSchemaNode && targetNodeLocalName.equals(dataSchemaNode.getQName
+ ().getLocalName())) {
+ node = ((ChoiceSchemaNode) dataSchemaNode).getCaseNodeByName(caseLocalName);
+ break;
+ }
}
+ } else {
+ node = targetNode.getCaseNodeByName(caseLocalName);
}
- } else {
- node = targetNode.getCaseNodeByName(caseLocalName);
- }
- final Iterable<DataSchemaNode> childNodes = node.getChildNodes();
- if (childNodes != null) {
- GenHelperUtil.resolveDataSchemaNodes(module, basePackageName, caseTypeBuilder, childOfType,
- childNodes);
+ final Iterable<DataSchemaNode> childNodes = node.getChildNodes();
+ if (childNodes != null) {
+ GenHelperUtil.resolveDataSchemaNodes(module, basePackageName, caseTypeBuilder, childOfType,
+ childNodes, genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider,
+ namespaceType);
+ }
+ genCtx.get(module).addCaseType(caseNode.getPath(), caseTypeBuilder);
+ genCtx.get(module).addChoiceToCaseMapping(targetType, caseTypeBuilder, node);
}
- genCtx.get(module).addCaseType(caseNode.getPath(), caseTypeBuilder);
- genCtx.get(module).addChoiceToCaseMapping(targetType, caseTypeBuilder, node);
}
}
return genCtx;
Code Review / mdsal.git / blobdiff