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.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;
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;
import java.util.List;
import java.util.Map;
import java.util.Set;
-import org.opendaylight.mdsal.binding.javav2.generator.context.ModuleContext;
import java.util.stream.Collectors;
+import javax.annotation.Nullable;
+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;
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.yangtools.yang.common.QName;
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;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UsesNode;
-import org.opendaylight.yangtools.yang.model.api.meta.ModelStatement;
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.UnionTypeDefinition;
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;
}
* if <code>module</code> is null
*/
static GeneratedTypeBuilder moduleTypeBuilder(final Module module, final String postfix, final boolean
- verboseClassComments, ModuleContext context) {
+ 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, context);
- moduleBuilder.setDescription(createDescription(module, verboseClassComments));
- moduleBuilder.setReference(module.getReference());
+ 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;
}
final DataSchemaNode schemaNode) {
if (!schemaNode.isAugmenting()) {
return true;
- } else if (schemaNode.isAugmenting()) {
- QName qname = schemaNode.getPath().getLastComponent();
- final Module originalModule = schemaContext.findModuleByNamespaceAndRevision(qname.getNamespace(),
- qname.getRevision());
- if (module.equals(originalModule)) {
- return true;
- }
}
- return false;
- }
-
- static GeneratedTypeBuilder addDefaultInterfaceDefinition(final String basePackageName, final SchemaNode
- schemaNode, final Module module, final Map<Module, ModuleContext> genCtx, final SchemaContext schemaContext,
- final boolean verboseClassComments, final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders,
- final TypeProvider typeProvider, final BindingNamespaceType namespaceType) {
- return addDefaultInterfaceDefinition(basePackageName, schemaNode, null, module, genCtx, schemaContext,
- verboseClassComments, genTypeBuilders, typeProvider , namespaceType);
+ final QName qname = schemaNode.getPath().getLastComponent();
+ final Module originalModule = schemaContext.findModule(qname.getModule()).get();
+ return module.equals(originalModule);
}
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());
- } else if (node instanceof AugmentationSchema) {
- childNodeQName = QName.create(module.getNamespace(), module.getRevision(), 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;
private static void addUsesImplements(final SchemaNode superNode, final Module superModule,
final Object node, final Module module, final SchemaContext schemaContext,
- Map<Module, ModuleContext> genCtx, final BindingNamespaceType namespaceType) {
+ final Map<Module, ModuleContext> genCtx, final BindingNamespaceType namespaceType) {
if (superNode instanceof DataNodeContainer) {
for (DataSchemaNode superChildNode : ((DataNodeContainer) superNode).getChildNodes()) {
if (superChildNode instanceof DataNodeContainer || superChildNode instanceof ChoiceSchemaNode) {
final QName childQName = createQNameFromSuperNode(module, node, superChildNode);
DataSchemaNode childNode = ((DataNodeContainer) node).getDataChildByName(childQName);
- Preconditions.checkNotNull(childNode, node.toString() + "->" + childQName.toString());
+ 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());
- 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()) {
}
}
} else if (superNode instanceof ChoiceSchemaNode) {
- for (ChoiceCaseNode superCaseNode : ((ChoiceSchemaNode) superNode).getCases()) {
+ for (CaseSchemaNode superCaseNode : ((ChoiceSchemaNode) superNode).getCases().values()) {
final QName childQName = createQNameFromSuperNode(module, node, superCaseNode);
- ChoiceCaseNode caseNode = ((ChoiceSchemaNode) node).getCaseNodeByName(childQName);
- Preconditions.checkNotNull(caseNode, node.toString() + "->" + childQName.toString());
+ 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);
}
}
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);
//FIXME: Schema path is not unique for Yang 1.1, findDataSchemaNode always does search from data node first.
final Iterable<QName> prefixedPath = usesNode.getGroupingPath().getPathFromRoot();
final QName current = prefixedPath.iterator().next();
- final Module targetModule = schemaContext.findModuleByNamespaceAndRevision(current.getNamespace(), current.getRevision());
+ 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()))
+ 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<Module, ModuleContext> processUsesImplements(final Object node, final Module module,
- final SchemaContext schemaContext, Map<Module, ModuleContext> genCtx, final BindingNamespaceType namespaceType) {
+ final SchemaContext schemaContext, final Map<Module, ModuleContext> genCtx, final BindingNamespaceType namespaceType) {
if (node instanceof DataNodeContainer) {
for (final UsesNode usesNode : ((DataNodeContainer) node).getUses()) {
final GroupingDefinition grouping = findGroupingNodeFromUses(module, schemaContext, node, usesNode);
return null;
}
- static Map<Module, ModuleContext> addRawAugmentGenTypeDefinition(final Module module, final String augmentPackageName,
- final Type targetTypeRef, final SchemaNode targetNode, final List<AugmentationSchema> schemaPathAugmentListEntry,
- final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final Map<Module, ModuleContext> genCtx,
- final SchemaContext schemaContext, final boolean verboseClassComments, final TypeProvider typeProvider,
+ static Map<Module, ModuleContext> addRawAugmentGenTypeDefinition(final Module module,
+ final String augmentPackageName, final Type targetTypeRef, final SchemaNode targetNode,
+ final List<AugmentationSchemaNode> schemaPathAugmentListEntry,
+ final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders,
+ final Map<Module, ModuleContext> 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<String, GeneratedTypeBuilder> 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;
}
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;
}
* string contains the module package name
* @param schemaNode
* schema node for which is created generated type builder
- * @param parent
- * parent type (can be null)
+ * @param childOf
+ * parent generated type of data tree node, which should be
+ * set null if current schema node is not a data tree node.
* @param schemaContext schema context
* @return generated type builder <code>schemaNode</code>
*/
- private static GeneratedTypeBuilder addDefaultInterfaceDefinition(final String basePackageName, final SchemaNode
- schemaNode, final Type parent, final Module module, final Map<Module, ModuleContext> genCtx,
+ public static GeneratedTypeBuilder addDefaultInterfaceDefinition(final String basePackageName, final SchemaNode
+ schemaNode, @Nullable final Type childOf, final Module module, final Map<Module, ModuleContext> genCtx,
final SchemaContext schemaContext, final boolean verboseClassComments, final Map<String, Map<String,
GeneratedTypeBuilder>> 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,
+ GeneratedTypeBuilder it = addRawInterfaceDefinition(basePackageName, schemaNode, schemaContext, "", "",
verboseClassComments, genTypeBuilders, namespaceType, genCtx.get(module));
+
if (namespaceType.equals(BindingNamespaceType.Data)) {
- if (parent == null) {
+ if (childOf == null) {
it.addImplementsType(BindingTypes.TREE_NODE);
} else {
- if (parent instanceof ListSchemaNode) {
- 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));
+ if (!(schemaNode instanceof ListSchemaNode) ||
+ ((ListSchemaNode) schemaNode).getKeyDefinition().isEmpty()) {
+ it.addImplementsType(parameterizedTypeFor(BindingTypes.TREE_CHILD_NODE, childOf,
+ parameterizedTypeFor(BindingTypes.ITEM, it)));
}
}
- if (!(schemaNode instanceof GroupingDefinition)) {
- it.addImplementsType(BindingTypes.augmentable(it));
+ if (!(schemaNode instanceof CaseSchemaNode)) {
+ it.addImplementsType(parameterizedTypeFor(BindingTypes.INSTANTIABLE, it));
}
+
+ it.addImplementsType(BindingTypes.augmentable(it));
} else {
it.addImplementsType(BindingTypes.TREE_NODE);
}
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<String, Map<String, GeneratedTypeBuilder>>
- genTypeBuilders, TypeProvider typeProvider, Map<Module, ModuleContext> genCtx) {
+ final SchemaContext schemaContext, final boolean verboseClassComments, final Map<String, Map<String, GeneratedTypeBuilder>>
+ genTypeBuilders, final TypeProvider typeProvider, final Map<Module, ModuleContext> genCtx) {
final GeneratedTypeBuilder notificationInterface = addDefaultInterfaceDefinition
(basePackageName, notification, null, module, genCtx, schemaContext,
verboseClassComments, genTypeBuilders, typeProvider, BindingNamespaceType.Data);
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;
}
static GeneratedTypeBuilder addRawInterfaceDefinition(final String basePackageName, final SchemaNode schemaNode,
final SchemaContext schemaContext, final String prefix, final String suffix,
final boolean verboseClassComments, final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders,
- final BindingNamespaceType namespaceType, ModuleContext context) {
+ 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.");
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<QName>) schemaNode.getPath().getPathFromRoot());
newType.setModuleName(module.getName());
newType.setBasePackageName(BindingMapping.getRootPackageName(module));
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, childOf,
(ChoiceSchemaNode) node, genTypeBuilders, genCtx, typeProvider, namespaceType);
} else if (node instanceof AnyXmlSchemaNode || node instanceof AnyDataSchemaNode) {
resolveAnyNodeAsMethod(schemaContext, typeBuilder, genCtx, node, module, typeProvider);
* </ul>
*/
private static void choiceToGenType(final Module module, final SchemaContext schemaContext, final boolean
- verboseClasssComments, final String basePackageName, final GeneratedTypeBuilder parent, final
- ChoiceSchemaNode choiceNode, final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders,
- final Map<Module, ModuleContext> genCtx, final TypeProvider typeProvider, final BindingNamespaceType namespaceType) {
+ verboseClasssComments, final String basePackageName, final GeneratedTypeBuilder parent,
+ final GeneratedTypeBuilder childOf, final ChoiceSchemaNode choiceNode,
+ final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders,
+ final Map<Module, ModuleContext> genCtx, final TypeProvider typeProvider,
+ final BindingNamespaceType namespaceType) {
checkArgument(basePackageName != null, "Base Package Name cannot be NULL.");
checkArgument(choiceNode != null, "Choice Schema Node cannot be NULL.");
final GeneratedTypeBuilder choiceTypeBuilder = addRawInterfaceDefinition(basePackageName, choiceNode,
- schemaContext, "", "", verboseClasssComments, genTypeBuilders, namespaceType, genCtx.get(module));
+ schemaContext, "", "", verboseClasssComments, genTypeBuilders, namespaceType, genCtx.get(module));
constructGetter(parent, choiceNode.getQName().getLocalName(),
- choiceNode.getDescription(), choiceTypeBuilder, choiceNode.getStatus());
+ choiceNode.getDescription().orElse(null), choiceTypeBuilder, choiceNode.getStatus());
+ choiceTypeBuilder.setParentTypeForBuilder(childOf);
if (namespaceType.equals(BindingNamespaceType.Data)) {
choiceTypeBuilder.addImplementsType(parameterizedTypeFor(BindingTypes.INSTANTIABLE, choiceTypeBuilder));
}
schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType);
if (genType != null) {
StringBuilder getterName = new StringBuilder(node.getQName().getLocalName());
- 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);
getterReturnType = Types.listTypeFor(wildcardTypeFor(genType.getPackageName(), genType.getName(),
true, true, null));
}
- constructGetter(parent, nodeName, node.getDescription(), getterReturnType, node.getStatus());
+ constructGetter(parent, nodeName, node.getDescription().orElse(null), getterReturnType, node.getStatus());
final List<QName> listKeys = node.getKeyDefinition();
final String packageName = new StringBuilder(packageNameForGeneratedType(basePackageName, node.getPath(),
processUsesImplements(node, module, schemaContext, genCtx, namespaceType);
} else {
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, childOf, parameterizedTypeFor
+ (BindingTypes.IDENTIFIABLE_ITEM, genType, genTOBuilder)));
+
+ }
+
for (final DataSchemaNode schemaNode : node.getChildNodes()) {
if (resolveDataSchemaNodesCheck(module, schemaContext, schemaNode)) {
addSchemaNodeToListBuilders(nodeName, basePackageName, schemaNode, genType, genTOBuilder, listKeys,
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);
}
returnKeyType = wildcardTypeFor(keyType.getPackageName(), keyType.getName(),
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);
}
}
*/
private static Type resolveLeafSchemaNodeAsMethod(final String nodeName, final SchemaContext schemaContext,
final GeneratedTypeBuilder typeBuilder, final Map<Module, ModuleContext> 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;
}
if (leaf.isAddedByUses()) {
Preconditions.checkState(leaf instanceof DerivableSchemaNode);
- LeafSchemaNode originalLeaf = (LeafSchemaNode)((DerivableSchemaNode) leaf).getOriginal().orNull();
- Preconditions.checkNotNull(originalLeaf);
- if (isInnerType(originalLeaf, typeDef)) {
- if (typeDef instanceof EnumTypeDefinition
- || typeDef instanceof UnionTypeDefinition
- || typeDef instanceof BitsTypeDefinition) {
+ 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(getBaseOrDeclaredType(typeDef), leaf,
- restrictions, genCtx.get(module));
+ returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf, restrictions, genCtx.get(module));
}
- } 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) {
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,
returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf, restrictions, genCtx.get(module));
}
-
if (returnType == null) {
return null;
}
((TypeProviderImpl) typeProvider).putReferencedType(leaf.getPath(), returnType);
}
- String leafDesc = leaf.getDescription();
- if (leafDesc == null) {
- leafDesc = "";
- }
-
final String leafGetterName;
if ("key".equals(leafName.toLowerCase())) {
StringBuilder sb = new StringBuilder(leafName)
} else {
leafGetterName = leafName;
}
- constructGetter(typeBuilder, leafGetterName, leafDesc, returnType, leaf.getStatus());
+ constructGetter(typeBuilder, leafGetterName, leaf.getDescription().orElse(""), returnType, leaf.getStatus());
return returnType;
}
*/
private static boolean resolveLeafListSchemaNode(final SchemaContext schemaContext, final GeneratedTypeBuilder
typeBuilder, final LeafListSchemaNode node, final Module module, final TypeProvider typeProvider,
- final Map<Module, ModuleContext> genCtx) {
+ final Map<Module, ModuleContext> genCtx, final boolean verboseClassComments) {
if (node == null || typeBuilder == null) {
return false;
}
final GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, node, parentModule,
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,
}
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;
}
* </ul>
*/
private static void generateTypesFromChoiceCases(final Module module, final SchemaContext schemaContext,
- final Map<Module, ModuleContext> genCtx, final String basePackageName, final Type refChoiceType,
- final ChoiceSchemaNode choiceNode, final boolean verboseClassComments, final TypeProvider typeProvider,
- final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final BindingNamespaceType namespaceType) {
+ final Map<Module, ModuleContext> genCtx, final String basePackageName, final GeneratedType refChoiceType,
+ final ChoiceSchemaNode choiceNode, final boolean verboseClassComments,
+ final TypeProvider typeProvider, final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders,
+ final BindingNamespaceType namespaceType) {
checkArgument(basePackageName != null, "Base Package Name cannot be NULL.");
checkArgument(refChoiceType != null, "Referenced Choice Type cannot be NULL.");
checkArgument(choiceNode != null, "ChoiceNode cannot be NULL.");
- final Set<ChoiceCaseNode> caseNodes = choiceNode.getCases();
- if (caseNodes == null) {
- return;
- }
-
- for (final ChoiceCaseNode caseNode : caseNodes) {
+ 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);
+ null, module, genCtx, schemaContext, verboseClassComments,
+ genTypeBuilders, typeProvider, namespaceType);
caseTypeBuilder.addImplementsType(refChoiceType);
- caseTypeBuilder.setParentTypeForBuilder(refChoiceType);
+ caseTypeBuilder.setParentTypeForBuilder(refChoiceType.getParentTypeForBuilder());
annotateDeprecatedIfNecessary(caseNode.getStatus(), caseTypeBuilder);
genCtx.get(module).addCaseType(caseNode.getPath(), caseTypeBuilder);
- genCtx.get(module).addChoiceToCaseMapping(refChoiceType, caseTypeBuilder, caseNode);
- final Iterable<DataSchemaNode> caseChildNodes = caseNode.getChildNodes();
- if (caseChildNodes != null) {
- final SchemaPath choiceNodeParentPath = choiceNode.getPath().getParent();
-
- if (!Iterables.isEmpty(choiceNodeParentPath.getPathFromRoot())) {
- SchemaNode parent = findDataSchemaNode(schemaContext, choiceNodeParentPath);
-
- if (parent instanceof AugmentationSchema) {
- final AugmentationSchema augSchema = (AugmentationSchema) 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();
- }
- if (targetSchemaNode == null) {
- throw new IllegalStateException(
- "Failed to find target node from grouping for augmentation " + augSchema
- + " in module " + module.getName());
- }
- }
- parent = targetSchemaNode;
- }
-
- Preconditions.checkState(parent != null, "Could not find Choice node parent %s",
- choiceNodeParentPath);
- GeneratedTypeBuilder childOfType = findChildNodeByPath(parent.getPath(), genCtx);
- if (childOfType == null) {
- childOfType = findGroupingByPath(parent.getPath(), genCtx);
- }
- resolveDataSchemaNodes(module, basePackageName, caseTypeBuilder, childOfType, caseChildNodes,
- genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
- } else {
- 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);
+ if (namespaceType.equals(BindingNamespaceType.Data)) {
+ genCtx.get(module).addChoiceToCaseMapping(refChoiceType, caseTypeBuilder, caseNode);
}
+
+ resolveDataSchemaNodes(module, basePackageName, caseTypeBuilder,
+ (GeneratedTypeBuilder) refChoiceType.getParentTypeForBuilder(), caseNode.getChildNodes(),
+ genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
+ processUsesImplements(caseNode, module, schemaContext, genCtx, namespaceType);
}
}
}
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;
}
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,
} 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);
listToGenType(module, basePackageName, typeBuilder, typeBuilder, (ListSchemaNode) schemaNode,
schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType);
} else if (schemaNode instanceof ChoiceSchemaNode) {
- choiceToGenType(module, schemaContext, verboseClassComments, basePackageName, typeBuilder,
+ choiceToGenType(module, schemaContext, verboseClassComments, basePackageName, typeBuilder, typeBuilder,
(ChoiceSchemaNode) schemaNode, genTypeBuilders, genCtx, typeProvider, namespaceType);
}
}
}
private static void addSchemaNodeToListTypeBuilders(final String nodeName, final String basePackageName,
- final DataSchemaNode schemaNode, final GeneratedTypeBuilder typeBuilder,
- final GeneratedTypeBuilder genTypeBuilder, final List<QName> listKeys, final Module module,
- final TypeProvider typeProvider, final SchemaContext schemaContext, final Map<Module, ModuleContext> genCtx,
- final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final boolean verboseClassComments,
- final BindingNamespaceType namespaceType) {
+ final DataSchemaNode schemaNode, final GeneratedTypeBuilder typeBuilder,
+ final GeneratedTypeBuilder genTypeBuilder, final List<QName> listKeys, final Module module,
+ final TypeProvider typeProvider, final SchemaContext schemaContext, final Map<Module, ModuleContext> genCtx,
+ final Map<String, Map<String, GeneratedTypeBuilder>> 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.");
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);
listToGenType(module, basePackageName, typeBuilder, typeBuilder, (ListSchemaNode) schemaNode,
schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType);
} else if (schemaNode instanceof ChoiceSchemaNode) {
- choiceToGenType(module, schemaContext, verboseClassComments, basePackageName, typeBuilder,
+ choiceToGenType(module, schemaContext, verboseClassComments, basePackageName, typeBuilder, typeBuilder,
(ChoiceSchemaNode) schemaNode, genTypeBuilders, genCtx, typeProvider, namespaceType);
}
}
// 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, genCtx.get(module));
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<Module, ModuleContext> genCtx, final Map<String, Map<String,
+ final boolean verboseClassComments, final Map<Module, ModuleContext> genCtx, final Map<String, Map<String,
GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider, final BindingNamespaceType namespaceType) {
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) {
*/
static Map<Module, ModuleContext> groupingsToGenTypes(final Module module, final Collection<GroupingDefinition>
groupings, Map<Module, ModuleContext> genCtx, final SchemaContext schemaContext, final boolean
- verboseClassComments, Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider) {
+ verboseClassComments, final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider) {
final String basePackageName = BindingMapping.getRootPackageName(module);
final List<GroupingDefinition> groupingsSortedByDependencies = new GroupingDefinitionDependencySort()
.sort(groupings);
*/
private static Map<Module, ModuleContext> groupingToGenType(final String basePackageName, final GroupingDefinition grouping, final Module
module, Map<Module, ModuleContext> genCtx, final SchemaContext schemaContext, final boolean
- verboseClassComments, Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider) {
- final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(basePackageName, grouping, module, genCtx,
+ verboseClassComments, final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider) {
+ final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(basePackageName, grouping, null, module, genCtx,
schemaContext, verboseClassComments, genTypeBuilders, typeProvider, BindingNamespaceType.Grouping);
annotateDeprecatedIfNecessary(grouping.getStatus(), genType);
genCtx.get(module).addGroupingType(grouping, genType);
* @return returns generated context
*/
static Map<Module, ModuleContext> identityToGenType(final Module module, final String basePackageName,
- final IdentitySchemaNode identity, final SchemaContext schemaContext, Map<Module, ModuleContext> genCtx,
- boolean verboseClassComments) {
+ final IdentitySchemaNode identity, final SchemaContext schemaContext, final Map<Module, ModuleContext> genCtx,
+ final boolean verboseClassComments) {
resolveIdentitySchemaNode(basePackageName, schemaContext, identity, module, verboseClassComments, genCtx);
return genCtx;
}
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());