X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=binding2%2Fmdsal-binding2-generator-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fmdsal%2Fbinding%2Fjavav2%2Fgenerator%2Fimpl%2FGenHelperUtil.java;h=73ea20003a3384fc796e7c423a4127a9b3108385;hb=675d69c062e3caf5cd9cad20246a955332622a4c;hp=d3570d4a997b1f9a2c2f697f7728f4bfde3f3a38;hpb=5bc8c8fc77afc3623570449df1bc847956c823b6;p=mdsal.git
diff --git a/binding2/mdsal-binding2-generator-impl/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/impl/GenHelperUtil.java b/binding2/mdsal-binding2-generator-impl/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/impl/GenHelperUtil.java
index d3570d4a99..73ea20003a 100644
--- a/binding2/mdsal-binding2-generator-impl/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/impl/GenHelperUtil.java
+++ b/binding2/mdsal-binding2-generator-impl/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/impl/GenHelperUtil.java
@@ -11,7 +11,6 @@ package org.opendaylight.mdsal.binding.javav2.generator.impl;
import static com.google.common.base.Preconditions.checkArgument;
import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.addTOToTypeBuilder;
import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.annotateDeprecatedIfNecessary;
-import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.augGenTypeName;
import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.constructGetter;
import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.createDescription;
import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.createReturnTypeForUnion;
@@ -20,11 +19,13 @@ import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenU
import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.qNameConstant;
import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.resolveInnerEnumFromTypeDefinition;
import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.resolveListKeyTOBuilder;
+import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.resolveListKeyTypeBuilder;
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.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.yangtools.yang.model.util.SchemaContextUtil.findParentModule;
@@ -37,6 +38,7 @@ import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
+import org.opendaylight.mdsal.binding.javav2.generator.context.ModuleContext;
import org.opendaylight.mdsal.binding.javav2.generator.spi.TypeProvider;
import org.opendaylight.mdsal.binding.javav2.generator.util.BindingGeneratorUtil;
import org.opendaylight.mdsal.binding.javav2.generator.util.BindingTypes;
@@ -50,7 +52,6 @@ import org.opendaylight.mdsal.binding.javav2.generator.util.generated.type.build
import org.opendaylight.mdsal.binding.javav2.generator.yang.types.GroupingDefinitionDependencySort;
import org.opendaylight.mdsal.binding.javav2.generator.yang.types.TypeProviderImpl;
import org.opendaylight.mdsal.binding.javav2.model.api.AccessModifier;
-import org.opendaylight.mdsal.binding.javav2.model.api.GeneratedTransferObject;
import org.opendaylight.mdsal.binding.javav2.model.api.GeneratedType;
import org.opendaylight.mdsal.binding.javav2.model.api.ParameterizedType;
import org.opendaylight.mdsal.binding.javav2.model.api.Restrictions;
@@ -108,8 +109,8 @@ final class GenHelperUtil {
*
* @param module
* Module object from which builder will be created
- * @param genCtx
- * @param verboseClassComments
+ * @param genCtx generated context
+ * @param verboseClassComments verbosity switch
*
* @return GeneratedTypeBuilder
which is internal
* representation of the module
@@ -119,7 +120,8 @@ final class GenHelperUtil {
static GeneratedTypeBuilder moduleToDataType(final Module module, final Map genCtx, final boolean verboseClassComments) {
Preconditions.checkArgument(module != null, "Module reference cannot be NULL.");
- final GeneratedTypeBuilder moduleDataTypeBuilder = moduleTypeBuilder(module, "Data", verboseClassComments);
+ final GeneratedTypeBuilder moduleDataTypeBuilder = moduleTypeBuilder(module, "Data", verboseClassComments,
+ genCtx.get(module));
addImplementedInterfaceFromUses(module, moduleDataTypeBuilder, genCtx);
moduleDataTypeBuilder.addImplementsType(BindingTypes.TREE_ROOT);
moduleDataTypeBuilder.addComment(module.getDescription());
@@ -137,24 +139,23 @@ final class GenHelperUtil {
* @param postfix
* string which is added to the module class name representation
* as suffix
- * @param verboseClassComments
+ * @param verboseClassComments verbosity switch
* @return instance of GeneratedTypeBuilder which represents
* module
.
* @throws IllegalArgumentException
* if module
is null
*/
static GeneratedTypeBuilder moduleTypeBuilder(final Module module, final String postfix, final boolean
- verboseClassComments) {
+ verboseClassComments, final ModuleContext context) {
Preconditions.checkArgument(module != null, "Module reference cannot be NULL.");
final String packageName = BindingMapping.getRootPackageName(module);
// underscore used as separator for distinction of module name parts
final String moduleName = new StringBuilder(module.getName()).append('_').append(postfix).toString();
- final GeneratedTypeBuilderImpl moduleBuilder = new GeneratedTypeBuilderImpl(packageName, moduleName);
+ final GeneratedTypeBuilderImpl moduleBuilder = new GeneratedTypeBuilderImpl(packageName, moduleName, context);
moduleBuilder.setDescription(createDescription(module, verboseClassComments));
moduleBuilder.setReference(module.getReference());
moduleBuilder.setModuleName(moduleName);
-
return moduleBuilder;
}
@@ -198,6 +199,16 @@ final class GenHelperUtil {
return null;
}
+ static GeneratedTOBuilder findIdentityByQname(final QName qname, final Map genCtx) {
+ for (final ModuleContext ctx : genCtx.values()) {
+ final GeneratedTOBuilder result = ctx.getIdentities().get(qname);
+ if (result != null) {
+ return result;
+ }
+ }
+ return null;
+ }
+
/**
* Adds the methods to typeBuilder
which represent subnodes of
* node for which typeBuilder
was created.
@@ -228,44 +239,139 @@ final class GenHelperUtil {
final Iterable schemaNodes, final Map genCtx,
final SchemaContext schemaContext, final boolean verboseClassComments,
final Map> genTypeBuilders,
- final TypeProvider typeProvider) {
+ final TypeProvider typeProvider, final BindingNamespaceType namespaceType) {
if (schemaNodes != null && parent != null) {
for (final DataSchemaNode schemaNode : schemaNodes) {
- if (!schemaNode.isAugmenting() && !schemaNode.isAddedByUses()) {
+ if (resolveDataSchemaNodesCheck(module, schemaContext, schemaNode)) {
addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode, parent, childOf, module, genCtx,
- schemaContext, verboseClassComments, genTypeBuilders, typeProvider);
+ schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
}
}
}
return parent;
}
- static GeneratedTypeBuilder addDefaultInterfaceDefinition(final String packageName, final SchemaNode
+ static boolean resolveDataSchemaNodesCheck(final Module module, final SchemaContext schemaContext,
+ final DataSchemaNode schemaNode) {
+ if (!schemaNode.isAugmenting()) {
+ return true;
+ }
+
+ final QName qname = schemaNode.getPath().getLastComponent();
+ final Module originalModule = schemaContext.findModuleByNamespaceAndRevision(qname.getNamespace(),
+ qname.getRevision());
+ return module.equals(originalModule);
+ }
+
+ static GeneratedTypeBuilder addDefaultInterfaceDefinition(final String basePackageName, final SchemaNode
schemaNode, final Module module, final Map genCtx, final SchemaContext schemaContext,
final boolean verboseClassComments, final Map> genTypeBuilders,
- final TypeProvider typeProvider) {
- return addDefaultInterfaceDefinition(packageName, schemaNode, null, module, genCtx, schemaContext,
- verboseClassComments, genTypeBuilders, typeProvider);
+ final TypeProvider typeProvider, final BindingNamespaceType namespaceType) {
+ return addDefaultInterfaceDefinition(basePackageName, schemaNode, null, module, genCtx, schemaContext,
+ verboseClassComments, genTypeBuilders, typeProvider , namespaceType);
}
- static Map processUsesAugments(final SchemaContext schemaContext, final
- DataNodeContainer node, final Module module, Map genCtx,
- final Map> genTypeBuilders,
- final boolean verboseClassComments, final TypeProvider typeProvider) {
- final String basePackageName = BindingMapping.getRootPackageName(module);
- for (final UsesNode usesNode : node.getUses()) {
- Map> augmentationsGrouped =
- usesNode.getAugmentations().stream().collect(Collectors.groupingBy(AugmentationSchema::getTargetPath));
- for (Map.Entry> schemaPathAugmentListEntry : augmentationsGrouped.entrySet()) {
- genCtx = AugmentToGenType.usesAugmentationToGenTypes(schemaContext, basePackageName,
- schemaPathAugmentListEntry.getValue(), module,
- usesNode, node, genCtx, genTypeBuilders, verboseClassComments, typeProvider);
- for (AugmentationSchema augSchema : schemaPathAugmentListEntry.getValue()) {
- genCtx = processUsesAugments(schemaContext, augSchema, module, genCtx, genTypeBuilders,
- verboseClassComments, typeProvider);
+ 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());
+ } else if (node instanceof SchemaNode) {
+ childNodeQName = QName.create(((SchemaNode) node).getQName(), superChildNode.getQName().getLocalName());
+ } else if (node instanceof AugmentationSchema) {
+ childNodeQName = QName.create(module.getQNameModule(), superChildNode.getQName().getLocalName());
+ } else {
+ 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,
+ final Map 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);
+
+ final GeneratedTypeBuilder type = genCtx.get(module).getChildNode(childNode.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());
+ type.addImplementsType(superType);
+ if (superChildNode instanceof ListSchemaNode
+ && !((ListSchemaNode) superChildNode).getKeyDefinition().isEmpty()) {
+ if (namespaceType.equals(BindingNamespaceType.Grouping)) {
+ genCtx.get(module).getKeyType(childNode.getPath())
+ .addImplementsType(genCtx.get(superModule).getKeyType(superChildNode.getPath()));
+ } else if (namespaceType.equals(BindingNamespaceType.Data)) {
+ genCtx.get(module).getKeyGenTO(childNode.getPath())
+ .addImplementsType(genCtx.get(superModule).getKeyType(superChildNode.getPath()));
+ }
+ }
+ addUsesImplements(superChildNode, superModule, childNode, module, schemaContext, genCtx, namespaceType);
}
}
+ } else if (superNode instanceof ChoiceSchemaNode) {
+ for (ChoiceCaseNode superCaseNode : ((ChoiceSchemaNode) superNode).getCases()) {
+ final QName childQName = createQNameFromSuperNode(module, node, superCaseNode);
+ ChoiceCaseNode 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, "%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);
+ }
+ }
+
+ private static GroupingDefinition findGroupingNodeFromUses(final Module module, final SchemaContext schemaContext,
+ 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());
+ groupingNode = superModule.getGroupings()
+ .stream().filter(grouping -> grouping.getPath().equals(usesNode.getGroupingPath()))
+ .findFirst().orElse(null);
+ } else {
+ //FIXME: Schema path is not unique for Yang 1.1, findDataSchemaNode always does search from data node first.
+ final Iterable prefixedPath = usesNode.getGroupingPath().getPathFromRoot();
+ final QName current = prefixedPath.iterator().next();
+ final Module targetModule = schemaContext.findModuleByNamespaceAndRevision(current.getNamespace(), current.getRevision());
+ Preconditions.checkArgument(targetModule != null, "Cannot find target module for %s and %s.",
+ current.getNamespace(), current.getRevision());
+ groupingNode = targetModule.getGroupings().stream().filter(grouping -> grouping.getPath().equals(usesNode.getGroupingPath()))
+ .collect(Collectors.toList()).get(0);
+ if (groupingNode == null) {
+ groupingNode = SchemaContextUtil.findDataSchemaNode(schemaContext, usesNode.getGroupingPath());
+ }
+ }
+
+ Preconditions.checkNotNull(groupingNode, "%s->%s", module, usesNode.getGroupingPath());
+ Preconditions.checkState(groupingNode instanceof GroupingDefinition, "%s->%s", module,
+ usesNode.getGroupingPath());
+ return (GroupingDefinition) groupingNode;
+ }
+
+ static Map processUsesImplements(final Object node, final Module module,
+ final SchemaContext schemaContext, final Map genCtx, final BindingNamespaceType namespaceType) {
+ if (node instanceof DataNodeContainer) {
+ for (final UsesNode usesNode : ((DataNodeContainer) node).getUses()) {
+ final GroupingDefinition grouping = findGroupingNodeFromUses(module, schemaContext, node, usesNode);
+ final Module superModule = SchemaContextUtil.findParentModule(schemaContext, grouping);
+ addUsesImplements(grouping, superModule, node, module, schemaContext, genCtx, namespaceType);
+ }
}
return genCtx;
}
@@ -291,9 +397,10 @@ final class GenHelperUtil {
}
static Map addRawAugmentGenTypeDefinition(final Module module, final String augmentPackageName,
- final Type targetTypeRef, final List schemaPathAugmentListEntry,
+ final Type targetTypeRef, final SchemaNode targetNode, final List schemaPathAugmentListEntry,
final Map> genTypeBuilders, final Map genCtx,
- final SchemaContext schemaContext, final boolean verboseClassComments, final TypeProvider typeProvider) {
+ final 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);
@@ -308,18 +415,19 @@ final class GenHelperUtil {
break;
}
- boolean isTypeNormalized = false;
if (augIdentifier == null) {
- augIdentifier = augGenTypeName(augmentBuilders, targetTypeRef.getName());
- isTypeNormalized = true;
+ augIdentifier = new StringBuilder(module.getName())
+ .append('_').append(targetNode.getQName().getLocalName()).toString();
}
- GeneratedTypeBuilder augTypeBuilder = new GeneratedTypeBuilderImpl(augmentPackageName, augIdentifier,
- false, isTypeNormalized);
+ GeneratedTypeBuilderImpl augTypeBuilder = new GeneratedTypeBuilderImpl(augmentPackageName, augIdentifier,
+ true, false, genCtx.get(module));
augTypeBuilder.addImplementsType(BindingTypes.TREE_NODE);
augTypeBuilder.addImplementsType(parameterizedTypeFor(BindingTypes.INSTANTIABLE, augTypeBuilder));
augTypeBuilder.addImplementsType(Types.augmentationTypeFor(targetTypeRef));
+ augTypeBuilder.setBasePackageName(BindingMapping.getRootPackageName(module));
+ augTypeBuilder.setWithBuilder(true);
annotateDeprecatedIfNecessary(augSchema.getStatus(), augTypeBuilder);
//produces getters for augTypeBuilder eventually
@@ -327,7 +435,7 @@ final class GenHelperUtil {
//apply all uses
addImplementedInterfaceFromUses(aug, augTypeBuilder, genCtx);
augSchemaNodeToMethods(module, BindingMapping.getRootPackageName(module), augTypeBuilder, augTypeBuilder, aug.getChildNodes(),
- genCtx, schemaContext, verboseClassComments, typeProvider, genTypeBuilders);
+ genCtx, schemaContext, verboseClassComments, typeProvider, genTypeBuilders, namespaceType);
}
augmentBuilders.put(augTypeBuilder.getName(), augTypeBuilder);
@@ -366,12 +474,12 @@ final class GenHelperUtil {
final GeneratedTypeBuilder typeBuilder, final GeneratedTypeBuilder childOf, final Iterable schemaNodes,
final Map genCtx, final SchemaContext schemaContext, final boolean
verboseClassComments, final TypeProvider typeProvider, final Map> genTypeBuilders) {
+ GeneratedTypeBuilder>> genTypeBuilders, final BindingNamespaceType namespaceType) {
if (schemaNodes != null && typeBuilder != null) {
for (final DataSchemaNode schemaNode : schemaNodes) {
if (!schemaNode.isAugmenting()) {
addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode, typeBuilder, childOf, module, genCtx,
- schemaContext, verboseClassComments, genTypeBuilders, typeProvider);
+ schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
}
}
}
@@ -392,9 +500,8 @@ final class GenHelperUtil {
* DataNodeContainer} it can also implement nodes which are specified in
* uses.
*
- * @param packageName
- * string with the name of the package to which
- * schemaNode
belongs.
+ * @param basePackageName
+ * string contains the module package name
* @param schemaNode
* schema node for which is created generated type builder
* @param parent
@@ -402,28 +509,39 @@ final class GenHelperUtil {
* @param schemaContext schema context
* @return generated type builder schemaNode
*/
- private static GeneratedTypeBuilder addDefaultInterfaceDefinition(final String packageName, final SchemaNode
+ private static GeneratedTypeBuilder addDefaultInterfaceDefinition(final String basePackageName, final SchemaNode
schemaNode, final Type parent, final Module module, final Map genCtx,
final SchemaContext schemaContext, final boolean verboseClassComments, final Map> genTypeBuilders, final TypeProvider typeProvider) {
+ GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider, final BindingNamespaceType namespaceType) {
- GeneratedTypeBuilder it = addRawInterfaceDefinition(packageName, schemaNode, schemaContext, "",
- verboseClassComments, genTypeBuilders);
- if (parent == null) {
- it.addImplementsType(BindingTypes.TREE_NODE);
- } else {
- if (parent instanceof ListSchemaNode) {
- it.addImplementsType(parameterizedTypeFor(BindingTypes.TREE_CHILD_NODE, parent, parameterizedTypeFor
- (BindingTypes.IDENTIFIABLE_ITEM, parent)));
+ String suffix = "";
+ if (schemaNode instanceof GroupingDefinition) {
+ suffix = "grouping";
+ } else if (namespaceType.equals(BindingNamespaceType.Grouping)) {
+ suffix = "data";
+ }
+
+ GeneratedTypeBuilder it = addRawInterfaceDefinition(basePackageName, schemaNode, schemaContext, "", suffix,
+ verboseClassComments, genTypeBuilders, namespaceType, genCtx.get(module));
+ if (namespaceType.equals(BindingNamespaceType.Data)) {
+ if (parent == null) {
+ it.addImplementsType(BindingTypes.TREE_NODE);
} else {
- it.addImplementsType(parameterizedTypeFor(BindingTypes.TREE_CHILD_NODE, parent, parameterizedTypeFor
- (BindingTypes.ITEM, parent)));
- it.addImplementsType(parameterizedTypeFor(BindingTypes.INSTANTIABLE, it));
+ 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 GroupingDefinition)) {
- it.addImplementsType(BindingTypes.augmentable(it));
+ if (!(schemaNode instanceof GroupingDefinition)) {
+ it.addImplementsType(BindingTypes.augmentable(it));
+ }
+ } else {
+ it.addImplementsType(BindingTypes.TREE_NODE);
}
if (schemaNode instanceof DataNodeContainer) {
@@ -435,17 +553,13 @@ final class GenHelperUtil {
return it;
}
- static GeneratedTypeBuilder resolveNotification(final GeneratedTypeBuilder listenerInterface, String
+ static GeneratedTypeBuilder resolveNotification(final GeneratedTypeBuilder listenerInterface, final String
parentName, final String basePackageName, final NotificationDefinition notification, final Module module,
- final SchemaContext schemaContext, final boolean verboseClassComments, Map>
- genTypeBuilders, TypeProvider typeProvider, Map genCtx) {
-
- processUsesAugments(schemaContext, notification, module, genCtx, genTypeBuilders,
- verboseClassComments, typeProvider);
-
+ final SchemaContext schemaContext, final boolean verboseClassComments, final Map>
+ genTypeBuilders, final TypeProvider typeProvider, final Map genCtx) {
final GeneratedTypeBuilder notificationInterface = addDefaultInterfaceDefinition
(basePackageName, notification, null, module, genCtx, schemaContext,
- verboseClassComments, genTypeBuilders, typeProvider);
+ verboseClassComments, genTypeBuilders, typeProvider, BindingNamespaceType.Data);
annotateDeprecatedIfNecessary(notification.getStatus(), notificationInterface);
notificationInterface.addImplementsType(NOTIFICATION);
genCtx.get(module).addChildNodeType(notification, notificationInterface);
@@ -453,7 +567,7 @@ final class GenHelperUtil {
// Notification object
resolveDataSchemaNodes(module, basePackageName, notificationInterface,
notificationInterface, notification.getChildNodes(), genCtx, schemaContext,
- verboseClassComments, genTypeBuilders, typeProvider);
+ verboseClassComments, genTypeBuilders, typeProvider, BindingNamespaceType.Data);
//in case of tied notification, incorporate parent's localName
final StringBuilder sb = new StringBuilder("on_");
@@ -476,9 +590,8 @@ final class GenHelperUtil {
* {@link BindingGeneratorImpl#genTypeBuilders genTypeBuilders}. If it isn't
* found it is created and added to genTypeBuilders
.
*
- * @param packageName
- * string with the package name to which returning generated type
- * builder belongs
+ * @param basePackageName
+ * string contains the module package name
* @param schemaNode
* schema node which provide data about the schema node name
* @param schemaContext schema context
@@ -494,12 +607,13 @@ final class GenHelperUtil {
*
*
*/
- static GeneratedTypeBuilder addRawInterfaceDefinition(final String packageName, final SchemaNode schemaNode,
- final SchemaContext schemaContext, final String prefix, final boolean verboseClassComments,
- final Map> genTypeBuilders) {
+ static GeneratedTypeBuilder addRawInterfaceDefinition(final String basePackageName, final SchemaNode schemaNode,
+ final SchemaContext schemaContext, final String prefix, final String suffix,
+ final boolean verboseClassComments, final Map> genTypeBuilders,
+ final BindingNamespaceType namespaceType, final ModuleContext context) {
Preconditions.checkArgument(schemaNode != null, "Data Schema Node cannot be NULL.");
- Preconditions.checkArgument(packageName != null, "Package Name for Generated Type cannot be NULL.");
+ Preconditions.checkArgument(basePackageName != null, "Base package Name for Generated Type cannot be NULL.");
String schemaNodeName = schemaNode.getQName().getLocalName();
Preconditions.checkArgument(schemaNodeName != null, "Local Name of QName for Data Schema Node cannot be NULL.");
@@ -508,14 +622,23 @@ final class GenHelperUtil {
schemaNodeName = new StringBuilder(prefix).append('_').append(schemaNodeName).toString();
}
- final GeneratedTypeBuilderImpl newType = new GeneratedTypeBuilderImpl(packageName, schemaNodeName);
+ if (suffix != null && !suffix.isEmpty()) {
+ // underscore used as separator for distinction of class name parts
+ schemaNodeName = new StringBuilder(schemaNodeName).append('_').append(suffix).toString();
+ }
+
+ final String packageName = packageNameForGeneratedType(basePackageName, schemaNode.getPath(), namespaceType);
+ 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));
+ newType.setDescription(createDescription(schemaNode, newType.getFullyQualifiedName(), schemaContext,
+ verboseClassComments, namespaceType));
newType.setReference(schemaNode.getReference());
newType.setSchemaPath((List) schemaNode.getPath().getPathFromRoot());
newType.setModuleName(module.getName());
+ newType.setBasePackageName(BindingMapping.getRootPackageName(module));
+ newType.setWithBuilder(AuxiliaryGenUtils.hasBuilderClass(schemaNode, namespaceType));
if (!genTypeBuilders.containsKey(packageName)) {
final Map builders = new HashMap<>();
@@ -534,12 +657,13 @@ final class GenHelperUtil {
private static void addSchemaNodeToBuilderAsMethod(final String basePackageName, final DataSchemaNode node,
final GeneratedTypeBuilder typeBuilder, final GeneratedTypeBuilder childOf, final Module module,
final Map genCtx, final SchemaContext schemaContext, final boolean verboseClassComments,
- final Map> genTypeBuilders, final TypeProvider typeProvider) {
+ final Map> genTypeBuilders, final TypeProvider typeProvider,
+ final BindingNamespaceType namespaceType) {
if (node != null && typeBuilder != null) {
if (node instanceof ContainerSchemaNode) {
containerToGenType(module, basePackageName, typeBuilder, childOf, (ContainerSchemaNode) node,
- schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider);
+ schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType);
} else if (node instanceof LeafListSchemaNode) {
resolveLeafListSchemaNode(schemaContext, typeBuilder, (LeafListSchemaNode) node, module,
typeProvider, genCtx);
@@ -548,10 +672,10 @@ final class GenHelperUtil {
typeProvider);
} else if (node instanceof ListSchemaNode) {
listToGenType(module, basePackageName, typeBuilder, childOf, (ListSchemaNode) node, schemaContext,
- verboseClassComments, genCtx, genTypeBuilders, typeProvider);
+ verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType);
} else if (node instanceof ChoiceSchemaNode) {
- choiceToGenType(module, schemaContext, verboseClassComments, basePackageName, childOf,
- (ChoiceSchemaNode) node, genTypeBuilders, genCtx, typeProvider);
+ choiceToGenType(module, schemaContext, verboseClassComments, basePackageName, typeBuilder,
+ (ChoiceSchemaNode) node, genTypeBuilders, genCtx, typeProvider, namespaceType);
} else if (node instanceof AnyXmlSchemaNode || node instanceof AnyDataSchemaNode) {
resolveAnyNodeAsMethod(schemaContext, typeBuilder, genCtx, node, module, typeProvider);
}
@@ -584,80 +708,110 @@ final class GenHelperUtil {
private static void choiceToGenType(final Module module, final SchemaContext schemaContext, final boolean
verboseClasssComments, final String basePackageName, final GeneratedTypeBuilder parent, final
ChoiceSchemaNode choiceNode, final Map> genTypeBuilders,
- final Map genCtx, final TypeProvider typeProvider) {
+ final Map 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.");
- if (!choiceNode.isAddedByUses()) {
- final String packageName = packageNameForGeneratedType(basePackageName, choiceNode.getPath(),
- BindingNamespaceType.Data);
- final GeneratedTypeBuilder choiceTypeBuilder = addRawInterfaceDefinition(packageName, choiceNode,
- schemaContext, "", verboseClasssComments, genTypeBuilders);
- constructGetter(parent, choiceNode.getQName().getLocalName(),
- choiceNode.getDescription(), choiceTypeBuilder, choiceNode.getStatus());
+ final GeneratedTypeBuilder choiceTypeBuilder = addRawInterfaceDefinition(basePackageName, choiceNode,
+ schemaContext, "", "", verboseClasssComments, genTypeBuilders, namespaceType, genCtx.get(module));
+ constructGetter(parent, choiceNode.getQName().getLocalName(),
+ choiceNode.getDescription(), choiceTypeBuilder, choiceNode.getStatus());
+ if (namespaceType.equals(BindingNamespaceType.Data)) {
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);
}
+ annotateDeprecatedIfNecessary(choiceNode.getStatus(), choiceTypeBuilder);
+ genCtx.get(module).addChildNodeType(choiceNode, choiceTypeBuilder);
+ generateTypesFromChoiceCases(module, schemaContext, genCtx, basePackageName, choiceTypeBuilder.toInstance(),
+ 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 genCtx,
- final Map> genTypeBuilders, final TypeProvider typeProvider) {
+ final Map> genTypeBuilders, final TypeProvider typeProvider,
+ final BindingNamespaceType namespaceType) {
final GeneratedTypeBuilder genType = processDataSchemaNode(module, basePackageName, childOf, node,
- schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider);
+ schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType);
if (genType != null) {
- constructGetter(parent, node.getQName().getLocalName(), node.getDescription(), genType, node.getStatus());
+ StringBuilder getterName = new StringBuilder(node.getQName().getLocalName());
+ constructGetter(parent, getterName.toString(), node.getDescription(), genType, node.getStatus());
resolveDataSchemaNodes(module, basePackageName, genType, genType, node.getChildNodes(), genCtx,
- schemaContext, verboseClassComments, genTypeBuilders, typeProvider);
+ 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 genCtx,
- final Map> genTypeBuilders, final TypeProvider typeProvider) {
+ final Map> genTypeBuilders, final TypeProvider typeProvider,
+ final BindingNamespaceType namespaceType) {
final GeneratedTypeBuilder genType = processDataSchemaNode(module, basePackageName, childOf, node,
- schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider);
+ schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType);
if (genType != null) {
final String nodeName = node.getQName().getLocalName();
- constructGetter(parent, nodeName, node.getDescription(), Types.listTypeFor(genType), node.getStatus());
+
+ Type getterReturnType = Types.listTypeFor(genType);
+ if (namespaceType.equals(BindingNamespaceType.Grouping)) {
+ getterReturnType = Types.listTypeFor(wildcardTypeFor(genType.getPackageName(), genType.getName(),
+ true, true, null));
+ }
+ constructGetter(parent, nodeName, node.getDescription(), getterReturnType, node.getStatus());
+
final List listKeys = node.getKeyDefinition();
final String packageName = new StringBuilder(packageNameForGeneratedType(basePackageName, node.getPath(),
BindingNamespaceType.Key)).append('.').append(nodeName).toString();
+ //FIXME: Is it neccessary to generate interface of key and implemented by class?
+ if (namespaceType.equals(BindingNamespaceType.Grouping)) {
+ final GeneratedTypeBuilder genTypeBuilder = resolveListKeyTypeBuilder(packageName, node, 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);
+ }
+ }
+ if (genTypeBuilder != null) {
+ typeBuildersToGenTypes(module, genType, genTypeBuilder.toInstance(), genCtx, namespaceType);
+ genCtx.get(module).addKeyType(node.getPath(), genTypeBuilder);
+ }
+ processUsesImplements(node, module, schemaContext, genCtx, namespaceType);
+ } else {
+ final GeneratedTOBuilder genTOBuilder = resolveListKeyTOBuilder(packageName, node, genCtx.get(module));
+ 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);
+ }
+ }
+ processUsesImplements(node, module, schemaContext, genCtx, namespaceType);
- final GeneratedTOBuilder genTOBuilder = resolveListKeyTOBuilder(packageName, node);
+ // serialVersionUID
+ if (genTOBuilder != null) {
+ final GeneratedPropertyBuilder prop = new GeneratedPropertyBuilderImpl("serialVersionUID");
+ prop.setValue(Long.toString(computeDefaultSUID(genTOBuilder)));
+ genTOBuilder.setSUID(prop);
- for (final DataSchemaNode schemaNode : node.getChildNodes()) {
- if (!schemaNode.isAugmenting()) {
- addSchemaNodeToListBuilders(nodeName, basePackageName, schemaNode, genType, genTOBuilder, listKeys,
- module, typeProvider, schemaContext, genCtx, genTypeBuilders, verboseClassComments);
+ typeBuildersToGenTypes(module, genType, genTOBuilder.toInstance(), genCtx, namespaceType);
+ genCtx.get(module).addGeneratedTOBuilder(node.getPath(), genTOBuilder);
}
}
-
- // serialVersionUID
- if (genTOBuilder != null) {
- final GeneratedPropertyBuilder prop = new GeneratedPropertyBuilderImpl("serialVersionUID");
- prop.setValue(Long.toString(computeDefaultSUID(genTOBuilder)));
- genTOBuilder.setSUID(prop);
- }
-
- typeBuildersToGenTypes(module, genType, genTOBuilder, genCtx);
}
}
private static void typeBuildersToGenTypes(final Module module, final GeneratedTypeBuilder typeBuilder,
- final GeneratedTOBuilder genTOBuilder, final Map genCtx) {
+ final Type keyType, final Map genCtx,
+ final BindingNamespaceType namespaceType) {
checkArgument(typeBuilder != null, "Generated Type Builder cannot be NULL.");
- if (genTOBuilder != null) {
- final GeneratedTransferObject genTO = genTOBuilder.toInstance();
- constructGetter(typeBuilder, "key", "Returns Primary Key of Yang List Type", genTO, Status.CURRENT);
- genCtx.get(module).addGeneratedTOBuilder(genTOBuilder);
+ if (keyType != null) {
+ Type returnKeyType = keyType;
+ if (namespaceType.equals(BindingNamespaceType.Grouping)) {
+ returnKeyType = wildcardTypeFor(keyType.getPackageName(), keyType.getName(),
+ true, true, null);
+ }
+ constructGetter(typeBuilder, "key", "Returns Primary Key of Yang List Type", returnKeyType, Status.CURRENT);
+
}
}
@@ -683,7 +837,7 @@ final class GenHelperUtil {
private static Type resolveLeafSchemaNodeAsMethod(final String nodeName, final SchemaContext schemaContext,
final GeneratedTypeBuilder typeBuilder, final Map genCtx, final LeafSchemaNode leaf,
final Module module, final TypeProvider typeProvider) {
- if (leaf == null || typeBuilder == null || leaf.isAddedByUses()) {
+ if (leaf == null || typeBuilder == null) {
return null;
}
@@ -696,9 +850,27 @@ final class GenHelperUtil {
Type returnType = null;
final TypeDefinition> typeDef = leaf.getType();
- if (isInnerType(leaf, typeDef)) {
+
+ if (leaf.isAddedByUses()) {
+ Preconditions.checkState(leaf instanceof DerivableSchemaNode);
+ if (isInnerType(leaf, typeDef)) {
+ final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(typeDef);
+ returnType = typeProvider.javaTypeForSchemaDefinitionType(getBaseOrDeclaredType(typeDef), leaf,
+ restrictions, genCtx.get(module));
+ } else {
+ if (typeDef.getBaseType() == null && (typeDef instanceof EnumTypeDefinition
+ || typeDef instanceof UnionTypeDefinition || typeDef instanceof BitsTypeDefinition)) {
+ LeafSchemaNode originalLeaf = (LeafSchemaNode) ((DerivableSchemaNode) leaf).getOriginal().orNull();
+ Preconditions.checkNotNull(originalLeaf);
+ returnType = genCtx.get(findParentModule(schemaContext, originalLeaf)).getInnerType(typeDef.getPath());
+ } else {
+ final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(typeDef);
+ returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf, restrictions, genCtx.get(module));
+ }
+ }
+ } else if (isInnerType(leaf, typeDef)) {
if (typeDef instanceof EnumTypeDefinition) {
- returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf);
+ returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf, genCtx.get(module));
final EnumTypeDefinition enumTypeDef = (EnumTypeDefinition) typeDef;
final EnumBuilder enumBuilder = resolveInnerEnumFromTypeDefinition(enumTypeDef, leaf.getQName(),
genCtx, typeBuilder, module);
@@ -708,14 +880,14 @@ final class GenHelperUtil {
((TypeProviderImpl) typeProvider).putReferencedType(leaf.getPath(), returnType);
} else if (typeDef instanceof UnionTypeDefinition) {
final GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, leaf, parentModule,
- typeProvider, schemaContext);
+ typeProvider, schemaContext, genCtx.get(module), genCtx);
if (genTOBuilder != null) {
//TODO: https://bugs.opendaylight.org/show_bug.cgi?id=2289
returnType = createReturnTypeForUnion(genTOBuilder, typeDef, typeBuilder, parentModule, typeProvider);
}
} else if (typeDef instanceof BitsTypeDefinition) {
final GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, leaf, parentModule,
- typeProvider, schemaContext);
+ typeProvider, schemaContext, genCtx.get(module), genCtx);
if (genTOBuilder != null) {
returnType = genTOBuilder.toInstance();
}
@@ -726,11 +898,11 @@ final class GenHelperUtil {
// and apply restrictions from leaf type
final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(typeDef);
returnType = typeProvider.javaTypeForSchemaDefinitionType(getBaseOrDeclaredType(typeDef), leaf,
- restrictions);
+ restrictions, genCtx.get(module));
}
} else {
final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(typeDef);
- returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf, restrictions);
+ returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf, restrictions, genCtx.get(module));
}
if (returnType == null) {
@@ -747,15 +919,13 @@ final class GenHelperUtil {
}
final String leafGetterName;
- if (!"".equals(nodeName)) {
- StringBuilder sb = new StringBuilder(nodeName)
- .append('_')
- .append(leafName);
+ if ("key".equals(leafName.toLowerCase())) {
+ StringBuilder sb = new StringBuilder(leafName)
+ .append('_').append("RESERVED_WORD");
leafGetterName = sb.toString();
} else {
leafGetterName = leafName;
}
-
constructGetter(typeBuilder, leafGetterName, leafDesc, returnType, leaf.getStatus());
return returnType;
}
@@ -773,7 +943,6 @@ final class GenHelperUtil {
* @param module module
* @param typeProvider type provider instance
* @param genCtx actual generated context
- * @param genCtx actual generated context
* @return boolean value
*
* - true - if
node
, typeBuilder
,
@@ -784,7 +953,7 @@ final class GenHelperUtil {
private static boolean resolveLeafListSchemaNode(final SchemaContext schemaContext, final GeneratedTypeBuilder
typeBuilder, final LeafListSchemaNode node, final Module module, final TypeProvider typeProvider,
final Map genCtx) {
- if (node == null || typeBuilder == null || node.isAddedByUses()) {
+ if (node == null || typeBuilder == null) {
return false;
}
@@ -796,29 +965,30 @@ final class GenHelperUtil {
Type returnType = null;
if (typeDef.getBaseType() == null) {
if (typeDef instanceof EnumTypeDefinition) {
- returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, node);
+ returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, node, genCtx.get(module));
final EnumTypeDefinition enumTypeDef = (EnumTypeDefinition) typeDef;
final EnumBuilder enumBuilder = resolveInnerEnumFromTypeDefinition(enumTypeDef, nodeName,
genCtx, typeBuilder, module);
- returnType = new ReferencedTypeImpl(enumBuilder.getPackageName(), enumBuilder.getName());
+ returnType = new ReferencedTypeImpl(enumBuilder.getPackageName(), enumBuilder.getName(), true,
+ null);
((TypeProviderImpl) typeProvider).putReferencedType(node.getPath(), returnType);
} else if (typeDef instanceof UnionTypeDefinition) {
final GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, node, parentModule,
- typeProvider, schemaContext);
+ typeProvider, schemaContext, genCtx.get(module), genCtx);
if (genTOBuilder != null) {
returnType = createReturnTypeForUnion(genTOBuilder, typeDef, typeBuilder, parentModule, typeProvider);
}
} else if (typeDef instanceof BitsTypeDefinition) {
final GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, node, parentModule,
- typeProvider, schemaContext);
+ typeProvider, schemaContext, genCtx.get(module), genCtx);
returnType = genTOBuilder.toInstance();
} else {
final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(typeDef);
- returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, node, restrictions);
+ returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, node, restrictions, genCtx.get(module));
}
} else {
final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(typeDef);
- returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, node, restrictions);
+ returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, node, restrictions, genCtx.get(module));
}
final ParameterizedType listType = Types.listTypeFor(returnType);
@@ -861,7 +1031,7 @@ final class GenHelperUtil {
private static void generateTypesFromChoiceCases(final Module module, final SchemaContext schemaContext,
final Map genCtx, final String basePackageName, final Type refChoiceType,
final ChoiceSchemaNode choiceNode, final boolean verboseClassComments, final TypeProvider typeProvider,
- final Map> genTypeBuilders) {
+ final Map> 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.");
@@ -872,11 +1042,9 @@ final class GenHelperUtil {
}
for (final ChoiceCaseNode caseNode : caseNodes) {
- if (caseNode != null && !caseNode.isAddedByUses() && !caseNode.isAugmenting()) {
- final String packageName = packageNameForGeneratedType(basePackageName, caseNode.getPath(),
- BindingNamespaceType.Data);
- final GeneratedTypeBuilder caseTypeBuilder = addDefaultInterfaceDefinition(packageName, caseNode,
- module, genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider);
+ if (caseNode != null && resolveDataSchemaNodesCheck(module, schemaContext, caseNode)) {
+ final GeneratedTypeBuilder caseTypeBuilder = addDefaultInterfaceDefinition(basePackageName, caseNode,
+ module, genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
caseTypeBuilder.addImplementsType(refChoiceType);
caseTypeBuilder.setParentTypeForBuilder(refChoiceType);
annotateDeprecatedIfNecessary(caseNode.getStatus(), caseTypeBuilder);
@@ -914,16 +1082,16 @@ final class GenHelperUtil {
childOfType = findGroupingByPath(parent.getPath(), genCtx);
}
resolveDataSchemaNodes(module, basePackageName, caseTypeBuilder, childOfType, caseChildNodes,
- genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider);
+ genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
} else {
- resolveDataSchemaNodes(module, basePackageName, caseTypeBuilder, moduleToDataType(module,
- genCtx, verboseClassComments), caseChildNodes, genCtx, schemaContext,
- verboseClassComments, genTypeBuilders, typeProvider);
+ final GeneratedTypeBuilder moduleType = genCtx.get(module).getModuleNode();
+ Preconditions.checkNotNull(moduleType, "Module type can not be null.");
+ resolveDataSchemaNodes(module, basePackageName, caseTypeBuilder, moduleType, caseChildNodes,
+ genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
}
+ processUsesImplements(caseNode, module, schemaContext, genCtx, namespaceType);
}
}
- processUsesAugments(schemaContext, caseNode, module, genCtx, genTypeBuilders, verboseClassComments,
- typeProvider);
}
}
@@ -987,7 +1155,8 @@ final class GenHelperUtil {
final DataSchemaNode schemaNode, final GeneratedTypeBuilder typeBuilder,
final GeneratedTOBuilder genTOBuilder, final List listKeys, final Module module,
final TypeProvider typeProvider, final SchemaContext schemaContext, final Map genCtx,
- final Map> genTypeBuilders, final boolean verboseClassComments) {
+ final Map> genTypeBuilders, final boolean verboseClassComments,
+ final BindingNamespaceType namespaceType) {
checkArgument(schemaNode != null, "Data Schema Node cannot be NULL.");
checkArgument(typeBuilder != null, "Generated Type Builder cannot be NULL.");
@@ -999,30 +1168,65 @@ final class GenHelperUtil {
typeProvider);
if (listKeys.contains(leafQName)) {
if (type == null) {
- resolveLeafSchemaNodeAsProperty(schemaContext, typeProvider, genCtx, genTOBuilder, leaf, true,
+ resolveLeafSchemaNodeAsProperty(nodeName, schemaContext, typeProvider, genCtx, genTOBuilder, leaf, true,
module);
} else {
- AuxiliaryGenUtils.resolveLeafSchemaNodeAsProperty(genTOBuilder, leaf, type, true);
+ AuxiliaryGenUtils.resolveLeafSchemaNodeAsProperty(nodeName, genTOBuilder, leaf, type, true);
}
}
- } else if (!schemaNode.isAddedByUses()) {
+ } else {
+ if (schemaNode instanceof LeafListSchemaNode) {
+ resolveLeafListSchemaNode(schemaContext, typeBuilder, (LeafListSchemaNode) schemaNode, module,
+ typeProvider, genCtx);
+ } else if (schemaNode instanceof ContainerSchemaNode) {
+ containerToGenType(module, basePackageName, typeBuilder, typeBuilder, (ContainerSchemaNode) schemaNode,
+ schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType);
+ } else if (schemaNode instanceof ListSchemaNode) {
+ listToGenType(module, basePackageName, typeBuilder, typeBuilder, (ListSchemaNode) schemaNode,
+ schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType);
+ } else if (schemaNode instanceof ChoiceSchemaNode) {
+ choiceToGenType(module, schemaContext, verboseClassComments, basePackageName, 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 listKeys, final Module module,
+ final TypeProvider typeProvider, final SchemaContext schemaContext, final Map genCtx,
+ final Map> genTypeBuilders, final boolean verboseClassComments,
+ final BindingNamespaceType namespaceType) {
+ checkArgument(schemaNode != null, "Data Schema Node cannot be NULL.");
+ checkArgument(typeBuilder != null, "Generated Type Builder cannot be NULL.");
+
+ if (schemaNode instanceof LeafSchemaNode) {
+ final LeafSchemaNode leaf = (LeafSchemaNode) schemaNode;
+ final QName leafQName = leaf.getQName();
+ final Type type = resolveLeafSchemaNodeAsMethod(nodeName, schemaContext, typeBuilder, genCtx, leaf, module,
+ typeProvider);
+ if (listKeys.contains(leafQName)) {
+ resolveLeafSchemaNodeAsMethod(nodeName, schemaContext, genTypeBuilder, genCtx, leaf, module,
+ typeProvider);
+ }
+ } else {
if (schemaNode instanceof LeafListSchemaNode) {
resolveLeafListSchemaNode(schemaContext, typeBuilder, (LeafListSchemaNode) schemaNode, module,
typeProvider, genCtx);
} else if (schemaNode instanceof ContainerSchemaNode) {
containerToGenType(module, basePackageName, typeBuilder, typeBuilder, (ContainerSchemaNode) schemaNode,
- schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider);
+ schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType);
} else if (schemaNode instanceof ListSchemaNode) {
listToGenType(module, basePackageName, typeBuilder, typeBuilder, (ListSchemaNode) schemaNode,
- schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider);
+ schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType);
} else if (schemaNode instanceof ChoiceSchemaNode) {
choiceToGenType(module, schemaContext, verboseClassComments, basePackageName, typeBuilder,
- (ChoiceSchemaNode) schemaNode, genTypeBuilders, genCtx, typeProvider);
+ (ChoiceSchemaNode) schemaNode, genTypeBuilders, genCtx, typeProvider, namespaceType);
}
}
}
- private static boolean resolveLeafSchemaNodeAsProperty(final SchemaContext schemaContext, final TypeProvider
+ private static boolean resolveLeafSchemaNodeAsProperty(final String nodeName, final SchemaContext schemaContext, final TypeProvider
typeProvider, final Map genCtx, final GeneratedTOBuilder
toBuilder, final LeafSchemaNode leaf, final boolean isReadOnly, final Module module) {
@@ -1045,43 +1249,36 @@ final class GenHelperUtil {
qname.getRevision());
returnType = genCtx.get(enumModule).getInnerType(originalLeaf.getType().getPath());
} else {
- returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf);
+ returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf, genCtx.get(module));
}
- return AuxiliaryGenUtils.resolveLeafSchemaNodeAsProperty(toBuilder, leaf, returnType, isReadOnly);
+ return AuxiliaryGenUtils.resolveLeafSchemaNodeAsProperty(nodeName, toBuilder, leaf, returnType, isReadOnly);
}
return false;
}
private static TypeDefinition> getBaseOrDeclaredType(final TypeDefinition> typeDef) {
final TypeDefinition> baseType = typeDef.getBaseType();
- return (baseType != null && baseType.getBaseType() != null) ? baseType : typeDef;
+ return baseType != null && baseType.getBaseType() != null ? baseType : typeDef;
}
@SuppressWarnings({ "rawtypes", "unchecked" })
private static GeneratedTypeBuilder processDataSchemaNode(final Module module, final String basePackageName,
final GeneratedTypeBuilder childOf, final DataSchemaNode node, final SchemaContext schemaContext,
- final boolean verboseClassComments, Map genCtx, final Map> genTypeBuilders, final TypeProvider typeProvider) {
+ final boolean verboseClassComments, final Map genCtx, final Map> genTypeBuilders, final TypeProvider typeProvider, final BindingNamespaceType namespaceType) {
- if (node.isAugmenting() || node.isAddedByUses()) {
- return null;
- }
- final String packageName = packageNameForGeneratedType(basePackageName, node.getPath(), BindingNamespaceType.Data);
- final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(packageName, node, childOf, module,
- genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider);
+ 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));
+ genType.setDescription(createDescription(node, genType.getFullyQualifiedName(), schemaContext,
+ verboseClassComments, namespaceType));
genType.setModuleName(module.getName());
genType.setReference(node.getReference());
genType.setSchemaPath((List) node.getPath().getPathFromRoot());
genType.setParentTypeForBuilder(childOf);
if (node instanceof DataNodeContainer) {
genCtx.get(module).addChildNodeType(node, genType);
- genCtx = groupingsToGenTypes(module, ((DataNodeContainer) node).getGroupings(), genCtx, schemaContext,
- verboseClassComments, genTypeBuilders, typeProvider);
- processUsesAugments(schemaContext, (DataNodeContainer) node, module, genCtx, genTypeBuilders,
- verboseClassComments, typeProvider);
}
return genType;
}
@@ -1111,7 +1308,7 @@ final class GenHelperUtil {
*/
static Map groupingsToGenTypes(final Module module, final Collection
groupings, Map genCtx, final SchemaContext schemaContext, final boolean
- verboseClassComments, Map> genTypeBuilders, final TypeProvider typeProvider) {
+ verboseClassComments, final Map> genTypeBuilders, final TypeProvider typeProvider) {
final String basePackageName = BindingMapping.getRootPackageName(module);
final List groupingsSortedByDependencies = new GroupingDefinitionDependencySort()
.sort(groupings);
@@ -1149,18 +1346,14 @@ final class GenHelperUtil {
*/
private static Map groupingToGenType(final String basePackageName, final GroupingDefinition grouping, final Module
module, Map genCtx, final SchemaContext schemaContext, final boolean
- verboseClassComments, Map> genTypeBuilders, final TypeProvider typeProvider) {
- final String packageName = packageNameForGeneratedType(basePackageName, grouping.getPath(), BindingNamespaceType.Grouping);
- final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(packageName, grouping, module, genCtx,
- schemaContext, verboseClassComments, genTypeBuilders, typeProvider);
+ verboseClassComments, final Map> genTypeBuilders, final TypeProvider typeProvider) {
+ final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(basePackageName, grouping, module, genCtx,
+ schemaContext, verboseClassComments, genTypeBuilders, typeProvider, BindingNamespaceType.Grouping);
annotateDeprecatedIfNecessary(grouping.getStatus(), genType);
- genCtx.get(module).addGroupingType(grouping.getPath(), genType);
+ genCtx.get(module).addGroupingType(grouping, genType);
resolveDataSchemaNodes(module, basePackageName, genType, genType, grouping.getChildNodes(), genCtx,
- schemaContext, verboseClassComments, genTypeBuilders, typeProvider);
- genCtx = groupingsToGenTypes(module, grouping.getGroupings(), genCtx, schemaContext, verboseClassComments,
- genTypeBuilders, typeProvider);
- genCtx = processUsesAugments(schemaContext, grouping, module, genCtx, genTypeBuilders, verboseClassComments,
- typeProvider);
+ schemaContext, verboseClassComments, genTypeBuilders, typeProvider, BindingNamespaceType.Grouping);
+ genCtx = processUsesImplements(grouping, module, schemaContext, genCtx, BindingNamespaceType.Grouping);
return genCtx;
}
@@ -1186,57 +1379,57 @@ final class GenHelperUtil {
* @return returns generated context
*/
static Map identityToGenType(final Module module, final String basePackageName,
- final IdentitySchemaNode identity, final SchemaContext schemaContext, Map genCtx,
- boolean verboseClassComments, final Map> genTypeBuilders,
- final TypeProvider typeProvider, Map generatedIdentities) {
-
- final String packageName = BindingGeneratorUtil.packageNameForGeneratedType(basePackageName, identity.getPath(),
- BindingNamespaceType.Identity);
- final GeneratedTOBuilderImpl newType = new GeneratedTOBuilderImpl(packageName,
- identity.getQName().getLocalName());
-
- final Set baseIdentities = identity.getBaseIdentities();
- if (baseIdentities.size() == 0) {
- //no base - abstract
- final GeneratedTOBuilderImpl gto = new GeneratedTOBuilderImpl(BaseIdentity.class.getPackage().getName(),
- BaseIdentity.class.getSimpleName());
- newType.setExtendsType(gto.toInstance());
- generatedIdentities.put(identity.getQName(), newType);
- } else {
- //one base - inheritance
- final IdentitySchemaNode baseIdentity = baseIdentities.iterator().next();
- final Module baseIdentityParentModule = SchemaContextUtil.findParentModule(schemaContext, baseIdentity);
- final String returnTypePkgName = new StringBuilder(BindingMapping.getRootPackageName
- (baseIdentityParentModule))
- .append('.')
- .append(BindingNamespaceType.Identity.getPackagePrefix())
- .toString();
-
- final GeneratedTOBuilderImpl existingIdentityGto = generatedIdentities.get(baseIdentity.getQName());
- if (existingIdentityGto != null) {
- newType.setExtendsType(existingIdentityGto.toInstance());
- } else {
- final GeneratedTOBuilderImpl gto = new GeneratedTOBuilderImpl(returnTypePkgName,
- baseIdentity.getQName().getLocalName());
+ final IdentitySchemaNode identity, final SchemaContext schemaContext, final Map 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 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);
+ 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(),
+ BindingNamespaceType.Identity);
+ newType = new GeneratedTOBuilderImpl(packageName, identity.getQName().getLocalName(), true, false,
+ genCtx.get(module));
+
+ final Set baseIdentities = identity.getBaseIdentities();
+ if (baseIdentities.size() == 0) {
+ //no base - abstract
+ final GeneratedTOBuilderImpl gto = new GeneratedTOBuilderImpl(BaseIdentity.class.getPackage().getName(),
+ BaseIdentity.class.getSimpleName(), genCtx.get(module));
newType.setExtendsType(gto.toInstance());
- generatedIdentities.put(baseIdentity.getQName(), gto);
+ } else {
+ //one base - inheritance
+ final IdentitySchemaNode baseIdentity = baseIdentities.iterator().next();
+ GeneratedTOBuilder baseType = resolveIdentitySchemaNode(basePackageName, schemaContext,
+ baseIdentity, module, verboseClassComments, genCtx);
+ newType.setExtendsType(baseType.toInstance());
}
- //FIXME: more bases - possible composition, multiple inheritance not possible
- }
- generatedIdentities.put(identity.getQName(), newType);
-
- newType.setAbstract(true);
- newType.addComment(identity.getDescription());
- newType.setDescription(createDescription(identity, newType.getFullyQualifiedName(), schemaContext,
- verboseClassComments));
- newType.setReference(identity.getReference());
- newType.setModuleName(module.getName());
- newType.setSchemaPath((List) identity.getPath().getPathFromRoot());
+ 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());
+ newType.setSchemaPath((List) identity.getPath().getPathFromRoot());
- qNameConstant(newType, BindingMapping.QNAME_STATIC_FIELD_NAME, identity.getQName());
+ qNameConstant(newType, BindingMapping.QNAME_STATIC_FIELD_NAME, identity.getQName());
- genCtx.get(module).addIdentityType(identity.getQName(), newType);
- return genCtx;
+ genCtx.get(module).addIdentityType(identity.getQName(), newType);
+ }
+ return newType;
}
}