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=f7bb3a7e54f44f529ca34175a460de6143deecd2;hb=f3709ae30f2fdb003f6691c49974be16b464da09;hp=1f3af42563d7293aa2c6f737728bbfc340b6d2b1;hpb=480afab4e0a0eb8d64367c0bd12fa3ec892a3383;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 1f3af42563..f7bb3a7e54 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 @@ -19,12 +19,14 @@ import static org.opendaylight.mdsal.binding.model.util.BindingTypes.DATA_OBJECT import static org.opendaylight.mdsal.binding.model.util.BindingTypes.DATA_ROOT; import static org.opendaylight.mdsal.binding.model.util.BindingTypes.NOTIFICATION; import static org.opendaylight.mdsal.binding.model.util.BindingTypes.NOTIFICATION_LISTENER; +import static org.opendaylight.mdsal.binding.model.util.BindingTypes.QNAME; import static org.opendaylight.mdsal.binding.model.util.BindingTypes.ROUTING_CONTEXT; import static org.opendaylight.mdsal.binding.model.util.BindingTypes.RPC_INPUT; import static org.opendaylight.mdsal.binding.model.util.BindingTypes.RPC_OUTPUT; import static org.opendaylight.mdsal.binding.model.util.BindingTypes.RPC_SERVICE; import static org.opendaylight.mdsal.binding.model.util.BindingTypes.action; import static org.opendaylight.mdsal.binding.model.util.BindingTypes.augmentable; +import static org.opendaylight.mdsal.binding.model.util.BindingTypes.augmentation; import static org.opendaylight.mdsal.binding.model.util.BindingTypes.childOf; import static org.opendaylight.mdsal.binding.model.util.BindingTypes.choiceIn; import static org.opendaylight.mdsal.binding.model.util.BindingTypes.identifiable; @@ -36,12 +38,11 @@ import static org.opendaylight.mdsal.binding.model.util.BindingTypes.opaqueObjec import static org.opendaylight.mdsal.binding.model.util.BindingTypes.rpcResult; import static org.opendaylight.mdsal.binding.model.util.Types.BOOLEAN; import static org.opendaylight.mdsal.binding.model.util.Types.STRING; -import static org.opendaylight.mdsal.binding.model.util.Types.augmentationTypeFor; import static org.opendaylight.mdsal.binding.model.util.Types.classType; import static org.opendaylight.mdsal.binding.model.util.Types.listTypeFor; import static org.opendaylight.mdsal.binding.model.util.Types.listenableFutureTypeFor; +import static org.opendaylight.mdsal.binding.model.util.Types.mapTypeFor; import static org.opendaylight.mdsal.binding.model.util.Types.primitiveVoidType; -import static org.opendaylight.mdsal.binding.model.util.Types.typeForClass; import static org.opendaylight.mdsal.binding.model.util.Types.wildcardTypeFor; import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.findDataSchemaNode; import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.findNodeInSchemaContext; @@ -61,10 +62,12 @@ import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Optional; -import java.util.Set; +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.GeneratedTransferObject; import org.opendaylight.mdsal.binding.model.api.GeneratedType; import org.opendaylight.mdsal.binding.model.api.JavaTypeName; @@ -81,12 +84,10 @@ import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilde 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.BindingGeneratorUtil; -import org.opendaylight.mdsal.binding.model.util.ReferencedTypeImpl; import org.opendaylight.mdsal.binding.model.util.TypeConstants; import org.opendaylight.mdsal.binding.model.util.generated.type.builder.GeneratedPropertyBuilderImpl; import org.opendaylight.mdsal.binding.spec.naming.BindingMapping; import org.opendaylight.mdsal.binding.yang.types.AbstractTypeProvider; -import org.opendaylight.mdsal.binding.yang.types.BaseYangTypes; import org.opendaylight.mdsal.binding.yang.types.GroupingDefinitionDependencySort; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.common.QNameModule; @@ -119,11 +120,11 @@ 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; import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition; -import org.opendaylight.yangtools.yang.model.util.DataNodeIterator; import org.opendaylight.yangtools.yang.model.util.ModuleDependencySort; import org.opendaylight.yangtools.yang.model.util.SchemaNodeUtils; import org.opendaylight.yangtools.yang.model.util.type.CompatUtils; @@ -141,8 +142,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,7 +186,7 @@ abstract class AbstractTypeGenerator { /** * Holds reference to schema context to resolve data of augmented element when creating augmentation builder. */ - private final SchemaContext schemaContext; + private final @NonNull SchemaContext schemaContext; /** * Holds renamed elements. @@ -207,6 +208,10 @@ abstract class AbstractTypeGenerator { contexts.forEach(this::allAugmentsToGenTypes); } + final @NonNull SchemaContext schemaContext() { + return schemaContext; + } + final Collection moduleContexts() { return genCtx.values(); } @@ -224,7 +229,7 @@ abstract class AbstractTypeGenerator { abstract void addCodegenInformation(GeneratedTypeBuilderBase genType, Module module, SchemaNode node); abstract void addCodegenInformation(GeneratedTypeBuilder interfaceBuilder, Module module, String description, - Set nodes); + Collection nodes); abstract void addComment(TypeMemberBuilder genType, DocumentedNode node); @@ -262,11 +267,8 @@ abstract class AbstractTypeGenerator { private void allTypeDefinitionsToGenTypes(final ModuleContext context) { final Module module = context.module(); checkArgument(module.getName() != null, "Module name cannot be NULL."); - final DataNodeIterator it = new DataNodeIterator(module); - final List> typeDefinitions = it.allTypedefs(); - checkState(typeDefinitions != null, "Type Definitions for module %s cannot be NULL.", module.getName()); - for (final TypeDefinition typedef : typeDefinitions) { + for (final TypeDefinition typedef : SchemaNodeUtils.getAllTypeDefinitions(module)) { if (typedef != null) { final Type type = typeProvider.generatedTypeForExtendedDefinitionType(typedef, typedef); if (type != null) { @@ -325,7 +327,14 @@ abstract class AbstractTypeGenerator { keyTypeBuilder = null; } - final ParameterizedType listType = listTypeFor(genType); + // Decide whether to generate a List or a Map + final ParameterizedType listType; + if (keyTypeBuilder != null && !node.isUserOrdered()) { + listType = mapTypeFor(keyTypeBuilder, genType); + } else { + listType = listTypeFor(genType); + } + constructGetter(parent, listType, node); constructNonnull(parent, listType, node); @@ -403,8 +412,7 @@ abstract class AbstractTypeGenerator { checkArgument(module != null, "Module reference cannot be NULL."); checkState(module.getAugmentations() != null, "Augmentations Set cannot be NULL."); - final Set augmentations = module.getAugmentations(); - final List sortedAugmentations = new ArrayList<>(augmentations); + final List sortedAugmentations = new ArrayList<>(module.getAugmentations()); sortedAugmentations.sort(AUGMENT_COMP); return sortedAugmentations; @@ -441,8 +449,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); @@ -470,9 +481,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; @@ -508,7 +522,7 @@ abstract class AbstractTypeGenerator { private void rpcMethodsToGenType(final ModuleContext context) { final Module module = context.module(); checkArgument(module.getName() != null, "Module name cannot be NULL."); - final Set rpcDefinitions = module.getRpcs(); + final Collection rpcDefinitions = module.getRpcs(); checkState(rpcDefinitions != null, "Set of rpcs from module " + module.getName() + " cannot be NULL."); if (rpcDefinitions.isEmpty()) { return; @@ -522,7 +536,7 @@ abstract class AbstractTypeGenerator { for (final RpcDefinition rpc : rpcDefinitions) { if (rpc != null) { final String rpcName = BindingMapping.getClassName(rpc.getQName()); - final String rpcMethodName = BindingMapping.getPropertyName(rpcName); + final String rpcMethodName = BindingMapping.getRpcMethodName(rpc.getQName()); final MethodSignatureBuilder method = interfaceBuilder.addMethod(rpcMethodName); // Do not refer to annotation class, as it may not be available at runtime @@ -573,7 +587,7 @@ abstract class AbstractTypeGenerator { private void notificationsToGenType(final ModuleContext context) { final Module module = context.module(); checkArgument(module.getName() != null, "Module name cannot be NULL."); - final Set notifications = module.getNotifications(); + final Collection notifications = module.getNotifications(); if (notifications.isEmpty()) { return; } @@ -609,7 +623,7 @@ abstract class AbstractTypeGenerator { private void notificationsToGenType( final ModuleContext context, final Type parent, final T parentSchema, final Type keyType, final boolean inGrouping) { - final Set notifications = parentSchema.getNotifications(); + final Collection notifications = parentSchema.getNotifications(); if (notifications.isEmpty()) { return; } @@ -653,7 +667,7 @@ abstract class AbstractTypeGenerator { * */ private void allIdentitiesToGenTypes(final ModuleContext context) { - final Set schemaIdentities = context.module().getIdentities(); + final Collection schemaIdentities = context.module().getIdentities(); if (schemaIdentities != null && !schemaIdentities.isEmpty()) { for (final IdentitySchemaNode identity : schemaIdentities) { @@ -689,7 +703,7 @@ abstract class AbstractTypeGenerator { } final GeneratedTypeBuilder newType = typeProvider.newGeneratedTypeBuilder(name); - final Set baseIdentities = identity.getBaseIdentities(); + final Collection baseIdentities = identity.getBaseIdentities(); if (!baseIdentities.isEmpty()) { for (IdentitySchemaNode baseIdentity : baseIdentities) { JavaTypeName base = renames.get(baseIdentity); @@ -719,7 +733,7 @@ abstract class AbstractTypeGenerator { private static Constant qnameConstant(final GeneratedTypeBuilderBase toBuilder, final JavaTypeName yangModuleInfo, final String localName) { - return toBuilder.addConstant(typeForClass(QName.class), BindingMapping.QNAME_STATIC_FIELD_NAME, + return toBuilder.addConstant(QNAME, BindingMapping.QNAME_STATIC_FIELD_NAME, new SimpleImmutableEntry<>(yangModuleInfo, localName)); } @@ -736,7 +750,8 @@ abstract class AbstractTypeGenerator { * collection of groupings from which types will be generated * */ - private void groupingsToGenTypes(final ModuleContext context, final Collection groupings) { + private void groupingsToGenTypes(final ModuleContext context, + final Collection groupings) { for (final GroupingDefinition grouping : new GroupingDefinitionDependencySort().sort(groupings)) { // Converts individual grouping to GeneratedType. Firstly generated type builder is created and every child // node of grouping is resolved to the method. @@ -815,10 +830,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); @@ -832,22 +848,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)) { - final Type targetType = new ReferencedTypeImpl(targetTypeBuilder.getIdentifier()); - addRawAugmentGenTypeDefinition(context, targetType, 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, @@ -857,7 +881,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); @@ -886,16 +910,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. * @@ -903,14 +917,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) { @@ -973,7 +1014,7 @@ abstract class AbstractTypeGenerator { augTypeBuilder.addImplementsType(DATA_OBJECT); defaultImplementedInterace(augTypeBuilder); - augTypeBuilder.addImplementsType(augmentationTypeFor(targetTypeRef)); + augTypeBuilder.addImplementsType(augmentation(targetTypeRef)); annotateDeprecatedIfNecessary(augSchema, augTypeBuilder); addImplementedInterfaceFromUses(augSchema, augTypeBuilder); @@ -997,7 +1038,7 @@ abstract class AbstractTypeGenerator { inGrouping); } - private static String getAugmentIdentifier(final List unknownSchemaNodes) { + private static String getAugmentIdentifier(final Collection unknownSchemaNodes) { for (final UnknownSchemaNode unknownSchemaNode : unknownSchemaNodes) { final QName nodeType = unknownSchemaNode.getNodeType(); if (AUGMENT_IDENTIFIER_NAME.equals(nodeType.getLocalName()) @@ -1042,7 +1083,8 @@ abstract class AbstractTypeGenerator { * child nodes) could be added to it. */ private GeneratedTypeBuilder resolveDataSchemaNodes(final ModuleContext context, final GeneratedTypeBuilder parent, - final @Nullable Type childOf, final Iterable schemaNodes, final boolean inGrouping) { + final @Nullable Type childOf, final Iterable schemaNodes, + final boolean inGrouping) { if (schemaNodes != null && parent != null) { final Type baseInterface = childOf == null ? DATA_OBJECT : childOf(childOf); for (final DataSchemaNode schemaNode : schemaNodes) { @@ -1069,7 +1111,7 @@ abstract class AbstractTypeGenerator { * The getter method could be added to it. */ private GeneratedTypeBuilder augSchemaNodeToMethods(final ModuleContext context, - final GeneratedTypeBuilder typeBuilder, final Iterable schemaNodes, + final GeneratedTypeBuilder typeBuilder, final Iterable schemaNodes, final boolean inGrouping) { if (schemaNodes != null && typeBuilder != null) { final Type baseInterface = childOf(typeBuilder); @@ -1180,7 +1222,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); @@ -1188,7 +1230,7 @@ abstract class AbstractTypeGenerator { annotateDeprecatedIfNecessary(caseNode, caseTypeBuilder); context.addCaseType(caseNode.getPath(), caseTypeBuilder); context.addChoiceToCaseMapping(refChoiceType, caseTypeBuilder, caseNode); - final Iterable caseChildNodes = caseNode.getChildNodes(); + final Iterable caseChildNodes = caseNode.getChildNodes(); if (caseChildNodes != null) { final SchemaPath choiceNodeParentPath = choiceNode.getPath().getParent(); @@ -1197,8 +1239,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) { @@ -1252,7 +1296,8 @@ abstract class AbstractTypeGenerator { // FIXME: nullness rules need to untangled in this method @SuppressFBWarnings("NP_NULL_ON_SOME_PATH") private void generateTypesFromAugmentedChoiceCases(final ModuleContext context, - final Type targetType, final ChoiceSchemaNode targetNode, final Iterable augmentedNodes, + final Type targetType, final ChoiceSchemaNode targetNode, + final Iterable augmentedNodes, final DataNodeContainer usesNodeParent, final boolean inGrouping) { checkArgument(targetType != null, "Referenced Choice Type cannot be NULL."); checkArgument(augmentedNodes != null, "Set of Choice Case Nodes cannot be NULL."); @@ -1279,7 +1324,7 @@ abstract class AbstractTypeGenerator { } else { node = findNamedCase(targetNode, caseLocalName); } - final Iterable childNodes = node.getChildNodes(); + final Iterable childNodes = node.getChildNodes(); if (childNodes != null) { resolveDataSchemaNodes(context, caseTypeBuilder, findChildOfType(targetNode), childNodes, inGrouping); @@ -1315,7 +1360,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); } @@ -1462,7 +1507,8 @@ abstract class AbstractTypeGenerator { } } - private static IdentitySchemaNode findIdentityByName(final Set identities, final String name) { + private static IdentitySchemaNode findIdentityByName(final Collection identities, + final String name) { for (final IdentitySchemaNode id : identities) { if (id.getQName().getLocalName().equals(name)) { return id; @@ -1471,7 +1517,7 @@ abstract class AbstractTypeGenerator { return null; } - private Module findModuleFromImports(final Set imports, final String prefix) { + private Module findModuleFromImports(final Collection imports, final String prefix) { for (final ModuleImport imp : imports) { if (imp.getPrefix().equals(prefix)) { return schemaContext.findModule(imp.getModuleName(), imp.getRevision()).orElse(null); @@ -1568,7 +1614,7 @@ abstract class AbstractTypeGenerator { final EnumTypeDefinition enumTypeDef = (EnumTypeDefinition) typeDef; final EnumBuilder enumBuilder = resolveInnerEnumFromTypeDefinition(enumTypeDef, nodeName, typeBuilder, context); - returnType = new ReferencedTypeImpl(enumBuilder.getIdentifier()); + returnType = DefaultType.of(enumBuilder); typeProvider.putReferencedType(node.getPath(), returnType); } else if (typeDef instanceof UnionTypeDefinition) { final UnionTypeDefinition unionDef = (UnionTypeDefinition)typeDef; @@ -1809,6 +1855,8 @@ abstract class AbstractTypeGenerator { choiceToGeneratedType(context, typeBuilder, (ChoiceSchemaNode) schemaNode, inGrouping); } else if (schemaNode instanceof ListSchemaNode) { listToGenType(context, typeBuilder, childOf(typeBuilder), (ListSchemaNode) schemaNode, inGrouping); + } else if (schemaNode instanceof AnyxmlSchemaNode || schemaNode instanceof AnydataSchemaNode) { + opaqueToGeneratedType(context, typeBuilder, schemaNode); } } } @@ -1914,10 +1962,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.getName()); } builder.addImplementsType(genType.build()); @@ -1925,6 +1973,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); @@ -1935,6 +1993,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); @@ -1982,8 +2050,7 @@ abstract class AbstractTypeGenerator { } private static void defaultImplementedInterace(final GeneratedTypeBuilder typeBuilder) { - defineImplementedInterfaceMethod(typeBuilder, new ReferencedTypeImpl(typeBuilder.getIdentifier())) - .setDefault(true); + defineImplementedInterfaceMethod(typeBuilder, DefaultType.of(typeBuilder)).setDefault(true); } private static MethodSignatureBuilder defineImplementedInterfaceMethod(final GeneratedTypeBuilder typeBuilder,