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.Map;
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;
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);
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);
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;
}
return module.equals(originalModule);
}
- 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);
- }
-
private static QName createQNameFromSuperNode(final Module module, final Object node, final SchemaNode superChildNode) {
QName childNodeQName = null;
if (node instanceof Module) {
* 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 (!(schemaNode instanceof ListSchemaNode) ||
((ListSchemaNode) schemaNode).getKeyDefinition().isEmpty()) {
- it.addImplementsType(parameterizedTypeFor(BindingTypes.TREE_CHILD_NODE, parent, parameterizedTypeFor
- (BindingTypes.ITEM, it)));
+ it.addImplementsType(parameterizedTypeFor(BindingTypes.TREE_CHILD_NODE, childOf,
+ parameterizedTypeFor(BindingTypes.ITEM, it)));
}
- it.addImplementsType(parameterizedTypeFor(BindingTypes.INSTANTIABLE, 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);
}
verboseClassComments, genTypeBuilders, typeProvider, BindingNamespaceType.Data);
annotateDeprecatedIfNecessary(notification.getStatus(), notificationInterface);
notificationInterface.addImplementsType(NOTIFICATION);
- notificationInterface.addImplementsType(parameterizedTypeFor(BindingTypes.INSTANTIABLE, notificationInterface));
genCtx.get(module).addChildNodeType(notification, notificationInterface);
// Notification object
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);
listToGenType(module, basePackageName, typeBuilder, childOf, (ListSchemaNode) node, schemaContext,
verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType);
} else if (node instanceof ChoiceSchemaNode) {
- choiceToGenType(module, schemaContext, verboseClassComments, basePackageName, typeBuilder,
+ 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().orElse(null), choiceTypeBuilder, choiceNode.getStatus());
+ choiceTypeBuilder.setParentTypeForBuilder(childOf);
if (namespaceType.equals(BindingNamespaceType.Data)) {
choiceTypeBuilder.addImplementsType(parameterizedTypeFor(BindingTypes.INSTANTIABLE, choiceTypeBuilder));
}
final Type identifiableMarker = Types.parameterizedTypeFor(IDENTIFIABLE, genTOBuilder);
genTOBuilder.addImplementsType(IDENTIFIER);
genType.addImplementsType(identifiableMarker);
- genType.addImplementsType(parameterizedTypeFor(BindingTypes.TREE_CHILD_NODE, parent, parameterizedTypeFor
+ genType.addImplementsType(parameterizedTypeFor(BindingTypes.TREE_CHILD_NODE, childOf, parameterizedTypeFor
(BindingTypes.IDENTIFIABLE_ITEM, genType, genTOBuilder)));
}
}
}
+ 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.CLASS)
+ .toUpperCase());
+ 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>.
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) {
} else {
final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(typeDef);
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);
* </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.");
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 AugmentationSchemaNode) {
- final AugmentationSchemaNode augSchema = (AugmentationSchemaNode) parent;
- final SchemaPath targetPath = augSchema.getTargetPath();
- SchemaNode targetSchemaNode = findDataSchemaNode(schemaContext, targetPath);
- if (targetSchemaNode instanceof DataSchemaNode
- && ((DataSchemaNode) targetSchemaNode).isAddedByUses()) {
- if (targetSchemaNode instanceof DerivableSchemaNode) {
- targetSchemaNode = ((DerivableSchemaNode) targetSchemaNode).getOriginal().orElse(null);
- }
- 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);
}
}
}
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);
}
}
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);
}
}
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);
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, module, genCtx,
+ 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 genCtx;
}
- private static GeneratedTOBuilder resolveIdentitySchemaNode(final String basePackageName, final SchemaContext schemaContext,
+ private static GeneratedTypeBuilder 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!");
//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),
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