X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=binding2%2Fmdsal-binding2-generator-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fmdsal%2Fbinding%2Fjavav2%2Fgenerator%2Fimpl%2FGenHelperUtil.java;h=fa67281bdf2721b283e196da5230a331ae2cfe79;hb=f02f575e17221e644aa3b6d27005aaf86ebe2f24;hp=b1270c6bed5685d5752a884eb8bde72129522ace;hpb=70c109ac0bde4fc1c1c94e423242522df0f06cc7;p=mdsal.git diff --git a/binding2/mdsal-binding2-generator-impl/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/impl/GenHelperUtil.java b/binding2/mdsal-binding2-generator-impl/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/impl/GenHelperUtil.java index b1270c6bed..fa67281bdf 100644 --- a/binding2/mdsal-binding2-generator-impl/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/impl/GenHelperUtil.java +++ b/binding2/mdsal-binding2-generator-impl/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/impl/GenHelperUtil.java @@ -11,9 +11,7 @@ package org.opendaylight.mdsal.binding.javav2.generator.impl; import static com.google.common.base.Preconditions.checkArgument; import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.addTOToTypeBuilder; import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.annotateDeprecatedIfNecessary; -import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.augGenTypeName; import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.constructGetter; -import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.createDescription; import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.createReturnTypeForUnion; import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.getAugmentIdentifier; import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.isInnerType; @@ -24,6 +22,8 @@ import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenU import static org.opendaylight.mdsal.binding.javav2.generator.util.BindingGeneratorUtil.computeDefaultSUID; import static org.opendaylight.mdsal.binding.javav2.generator.util.BindingGeneratorUtil.encodeAngleBrackets; import static org.opendaylight.mdsal.binding.javav2.generator.util.BindingGeneratorUtil.packageNameForGeneratedType; +import static org.opendaylight.mdsal.binding.javav2.generator.util.BindingTypes.IDENTIFIABLE; +import static org.opendaylight.mdsal.binding.javav2.generator.util.BindingTypes.IDENTIFIER; import static org.opendaylight.mdsal.binding.javav2.generator.util.BindingTypes.NOTIFICATION; import static org.opendaylight.mdsal.binding.javav2.generator.util.Types.parameterizedTypeFor; import static org.opendaylight.mdsal.binding.javav2.generator.util.Types.wildcardTypeFor; @@ -39,12 +39,14 @@ import java.util.List; import java.util.Map; import java.util.Set; import java.util.stream.Collectors; +import org.opendaylight.mdsal.binding.javav2.generator.context.ModuleContext; import org.opendaylight.mdsal.binding.javav2.generator.spi.TypeProvider; import org.opendaylight.mdsal.binding.javav2.generator.util.BindingGeneratorUtil; import org.opendaylight.mdsal.binding.javav2.generator.util.BindingTypes; import org.opendaylight.mdsal.binding.javav2.generator.util.JavaIdentifier; import org.opendaylight.mdsal.binding.javav2.generator.util.JavaIdentifierNormalizer; import org.opendaylight.mdsal.binding.javav2.generator.util.ReferencedTypeImpl; +import org.opendaylight.mdsal.binding.javav2.generator.util.TypeComments; import org.opendaylight.mdsal.binding.javav2.generator.util.Types; import org.opendaylight.mdsal.binding.javav2.generator.util.generated.type.builder.GeneratedPropertyBuilderImpl; import org.opendaylight.mdsal.binding.javav2.generator.util.generated.type.builder.GeneratedTOBuilderImpl; @@ -52,27 +54,25 @@ import org.opendaylight.mdsal.binding.javav2.generator.util.generated.type.build import org.opendaylight.mdsal.binding.javav2.generator.yang.types.GroupingDefinitionDependencySort; import org.opendaylight.mdsal.binding.javav2.generator.yang.types.TypeProviderImpl; import org.opendaylight.mdsal.binding.javav2.model.api.AccessModifier; -import org.opendaylight.mdsal.binding.javav2.model.api.GeneratedTransferObject; import org.opendaylight.mdsal.binding.javav2.model.api.GeneratedType; import org.opendaylight.mdsal.binding.javav2.model.api.ParameterizedType; import org.opendaylight.mdsal.binding.javav2.model.api.Restrictions; import org.opendaylight.mdsal.binding.javav2.model.api.Type; +import org.opendaylight.mdsal.binding.javav2.model.api.YangSourceDefinition; import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.EnumBuilder; import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedPropertyBuilder; import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedTOBuilder; import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedTypeBuilder; -import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.MethodSignatureBuilder; import org.opendaylight.mdsal.binding.javav2.spec.base.BaseIdentity; import org.opendaylight.mdsal.binding.javav2.spec.base.TreeNode; import org.opendaylight.mdsal.binding.javav2.spec.runtime.BindingNamespaceType; import org.opendaylight.mdsal.binding.javav2.spec.structural.Augmentable; import org.opendaylight.mdsal.binding.javav2.util.BindingMapping; import org.opendaylight.yangtools.yang.common.QName; -import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode; import org.opendaylight.yangtools.yang.model.api.AnyDataSchemaNode; import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode; -import org.opendaylight.yangtools.yang.model.api.AugmentationSchema; -import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode; +import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode; +import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode; import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode; import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode; import org.opendaylight.yangtools.yang.model.api.DataNodeContainer; @@ -123,12 +123,18 @@ final class GenHelperUtil { static GeneratedTypeBuilder moduleToDataType(final Module module, final Map genCtx, final boolean verboseClassComments) { Preconditions.checkArgument(module != null, "Module reference cannot be NULL."); - final GeneratedTypeBuilder moduleDataTypeBuilder = moduleTypeBuilder(module, "Data", verboseClassComments); + final GeneratedTypeBuilder moduleDataTypeBuilder = moduleTypeBuilder(module, "Data", verboseClassComments, + genCtx.get(module)); addImplementedInterfaceFromUses(module, moduleDataTypeBuilder, genCtx); moduleDataTypeBuilder.addImplementsType(BindingTypes.TREE_ROOT); - moduleDataTypeBuilder.addComment(module.getDescription()); - moduleDataTypeBuilder.setDescription(createDescription(module, verboseClassComments)); - moduleDataTypeBuilder.setReference(module.getReference()); + + if (verboseClassComments) { + moduleDataTypeBuilder.setYangSourceDefinition(YangSourceDefinition.of(module)); + TypeComments.description(module).ifPresent(moduleDataTypeBuilder::addComment); + module.getDescription().ifPresent(moduleDataTypeBuilder::setDescription); + module.getReference().ifPresent(moduleDataTypeBuilder::setReference); + } + return moduleDataTypeBuilder; } @@ -148,15 +154,19 @@ final class GenHelperUtil { * if module is null */ static GeneratedTypeBuilder moduleTypeBuilder(final Module module, final String postfix, final boolean - verboseClassComments) { + verboseClassComments, final ModuleContext context) { Preconditions.checkArgument(module != null, "Module reference cannot be NULL."); final String packageName = BindingMapping.getRootPackageName(module); // underscore used as separator for distinction of module name parts final String moduleName = new StringBuilder(module.getName()).append('_').append(postfix).toString(); - final GeneratedTypeBuilderImpl moduleBuilder = new GeneratedTypeBuilderImpl(packageName, moduleName); - moduleBuilder.setDescription(createDescription(module, verboseClassComments)); - moduleBuilder.setReference(module.getReference()); + final GeneratedTypeBuilderImpl moduleBuilder = new GeneratedTypeBuilderImpl(packageName, moduleName, context); + if (verboseClassComments) { + moduleBuilder.setYangSourceDefinition(YangSourceDefinition.of(module)); + TypeComments.description(module).ifPresent(moduleBuilder::addComment); + module.getDescription().ifPresent(moduleBuilder::setDescription); + module.getReference().ifPresent(moduleBuilder::setReference); + } moduleBuilder.setModuleName(moduleName); return moduleBuilder; } @@ -245,7 +255,7 @@ final class GenHelperUtil { if (schemaNodes != null && parent != null) { for (final DataSchemaNode schemaNode : schemaNodes) { - if (!schemaNode.isAugmenting()) { + if (resolveDataSchemaNodesCheck(module, schemaContext, schemaNode)) { addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode, parent, childOf, module, genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType); } @@ -254,6 +264,17 @@ final class GenHelperUtil { return parent; } + static boolean resolveDataSchemaNodesCheck(final Module module, final SchemaContext schemaContext, + final DataSchemaNode schemaNode) { + if (!schemaNode.isAugmenting()) { + return true; + } + + final QName qname = schemaNode.getPath().getLastComponent(); + final Module originalModule = schemaContext.findModule(qname.getModule()).get(); + return module.equals(originalModule); + } + static GeneratedTypeBuilder addDefaultInterfaceDefinition(final String basePackageName, final SchemaNode schemaNode, final Module module, final Map genCtx, final SchemaContext schemaContext, final boolean verboseClassComments, final Map> genTypeBuilders, @@ -262,62 +283,36 @@ final class GenHelperUtil { verboseClassComments, genTypeBuilders, typeProvider , namespaceType); } - static Map processUsesAugments(final SchemaContext schemaContext, final - DataNodeContainer node, final Module module, Map genCtx, - final Map> genTypeBuilders, - final boolean verboseClassComments, final TypeProvider typeProvider, - final BindingNamespaceType namespaceType) { - final String basePackageName = BindingMapping.getRootPackageName(module); - for (final UsesNode usesNode : node.getUses()) { - Map> augmentationsGrouped = - usesNode.getAugmentations().stream().collect(Collectors.groupingBy(AugmentationSchema::getTargetPath)); - for (Map.Entry> schemaPathAugmentListEntry : augmentationsGrouped.entrySet()) { - genCtx = AugmentToGenType.usesAugmentationToGenTypes(schemaContext, basePackageName, - schemaPathAugmentListEntry.getValue(), module, - usesNode, node, genCtx, genTypeBuilders, verboseClassComments, typeProvider, namespaceType); - for (AugmentationSchema augSchema : schemaPathAugmentListEntry.getValue()) { - genCtx = processUsesAugments(schemaContext, augSchema, module, genCtx, genTypeBuilders, - verboseClassComments, typeProvider, namespaceType); - } - } - } - return genCtx; - } - - private static QName createQNameFromSuperNode(final Object node, final SchemaNode superChildNode) { + private static QName createQNameFromSuperNode(final Module module, final Object node, final SchemaNode superChildNode) { QName childNodeQName = null; if (node instanceof Module) { - childNodeQName = QName.create(((Module)node).getNamespace(), ((Module)node).getRevision(), - superChildNode.getQName().getLocalName()); + childNodeQName = QName.create(((Module) node).getQNameModule(), superChildNode.getQName().getLocalName()); } else if (node instanceof SchemaNode) { - childNodeQName = QName.create(((SchemaNode)node).getQName(), superChildNode.getQName().getLocalName()); + childNodeQName = QName.create(((SchemaNode) node).getQName(), superChildNode.getQName().getLocalName()); + } else if (node instanceof AugmentationSchemaNode) { + childNodeQName = QName.create(module.getQNameModule(), superChildNode.getQName().getLocalName()); } else { - throw new IllegalArgumentException("Not support node type:" + node.toString()); + throw new IllegalArgumentException("Not support node type:" + node); } return childNodeQName; } - static void addUsesImplements(final SchemaNode superNode, final Module superModule, + private static void addUsesImplements(final SchemaNode superNode, final Module superModule, final Object node, final Module module, final SchemaContext schemaContext, - Map genCtx, final BindingNamespaceType namespaceType) { - + final Map genCtx, final BindingNamespaceType namespaceType) { if (superNode instanceof DataNodeContainer) { - for (DataSchemaNode superChildNode : ((DataNodeContainer)superNode).getChildNodes()) { + for (DataSchemaNode superChildNode : ((DataNodeContainer) superNode).getChildNodes()) { if (superChildNode instanceof DataNodeContainer || superChildNode instanceof ChoiceSchemaNode) { - final QName childQName = createQNameFromSuperNode(node, superChildNode); - DataSchemaNode childNode = ((DataNodeContainer)node).getDataChildByName(childQName); - Preconditions.checkNotNull(childNode, node.toString() + "->" + childQName.toString()); + final QName childQName = createQNameFromSuperNode(module, node, superChildNode); + DataSchemaNode childNode = ((DataNodeContainer) node).getDataChildByName(childQName); + Preconditions.checkNotNull(childNode, "%s->%s", node, childQName); final GeneratedTypeBuilder type = genCtx.get(module).getChildNode(childNode.getPath()); final GeneratedTypeBuilder superType = genCtx.get(superModule).getChildNode(superChildNode.getPath()); - //TODO:delete this after supporting uses augment - if (type == null || superType == null) { - return; - } - Preconditions.checkNotNull(type, module.toString() + "->" + childNode.getPath().toString()); - Preconditions.checkNotNull(superType, superModule.toString() + "->" + superChildNode.getPath().toString()); + Preconditions.checkNotNull(type, "%s->%s", module, childNode.getPath()); + Preconditions.checkNotNull(superType, "%s->%s", superModule, superChildNode.getPath()); type.addImplementsType(superType); if (superChildNode instanceof ListSchemaNode && !((ListSchemaNode) superChildNode).getKeyDefinition().isEmpty()) { @@ -333,20 +328,20 @@ final class GenHelperUtil { } } } else if (superNode instanceof ChoiceSchemaNode) { - for (ChoiceCaseNode superCaseNode : ((ChoiceSchemaNode)superNode).getCases()) { - final QName childQName = createQNameFromSuperNode(node, superCaseNode); - ChoiceCaseNode caseNode = ((ChoiceSchemaNode)node).getCaseNodeByName(childQName); - Preconditions.checkNotNull(caseNode, node.toString() + "->" + childQName.toString()); + for (CaseSchemaNode superCaseNode : ((ChoiceSchemaNode) superNode).getCases().values()) { + final QName childQName = createQNameFromSuperNode(module, node, superCaseNode); + CaseSchemaNode caseNode = ((ChoiceSchemaNode) node).getCaseNodeByName(childQName); + Preconditions.checkNotNull(caseNode, "%s->%s", node, childQName); final GeneratedTypeBuilder type = genCtx.get(module).getCase(caseNode.getPath()); final GeneratedTypeBuilder superType = genCtx.get(superModule).getCase(superCaseNode.getPath()); - Preconditions.checkNotNull(type, module.toString() + "->" + caseNode.getPath().toString()); - Preconditions.checkNotNull(superType, superModule.toString() + "->" + superCaseNode.getPath().toString()); + Preconditions.checkNotNull(type, "%s->%s", module, caseNode.getPath()); + Preconditions.checkNotNull(superType, "%s->%s", superModule, superCaseNode.getPath()); type.addImplementsType(superType); addUsesImplements(superCaseNode, superModule, caseNode, module, schemaContext, genCtx, namespaceType); } } else { - throw new IllegalArgumentException("Not support super node :" + superNode.toString()); + throw new IllegalArgumentException("Not support super node :" + superNode); } } @@ -354,27 +349,36 @@ final class GenHelperUtil { final Object parentNode, final UsesNode usesNode) { SchemaNode groupingNode; if (parentNode instanceof Module) { - final Module superModule = schemaContext.findModuleByNamespaceAndRevision( - usesNode.getGroupingPath().getLastComponent().getModule().getNamespace(), - usesNode.getGroupingPath().getLastComponent().getModule().getRevision()); + final Module superModule = schemaContext.findModule( + usesNode.getGroupingPath().getLastComponent().getModule()).get(); groupingNode = superModule.getGroupings() .stream().filter(grouping -> grouping.getPath().equals(usesNode.getGroupingPath())) .findFirst().orElse(null); } else { //FIXME: Schema path is not unique for Yang 1.1, findDataSchemaNode always does search from data node first. - groupingNode = SchemaContextUtil.findDataSchemaNode(schemaContext, usesNode.getGroupingPath()); + final Iterable prefixedPath = usesNode.getGroupingPath().getPathFromRoot(); + final QName current = prefixedPath.iterator().next(); + final Module targetModule = schemaContext.findModule(current.getModule()).orElse(null); + Preconditions.checkArgument(targetModule != null, "Cannot find target module for %s and %s.", + current.getNamespace(), current.getRevision()); + groupingNode = targetModule.getGroupings().stream() + .filter(grouping -> grouping.getPath().equals(usesNode.getGroupingPath())) + .collect(Collectors.toList()).get(0); + if (groupingNode == null) { + groupingNode = SchemaContextUtil.findDataSchemaNode(schemaContext, usesNode.getGroupingPath()); + } } - Preconditions.checkNotNull(groupingNode, module.toString() + "->" - + usesNode.getGroupingPath().toString()); - Preconditions.checkState(groupingNode instanceof GroupingDefinition, - module.toString() + "->" + usesNode.getGroupingPath().toString()); + + Preconditions.checkNotNull(groupingNode, "%s->%s", module, usesNode.getGroupingPath()); + Preconditions.checkState(groupingNode instanceof GroupingDefinition, "%s->%s", module, + usesNode.getGroupingPath()); return (GroupingDefinition) groupingNode; } static Map processUsesImplements(final Object node, final Module module, - final SchemaContext schemaContext, Map genCtx, final BindingNamespaceType namespaceType) { + final SchemaContext schemaContext, final Map genCtx, final BindingNamespaceType namespaceType) { if (node instanceof DataNodeContainer) { - for (final UsesNode usesNode : ((DataNodeContainer)node).getUses()) { + for (final UsesNode usesNode : ((DataNodeContainer) node).getUses()) { final GroupingDefinition grouping = findGroupingNodeFromUses(module, schemaContext, node, usesNode); final Module superModule = SchemaContextUtil.findParentModule(schemaContext, grouping); addUsesImplements(grouping, superModule, node, module, schemaContext, genCtx, namespaceType); @@ -403,43 +407,36 @@ final class GenHelperUtil { return null; } - static GeneratedTypeBuilder findKeyByPath(final SchemaPath path, final Map genCtx) { - for (final ModuleContext ctx : genCtx.values()) { - final GeneratedTypeBuilder result = ctx.getKeyType(path); - if (result != null) { - return result; - } - } - return null; - } - - static Map addRawAugmentGenTypeDefinition(final Module module, final String augmentPackageName, - final Type targetTypeRef, final List schemaPathAugmentListEntry, - final Map> genTypeBuilders, final Map genCtx, - final SchemaContext schemaContext, final boolean verboseClassComments, final TypeProvider typeProvider, + static Map addRawAugmentGenTypeDefinition(final Module module, + final String augmentPackageName, final Type targetTypeRef, final SchemaNode targetNode, + final List schemaPathAugmentListEntry, + final Map> genTypeBuilders, + final Map genCtx, final SchemaContext schemaContext, + final boolean verboseClassComments, final TypeProvider typeProvider, final BindingNamespaceType namespaceType) { //pick augmentation grouped by augmentation target, there is always at least one - final AugmentationSchema augSchema = schemaPathAugmentListEntry.get(0); + final AugmentationSchemaNode augSchema = schemaPathAugmentListEntry.get(0); Map augmentBuilders = genTypeBuilders.computeIfAbsent( augmentPackageName, k -> new HashMap<>()); //this requires valid semantics in YANG model String augIdentifier = null; - for (AugmentationSchema aug : schemaPathAugmentListEntry) { + for (AugmentationSchemaNode aug : schemaPathAugmentListEntry) { + // FIXME: when there're multiple augment identifiers for augmentations of same target, + // it would pick the first identifier. augIdentifier = getAugmentIdentifier(aug.getUnknownSchemaNodes()); break; } - boolean isTypeNormalized = false; if (augIdentifier == null) { - augIdentifier = augGenTypeName(augmentBuilders, targetTypeRef.getName()); - isTypeNormalized = true; + augIdentifier = new StringBuilder(module.getName()) + .append('_').append(targetNode.getQName().getLocalName()).toString(); } GeneratedTypeBuilderImpl augTypeBuilder = new GeneratedTypeBuilderImpl(augmentPackageName, augIdentifier, - false, isTypeNormalized); + true, false, genCtx.get(module)); augTypeBuilder.addImplementsType(BindingTypes.TREE_NODE); augTypeBuilder.addImplementsType(parameterizedTypeFor(BindingTypes.INSTANTIABLE, augTypeBuilder)); @@ -449,20 +446,21 @@ final class GenHelperUtil { annotateDeprecatedIfNecessary(augSchema.getStatus(), augTypeBuilder); //produces getters for augTypeBuilder eventually - for (AugmentationSchema aug : schemaPathAugmentListEntry) { + for (AugmentationSchemaNode aug : schemaPathAugmentListEntry) { //apply all uses addImplementedInterfaceFromUses(aug, augTypeBuilder, genCtx); - augSchemaNodeToMethods(module, BindingMapping.getRootPackageName(module), augTypeBuilder, augTypeBuilder, aug.getChildNodes(), - genCtx, schemaContext, verboseClassComments, typeProvider, genTypeBuilders, namespaceType); + augSchemaNodeToMethods(module, BindingMapping.getRootPackageName(module), augTypeBuilder, augTypeBuilder, + aug.getChildNodes(), genCtx, schemaContext, verboseClassComments, typeProvider, genTypeBuilders, + namespaceType); } augmentBuilders.put(augTypeBuilder.getName(), augTypeBuilder); if(!augSchema.getChildNodes().isEmpty()) { - genCtx.get(module).addTypeToAugmentation(augTypeBuilder, augSchema); genCtx.get(module).addTargetToAugmentation(augTypeBuilder, augSchema.getTargetPath()); } genCtx.get(module).addAugmentType(augTypeBuilder); + genCtx.get(module).addTypeToAugmentations(augTypeBuilder, schemaPathAugmentListEntry); return genCtx; } @@ -532,27 +530,18 @@ final class GenHelperUtil { final SchemaContext schemaContext, final boolean verboseClassComments, final Map> genTypeBuilders, final TypeProvider typeProvider, final BindingNamespaceType namespaceType) { - String suffix = ""; - if (schemaNode instanceof GroupingDefinition) { - suffix = "grouping"; - } else if (namespaceType.equals(BindingNamespaceType.Grouping)) { - suffix = "data"; - } - - GeneratedTypeBuilder it = addRawInterfaceDefinition(basePackageName, schemaNode, schemaContext, "", suffix, - verboseClassComments, genTypeBuilders, namespaceType); + GeneratedTypeBuilder it = addRawInterfaceDefinition(basePackageName, schemaNode, schemaContext, "", "", + verboseClassComments, genTypeBuilders, namespaceType, genCtx.get(module)); if (namespaceType.equals(BindingNamespaceType.Data)) { if (parent == null) { it.addImplementsType(BindingTypes.TREE_NODE); } else { - if (parent instanceof ListSchemaNode) { + if (!(schemaNode instanceof ListSchemaNode) || + ((ListSchemaNode) schemaNode).getKeyDefinition().isEmpty()) { it.addImplementsType(parameterizedTypeFor(BindingTypes.TREE_CHILD_NODE, parent, parameterizedTypeFor - (BindingTypes.IDENTIFIABLE_ITEM, parent))); - } else { - it.addImplementsType(parameterizedTypeFor(BindingTypes.TREE_CHILD_NODE, parent, parameterizedTypeFor - (BindingTypes.ITEM, parent))); - it.addImplementsType(parameterizedTypeFor(BindingTypes.INSTANTIABLE, it)); + (BindingTypes.ITEM, it))); } + it.addImplementsType(parameterizedTypeFor(BindingTypes.INSTANTIABLE, it)); } if (!(schemaNode instanceof GroupingDefinition)) { @@ -571,19 +560,16 @@ final class GenHelperUtil { return it; } - static GeneratedTypeBuilder resolveNotification(final GeneratedTypeBuilder listenerInterface, String + static GeneratedTypeBuilder resolveNotification(final GeneratedTypeBuilder listenerInterface, final String parentName, final String basePackageName, final NotificationDefinition notification, final Module module, - final SchemaContext schemaContext, final boolean verboseClassComments, Map> - genTypeBuilders, TypeProvider typeProvider, Map genCtx) { - - processUsesAugments(schemaContext, notification, module, genCtx, genTypeBuilders, - verboseClassComments, typeProvider, BindingNamespaceType.Data); - + final SchemaContext schemaContext, final boolean verboseClassComments, final Map> + genTypeBuilders, final TypeProvider typeProvider, final Map genCtx) { final GeneratedTypeBuilder notificationInterface = addDefaultInterfaceDefinition (basePackageName, notification, null, module, genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider, BindingNamespaceType.Data); annotateDeprecatedIfNecessary(notification.getStatus(), notificationInterface); notificationInterface.addImplementsType(NOTIFICATION); + notificationInterface.addImplementsType(parameterizedTypeFor(BindingTypes.INSTANTIABLE, notificationInterface)); genCtx.get(module).addChildNodeType(notification, notificationInterface); // Notification object @@ -600,7 +586,7 @@ final class GenHelperUtil { listenerInterface.addMethod(JavaIdentifierNormalizer.normalizeSpecificIdentifier(sb.toString(), JavaIdentifier.METHOD)) .setAccessModifier(AccessModifier.PUBLIC).addParameter(notificationInterface, "notification") - .setComment(encodeAngleBrackets(notification.getDescription())).setReturnType(Types.VOID); + .setComment(encodeAngleBrackets(notification.getDescription().orElse(null))).setReturnType(Types.VOID); return listenerInterface; } @@ -632,7 +618,7 @@ final class GenHelperUtil { static GeneratedTypeBuilder addRawInterfaceDefinition(final String basePackageName, final SchemaNode schemaNode, final SchemaContext schemaContext, final String prefix, final String suffix, final boolean verboseClassComments, final Map> genTypeBuilders, - final BindingNamespaceType namespaceType) { + final BindingNamespaceType namespaceType, final ModuleContext context) { Preconditions.checkArgument(schemaNode != null, "Data Schema Node cannot be NULL."); Preconditions.checkArgument(basePackageName != null, "Base package Name for Generated Type cannot be NULL."); @@ -650,13 +636,15 @@ final class GenHelperUtil { } final String packageName = packageNameForGeneratedType(basePackageName, schemaNode.getPath(), namespaceType); - final GeneratedTypeBuilderImpl newType = new GeneratedTypeBuilderImpl(packageName, schemaNodeName); + final GeneratedTypeBuilderImpl newType = new GeneratedTypeBuilderImpl(packageName, schemaNodeName, context); final Module module = SchemaContextUtil.findParentModule(schemaContext, schemaNode); qNameConstant(newType, BindingMapping.QNAME_STATIC_FIELD_NAME, schemaNode.getQName()); - newType.addComment(schemaNode.getDescription()); - newType.setDescription(createDescription(schemaNode, newType.getFullyQualifiedName(), schemaContext, - verboseClassComments, namespaceType)); - newType.setReference(schemaNode.getReference()); + if (verboseClassComments) { + newType.setYangSourceDefinition(YangSourceDefinition.of(module, schemaNode)); + TypeComments.description(schemaNode).ifPresent(newType::addComment); + schemaNode.getDescription().ifPresent(newType::setDescription); + schemaNode.getReference().ifPresent(newType::setReference); + } newType.setSchemaPath((List) schemaNode.getPath().getPathFromRoot()); newType.setModuleName(module.getName()); newType.setBasePackageName(BindingMapping.getRootPackageName(module)); @@ -688,15 +676,15 @@ final class GenHelperUtil { schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType); } else if (node instanceof LeafListSchemaNode) { resolveLeafListSchemaNode(schemaContext, typeBuilder, (LeafListSchemaNode) node, module, - typeProvider, genCtx); + typeProvider, genCtx, verboseClassComments); } else if (node instanceof LeafSchemaNode) { resolveLeafSchemaNodeAsMethod("", schemaContext, typeBuilder, genCtx, (LeafSchemaNode) node, module, - typeProvider); + typeProvider, verboseClassComments); } else if (node instanceof ListSchemaNode) { listToGenType(module, basePackageName, typeBuilder, childOf, (ListSchemaNode) node, schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType); } else if (node instanceof ChoiceSchemaNode) { - choiceToGenType(module, schemaContext, verboseClassComments, basePackageName, childOf, + choiceToGenType(module, schemaContext, verboseClassComments, basePackageName, typeBuilder, (ChoiceSchemaNode) node, genTypeBuilders, genCtx, typeProvider, namespaceType); } else if (node instanceof AnyXmlSchemaNode || node instanceof AnyDataSchemaNode) { resolveAnyNodeAsMethod(schemaContext, typeBuilder, genCtx, node, module, typeProvider); @@ -735,9 +723,9 @@ final class GenHelperUtil { checkArgument(choiceNode != null, "Choice Schema Node cannot be NULL."); final GeneratedTypeBuilder choiceTypeBuilder = addRawInterfaceDefinition(basePackageName, choiceNode, - schemaContext, "", "", verboseClasssComments, genTypeBuilders, namespaceType); + schemaContext, "", "", verboseClasssComments, genTypeBuilders, namespaceType, genCtx.get(module)); constructGetter(parent, choiceNode.getQName().getLocalName(), - choiceNode.getDescription(), choiceTypeBuilder, choiceNode.getStatus()); + choiceNode.getDescription().orElse(null), choiceTypeBuilder, choiceNode.getStatus()); if (namespaceType.equals(BindingNamespaceType.Data)) { choiceTypeBuilder.addImplementsType(parameterizedTypeFor(BindingTypes.INSTANTIABLE, choiceTypeBuilder)); } @@ -757,7 +745,7 @@ final class GenHelperUtil { schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType); if (genType != null) { StringBuilder getterName = new StringBuilder(node.getQName().getLocalName()); - final MethodSignatureBuilder getter = constructGetter(parent, getterName.toString(), node.getDescription(), genType, node.getStatus()); + constructGetter(parent, getterName.toString(), node.getDescription().orElse(null), genType, node.getStatus()); resolveDataSchemaNodes(module, basePackageName, genType, genType, node.getChildNodes(), genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType); processUsesImplements(node, module, schemaContext, genCtx, namespaceType); @@ -778,18 +766,18 @@ final class GenHelperUtil { Type getterReturnType = Types.listTypeFor(genType); if (namespaceType.equals(BindingNamespaceType.Grouping)) { getterReturnType = Types.listTypeFor(wildcardTypeFor(genType.getPackageName(), genType.getName(), - true, true)); + true, true, null)); } - constructGetter(parent, nodeName, node.getDescription(), getterReturnType, node.getStatus()); + constructGetter(parent, nodeName, node.getDescription().orElse(null), getterReturnType, node.getStatus()); final List listKeys = node.getKeyDefinition(); final String packageName = new StringBuilder(packageNameForGeneratedType(basePackageName, node.getPath(), BindingNamespaceType.Key)).append('.').append(nodeName).toString(); //FIXME: Is it neccessary to generate interface of key and implemented by class? if (namespaceType.equals(BindingNamespaceType.Grouping)) { - final GeneratedTypeBuilder genTypeBuilder = resolveListKeyTypeBuilder(packageName, node); + final GeneratedTypeBuilder genTypeBuilder = resolveListKeyTypeBuilder(packageName, node, genCtx.get(module)); for (final DataSchemaNode schemaNode : node.getChildNodes()) { - if (!schemaNode.isAugmenting()) { + if (resolveDataSchemaNodesCheck(module, schemaContext, schemaNode)) { addSchemaNodeToListTypeBuilders(nodeName, basePackageName, schemaNode, genType, genTypeBuilder, listKeys, module, typeProvider, schemaContext, genCtx, genTypeBuilders, verboseClassComments, namespaceType); } @@ -798,21 +786,31 @@ final class GenHelperUtil { typeBuildersToGenTypes(module, genType, genTypeBuilder.toInstance(), genCtx, namespaceType); genCtx.get(module).addKeyType(node.getPath(), genTypeBuilder); } + processUsesImplements(node, module, schemaContext, genCtx, namespaceType); } else { - final GeneratedTOBuilder genTOBuilder = resolveListKeyTOBuilder(packageName, node); + final GeneratedTOBuilder genTOBuilder = resolveListKeyTOBuilder(packageName, node, genCtx.get(module)); + if (genTOBuilder != null) { + final Type identifiableMarker = Types.parameterizedTypeFor(IDENTIFIABLE, genTOBuilder); + genTOBuilder.addImplementsType(IDENTIFIER); + genType.addImplementsType(identifiableMarker); + genType.addImplementsType(parameterizedTypeFor(BindingTypes.TREE_CHILD_NODE, parent, parameterizedTypeFor + (BindingTypes.IDENTIFIABLE_ITEM, genType, genTOBuilder))); + + } + for (final DataSchemaNode schemaNode : node.getChildNodes()) { - if (!schemaNode.isAugmenting()) { + if (resolveDataSchemaNodesCheck(module, schemaContext, schemaNode)) { addSchemaNodeToListBuilders(nodeName, basePackageName, schemaNode, genType, genTOBuilder, listKeys, module, typeProvider, schemaContext, genCtx, genTypeBuilders, verboseClassComments, namespaceType); } } + processUsesImplements(node, module, schemaContext, genCtx, namespaceType); // serialVersionUID if (genTOBuilder != null) { final GeneratedPropertyBuilder prop = new GeneratedPropertyBuilderImpl("serialVersionUID"); prop.setValue(Long.toString(computeDefaultSUID(genTOBuilder))); genTOBuilder.setSUID(prop); - typeBuildersToGenTypes(module, genType, genTOBuilder.toInstance(), genCtx, namespaceType); genCtx.get(module).addGeneratedTOBuilder(node.getPath(), genTOBuilder); } @@ -828,9 +826,9 @@ final class GenHelperUtil { Type returnKeyType = keyType; if (namespaceType.equals(BindingNamespaceType.Grouping)) { returnKeyType = wildcardTypeFor(keyType.getPackageName(), keyType.getName(), - true, true); + true, true, null); } - constructGetter(typeBuilder, "key", "Returns Primary Key of Yang List Type", returnKeyType, Status.CURRENT); + constructGetter(typeBuilder, "identifier", "Returns Primary Key of Yang List Type", returnKeyType, Status.CURRENT); } } @@ -856,7 +854,7 @@ final class GenHelperUtil { */ private static Type resolveLeafSchemaNodeAsMethod(final String nodeName, final SchemaContext schemaContext, final GeneratedTypeBuilder typeBuilder, final Map genCtx, final LeafSchemaNode leaf, - final Module module, final TypeProvider typeProvider) { + final Module module, final TypeProvider typeProvider, final boolean verboseClassComments) { if (leaf == null || typeBuilder == null) { return null; } @@ -870,9 +868,27 @@ final class GenHelperUtil { Type returnType = null; final TypeDefinition typeDef = leaf.getType(); - if (isInnerType(leaf, typeDef)) { + + if (leaf.isAddedByUses()) { + Preconditions.checkState(leaf instanceof DerivableSchemaNode); + if (isInnerType(leaf, typeDef)) { + final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(typeDef); + returnType = typeProvider.javaTypeForSchemaDefinitionType(getBaseOrDeclaredType(typeDef), leaf, + restrictions, genCtx.get(module)); + } else { + if (typeDef.getBaseType() == null && (typeDef instanceof EnumTypeDefinition + || typeDef instanceof UnionTypeDefinition || typeDef instanceof BitsTypeDefinition)) { + LeafSchemaNode originalLeaf = (LeafSchemaNode) ((DerivableSchemaNode) leaf).getOriginal().orElse(null); + Preconditions.checkNotNull(originalLeaf); + returnType = genCtx.get(findParentModule(schemaContext, originalLeaf)).getInnerType(typeDef.getPath()); + } else { + final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(typeDef); + returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf, restrictions, genCtx.get(module)); + } + } + } else if (isInnerType(leaf, typeDef)) { if (typeDef instanceof EnumTypeDefinition) { - returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf); + returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf, genCtx.get(module)); final EnumTypeDefinition enumTypeDef = (EnumTypeDefinition) typeDef; final EnumBuilder enumBuilder = resolveInnerEnumFromTypeDefinition(enumTypeDef, leaf.getQName(), genCtx, typeBuilder, module); @@ -882,14 +898,15 @@ final class GenHelperUtil { ((TypeProviderImpl) typeProvider).putReferencedType(leaf.getPath(), returnType); } else if (typeDef instanceof UnionTypeDefinition) { final GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, leaf, parentModule, - typeProvider, schemaContext); + typeProvider, schemaContext, genCtx.get(module), genCtx); if (genTOBuilder != null) { //TODO: https://bugs.opendaylight.org/show_bug.cgi?id=2289 - returnType = createReturnTypeForUnion(genTOBuilder, typeDef, typeBuilder, parentModule, typeProvider); + returnType = createReturnTypeForUnion(genTOBuilder, typeDef, typeBuilder, parentModule, + typeProvider, verboseClassComments); } } else if (typeDef instanceof BitsTypeDefinition) { final GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, leaf, parentModule, - typeProvider, schemaContext); + typeProvider, schemaContext, genCtx.get(module), genCtx); if (genTOBuilder != null) { returnType = genTOBuilder.toInstance(); } @@ -900,11 +917,11 @@ final class GenHelperUtil { // and apply restrictions from leaf type final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(typeDef); returnType = typeProvider.javaTypeForSchemaDefinitionType(getBaseOrDeclaredType(typeDef), leaf, - restrictions); + restrictions, genCtx.get(module)); } } else { final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(typeDef); - returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf, restrictions); + returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf, restrictions, genCtx.get(module)); } if (returnType == null) { @@ -915,22 +932,15 @@ final class GenHelperUtil { ((TypeProviderImpl) typeProvider).putReferencedType(leaf.getPath(), returnType); } - String leafDesc = leaf.getDescription(); - if (leafDesc == null) { - leafDesc = ""; - } - final String leafGetterName; - if (!"".equals(nodeName)) { - StringBuilder sb = new StringBuilder(nodeName) - .append('_') - .append(leafName); + if ("key".equals(leafName.toLowerCase())) { + StringBuilder sb = new StringBuilder(leafName) + .append('_').append("RESERVED_WORD"); leafGetterName = sb.toString(); } else { leafGetterName = leafName; } - - constructGetter(typeBuilder, leafGetterName, leafDesc, returnType, leaf.getStatus()); + constructGetter(typeBuilder, leafGetterName, leaf.getDescription().orElse(""), returnType, leaf.getStatus()); return returnType; } @@ -956,7 +966,7 @@ final class GenHelperUtil { */ private static boolean resolveLeafListSchemaNode(final SchemaContext schemaContext, final GeneratedTypeBuilder typeBuilder, final LeafListSchemaNode node, final Module module, final TypeProvider typeProvider, - final Map genCtx) { + final Map genCtx, final boolean verboseClassComments) { if (node == null || typeBuilder == null) { return false; } @@ -969,33 +979,35 @@ final class GenHelperUtil { Type returnType = null; if (typeDef.getBaseType() == null) { if (typeDef instanceof EnumTypeDefinition) { - returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, node); + returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, node, genCtx.get(module)); final EnumTypeDefinition enumTypeDef = (EnumTypeDefinition) typeDef; final EnumBuilder enumBuilder = resolveInnerEnumFromTypeDefinition(enumTypeDef, nodeName, genCtx, typeBuilder, module); - returnType = new ReferencedTypeImpl(enumBuilder.getPackageName(), enumBuilder.getName()); + returnType = new ReferencedTypeImpl(enumBuilder.getPackageName(), enumBuilder.getName(), true, + null); ((TypeProviderImpl) typeProvider).putReferencedType(node.getPath(), returnType); } else if (typeDef instanceof UnionTypeDefinition) { final GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, node, parentModule, - typeProvider, schemaContext); + typeProvider, schemaContext, genCtx.get(module), genCtx); if (genTOBuilder != null) { - returnType = createReturnTypeForUnion(genTOBuilder, typeDef, typeBuilder, parentModule, typeProvider); + returnType = createReturnTypeForUnion(genTOBuilder, typeDef, typeBuilder, parentModule, + typeProvider, verboseClassComments); } } else if (typeDef instanceof BitsTypeDefinition) { final GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, node, parentModule, - typeProvider, schemaContext); + typeProvider, schemaContext, genCtx.get(module), genCtx); returnType = genTOBuilder.toInstance(); } else { final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(typeDef); - returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, node, restrictions); + returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, node, restrictions, genCtx.get(module)); } } else { final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(typeDef); - returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, node, restrictions); + returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, node, restrictions, genCtx.get(module)); } final ParameterizedType listType = Types.listTypeFor(returnType); - constructGetter(typeBuilder, nodeName.getLocalName(), node.getDescription(), listType, node.getStatus()); + constructGetter(typeBuilder, nodeName.getLocalName(), node.getDescription().orElse(null), listType, node.getStatus()); return true; } @@ -1039,13 +1051,8 @@ final class GenHelperUtil { checkArgument(refChoiceType != null, "Referenced Choice Type cannot be NULL."); checkArgument(choiceNode != null, "ChoiceNode cannot be NULL."); - final Set caseNodes = choiceNode.getCases(); - if (caseNodes == null) { - return; - } - - for (final ChoiceCaseNode caseNode : caseNodes) { - if (caseNode != null && !caseNode.isAugmenting()) { + for (final CaseSchemaNode caseNode : choiceNode.getCases().values()) { + if (caseNode != null && resolveDataSchemaNodesCheck(module, schemaContext, caseNode)) { final GeneratedTypeBuilder caseTypeBuilder = addDefaultInterfaceDefinition(basePackageName, caseNode, module, genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType); caseTypeBuilder.addImplementsType(refChoiceType); @@ -1060,14 +1067,14 @@ final class GenHelperUtil { if (!Iterables.isEmpty(choiceNodeParentPath.getPathFromRoot())) { SchemaNode parent = findDataSchemaNode(schemaContext, choiceNodeParentPath); - if (parent instanceof AugmentationSchema) { - final AugmentationSchema augSchema = (AugmentationSchema) parent; + if (parent instanceof AugmentationSchemaNode) { + final AugmentationSchemaNode augSchema = (AugmentationSchemaNode) parent; final SchemaPath targetPath = augSchema.getTargetPath(); SchemaNode targetSchemaNode = findDataSchemaNode(schemaContext, targetPath); if (targetSchemaNode instanceof DataSchemaNode && ((DataSchemaNode) targetSchemaNode).isAddedByUses()) { if (targetSchemaNode instanceof DerivableSchemaNode) { - targetSchemaNode = ((DerivableSchemaNode) targetSchemaNode).getOriginal().orNull(); + targetSchemaNode = ((DerivableSchemaNode) targetSchemaNode).getOriginal().orElse(null); } if (targetSchemaNode == null) { throw new IllegalStateException( @@ -1087,14 +1094,14 @@ final class GenHelperUtil { resolveDataSchemaNodes(module, basePackageName, caseTypeBuilder, childOfType, caseChildNodes, genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType); } else { - resolveDataSchemaNodes(module, basePackageName, caseTypeBuilder, moduleToDataType(module, - genCtx, verboseClassComments), caseChildNodes, genCtx, schemaContext, - verboseClassComments, genTypeBuilders, typeProvider, namespaceType); + final GeneratedTypeBuilder moduleType = genCtx.get(module).getModuleNode(); + Preconditions.checkNotNull(moduleType, "Module type can not be null."); + resolveDataSchemaNodes(module, basePackageName, caseTypeBuilder, moduleType, caseChildNodes, + genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType); } + processUsesImplements(caseNode, module, schemaContext, genCtx, namespaceType); } } - processUsesAugments(schemaContext, caseNode, module, genCtx, genTypeBuilders, verboseClassComments, - typeProvider, namespaceType); } } @@ -1107,14 +1114,8 @@ final class GenHelperUtil { return null; } - String anyDesc = node.getDescription(); - if (anyDesc == null) { - anyDesc = ""; - } - Type returnType = Types.DOCUMENT; - - constructGetter(typeBuilder, anyName, anyDesc, returnType, node.getStatus()); + constructGetter(typeBuilder, anyName, node.getDescription().orElse(""), returnType, node.getStatus()); return returnType; } @@ -1168,7 +1169,7 @@ final class GenHelperUtil { final QName leafQName = leaf.getQName(); final Type type = resolveLeafSchemaNodeAsMethod(nodeName, schemaContext, typeBuilder, genCtx, leaf, module, - typeProvider); + typeProvider, verboseClassComments); if (listKeys.contains(leafQName)) { if (type == null) { resolveLeafSchemaNodeAsProperty(nodeName, schemaContext, typeProvider, genCtx, genTOBuilder, leaf, true, @@ -1180,7 +1181,7 @@ final class GenHelperUtil { } else { if (schemaNode instanceof LeafListSchemaNode) { resolveLeafListSchemaNode(schemaContext, typeBuilder, (LeafListSchemaNode) schemaNode, module, - typeProvider, genCtx); + typeProvider, genCtx, verboseClassComments); } else if (schemaNode instanceof ContainerSchemaNode) { containerToGenType(module, basePackageName, typeBuilder, typeBuilder, (ContainerSchemaNode) schemaNode, schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType); @@ -1195,11 +1196,11 @@ final class GenHelperUtil { } private static void addSchemaNodeToListTypeBuilders(final String nodeName, final String basePackageName, - final DataSchemaNode schemaNode, final GeneratedTypeBuilder typeBuilder, - final GeneratedTypeBuilder genTypeBuilder, final List listKeys, final Module module, - final TypeProvider typeProvider, final SchemaContext schemaContext, final Map genCtx, - final Map> genTypeBuilders, final boolean verboseClassComments, - final BindingNamespaceType namespaceType) { + final DataSchemaNode schemaNode, final GeneratedTypeBuilder typeBuilder, + final GeneratedTypeBuilder genTypeBuilder, final List listKeys, final Module module, + final TypeProvider typeProvider, final SchemaContext schemaContext, final Map genCtx, + final Map> genTypeBuilders, final boolean verboseClassComments, + final BindingNamespaceType namespaceType) { checkArgument(schemaNode != null, "Data Schema Node cannot be NULL."); checkArgument(typeBuilder != null, "Generated Type Builder cannot be NULL."); @@ -1207,15 +1208,15 @@ final class GenHelperUtil { final LeafSchemaNode leaf = (LeafSchemaNode) schemaNode; final QName leafQName = leaf.getQName(); final Type type = resolveLeafSchemaNodeAsMethod(nodeName, schemaContext, typeBuilder, genCtx, leaf, module, - typeProvider); + typeProvider, verboseClassComments); if (listKeys.contains(leafQName)) { resolveLeafSchemaNodeAsMethod(nodeName, schemaContext, genTypeBuilder, genCtx, leaf, module, - typeProvider); + typeProvider, verboseClassComments); } } else { if (schemaNode instanceof LeafListSchemaNode) { resolveLeafListSchemaNode(schemaContext, typeBuilder, (LeafListSchemaNode) schemaNode, module, - typeProvider, genCtx); + typeProvider, genCtx, verboseClassComments); } else if (schemaNode instanceof ContainerSchemaNode) { containerToGenType(module, basePackageName, typeBuilder, typeBuilder, (ContainerSchemaNode) schemaNode, schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType); @@ -1240,19 +1241,17 @@ final class GenHelperUtil { // GeneratedType for this type definition should be already // created final QName qname = typeDef.getQName(); - final Module unionModule = schemaContext.findModuleByNamespaceAndRevision(qname.getNamespace(), - qname.getRevision()); + final Module unionModule = schemaContext.findModule(qname.getModule()).get(); final ModuleContext mc = genCtx.get(unionModule); returnType = mc.getTypedefs().get(typeDef.getPath()); } else if (typeDef instanceof EnumTypeDefinition && typeDef.getBaseType() == null) { // Annonymous enumeration (already generated, since it is inherited via uses). LeafSchemaNode originalLeaf = (LeafSchemaNode) SchemaNodeUtils.getRootOriginalIfPossible(leaf); QName qname = originalLeaf.getQName(); - final Module enumModule = schemaContext.findModuleByNamespaceAndRevision(qname.getNamespace(), - qname.getRevision()); + final Module enumModule = schemaContext.findModule(qname.getModule()).orElse(null); returnType = genCtx.get(enumModule).getInnerType(originalLeaf.getType().getPath()); } else { - returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf); + returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf, genCtx.get(module)); } return AuxiliaryGenUtils.resolveLeafSchemaNodeAsProperty(nodeName, toBuilder, leaf, returnType, isReadOnly); } @@ -1261,33 +1260,29 @@ final class GenHelperUtil { private static TypeDefinition getBaseOrDeclaredType(final TypeDefinition typeDef) { final TypeDefinition baseType = typeDef.getBaseType(); - return (baseType != null && baseType.getBaseType() != null) ? baseType : typeDef; + return baseType != null && baseType.getBaseType() != null ? baseType : typeDef; } @SuppressWarnings({ "rawtypes", "unchecked" }) private static GeneratedTypeBuilder processDataSchemaNode(final Module module, final String basePackageName, final GeneratedTypeBuilder childOf, final DataSchemaNode node, final SchemaContext schemaContext, - final boolean verboseClassComments, Map genCtx, final Map genCtx, final Map> genTypeBuilders, final TypeProvider typeProvider, final BindingNamespaceType namespaceType) { - if (node.isAugmenting()) { - return null; - } - final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(basePackageName, node, childOf, module, genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType); - genType.addComment(node.getDescription()); annotateDeprecatedIfNecessary(node.getStatus(), genType); - genType.setDescription(createDescription(node, genType.getFullyQualifiedName(), schemaContext, - verboseClassComments, namespaceType)); genType.setModuleName(module.getName()); - genType.setReference(node.getReference()); + if (verboseClassComments) { + genType.setYangSourceDefinition(YangSourceDefinition.of(module, node)); + TypeComments.description(node).ifPresent(genType::addComment); + node.getDescription().ifPresent(genType::setDescription); + node.getReference().ifPresent(genType::setReference); + } genType.setSchemaPath((List) node.getPath().getPathFromRoot()); genType.setParentTypeForBuilder(childOf); if (node instanceof DataNodeContainer) { genCtx.get(module).addChildNodeType(node, genType); - processUsesAugments(schemaContext, (DataNodeContainer) node, module, genCtx, genTypeBuilders, - verboseClassComments, typeProvider, namespaceType); } return genType; } @@ -1317,7 +1312,7 @@ final class GenHelperUtil { */ static Map groupingsToGenTypes(final Module module, final Collection groupings, Map genCtx, final SchemaContext schemaContext, final boolean - verboseClassComments, Map> genTypeBuilders, final TypeProvider typeProvider) { + verboseClassComments, final Map> genTypeBuilders, final TypeProvider typeProvider) { final String basePackageName = BindingMapping.getRootPackageName(module); final List groupingsSortedByDependencies = new GroupingDefinitionDependencySort() .sort(groupings); @@ -1355,15 +1350,13 @@ final class GenHelperUtil { */ private static Map groupingToGenType(final String basePackageName, final GroupingDefinition grouping, final Module module, Map genCtx, final SchemaContext schemaContext, final boolean - verboseClassComments, Map> genTypeBuilders, final TypeProvider typeProvider) { + verboseClassComments, final Map> genTypeBuilders, final TypeProvider typeProvider) { final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(basePackageName, grouping, module, genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider, BindingNamespaceType.Grouping); annotateDeprecatedIfNecessary(grouping.getStatus(), genType); genCtx.get(module).addGroupingType(grouping, genType); resolveDataSchemaNodes(module, basePackageName, genType, genType, grouping.getChildNodes(), genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider, BindingNamespaceType.Grouping); - genCtx = processUsesAugments(schemaContext, grouping, module, genCtx, genTypeBuilders, verboseClassComments, - typeProvider, BindingNamespaceType.Grouping); genCtx = processUsesImplements(grouping, module, schemaContext, genCtx, BindingNamespaceType.Grouping); return genCtx; } @@ -1390,8 +1383,8 @@ final class GenHelperUtil { * @return returns generated context */ static Map identityToGenType(final Module module, final String basePackageName, - final IdentitySchemaNode identity, final SchemaContext schemaContext, Map genCtx, - boolean verboseClassComments) { + final IdentitySchemaNode identity, final SchemaContext schemaContext, final Map genCtx, + final boolean verboseClassComments) { resolveIdentitySchemaNode(basePackageName, schemaContext, identity, module, verboseClassComments, genCtx); return genCtx; @@ -1412,13 +1405,14 @@ final class GenHelperUtil { final String packageName = BindingGeneratorUtil.packageNameForGeneratedType(basePackageName, identity.getPath(), BindingNamespaceType.Identity); - newType = new GeneratedTOBuilderImpl(packageName, identity.getQName().getLocalName(), true, false); + newType = new GeneratedTOBuilderImpl(packageName, identity.getQName().getLocalName(), true, false, + genCtx.get(module)); final Set baseIdentities = identity.getBaseIdentities(); if (baseIdentities.size() == 0) { //no base - abstract final GeneratedTOBuilderImpl gto = new GeneratedTOBuilderImpl(BaseIdentity.class.getPackage().getName(), - BaseIdentity.class.getSimpleName()); + BaseIdentity.class.getSimpleName(), genCtx.get(module)); newType.setExtendsType(gto.toInstance()); } else { //one base - inheritance @@ -1429,11 +1423,13 @@ final class GenHelperUtil { } newType.setAbstract(true); - newType.addComment(identity.getDescription()); - newType.setDescription(createDescription(identity, newType.getFullyQualifiedName(), schemaContext, - verboseClassComments, BindingNamespaceType.Identity)); - newType.setReference(identity.getReference()); - newType.setModuleName(module.getName()); + + if (verboseClassComments) { + newType.setYangSourceDefinition(YangSourceDefinition.of(module)); + TypeComments.description(module).ifPresent(newType::addComment); + module.getDescription().ifPresent(newType::setDescription); + module.getReference().ifPresent(newType::setReference); + } newType.setSchemaPath((List) identity.getPath().getPathFromRoot()); qNameConstant(newType, BindingMapping.QNAME_STATIC_FIELD_NAME, identity.getQName());