package org.opendaylight.mdsal.binding.javav2.generator.impl;
import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
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.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 static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.findDataSchemaNode;
+import static org.opendaylight.mdsal.binding.javav2.generator.yang.types.TypeGenHelper.resolveRegExpressions;
import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.findParentModule;
import com.google.common.annotations.Beta;
import com.google.common.base.Preconditions;
-import com.google.common.collect.Iterables;
+
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Set;
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.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.generator.util.generated.type.builder.GeneratedTypeBuilderImpl;
+import org.opendaylight.mdsal.binding.javav2.generator.yang.types.BaseYangTypes;
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.yangtools.yang.model.api.UsesNode;
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
import org.opendaylight.yangtools.yang.model.util.SchemaNodeUtils;
/**
* Create GeneratedTypeBuilder object from module argument.
*
- * @param module
- * Module object from which builder will be created
- * @param genCtx generated context
+ * @param module Module object from which builder will be created
+ * @param genCtx generated context
* @param verboseClassComments verbosity switch
- *
* @return <code>GeneratedTypeBuilder</code> which is internal
- * representation of the module
- * @throws IllegalArgumentException
- * if module is null
+ * representation of the module
+ * @throws IllegalArgumentException if module is null
*/
- static GeneratedTypeBuilder moduleToDataType(final Module module, final Map<Module, ModuleContext> genCtx, final boolean verboseClassComments) {
+ static GeneratedTypeBuilder moduleToDataType(final Module module, final Map<Module, ModuleContext> genCtx,
+ final boolean verboseClassComments) {
Preconditions.checkArgument(module != null, "Module reference cannot be NULL.");
final GeneratedTypeBuilder moduleDataTypeBuilder = moduleTypeBuilder(module, "Data", verboseClassComments,
moduleDataTypeBuilder.addImplementsType(BindingTypes.TREE_ROOT);
if (verboseClassComments) {
- moduleDataTypeBuilder.setYangSourceDefinition(YangSourceDefinition.of(module));
+ YangSourceDefinition.of(module).ifPresent(moduleDataTypeBuilder::setYangSourceDefinition);
TypeComments.description(module).ifPresent(moduleDataTypeBuilder::addComment);
module.getDescription().ifPresent(moduleDataTypeBuilder::setDescription);
module.getReference().ifPresent(moduleDataTypeBuilder::setReference);
/**
* Generates type builder for <code>module</code>.
*
- * @param module
- * Module which is source of package name for generated type
- * builder
- * @param postfix
- * string which is added to the module class name representation
- * as suffix
+ * @param module Module which is source of package name for generated type
+ * builder
+ * @param postfix string which is added to the module class name representation
+ * as suffix
* @param verboseClassComments verbosity switch
* @return instance of GeneratedTypeBuilder which represents
- * <code>module</code>.
- * @throws IllegalArgumentException
- * if <code>module</code> is null
+ * <code>module</code>.
+ * @throws IllegalArgumentException if <code>module</code> is null
*/
static GeneratedTypeBuilder moduleTypeBuilder(final Module module, final String postfix, final boolean
verboseClassComments, final ModuleContext context) {
final GeneratedTypeBuilderImpl moduleBuilder = new GeneratedTypeBuilderImpl(packageName, moduleName, context);
if (verboseClassComments) {
- moduleBuilder.setYangSourceDefinition(YangSourceDefinition.of(module));
+ YangSourceDefinition.of(module).ifPresent(moduleBuilder::setYangSourceDefinition);
TypeComments.description(module).ifPresent(moduleBuilder::addComment);
module.getDescription().ifPresent(moduleBuilder::setDescription);
module.getReference().ifPresent(moduleBuilder::setReference);
/**
* Adds the implemented types to type builder.
*
+ * <p>
* The method passes through the list of <i>uses</i> in
* {@code dataNodeContainer}. For every <i>use</i> is obtained corresponding
* generated type from all groupings
* allGroupings} which is added as <i>implements type</i> to
* <code>builder</code>
*
- * @param dataNodeContainer
- * element which contains the list of used YANG groupings
- * @param builder
- * builder to which are added implemented types according to
- * <code>dataNodeContainer</code>
- * @param genCtx generated context
+ * @param dataNodeContainer element which contains the list of used YANG groupings
+ * @param builder builder to which are added implemented types according to
+ * <code>dataNodeContainer</code>
+ * @param genCtx generated context
* @return generated type builder with all implemented types
*/
static GeneratedTypeBuilder addImplementedInterfaceFromUses(final DataNodeContainer dataNodeContainer,
- final GeneratedTypeBuilder builder, final Map<Module, ModuleContext> genCtx) {
+ final GeneratedTypeBuilder builder, final Map<Module,
+ ModuleContext> genCtx) {
for (final UsesNode usesNode : dataNodeContainer.getUses()) {
final GeneratedType genType = findGroupingByPath(usesNode.getGroupingPath(), genCtx).toInstance();
if (genType == null) {
throw new IllegalStateException("Grouping " + usesNode.getGroupingPath() + "is not resolved for "
- + builder.getName());
+ + builder.getName());
}
builder.addImplementsType(genType);
}
return builder;
}
- static GeneratedTypeBuilder findGroupingByPath(final SchemaPath path, final Map<Module, ModuleContext> genCtx) {
+ static GeneratedTypeBuilder findGroupingByPath(final SchemaPath path, final Map<Module, ModuleContext> genCtx) {
for (final ModuleContext ctx : genCtx.values()) {
final GeneratedTypeBuilder result = ctx.getGrouping(path);
if (result != null) {
}
}
return null;
- }
+ }
- static GeneratedTOBuilder findIdentityByQname(final QName qname, final Map<Module, ModuleContext> genCtx) {
+ static GeneratedTypeBuilder findIdentityByQname(final QName qname, final Map<Module, ModuleContext> genCtx) {
for (final ModuleContext ctx : genCtx.values()) {
- final GeneratedTOBuilder result = ctx.getIdentities().get(qname);
+ final GeneratedTypeBuilder result = ctx.getIdentities().get(qname);
if (result != null) {
return result;
}
* Adds the methods to <code>typeBuilder</code> which represent subnodes of
* node for which <code>typeBuilder</code> was created.
*
+ * <p>
* The subnodes aren't mapped to the methods if they are part of grouping or
* augment (in this case are already part of them).
*
- * @param module
- * current module
- * @param basePackageName
- * string contains the module package name
- * @param parent
- * generated type builder which represents any node. The subnodes
- * of this node are added to the <code>typeBuilder</code> as
- * methods. The subnode can be of type leaf, leaf-list, list,
- * container, choice.
- * @param childOf
- * parent type
- * @param schemaNodes
- * set of data schema nodes which are the children of the node
- * for which <code>typeBuilder</code> was created
+ * @param module current module
+ * @param basePackageName string contains the module package name
+ * @param parent generated type builder which represents any node. The subnodes
+ * of this node are added to the <code>typeBuilder</code> as
+ * methods. The subnode can be of type leaf, leaf-list, list,
+ * container, choice.
+ * @param childOf parent type
+ * @param schemaNodes set of data schema nodes which are the children of the node
+ * for which <code>typeBuilder</code> was created
* @return generated type builder which is the same builder as input
- * parameter. The getter methods (representing child nodes) could be
- * added to it.
+ * parameter. The getter methods (representing child nodes) could be
+ * added to it.
*/
static GeneratedTypeBuilder resolveDataSchemaNodes(final Module module, final String basePackageName,
- final GeneratedTypeBuilder parent, final GeneratedTypeBuilder childOf,
- final Iterable<DataSchemaNode> schemaNodes, final Map<Module, ModuleContext> genCtx,
- final SchemaContext schemaContext, final boolean verboseClassComments,
- final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders,
- final TypeProvider typeProvider, final BindingNamespaceType namespaceType) {
+ final GeneratedTypeBuilder parent, final GeneratedTypeBuilder
+ childOf,
+ final Iterable<DataSchemaNode> schemaNodes, final Map<Module,
+ ModuleContext> genCtx,
+ final SchemaContext schemaContext, final boolean
+ verboseClassComments,
+ final Map<String, Map<String, GeneratedTypeBuilder>>
+ genTypeBuilders,
+ final TypeProvider typeProvider, final BindingNamespaceType
+ namespaceType) {
if (schemaNodes != null && parent != null) {
for (final DataSchemaNode schemaNode : schemaNodes) {
}
static boolean resolveDataSchemaNodesCheck(final Module module, final SchemaContext schemaContext,
- final DataSchemaNode schemaNode) {
+ final DataSchemaNode schemaNode) {
if (!schemaNode.isAugmenting()) {
return true;
}
return module.equals(originalModule);
}
- private static QName createQNameFromSuperNode(final Module module, 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).getQNameModule(), superChildNode.getQName().getLocalName());
}
private static void addUsesImplements(final SchemaNode superNode, final Module superModule,
- final Object node, final Module module, final SchemaContext schemaContext,
- final Map<Module, ModuleContext> genCtx, final BindingNamespaceType namespaceType) {
+ final Object node, final Module module, final SchemaContext schemaContext,
+ 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, "%s->%s", node, childQName);
+ requireNonNull(childNode, () -> node + "->" + childQName);
final GeneratedTypeBuilder type = genCtx.get(module).getChildNode(childNode.getPath());
- final GeneratedTypeBuilder superType = genCtx.get(superModule).getChildNode(superChildNode.getPath());
+ final GeneratedTypeBuilder superType = genCtx.get(superModule).getChildNode(superChildNode
+ .getPath());
- Preconditions.checkNotNull(type, "%s->%s", module, childNode.getPath());
- Preconditions.checkNotNull(superType, "%s->%s", superModule, superChildNode.getPath());
+ requireNonNull(type, () -> module + "->" + childNode.getPath());
+ requireNonNull(superType, () -> superModule + "->" + superChildNode.getPath());
type.addImplementsType(superType);
if (superChildNode instanceof ListSchemaNode
&& !((ListSchemaNode) superChildNode).getKeyDefinition().isEmpty()) {
- if (namespaceType.equals(BindingNamespaceType.Grouping)) {
+ if (BindingNamespaceType.isGrouping(namespaceType)) {
genCtx.get(module).getKeyType(childNode.getPath())
.addImplementsType(genCtx.get(superModule).getKeyType(superChildNode.getPath()));
- } else if (namespaceType.equals(BindingNamespaceType.Data)) {
+ } else if (BindingNamespaceType.isData(namespaceType)) {
genCtx.get(module).getKeyGenTO(childNode.getPath())
.addImplementsType(genCtx.get(superModule).getKeyType(superChildNode.getPath()));
}
}
- addUsesImplements(superChildNode, superModule, childNode, module, schemaContext, genCtx, namespaceType);
+ addUsesImplements(superChildNode, superModule, childNode, module, schemaContext, genCtx,
+ namespaceType);
}
}
} else if (superNode instanceof ChoiceSchemaNode) {
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);
+ requireNonNull(caseNode, () -> node + "->" + childQName);
final GeneratedTypeBuilder type = genCtx.get(module).getCase(caseNode.getPath());
final GeneratedTypeBuilder superType = genCtx.get(superModule).getCase(superCaseNode.getPath());
- Preconditions.checkNotNull(type, "%s->%s", module, caseNode.getPath());
- Preconditions.checkNotNull(superType, "%s->%s", superModule, superCaseNode.getPath());
+ requireNonNull(type, () -> module + "->" + caseNode.getPath());
+ requireNonNull(superType, () -> superModule + "->" + superCaseNode.getPath());
type.addImplementsType(superType);
addUsesImplements(superCaseNode, superModule, caseNode, module, schemaContext, genCtx, namespaceType);
}
}
private static GroupingDefinition findGroupingNodeFromUses(final Module module, final SchemaContext schemaContext,
- final Object parentNode, final UsesNode usesNode) {
+ final Object parentNode, final UsesNode usesNode) {
SchemaNode groupingNode;
if (parentNode instanceof Module) {
final Module superModule = schemaContext.findModule(
- usesNode.getGroupingPath().getLastComponent().getModule()).get();
+ usesNode.getGroupingPath().getLastComponent().getModule()).get();
groupingNode = superModule.getGroupings()
.stream().filter(grouping -> grouping.getPath().equals(usesNode.getGroupingPath()))
.findFirst().orElse(null);
}
}
- Preconditions.checkNotNull(groupingNode, "%s->%s", module, usesNode.getGroupingPath());
+ requireNonNull(groupingNode, () -> module + "->" + usesNode.getGroupingPath());
Preconditions.checkState(groupingNode instanceof GroupingDefinition, "%s->%s", module,
- usesNode.getGroupingPath());
+ usesNode.getGroupingPath());
return (GroupingDefinition) groupingNode;
}
static Map<Module, ModuleContext> processUsesImplements(final Object node, final Module module,
- final SchemaContext schemaContext, final 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);
}
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 String augmentPackageName, final GeneratedTypeBuilder targetTypeBuilder, 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 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 (AugmentationSchemaNode aug : schemaPathAugmentListEntry) {
augTypeBuilder.addImplementsType(BindingTypes.TREE_NODE);
augTypeBuilder.addImplementsType(parameterizedTypeFor(BindingTypes.INSTANTIABLE, augTypeBuilder));
- augTypeBuilder.addImplementsType(Types.augmentationTypeFor(targetTypeRef));
+ augTypeBuilder.addImplementsType(Types.augmentationTypeFor(targetTypeBuilder.toInstance()));
augTypeBuilder.setBasePackageName(BindingMapping.getRootPackageName(module));
augTypeBuilder.setWithBuilder(true);
+ augTypeBuilder.setBindingNamespaceType(namespaceType);
annotateDeprecatedIfNecessary(augSchema.getStatus(), augTypeBuilder);
+ //If target is case node then pass down parent type (the closest ancestor) to children data nodes.
+ final GeneratedTypeBuilder childOf;
+ if (targetNode instanceof CaseSchemaNode) {
+ childOf = (GeneratedTypeBuilder) targetTypeBuilder.getParentTypeForBuilder();
+ } else {
+ augTypeBuilder.setParentTypeForBuilder(targetTypeBuilder);
+ childOf = targetTypeBuilder;
+ }
+
//produces getters for augTypeBuilder eventually
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, childOf,
+ aug.getChildNodes(), genCtx, schemaContext, verboseClassComments, typeProvider, genTypeBuilders,
+ targetTypeBuilder.getBindingNamespaceType());
}
+ final Map<String, GeneratedTypeBuilder> augmentBuilders = genTypeBuilders.computeIfAbsent(
+ augmentPackageName, k -> new HashMap<>());
+
augmentBuilders.put(augTypeBuilder.getName(), augTypeBuilder);
- if(!augSchema.getChildNodes().isEmpty()) {
+ if (!augSchema.getChildNodes().isEmpty()) {
genCtx.get(module).addTargetToAugmentation(augTypeBuilder, augSchema.getTargetPath());
}
genCtx.get(module).addAugmentType(augTypeBuilder);
* Adds the methods to <code>typeBuilder</code> what represents subnodes of
* node for which <code>typeBuilder</code> was created.
*
- * @param module
- * current module
- * @param basePackageName
- * string contains the module package name
- * @param typeBuilder
- * generated type builder which represents any node. The subnodes
- * of this node are added to the <code>typeBuilder</code> as
- * methods. The subnode can be of type leaf, leaf-list, list,
- * container, choice.
- * @param childOf
- * parent type
- * @param schemaNodes
- * set of data schema nodes which are the children of the node
- * for which <code>typeBuilder</code> was created
- * @return generated type builder which is the same object as the input
- * parameter <code>typeBuilder</code>. The getter method could be
- * added to it.
+ * @param module current module
+ * @param basePackageName string contains the module package name
+ * @param typeBuilder generated type builder which represents any node. The subnodes
+ * of this node are added to the <code>typeBuilder</code> as
+ * methods. The subnode can be of type leaf, leaf-list, list,
+ * container, choice.
+ * @param childOf parent type
+ * @param schemaNodes set of data schema nodes which are the children of the node
+ * for which <code>typeBuilder</code> was created
+ * @return generated type builder which is the same object as the input added to it.
*/
private static GeneratedTypeBuilder augSchemaNodeToMethods(final Module module, final String basePackageName,
- final GeneratedTypeBuilder typeBuilder, final GeneratedTypeBuilder childOf, final Iterable<DataSchemaNode> schemaNodes,
- final Map<Module, ModuleContext> genCtx, final SchemaContext schemaContext, final boolean
- verboseClassComments, final TypeProvider typeProvider, final Map<String, Map<String,
+ final GeneratedTypeBuilder typeBuilder, final
+ GeneratedTypeBuilder childOf, final
+ Iterable<DataSchemaNode> schemaNodes,
+ final Map<Module, ModuleContext> genCtx, final
+ SchemaContext schemaContext, final boolean
+ verboseClassComments, final TypeProvider
+ typeProvider, final Map<String, Map<String,
GeneratedTypeBuilder>> genTypeBuilders, final BindingNamespaceType namespaceType) {
if (schemaNodes != null && typeBuilder != null) {
for (final DataSchemaNode schemaNode : schemaNodes) {
* Instantiates generated type builder with <code>packageName</code> and
* <code>schemaNode</code>.
*
+ * <p>
* The new builder always implements
* {@link TreeNode TreeNode}.<br>
* If <code>schemaNode</code> is instance of GroupingDefinition it also
* DataNodeContainer} it can also implement nodes which are specified in
* <i>uses</i>.
*
- * @param basePackageName
- * string contains the module package name
- * @param schemaNode
- * schema node for which is created generated type builder
- * @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
+ * @param basePackageName string contains the module package name
+ * @param schemaNode schema node for which is created generated type builder
+ * @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>
*/
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) {
+ final SchemaContext schemaContext, final boolean
+ verboseClassComments, final Map<String,
+ Map<String,
+ GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider, final BindingNamespaceType
+ namespaceType) {
GeneratedTypeBuilder it = addRawInterfaceDefinition(basePackageName, schemaNode, schemaContext, "", "",
verboseClassComments, genTypeBuilders, namespaceType, genCtx.get(module));
-
- if (namespaceType.equals(BindingNamespaceType.Data)) {
+ if (BindingNamespaceType.isData(namespaceType)) {
if (childOf == null) {
it.addImplementsType(BindingTypes.TREE_NODE);
} else {
- if (!(schemaNode instanceof ListSchemaNode) ||
- ((ListSchemaNode) schemaNode).getKeyDefinition().isEmpty()) {
+ if (!(schemaNode instanceof ListSchemaNode)
+ || ((ListSchemaNode) schemaNode).getKeyDefinition().isEmpty()) {
it.addImplementsType(parameterizedTypeFor(BindingTypes.TREE_CHILD_NODE, childOf,
- parameterizedTypeFor(BindingTypes.ITEM, it)));
+ parameterizedTypeFor(BindingTypes.ITEM, it)));
}
}
}
it.addImplementsType(BindingTypes.augmentable(it));
- } else {
- it.addImplementsType(BindingTypes.TREE_NODE);
}
if (schemaNode instanceof DataNodeContainer) {
static GeneratedTypeBuilder resolveNotification(final GeneratedTypeBuilder listenerInterface, final String
parentName, final String basePackageName, final NotificationDefinition notification, final Module module,
- 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);
+ 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.Notification);
annotateDeprecatedIfNecessary(notification.getStatus(), notificationInterface);
notificationInterface.addImplementsType(NOTIFICATION);
genCtx.get(module).addChildNodeType(notification, notificationInterface);
// Notification object
resolveDataSchemaNodes(module, basePackageName, notificationInterface,
notificationInterface, notification.getChildNodes(), genCtx, schemaContext,
- verboseClassComments, genTypeBuilders, typeProvider, BindingNamespaceType.Data);
+ verboseClassComments, genTypeBuilders, typeProvider, BindingNamespaceType.Notification);
//in case of tied notification, incorporate parent's localName
final StringBuilder sb = new StringBuilder("on_");
}
sb.append(notificationInterface.getName());
- listenerInterface.addMethod(JavaIdentifierNormalizer.normalizeSpecificIdentifier(sb.toString(), JavaIdentifier.METHOD))
+ listenerInterface.addMethod(JavaIdentifierNormalizer.normalizeSpecificIdentifier(sb.toString(),
+ JavaIdentifier.METHOD))
.setAccessModifier(AccessModifier.PUBLIC).addParameter(notificationInterface, "notification")
.setComment(encodeAngleBrackets(notification.getDescription().orElse(null))).setReturnType(Types.VOID);
return listenerInterface;
* Returns reference to generated type builder for specified
* <code>schemaNode</code> with <code>packageName</code>.
*
+ * <p>
* Firstly the generated type builder is searched in
* {@link BindingGeneratorImpl#genTypeBuilders genTypeBuilders}. If it isn't
* found it is created and added to <code>genTypeBuilders</code>.
*
- * @param basePackageName
- * string contains the module package name
- * @param schemaNode
- * schema node which provide data about the schema node name
- * @param schemaContext schema context
- * @param prefix
- * return type name prefix
+ * @param basePackageName string contains the module package name
+ * @param schemaNode schema node which provide data about the schema node name
+ * @param schemaContext schema context
+ * @param prefix return type name prefix
* @return generated type builder for <code>schemaNode</code>
- * @throws IllegalArgumentException
- * <ul>
- * <li>if <code>schemaNode</code> is null</li>
- * <li>if <code>packageName</code> is null</li>
- * <li>if QName of schema node is null</li>
- * <li>if schemaNode name is null</li>
- * </ul>
- *
+ * @throws IllegalArgumentException <ul>
+ * <li>if <code>schemaNode</code> is null</li>
+ * <li>if <code>packageName</code> is null</li>
+ * <li>if QName of schema node is null</li>
+ * <li>if schemaNode name is null</li>
+ * </ul>
*/
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, final ModuleContext context) {
+ final SchemaContext schemaContext, final String prefix,
+ final String suffix,
+ final boolean verboseClassComments, final Map<String,
+ Map<String, GeneratedTypeBuilder>> genTypeBuilders,
+ 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 Module module = SchemaContextUtil.findParentModule(schemaContext, schemaNode);
qNameConstant(newType, BindingMapping.QNAME_STATIC_FIELD_NAME, schemaNode.getQName());
if (verboseClassComments) {
- newType.setYangSourceDefinition(YangSourceDefinition.of(module, schemaNode));
+ YangSourceDefinition.of(module, schemaNode).ifPresent(newType::setYangSourceDefinition);
TypeComments.description(schemaNode).ifPresent(newType::addComment);
schemaNode.getDescription().ifPresent(newType::setDescription);
schemaNode.getReference().ifPresent(newType::setReference);
newType.setModuleName(module.getName());
newType.setBasePackageName(BindingMapping.getRootPackageName(module));
newType.setWithBuilder(AuxiliaryGenUtils.hasBuilderClass(schemaNode, namespaceType));
+ newType.setBindingNamespaceType(namespaceType);
if (!genTypeBuilders.containsKey(packageName)) {
final Map<String, GeneratedTypeBuilder> builders = new HashMap<>();
}
private static void addSchemaNodeToBuilderAsMethod(final String basePackageName, final DataSchemaNode node,
- final GeneratedTypeBuilder typeBuilder, final GeneratedTypeBuilder 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) {
+ final GeneratedTypeBuilder typeBuilder, final
+ GeneratedTypeBuilder 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) {
if (node != null && typeBuilder != null) {
if (node instanceof ContainerSchemaNode) {
schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType);
} else if (node instanceof LeafListSchemaNode) {
resolveLeafListSchemaNode(schemaContext, typeBuilder, (LeafListSchemaNode) node, module,
- typeProvider, genCtx, verboseClassComments);
+ typeProvider, genCtx, verboseClassComments);
} else if (node instanceof LeafSchemaNode) {
resolveLeafSchemaNodeAsMethod("", schemaContext, typeBuilder, genCtx, (LeafSchemaNode) node, module,
typeProvider, verboseClassComments);
* Converts <code>choiceNode</code> to the list of generated types for
* choice and its cases.
*
+ * <p>
* The package names for choice and for its cases are created as
* concatenation of the module package (<code>basePackageName</code>) and
* names of all parents node.
*
- * @param module
- * current module
- * @param basePackageName
- * string with the module package name
- * @param parent
- * parent type
- * @param choiceNode
- * choice node which is mapped to generated type. Also child
- * nodes - cases are mapped to generated types.
- * @throws IllegalArgumentException
- * <ul>
- * <li>if <code>basePackageName</code> is null</li>
- * <li>if <code>choiceNode</code> is null</li>
- * </ul>
+ * @param module current module
+ * @param basePackageName string with the module package name
+ * @param parent parent type
+ * @param choiceNode choice node which is mapped to generated type. Also child
+ * nodes - cases are mapped to generated types.
+ * @throws IllegalArgumentException <ul>
+ * <li>if <code>basePackageName</code> is null</li>
+ * <li>if <code>choiceNode</code> is null</li>
+ * </ul>
*/
private static void choiceToGenType(final Module module, final SchemaContext schemaContext, final boolean
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) {
+ 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().orElse(null), choiceTypeBuilder, choiceNode.getStatus());
choiceTypeBuilder.setParentTypeForBuilder(childOf);
- if (namespaceType.equals(BindingNamespaceType.Data)) {
+ if (BindingNamespaceType.isData(namespaceType)) {
choiceTypeBuilder.addImplementsType(parameterizedTypeFor(BindingTypes.INSTANTIABLE, choiceTypeBuilder));
}
annotateDeprecatedIfNecessary(choiceNode.getStatus(), choiceTypeBuilder);
genCtx.get(module).addChildNodeType(choiceNode, choiceTypeBuilder);
generateTypesFromChoiceCases(module, schemaContext, genCtx, basePackageName, choiceTypeBuilder.toInstance(),
- choiceNode, verboseClasssComments, typeProvider, genTypeBuilders, namespaceType);
+ choiceNode, verboseClasssComments, typeProvider, genTypeBuilders, namespaceType);
}
private static void containerToGenType(final Module module, final String basePackageName,
- final GeneratedTypeBuilder parent, final GeneratedTypeBuilder childOf, final ContainerSchemaNode node,
- final SchemaContext schemaContext, final boolean verboseClassComments, final Map<Module, ModuleContext> genCtx,
- final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider,
- final BindingNamespaceType namespaceType) {
+ final GeneratedTypeBuilder parent, final GeneratedTypeBuilder childOf,
+ final ContainerSchemaNode node,
+ final SchemaContext schemaContext, final boolean verboseClassComments,
+ final Map<Module, ModuleContext> genCtx,
+ final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders,
+ final TypeProvider typeProvider,
+ final BindingNamespaceType namespaceType) {
final GeneratedTypeBuilder genType = processDataSchemaNode(module, basePackageName, childOf, node,
schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType);
if (genType != null) {
StringBuilder getterName = new StringBuilder(node.getQName().getLocalName());
- constructGetter(parent, getterName.toString(), node.getDescription().orElse(null), 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);
private static void listToGenType(final Module module, final String basePackageName, final GeneratedTypeBuilder
parent, final GeneratedTypeBuilder childOf, final ListSchemaNode node, final SchemaContext schemaContext,
- final boolean verboseClassComments, final Map<Module, ModuleContext> genCtx,
- final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider,
- final BindingNamespaceType namespaceType) {
+ final boolean verboseClassComments, final Map<Module, ModuleContext> genCtx,
+ final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final
+ TypeProvider typeProvider,
+ final BindingNamespaceType namespaceType) {
final GeneratedTypeBuilder genType = processDataSchemaNode(module, basePackageName, childOf, node,
schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType);
final String nodeName = node.getQName().getLocalName();
Type getterReturnType = Types.listTypeFor(genType);
- if (namespaceType.equals(BindingNamespaceType.Grouping)) {
+ if (BindingNamespaceType.isGrouping(namespaceType)) {
getterReturnType = Types.listTypeFor(wildcardTypeFor(genType.getPackageName(), genType.getName(),
- true, true, null));
+ true, true, null));
}
constructGetter(parent, nodeName, node.getDescription().orElse(null), getterReturnType, node.getStatus());
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, genCtx.get(module));
+ if (BindingNamespaceType.isGrouping(namespaceType)) {
+ final GeneratedTypeBuilder genTypeBuilder = resolveListKeyTypeBuilder(packageName, node,
+ genCtx.get(module));
for (final DataSchemaNode schemaNode : node.getChildNodes()) {
if (resolveDataSchemaNodesCheck(module, schemaContext, schemaNode)) {
- addSchemaNodeToListTypeBuilders(nodeName, basePackageName, schemaNode, genType, genTypeBuilder, listKeys,
- module, typeProvider, schemaContext, genCtx, genTypeBuilders, verboseClassComments, namespaceType);
+ addSchemaNodeToListTypeBuilders(nodeName, basePackageName, schemaNode, genType,
+ genTypeBuilder, listKeys,
+ module, typeProvider, schemaContext, genCtx, genTypeBuilders, verboseClassComments,
+ namespaceType);
}
}
if (genTypeBuilder != 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)));
-
+ if (BindingNamespaceType.isData(namespaceType)) {
+ 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,
- module, typeProvider, schemaContext, genCtx, genTypeBuilders, verboseClassComments, namespaceType);
+ addSchemaNodeToListBuilders(nodeName, basePackageName, schemaNode, genType, genTOBuilder,
+ listKeys,
+ module, typeProvider, schemaContext, genCtx, genTypeBuilders, verboseClassComments,
+ namespaceType);
}
}
processUsesImplements(node, module, schemaContext, genCtx, namespaceType);
}
private static void typeBuildersToGenTypes(final Module module, final GeneratedTypeBuilder typeBuilder,
- final Type keyType, final Map<Module, ModuleContext> genCtx,
- final BindingNamespaceType namespaceType) {
+ final Type keyType, final Map<Module, ModuleContext> genCtx,
+ final BindingNamespaceType namespaceType) {
checkArgument(typeBuilder != null, "Generated Type Builder cannot be NULL.");
if (keyType != null) {
Type returnKeyType = keyType;
- if (namespaceType.equals(BindingNamespaceType.Grouping)) {
+ if (BindingNamespaceType.isGrouping(namespaceType)) {
returnKeyType = wildcardTypeFor(keyType.getPackageName(), keyType.getName(),
true, true, null);
}
- constructGetter(typeBuilder, "identifier", "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 void addPatternConstant(final GeneratedTypeBuilder typeBuilder, final String leafName,
+ final List<PatternConstraint> patternConstraints) {
+ if (!patternConstraints.isEmpty()) {
+ final StringBuilder field = new StringBuilder();
+ field.append(BindingMapping.PATTERN_CONSTANT_NAME).append("_")
+ .append(JavaIdentifierNormalizer.normalizeSpecificIdentifier(leafName, JavaIdentifier.METHOD));
+ typeBuilder.addConstant(Types.listTypeFor(BaseYangTypes.STRING_TYPE), field.toString(),
+ resolveRegExpressions(patternConstraints));
}
}
* Converts <code>leaf</code> to the getter method which is added to
* <code>typeBuilder</code>.
*
- * @param typeBuilder
- * generated type builder to which is added getter method as
- * <code>leaf</code> mapping
- * @param leaf
- * leaf schema node which is mapped as getter method which is
- * added to <code>typeBuilder</code>
- * @param module
- * Module in which type was defined
+ * @param typeBuilder generated type builder to which is added getter method as
+ * <code>leaf</code> mapping
+ * @param leaf leaf schema node which is mapped as getter method which is
+ * added to <code>typeBuilder</code>
+ * @param module Module in which type was defined
* @return boolean value
- * <li>false - if <code>leaf</code> or <code>typeBuilder</code> are
- * null</li>
- * <li>true - in other cases</li>
- * </ul>
+ * <ul>
+ * <li>false - if <code>leaf</code> or <code>typeBuilder</code> are
+ * null</li>
+ * <li>true - in other cases</li>
+ * </ul>
*/
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 boolean verboseClassComments) {
+ final GeneratedTypeBuilder typeBuilder, final Map<Module,
+ ModuleContext> genCtx, final LeafSchemaNode leaf,
+ final Module module, final TypeProvider typeProvider, final
+ boolean verboseClassComments) {
if (leaf == null || typeBuilder == null) {
return null;
}
} 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());
+ LeafSchemaNode originalLeaf = (LeafSchemaNode) ((DerivableSchemaNode) leaf).getOriginal()
+ .orElse(null);
+ requireNonNull(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));
+ returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf, restrictions,
+ genCtx.get(module));
}
}
} else if (isInnerType(leaf, typeDef)) {
if (genTOBuilder != null) {
//TODO: https://bugs.opendaylight.org/show_bug.cgi?id=2289
returnType = createReturnTypeForUnion(genTOBuilder, typeDef, typeBuilder, parentModule,
- typeProvider, verboseClassComments);
+ typeProvider, verboseClassComments);
}
} else if (typeDef instanceof BitsTypeDefinition) {
final GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, leaf, parentModule,
final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(typeDef);
returnType = typeProvider.javaTypeForSchemaDefinitionType(getBaseOrDeclaredType(typeDef), leaf,
restrictions, genCtx.get(module));
+ addPatternConstant(typeBuilder, leafName, restrictions.getPatternConstraints());
}
} else {
final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(typeDef);
returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf, restrictions, genCtx.get(module));
+ addPatternConstant(typeBuilder, leafName, restrictions.getPatternConstraints());
}
if (returnType == null) {
final String leafGetterName;
if ("key".equals(leafName.toLowerCase())) {
StringBuilder sb = new StringBuilder(leafName)
- .append('_').append("RESERVED_WORD");
+ .append('_').append("RESERVED_WORD");
leafGetterName = sb.toString();
} else {
leafGetterName = leafName;
* Converts <code>node</code> leaf list schema node to getter method of
* <code>typeBuilder</code>.
*
- * @param typeBuilder
- * generated type builder to which is <code>node</code> added as
- * getter method
- * @param node
- * leaf list schema node which is added to
- * <code>typeBuilder</code> as getter method
- * @param module module
+ * @param typeBuilder generated type builder to which is <code>node</code> added as
+ * getter method
+ * @param node leaf list schema node which is added to
+ * <code>typeBuilder</code> as getter method
+ * @param module module
* @param typeProvider type provider instance
- * @param genCtx actual generated context
+ * @param genCtx actual generated context
* @return boolean value
- * <li>true - if <code>node</code>, <code>typeBuilder</code>,
- * nodeName equal null or <code>node</code> is added by <i>uses</i></li>
- * <li>false - other cases</li>
- * </ul>
+ * <ul>
+ * <li>true - if <code>node</code>, <code>typeBuilder</code>,
+ * nodeName equal null or <code>node</code> is added by <i>uses</i></li>
+ * <li>false - other cases</li>
+ * </ul>
*/
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 boolean verboseClassComments) {
+ final Map<Module, ModuleContext> genCtx, final boolean
+ verboseClassComments) {
if (node == null || typeBuilder == null) {
return false;
}
typeProvider, schemaContext, genCtx.get(module), genCtx);
if (genTOBuilder != null) {
returnType = createReturnTypeForUnion(genTOBuilder, typeDef, typeBuilder, parentModule,
- typeProvider, verboseClassComments);
+ typeProvider, verboseClassComments);
}
} else if (typeDef instanceof BitsTypeDefinition) {
final GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, node, parentModule,
returnType = genTOBuilder.toInstance();
} else {
final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(typeDef);
- returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, node, restrictions, genCtx.get(module));
+ returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, node, restrictions,
+ genCtx.get(module));
+
+ addPatternConstant(typeBuilder, nodeName.getLocalName(), restrictions.getPatternConstraints());
}
} else {
final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(typeDef);
returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, node, restrictions, genCtx.get(module));
+
+ addPatternConstant(typeBuilder, nodeName.getLocalName(), restrictions.getPatternConstraints());
}
final ParameterizedType listType = Types.listTypeFor(returnType);
- constructGetter(typeBuilder, nodeName.getLocalName(), node.getDescription().orElse(null), listType, node.getStatus());
+ constructGetter(typeBuilder, nodeName.getLocalName(), node.getDescription().orElse(null), listType, node
+ .getStatus());
return true;
}
* Converts <code>caseNodes</code> set to list of corresponding generated
* types.
*
+ * <p>
* For every <i>case</i> which isn't added through augment or <i>uses</i> is
* created generated type builder. The package names for the builder is
* created as concatenation of the module package (
* concrete <i>case</i>. There is also relation "<i>implements type</i>"
* between every case builder and <i>choice</i> type
*
- * @param module
- * current module
- * @param schemaContext
- * current schema context
- * @param genCtx
- * actual generated context
- * @param basePackageName
- * string with the module package name
- * @param refChoiceType
- * type which represents superior <i>case</i>
- * @param choiceNode
- * choice case node which is mapped to generated type
- * @param verboseClassComments
- * Javadoc verbosity switch
- * @throws IllegalArgumentException
- * <ul>
- * <li>if <code>basePackageName</code> equals null</li>
- * <li>if <code>refChoiceType</code> equals null</li>
- * <li>if <code>caseNodes</code> equals null</li>
- * </ul>
+ * @param module current module
+ * @param schemaContext current schema context
+ * @param genCtx actual generated context
+ * @param basePackageName string with the module package name
+ * @param refChoiceType type which represents superior <i>case</i>
+ * @param choiceNode choice case node which is mapped to generated type
+ * @param verboseClassComments Javadoc verbosity switch
+ * @throws IllegalArgumentException <ul>
+ * <li>if <code>basePackageName</code> equals null</li>
+ * <li>if <code>refChoiceType</code> equals null</li>
+ * <li>if <code>caseNodes</code> equals null</li>
+ * </ul>
*/
private static void generateTypesFromChoiceCases(final Module module, final SchemaContext schemaContext,
- 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) {
+ 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.");
for (final CaseSchemaNode caseNode : choiceNode.getCases().values()) {
if (caseNode != null && resolveDataSchemaNodesCheck(module, schemaContext, caseNode)) {
final GeneratedTypeBuilder caseTypeBuilder = addDefaultInterfaceDefinition(basePackageName, caseNode,
- null, module, genCtx, schemaContext, verboseClassComments,
- genTypeBuilders, typeProvider, namespaceType);
+ null, module, genCtx, schemaContext, verboseClassComments,
+ genTypeBuilders, typeProvider, namespaceType);
caseTypeBuilder.addImplementsType(refChoiceType);
caseTypeBuilder.setParentTypeForBuilder(refChoiceType.getParentTypeForBuilder());
annotateDeprecatedIfNecessary(caseNode.getStatus(), caseTypeBuilder);
genCtx.get(module).addCaseType(caseNode.getPath(), caseTypeBuilder);
- if (namespaceType.equals(BindingNamespaceType.Data)) {
+ if (BindingNamespaceType.isData(namespaceType)) {
genCtx.get(module).addChoiceToCaseMapping(refChoiceType, caseTypeBuilder, caseNode);
}
resolveDataSchemaNodes(module, basePackageName, caseTypeBuilder,
(GeneratedTypeBuilder) refChoiceType.getParentTypeForBuilder(), caseNode.getChildNodes(),
- genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
+ genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
processUsesImplements(caseNode, module, schemaContext, genCtx, namespaceType);
}
}
private static Type resolveAnyNodeAsMethod(final SchemaContext schemaContext, final GeneratedTypeBuilder
typeBuilder, final Map<Module, ModuleContext> genCtx, final DataSchemaNode node, final Module module,
- final TypeProvider typeProvider) {
+ final TypeProvider typeProvider) {
final String anyName = node.getQName().getLocalName();
if (anyName == null) {
* Adds <code>schemaNode</code> to <code>typeBuilder</code> as getter method
* or to <code>genTOBuilder</code> as property.
*
- * @param nodeName
- * string contains the name of list
- * @param basePackageName
- * string contains the module package name
- * @param schemaNode
- * data schema node which should be added as getter method to
- * <code>typeBuilder</code> or as a property to
- * <code>genTOBuilder</code> if is part of the list key
- * @param typeBuilder
- * generated type builder for the list schema node
- * @param genTOBuilder
- * generated TO builder for the list keys
- * @param listKeys
- * list of string which contains QNames of the list keys
- * @param module
- * current module
- * @param typeProvider
- * provider that defines contract for generated types
- * @param schemaContext
- * schema context
- * @param genCtx
- * map of generated entities in context of YANG modules
- * @param genTypeBuilders
- * map of generated type builders
- * @param verboseClassComments
- * generate verbose comments
- * @throws IllegalArgumentException
- * <ul>
- * <li>if <code>schemaNode</code> equals null</li>
- * <li>if <code>typeBuilder</code> equals null</li>
- * </ul>
+ * @param nodeName string contains the name of list
+ * @param basePackageName string contains the module package name
+ * @param schemaNode data schema node which should be added as getter method to
+ * <code>typeBuilder</code> or as a property to
+ * <code>genTOBuilder</code> if is part of the list key
+ * @param typeBuilder generated type builder for the list schema node
+ * @param genTOBuilder generated TO builder for the list keys
+ * @param listKeys list of string which contains QNames of the list keys
+ * @param module current module
+ * @param typeProvider provider that defines contract for generated types
+ * @param schemaContext schema context
+ * @param genCtx map of generated entities in context of YANG modules
+ * @param genTypeBuilders map of generated type builders
+ * @param verboseClassComments generate verbose comments
+ * @throws IllegalArgumentException <ul>
+ * <li>if <code>schemaNode</code> equals null</li>
+ * <li>if <code>typeBuilder</code> equals null</li>
+ * </ul>
*/
private static void addSchemaNodeToListBuilders(final String nodeName, final String basePackageName,
- final DataSchemaNode schemaNode, final GeneratedTypeBuilder typeBuilder,
- final GeneratedTOBuilder genTOBuilder, 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 GeneratedTOBuilder genTOBuilder, 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.");
typeProvider, verboseClassComments);
if (listKeys.contains(leafQName)) {
if (type == null) {
- resolveLeafSchemaNodeAsProperty(nodeName, schemaContext, typeProvider, genCtx, genTOBuilder, leaf, true,
- module);
+ resolveLeafSchemaNodeAsProperty(nodeName, schemaContext, typeProvider, genCtx, genTOBuilder,
+ leaf, true,
+ module);
} else {
AuxiliaryGenUtils.resolveLeafSchemaNodeAsProperty(nodeName, genTOBuilder, leaf, type, true);
}
}
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.");
}
}
- private static boolean resolveLeafSchemaNodeAsProperty(final String nodeName, final SchemaContext schemaContext, final TypeProvider
- typeProvider, final Map<Module, ModuleContext> genCtx, final GeneratedTOBuilder
- toBuilder, final LeafSchemaNode leaf, final boolean isReadOnly, final Module module) {
+ private static boolean resolveLeafSchemaNodeAsProperty(final String nodeName, final SchemaContext schemaContext,
+ final TypeProvider
+ typeProvider, final Map<Module, ModuleContext>
+ genCtx, final GeneratedTOBuilder
+ toBuilder, final LeafSchemaNode leaf, final
+ boolean isReadOnly, final Module module) {
if (leaf != null && toBuilder != null) {
Type returnType;
// Annonymous enumeration (already generated, since it is inherited via uses).
LeafSchemaNode originalLeaf = (LeafSchemaNode) SchemaNodeUtils.getRootOriginalIfPossible(leaf);
QName qname = originalLeaf.getQName();
- final Module enumModule = schemaContext.findModule(qname.getModule()).orElse(null);
+ 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));
return baseType != null && baseType.getBaseType() != null ? baseType : typeDef;
}
- @SuppressWarnings({ "rawtypes", "unchecked" })
+ @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, final Map<Module, ModuleContext> genCtx, final Map<String, Map<String,
- GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider, final BindingNamespaceType namespaceType) {
+ final GeneratedTypeBuilder childOf, final
+ DataSchemaNode node, final SchemaContext
+ schemaContext,
+ 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);
annotateDeprecatedIfNecessary(node.getStatus(), genType);
genType.setModuleName(module.getName());
if (verboseClassComments) {
- genType.setYangSourceDefinition(YangSourceDefinition.of(module, node));
+ YangSourceDefinition.of(module, node).ifPresent(genType::setYangSourceDefinition);
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 (BindingNamespaceType.isData(namespaceType)) {
+ genType.setParentTypeForBuilder(childOf);
+ }
+
if (node instanceof DataNodeContainer) {
genCtx.get(module).addChildNodeType(node, genType);
}
* saved at first positions. For every grouping the record is added to map
* {@link ModuleContext#groupings allGroupings}
*
- * @param module
- * current module
- * @param groupings
- * collection of groupings from which types will be generated
- * @param typeProvider
- * provider that defines contract for generated types
- * @param schemaContext
- * schema context
- * @param genCtx
- * map of generated entities in context of YANG modules
- * @param genTypeBuilders
- * map of generated type builders
- * @param verboseClassComments
- * generate verbose comments
- *
+ * @param module current module
+ * @param groupings collection of groupings from which types will be generated
+ * @param typeProvider provider that defines contract for generated types
+ * @param schemaContext schema context
+ * @param genCtx map of generated entities in context of YANG modules
+ * @param genTypeBuilders map of generated type builders
+ * @param verboseClassComments generate verbose comments
*/
static Map<Module, ModuleContext> groupingsToGenTypes(final Module module, final Collection<GroupingDefinition>
groupings, Map<Module, ModuleContext> genCtx, final SchemaContext schemaContext, final boolean
- verboseClassComments, final 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);
* builder is created and every child node of grouping is resolved to the
* method.
*
- * @param basePackageName
- * string contains the module package name
- * @param grouping
- * GroupingDefinition which contains data about grouping
- * @param module
- * current module
- * @param typeProvider
- * provider that defines contract for generated types
- * @param schemaContext
- * schema context
- * @param genCtx
- * map of generated entities in context of YANG modules
- * @param genTypeBuilders
- * map of generated type builders
- * @param verboseClassComments
- * generate verbose comments
- *
+ * @param basePackageName string contains the module package name
+ * @param grouping GroupingDefinition which contains data about grouping
+ * @param module current module
+ * @param typeProvider provider that defines contract for generated types
+ * @param schemaContext schema context
+ * @param genCtx map of generated entities in context of YANG modules
+ * @param genTypeBuilders map of generated type builders
+ * @param verboseClassComments generate verbose comments
* @return GeneratedType which is generated from grouping (object of type
- * <code>GroupingDefinition</code>)
+ * <code>GroupingDefinition</code>)
*/
- 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, final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider) {
- final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(basePackageName, grouping, null, module, genCtx,
+ 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,
+ 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);
* class {@link org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode
* BaseIdentity} is added
*
- * @param module
- * current module
- * @param basePackageName
- * string contains the module package name
- * @param identity
- * IdentitySchemaNode which contains data about identity
- * @param schemaContext
- * SchemaContext which is used to get package and name
- * information about base of identity
- * @param genCtx generated context
+ * @param module current module
+ * @param basePackageName string contains the module package name
+ * @param identity IdentitySchemaNode which contains data about identity
+ * @param schemaContext SchemaContext which is used to get package and name
+ * information about base of identity
+ * @param genCtx generated context
* @return returns generated context
*/
static Map<Module, ModuleContext> identityToGenType(final Module module, final String basePackageName,
- final IdentitySchemaNode identity, final SchemaContext schemaContext, final Map<Module, ModuleContext> genCtx,
- final 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;
}
- private static GeneratedTOBuilder resolveIdentitySchemaNode(final String basePackageName, final SchemaContext schemaContext,
- final IdentitySchemaNode identity, final Module module, final boolean verboseClassComments,
- final Map<Module, ModuleContext> genCtx) {
- Preconditions.checkNotNull(identity,"Identity can not be null!");
+ private static GeneratedTypeBuilder resolveIdentitySchemaNode(final String basePackageName, final SchemaContext
+ schemaContext,
+ final IdentitySchemaNode identity, final Module
+ module, final boolean verboseClassComments,
+ final Map<Module, ModuleContext> genCtx) {
+ requireNonNull(identity, "Identity can not be null!");
//check first if identity has been resolved as base identity of some other one
- GeneratedTOBuilder newType = findIdentityByQname(identity.getQName(), genCtx);
+ GeneratedTypeBuilder newType = findIdentityByQname(identity.getQName(), genCtx);
if (newType == null) {
final Module parentModule = SchemaContextUtil.findParentModule(schemaContext, identity);
Preconditions.checkState(module.equals(parentModule),
"If the type is null ,it must be in the same module, otherwise it must has been"
+ "resolved by an imported module.");
- final String packageName = BindingGeneratorUtil.packageNameForGeneratedType(basePackageName, identity.getPath(),
+ final String packageName = BindingGeneratorUtil.packageNameForGeneratedType(basePackageName, identity
+ .getPath(),
BindingNamespaceType.Identity);
- newType = new GeneratedTOBuilderImpl(packageName, identity.getQName().getLocalName(), true, false,
+ newType = new GeneratedTypeBuilderImpl(packageName, identity.getQName().getLocalName(), true, false,
genCtx.get(module));
final Set<IdentitySchemaNode> baseIdentities = identity.getBaseIdentities();
if (baseIdentities.size() == 0) {
//no base - abstract
- final GeneratedTOBuilderImpl gto = new GeneratedTOBuilderImpl(BaseIdentity.class.getPackage().getName(),
+ final GeneratedTypeBuilderImpl genType = new GeneratedTypeBuilderImpl(BaseIdentity.class.getPackage()
+ .getName(),
BaseIdentity.class.getSimpleName(), genCtx.get(module));
- newType.setExtendsType(gto.toInstance());
+ newType.addImplementsType(genType.toInstance());
} else {
- //one base - inheritance
- final IdentitySchemaNode baseIdentity = baseIdentities.iterator().next();
- GeneratedTOBuilder baseType = resolveIdentitySchemaNode(basePackageName, schemaContext,
- baseIdentity, module, verboseClassComments, genCtx);
- newType.setExtendsType(baseType.toInstance());
+ //multiple bases - inheritance
+ for (IdentitySchemaNode baseIdentity : baseIdentities) {
+ GeneratedTypeBuilder baseType = resolveIdentitySchemaNode(basePackageName, schemaContext,
+ baseIdentity, module, verboseClassComments, genCtx);
+ newType.addImplementsType(baseType.toInstance());
+ }
}
- newType.setAbstract(true);
-
if (verboseClassComments) {
- newType.setYangSourceDefinition(YangSourceDefinition.of(module));
+ YangSourceDefinition.of(module).ifPresent(newType::setYangSourceDefinition);
TypeComments.description(module).ifPresent(newType::addComment);
module.getDescription().ifPresent(newType::setDescription);
module.getReference().ifPresent(newType::setReference);
Code Review / mdsal.git / blobdiff