X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=binding%2Fmdsal-binding-generator-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fmdsal%2Fbinding%2Fgenerator%2Fimpl%2FAbstractTypeGenerator.java;h=4b2776e78f7f17c94fb0b6f4fdc93a0f6351d5c5;hb=30794cd4999beb5a7a4902d4cf0484692cbd629b;hp=7ecd4b16046bbb00ff7d0546ec775631bec6b631;hpb=e14d0e0f87afe1e39eb1668e3498021ce31ec5ec;p=mdsal.git diff --git a/binding/mdsal-binding-generator-impl/src/main/java/org/opendaylight/mdsal/binding/generator/impl/AbstractTypeGenerator.java b/binding/mdsal-binding-generator-impl/src/main/java/org/opendaylight/mdsal/binding/generator/impl/AbstractTypeGenerator.java index 7ecd4b1604..4b2776e78f 100644 --- a/binding/mdsal-binding-generator-impl/src/main/java/org/opendaylight/mdsal/binding/generator/impl/AbstractTypeGenerator.java +++ b/binding/mdsal-binding-generator-impl/src/main/java/org/opendaylight/mdsal/binding/generator/impl/AbstractTypeGenerator.java @@ -64,13 +64,14 @@ import java.util.Map; import java.util.Optional; import org.eclipse.jdt.annotation.NonNull; import org.eclipse.jdt.annotation.Nullable; -import org.opendaylight.mdsal.binding.generator.util.BaseYangTypes; import org.opendaylight.mdsal.binding.model.api.AccessModifier; import org.opendaylight.mdsal.binding.model.api.Constant; import org.opendaylight.mdsal.binding.model.api.DefaultType; +import org.opendaylight.mdsal.binding.model.api.Enumeration; import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject; import org.opendaylight.mdsal.binding.model.api.GeneratedType; import org.opendaylight.mdsal.binding.model.api.JavaTypeName; +import org.opendaylight.mdsal.binding.model.api.MethodSignature.ValueMechanics; import org.opendaylight.mdsal.binding.model.api.ParameterizedType; import org.opendaylight.mdsal.binding.model.api.Restrictions; import org.opendaylight.mdsal.binding.model.api.Type; @@ -83,6 +84,7 @@ import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilde import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilderBase; import org.opendaylight.mdsal.binding.model.api.type.builder.MethodSignatureBuilder; import org.opendaylight.mdsal.binding.model.api.type.builder.TypeMemberBuilder; +import org.opendaylight.mdsal.binding.model.util.BaseYangTypes; import org.opendaylight.mdsal.binding.model.util.BindingGeneratorUtil; import org.opendaylight.mdsal.binding.model.util.TypeConstants; import org.opendaylight.mdsal.binding.model.util.generated.type.builder.GeneratedPropertyBuilderImpl; @@ -104,6 +106,7 @@ import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode; import org.opendaylight.yangtools.yang.model.api.DocumentedNode; import org.opendaylight.yangtools.yang.model.api.DocumentedNode.WithStatus; +import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext; import org.opendaylight.yangtools.yang.model.api.GroupingDefinition; import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode; import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode; @@ -114,12 +117,12 @@ import org.opendaylight.yangtools.yang.model.api.ModuleImport; import org.opendaylight.yangtools.yang.model.api.NotificationDefinition; import org.opendaylight.yangtools.yang.model.api.NotificationNodeContainer; import org.opendaylight.yangtools.yang.model.api.RpcDefinition; -import org.opendaylight.yangtools.yang.model.api.SchemaContext; import org.opendaylight.yangtools.yang.model.api.SchemaNode; import org.opendaylight.yangtools.yang.model.api.SchemaPath; import org.opendaylight.yangtools.yang.model.api.TypeDefinition; import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode; import org.opendaylight.yangtools.yang.model.api.UsesNode; +import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier; import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition; import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition; import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint; @@ -141,8 +144,8 @@ abstract class AbstractTypeGenerator { * Comparator based on augment target path. */ private static final Comparator AUGMENT_COMP = (o1, o2) -> { - final Iterator thisIt = o1.getTargetPath().getPathFromRoot().iterator(); - final Iterator otherIt = o2.getTargetPath().getPathFromRoot().iterator(); + final Iterator thisIt = o1.getTargetPath().getNodeIdentifiers().iterator(); + final Iterator otherIt = o2.getTargetPath().getNodeIdentifiers().iterator(); while (thisIt.hasNext()) { if (!otherIt.hasNext()) { @@ -185,14 +188,14 @@ abstract class AbstractTypeGenerator { /** * Holds reference to schema context to resolve data of augmented element when creating augmentation builder. */ - private final @NonNull SchemaContext schemaContext; + private final @NonNull EffectiveModelContext schemaContext; /** * Holds renamed elements. */ private final Map renames; - AbstractTypeGenerator(final SchemaContext context, final AbstractTypeProvider typeProvider, + AbstractTypeGenerator(final EffectiveModelContext context, final AbstractTypeProvider typeProvider, final Map renames) { this.schemaContext = requireNonNull(context); this.typeProvider = requireNonNull(typeProvider); @@ -207,7 +210,7 @@ abstract class AbstractTypeGenerator { contexts.forEach(this::allAugmentsToGenTypes); } - final @NonNull SchemaContext schemaContext() { + final @NonNull EffectiveModelContext schemaContext() { return schemaContext; } @@ -237,15 +240,17 @@ abstract class AbstractTypeGenerator { genCtx.put(module.getQNameModule(), context); allTypeDefinitionsToGenTypes(context); groupingsToGenTypes(context, module.getGroupings()); - rpcMethodsToGenType(context); allIdentitiesToGenTypes(context); - notificationsToGenType(context); if (!module.getChildNodes().isEmpty()) { final GeneratedTypeBuilder moduleType = moduleToDataType(context); context.addModuleNode(moduleType); resolveDataSchemaNodes(context, moduleType, moduleType, module.getChildNodes(), false); } + + // Resolve RPCs and notifications only after we have created instantiated tree + rpcMethodsToGenType(context); + notificationsToGenType(context); return context; } @@ -334,7 +339,7 @@ abstract class AbstractTypeGenerator { listType = listTypeFor(genType); } - constructGetter(parent, listType, node); + constructGetter(parent, listType, node).setMechanics(ValueMechanics.NULLIFY_EMPTY); constructNonnull(parent, listType, node); actionsToGenType(context, genType, node, keyTypeBuilder, inGrouping); @@ -432,6 +437,11 @@ abstract class AbstractTypeGenerator { final Module module = context.module(); addImplementedInterfaceFromUses(module, moduleDataTypeBuilder); moduleDataTypeBuilder.addImplementsType(DATA_ROOT); + // if we have more than 2 top level uses statements we need to define getImplementedInterface() on the + // top level DataRoot object + if (module.getUses().size() > 1) { + narrowImplementedInterface(moduleDataTypeBuilder); + } addCodegenInformation(moduleDataTypeBuilder, module); return moduleDataTypeBuilder; @@ -448,8 +458,11 @@ abstract class AbstractTypeGenerator { final GeneratedType output; if (action.isAddedByUses()) { final ActionDefinition orig = findOrigAction(parentSchema, action).get(); - input = context.getChildNode(orig.getInput().getPath()).build(); - output = context.getChildNode(orig.getOutput().getPath()).build(); + // Original definition may live in a different module, make sure we account for that + final ModuleContext origContext = moduleContext( + orig.getPath().getPathFromRoot().iterator().next().getModule()); + input = context.addAliasType(origContext, orig.getInput(), action.getInput()); + output = context.addAliasType(origContext, orig.getOutput(), action.getOutput()); } else { input = actionContainer(context, RPC_INPUT, action.getInput(), inGrouping); output = actionContainer(context, RPC_OUTPUT, action.getOutput(), inGrouping); @@ -463,8 +476,7 @@ abstract class AbstractTypeGenerator { final GeneratedTypeBuilder builder = typeProvider.newGeneratedTypeBuilder(JavaTypeName.create( packageNameForGeneratedType(context.modulePackageName(), action.getPath()), BindingMapping.getClassName(qname))); - qnameConstant(builder, JavaTypeName.create(context.modulePackageName(), - BindingMapping.MODULE_INFO_CLASS_NAME), qname.getLocalName()); + qnameConstant(builder, context.moduleInfoType(), qname.getLocalName()); annotateDeprecatedIfNecessary(action, builder); builder.addImplementsType(keyType != null ? keyedListAction(parent, keyType, input, output) @@ -477,9 +489,12 @@ abstract class AbstractTypeGenerator { } private Optional findOrigAction(final DataNodeContainer parent, final ActionDefinition action) { + final QName qname = action.getQName(); for (UsesNode uses : parent.getUses()) { - final GroupingDefinition grp = findUsedGrouping(uses); - final Optional found = grp.findAction(action.getQName()); + final GroupingDefinition grp = uses.getSourceGrouping(); + // Target grouping may reside in a different module, hence we need to rebind the QName to match grouping's + // namespace + final Optional found = grp.findAction(qname.bindTo(grp.getQName().getModule())); if (found.isPresent()) { final ActionDefinition result = found.get(); return result.isAddedByUses() ? findOrigAction(grp, result) : found; @@ -548,7 +563,7 @@ abstract class AbstractTypeGenerator { private Type createRpcContainer(final ModuleContext context, final String rpcName, final RpcDefinition rpc, final ContainerSchemaNode schema, final Type type) { processUsesAugments(schema, context, false); - final GeneratedTypeBuilder outType = addRawInterfaceDefinition( + final GeneratedTypeBuilder outType = addRawInterfaceDefinition(context, JavaTypeName.create(context.modulePackageName(), rpcName + BindingMapping.getClassName(schema.getQName())), schema); addImplementedInterfaceFromUses(schema, outType); @@ -718,8 +733,7 @@ abstract class AbstractTypeGenerator { newType.setModuleName(module.getName()); newType.setSchemaPath(identity.getPath()); - qnameConstant(newType, JavaTypeName.create(context.modulePackageName(), BindingMapping.MODULE_INFO_CLASS_NAME), - identity.getQName().getLocalName()); + qnameConstant(newType, context.moduleInfoType(), identity.getQName().getLocalName()); context.addIdentityType(identity, newType); } @@ -770,16 +784,15 @@ abstract class AbstractTypeGenerator { * @param module Module in which type should be generated * @return enumeration builder which contains data from enumTypeDef */ - private EnumBuilder resolveInnerEnumFromTypeDefinition(final EnumTypeDefinition enumTypeDef, final QName enumName, + private Enumeration resolveInnerEnumFromTypeDefinition(final EnumTypeDefinition enumTypeDef, final QName enumName, final GeneratedTypeBuilder typeBuilder, final ModuleContext context) { - if (enumTypeDef != null && typeBuilder != null && enumTypeDef.getQName().getLocalName() != null) { - final EnumBuilder enumBuilder = typeBuilder.addEnumeration(BindingMapping.getClassName(enumName)); - typeProvider.addEnumDescription(enumBuilder, enumTypeDef); - enumBuilder.updateEnumPairsFromEnumTypeDef(enumTypeDef); - context.addInnerTypedefType(enumTypeDef.getPath(), enumBuilder); - return enumBuilder; - } - return null; + final EnumBuilder enumBuilder = typeBuilder.addEnumeration(BindingMapping.getClassName(enumName)); + typeProvider.addEnumDescription(enumBuilder, enumTypeDef); + enumBuilder.updateEnumPairsFromEnumTypeDef(enumTypeDef); + final Enumeration ret = enumBuilder.toInstance(typeBuilder); + context.addTypeToSchema(ret, enumTypeDef); + context.addInnerTypedefType(enumTypeDef.getPath(), ret); + return ret; } /** @@ -823,10 +836,11 @@ abstract class AbstractTypeGenerator { "Augmentation Schema does not contain Target Path (Target Path is NULL)."); processUsesAugments(augSchema, context, false); - final SchemaPath targetPath = augSchema.getTargetPath(); + final SchemaNodeIdentifier targetPath = augSchema.getTargetPath(); SchemaNode targetSchemaNode = null; - targetSchemaNode = findDataSchemaNode(schemaContext, targetPath); + // FIXME: can we use findDataSchemaNode() instead? + targetSchemaNode = findDataSchemaNode(schemaContext, targetPath.getNodeIdentifiers()); if (targetSchemaNode instanceof DataSchemaNode && ((DataSchemaNode) targetSchemaNode).isAddedByUses()) { if (targetSchemaNode instanceof DerivableSchemaNode) { targetSchemaNode = ((DerivableSchemaNode) targetSchemaNode).getOriginal().orElse(null); @@ -840,21 +854,30 @@ abstract class AbstractTypeGenerator { throw new IllegalArgumentException("augment target not found: " + targetPath); } - GeneratedTypeBuilder targetTypeBuilder = findChildNodeByPath(targetSchemaNode.getPath()); - if (targetTypeBuilder == null) { - targetTypeBuilder = findCaseByPath(targetSchemaNode.getPath()); - } - if (targetTypeBuilder == null) { - throw new NullPointerException("Target type not yet generated: " + targetSchemaNode); + if (targetSchemaNode instanceof ChoiceSchemaNode) { + final GeneratedTypeBuilder builder = findChildNodeByPath(targetSchemaNode.getPath()); + checkState(builder != null, "Choice target type not generated for %s", targetSchemaNode); + generateTypesFromAugmentedChoiceCases(context, builder.build(), (ChoiceSchemaNode) targetSchemaNode, + augSchema.getChildNodes(), null, false); + return; } - if (!(targetSchemaNode instanceof ChoiceSchemaNode)) { - addRawAugmentGenTypeDefinition(context, DefaultType.of(targetTypeBuilder), augSchema, false); - + final JavaTypeName targetName; + if (targetSchemaNode instanceof CaseSchemaNode) { + final GeneratedTypeBuilder builder = findCaseByPath(targetSchemaNode.getPath()); + checkState(builder != null, "Case target type not generated for %s", targetSchemaNode); + targetName = builder.getIdentifier(); } else { - generateTypesFromAugmentedChoiceCases(context, targetTypeBuilder.build(), - (ChoiceSchemaNode) targetSchemaNode, augSchema.getChildNodes(), null, false); + final GeneratedTypeBuilder builder = findChildNodeByPath(targetSchemaNode.getPath()); + if (builder == null) { + targetName = findAliasByPath(targetSchemaNode.getPath()); + checkState(targetName != null, "Target type not yet generated: %s", targetSchemaNode); + } else { + targetName = builder.getIdentifier(); + } } + + addRawAugmentGenTypeDefinition(context, DefaultType.of(targetName), augSchema, false); } private void usesAugmentationToGenTypes(final ModuleContext context, final AugmentationSchemaNode augSchema, @@ -864,7 +887,7 @@ abstract class AbstractTypeGenerator { "Augmentation Schema does not contain Target Path (Target Path is NULL)."); processUsesAugments(augSchema, context, inGrouping); - final SchemaPath targetPath = augSchema.getTargetPath(); + final SchemaNodeIdentifier targetPath = augSchema.getTargetPath(); final SchemaNode targetSchemaNode = findOriginalTargetFromGrouping(targetPath, usesNode); if (targetSchemaNode == null) { throw new IllegalArgumentException("augment target not found: " + targetPath); @@ -893,16 +916,6 @@ abstract class AbstractTypeGenerator { } } - private GroupingDefinition findUsedGrouping(final UsesNode uses) { - final SchemaNode targetGrouping = findNodeInSchemaContext(schemaContext, uses.getGroupingPath() - .getPathFromRoot()); - if (targetGrouping instanceof GroupingDefinition) { - return (GroupingDefinition) targetGrouping; - } - - throw new IllegalArgumentException("Failed to resolve used grouping for " + uses); - } - /** * Convenient method to find node added by uses statement. * @@ -910,14 +923,41 @@ abstract class AbstractTypeGenerator { * @param parentUsesNode parent of uses node * @return node from its original location in grouping */ - private DataSchemaNode findOriginalTargetFromGrouping(final SchemaPath targetPath, final UsesNode parentUsesNode) { - SchemaNode result = findUsedGrouping(parentUsesNode); - for (final QName node : targetPath.getPathFromRoot()) { + private static DataSchemaNode findOriginalTargetFromGrouping(final SchemaNodeIdentifier targetPath, + final UsesNode parentUsesNode) { + SchemaNode result = parentUsesNode.getSourceGrouping(); + for (final QName node : targetPath.getNodeIdentifiers()) { + // FIXME: this dispatch is rather ugly, we probably want to refactor it a bit if (result instanceof DataNodeContainer) { - final QName resultNode = node.withModule(result.getQName().getModule()); - result = ((DataNodeContainer) result).getDataChildByName(resultNode); + final QName resultNode = node.bindTo(result.getQName().getModule()); + + SchemaNode found = ((DataNodeContainer) result).getDataChildByName(resultNode); + if (found == null) { + if (result instanceof ActionNodeContainer) { + found = ((ActionNodeContainer) result).findAction(resultNode).orElse(null); + } + if (found == null && result instanceof NotificationNodeContainer) { + found = ((NotificationNodeContainer) result).findNotification(resultNode).orElse(null); + } + } + result = found; } else if (result instanceof ChoiceSchemaNode) { result = findNamedCase((ChoiceSchemaNode) result, node.getLocalName()); + } else if (result instanceof ActionDefinition) { + final ActionDefinition action = (ActionDefinition) result; + final QName resultNode = node.bindTo(result.getQName().getModule()); + + final ContainerSchemaNode input = action.getInput(); + final ContainerSchemaNode output = action.getOutput(); + if (resultNode.equals(input.getQName())) { + result = input; + } else if (resultNode.equals(output.getQName())) { + result = output; + } else { + result = null; + } + } else if (result != null) { + throw new IllegalStateException("Cannot handle " + result); } } if (result == null) { @@ -977,10 +1017,9 @@ abstract class AbstractTypeGenerator { final GeneratedTypeBuilder augTypeBuilder = typeProvider.newGeneratedTypeBuilder( JavaTypeName.create(augmentPackageName, augTypeName)); - augTypeBuilder.addImplementsType(DATA_OBJECT); + augTypeBuilder.addImplementsType(augmentation(targetTypeRef)); defaultImplementedInterace(augTypeBuilder); - augTypeBuilder.addImplementsType(augmentation(targetTypeRef)); annotateDeprecatedIfNecessary(augSchema, augTypeBuilder); addImplementedInterfaceFromUses(augSchema, augTypeBuilder); @@ -1139,7 +1178,7 @@ abstract class AbstractTypeGenerator { private void choiceToGeneratedType(final ModuleContext context, final GeneratedTypeBuilder parent, final ChoiceSchemaNode choiceNode, final boolean inGrouping) { if (!choiceNode.isAddedByUses()) { - final GeneratedTypeBuilder choiceTypeBuilder = addRawInterfaceDefinition( + final GeneratedTypeBuilder choiceTypeBuilder = addRawInterfaceDefinition(context, JavaTypeName.create(packageNameForGeneratedType(context.modulePackageName(), choiceNode.getPath()), BindingMapping.getClassName(choiceNode.getQName())), choiceNode); choiceTypeBuilder.addImplementsType(choiceIn(parent)); @@ -1156,7 +1195,7 @@ abstract class AbstractTypeGenerator { private void opaqueToGeneratedType(final ModuleContext context, final GeneratedTypeBuilder parent, final DataSchemaNode anyNode) { if (!anyNode.isAddedByUses()) { - final GeneratedTypeBuilder anyxmlTypeBuilder = addRawInterfaceDefinition( + final GeneratedTypeBuilder anyxmlTypeBuilder = addRawInterfaceDefinition(context, JavaTypeName.create(packageNameForGeneratedType(context.modulePackageName(), anyNode.getPath()), BindingMapping.getClassName(anyNode.getQName())), anyNode); anyxmlTypeBuilder.addImplementsType(opaqueObject(anyxmlTypeBuilder)).addImplementsType(childOf(parent)); @@ -1188,7 +1227,7 @@ abstract class AbstractTypeGenerator { checkArgument(refChoiceType != null, "Referenced Choice Type cannot be NULL."); checkArgument(choiceNode != null, "ChoiceNode cannot be NULL."); - for (final CaseSchemaNode caseNode : choiceNode.getCases().values()) { + for (final CaseSchemaNode caseNode : choiceNode.getCases()) { if (caseNode != null && !caseNode.isAddedByUses() && !caseNode.isAugmenting()) { final GeneratedTypeBuilder caseTypeBuilder = addDefaultInterfaceDefinition(context, caseNode); caseTypeBuilder.addImplementsType(refChoiceType); @@ -1205,8 +1244,10 @@ abstract class AbstractTypeGenerator { if (parent instanceof AugmentationSchemaNode) { final AugmentationSchemaNode augSchema = (AugmentationSchemaNode) parent; - final SchemaPath targetPath = augSchema.getTargetPath(); - SchemaNode targetSchemaNode = findDataSchemaNode(schemaContext, targetPath); + final SchemaNodeIdentifier targetPath = augSchema.getTargetPath(); + // FIXME: can we use findDataSchemaNode? + SchemaNode targetSchemaNode = findNodeInSchemaContext(schemaContext, + targetPath.getNodeIdentifiers()); if (targetSchemaNode instanceof DataSchemaNode && ((DataSchemaNode) targetSchemaNode).isAddedByUses()) { if (targetSchemaNode instanceof DerivableSchemaNode) { @@ -1324,7 +1365,7 @@ abstract class AbstractTypeGenerator { } private static CaseSchemaNode findNamedCase(final ChoiceSchemaNode choice, final String caseName) { - final List cases = choice.findCaseNodes(caseName); + final List cases = choice.findCaseNodes(caseName); return cases.isEmpty() ? null : cases.get(0); } @@ -1377,13 +1418,8 @@ abstract class AbstractTypeGenerator { final TypeDefinition typeDef = CompatUtils.compatType(leaf); if (isInnerType(leaf, typeDef)) { if (typeDef instanceof EnumTypeDefinition) { - returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf, inGrouping); final EnumTypeDefinition enumTypeDef = (EnumTypeDefinition) typeDef; - final EnumBuilder enumBuilder = resolveInnerEnumFromTypeDefinition(enumTypeDef, leaf.getQName(), - typeBuilder, context); - if (enumBuilder != null) { - returnType = enumBuilder.toInstance(typeBuilder); - } + returnType = resolveInnerEnumFromTypeDefinition(enumTypeDef, leaf.getQName(), typeBuilder, context); typeProvider.putReferencedType(leaf.getPath(), returnType); } else if (typeDef instanceof UnionTypeDefinition) { final UnionTypeDefinition unionDef = (UnionTypeDefinition)typeDef; @@ -1574,11 +1610,8 @@ abstract class AbstractTypeGenerator { Type returnType = null; if (typeDef.getBaseType() == null) { if (typeDef instanceof EnumTypeDefinition) { - returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, node, inGrouping); final EnumTypeDefinition enumTypeDef = (EnumTypeDefinition) typeDef; - final EnumBuilder enumBuilder = resolveInnerEnumFromTypeDefinition(enumTypeDef, nodeName, - typeBuilder, context); - returnType = DefaultType.of(enumBuilder); + returnType = resolveInnerEnumFromTypeDefinition(enumTypeDef, nodeName, typeBuilder, context); typeProvider.putReferencedType(node.getPath(), returnType); } else if (typeDef instanceof UnionTypeDefinition) { final UnionTypeDefinition unionDef = (UnionTypeDefinition)typeDef; @@ -1670,7 +1703,7 @@ abstract class AbstractTypeGenerator { name = JavaTypeName.create(packageName, BindingMapping.getClassName(schemaNode.getQName())); } - final GeneratedTypeBuilder it = addRawInterfaceDefinition(name, schemaNode); + final GeneratedTypeBuilder it = addRawInterfaceDefinition(context, name, schemaNode); it.addImplementsType(baseInterface); if (!(schemaNode instanceof GroupingDefinition)) { it.addImplementsType(augmentable(it)); @@ -1701,7 +1734,8 @@ abstract class AbstractTypeGenerator { *
  • if schemaNode name is null
    • * */ - private GeneratedTypeBuilder addRawInterfaceDefinition(final JavaTypeName identifier, final SchemaNode schemaNode) { + private GeneratedTypeBuilder addRawInterfaceDefinition(final ModuleContext context, final JavaTypeName identifier, + final SchemaNode schemaNode) { checkArgument(schemaNode != null, "Data Schema Node cannot be NULL."); checkArgument(schemaNode.getQName() != null, "QName for Data Schema Node cannot be NULL."); final String schemaNodeName = schemaNode.getQName().getLocalName(); @@ -1709,10 +1743,9 @@ abstract class AbstractTypeGenerator { // FIXME: Validation of name conflict final GeneratedTypeBuilder newType = typeProvider.newGeneratedTypeBuilder(identifier); - final Module module = findParentModule(schemaContext, schemaNode); - qnameConstant(newType, JavaTypeName.create(BindingMapping.getRootPackageName(module.getQNameModule()), - BindingMapping.MODULE_INFO_CLASS_NAME), schemaNode.getQName().getLocalName()); + qnameConstant(newType, context.moduleInfoType(), schemaNode.getQName().getLocalName()); + final Module module = context.module(); addCodegenInformation(newType, module, schemaNode); newType.setSchemaPath(schemaNode.getPath()); newType.setModuleName(module.getName()); @@ -1926,10 +1959,10 @@ abstract class AbstractTypeGenerator { private GeneratedTypeBuilder addImplementedInterfaceFromUses(final DataNodeContainer dataNodeContainer, final GeneratedTypeBuilder builder) { for (final UsesNode usesNode : dataNodeContainer.getUses()) { - final GeneratedTypeBuilder genType = findGroupingByPath(usesNode.getGroupingPath()); + final GeneratedTypeBuilder genType = findGrouping(usesNode.getSourceGrouping()); if (genType == null) { - throw new IllegalStateException("Grouping " + usesNode.getGroupingPath() + "is not resolved for " - + builder.getName()); + throw new IllegalStateException("Grouping " + usesNode.getSourceGrouping().getQName() + + " is not resolved for " + builder.getFullyQualifiedName()); } builder.addImplementsType(genType.build()); @@ -1937,6 +1970,16 @@ abstract class AbstractTypeGenerator { return builder; } + private JavaTypeName findAliasByPath(final SchemaPath path) { + for (final ModuleContext ctx : genCtx.values()) { + final JavaTypeName result = ctx.getAlias(path); + if (result != null) { + return result; + } + } + return null; + } + private GeneratedTypeBuilder findChildNodeByPath(final SchemaPath path) { for (final ModuleContext ctx : genCtx.values()) { final GeneratedTypeBuilder result = ctx.getChildNode(path); @@ -1947,6 +1990,16 @@ abstract class AbstractTypeGenerator { return null; } + private GeneratedTypeBuilder findGrouping(final GroupingDefinition grouping) { + for (final ModuleContext ctx : genCtx.values()) { + final GeneratedTypeBuilder result = ctx.getGrouping(grouping.getPath()); + if (result != null) { + return result; + } + } + return null; + } + private GeneratedTypeBuilder findGroupingByPath(final SchemaPath path) { for (final ModuleContext ctx : genCtx.values()) { final GeneratedTypeBuilder result = ctx.getGrouping(path);