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.INSTANTIABLE;
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.yangtools.yang.model.util.SchemaContextUtil.findDataSchemaNode;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
-
import org.opendaylight.mdsal.binding.javav2.generator.spi.TypeProvider;
import org.opendaylight.mdsal.binding.javav2.generator.util.BindingGeneratorUtil;
import org.opendaylight.mdsal.binding.javav2.generator.util.BindingTypes;
import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedPropertyBuilder;
import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedTOBuilder;
import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedTypeBuilder;
+import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.MethodSignatureBuilder;
import org.opendaylight.mdsal.binding.javav2.spec.base.BaseIdentity;
import org.opendaylight.mdsal.binding.javav2.spec.base.TreeNode;
import org.opendaylight.mdsal.binding.javav2.spec.runtime.BindingNamespaceType;
*
* @param module
* Module object from which builder will be created
- * @param genCtx
- * @param verboseClassComments
+ * @param genCtx generated context
+ * @param verboseClassComments verbosity switch
*
* @return <code>GeneratedTypeBuilder</code> which is internal
* representation of the module
* @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
* <code>module</code>.
* @throws IllegalArgumentException
moduleBuilder.setDescription(createDescription(module, verboseClassComments));
moduleBuilder.setReference(module.getReference());
moduleBuilder.setModuleName(moduleName);
-
return moduleBuilder;
}
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 TypeProvider typeProvider, final BindingNamespaceType namespaceType) {
if (schemaNodes != null && parent != null) {
for (final DataSchemaNode schemaNode : schemaNodes) {
- if (!schemaNode.isAugmenting() && !schemaNode.isAddedByUses()) {
+ if (!schemaNode.isAugmenting()) {
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 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) {
- 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<Module, ModuleContext> processUsesAugments(final SchemaContext schemaContext, final
DataNodeContainer node, final Module module, Map<Module, ModuleContext> genCtx,
final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders,
- final boolean verboseClassComments, final TypeProvider typeProvider) {
+ final boolean verboseClassComments, final TypeProvider typeProvider,
+ final BindingNamespaceType namespaceType) {
final String basePackageName = BindingMapping.getRootPackageName(module);
for (final UsesNode usesNode : node.getUses()) {
Map<SchemaPath, List<AugmentationSchema>> augmentationsGrouped =
for (Map.Entry<SchemaPath, List<AugmentationSchema>> schemaPathAugmentListEntry : augmentationsGrouped.entrySet()) {
genCtx = AugmentToGenType.usesAugmentationToGenTypes(schemaContext, basePackageName,
schemaPathAugmentListEntry.getValue(), module,
- usesNode, node, genCtx, genTypeBuilders, verboseClassComments, typeProvider);
+ usesNode, node, genCtx, genTypeBuilders, verboseClassComments, typeProvider, namespaceType);
for (AugmentationSchema augSchema : schemaPathAugmentListEntry.getValue()) {
genCtx = processUsesAugments(schemaContext, augSchema, module, genCtx, genTypeBuilders,
- verboseClassComments, typeProvider);
+ verboseClassComments, typeProvider, namespaceType);
}
}
}
static Map<Module, ModuleContext> addRawAugmentGenTypeDefinition(final Module module, final String augmentPackageName,
final Type targetTypeRef, final List<AugmentationSchema> schemaPathAugmentListEntry,
final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final Map<Module, ModuleContext> genCtx,
- final SchemaContext schemaContext, final boolean verboseClassComments, final TypeProvider typeProvider) {
+ 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);
break;
}
+ boolean isTypeNormalized = false;
if (augIdentifier == null) {
augIdentifier = augGenTypeName(augmentBuilders, targetTypeRef.getName());
+ isTypeNormalized = true;
}
- GeneratedTypeBuilder augTypeBuilder = new GeneratedTypeBuilderImpl(augmentPackageName, augIdentifier,
- false, true);
+ GeneratedTypeBuilderImpl augTypeBuilder = new GeneratedTypeBuilderImpl(augmentPackageName, augIdentifier,
+ false, isTypeNormalized);
augTypeBuilder.addImplementsType(BindingTypes.TREE_NODE);
augTypeBuilder.addImplementsType(parameterizedTypeFor(BindingTypes.INSTANTIABLE, augTypeBuilder));
augTypeBuilder.addImplementsType(Types.augmentationTypeFor(targetTypeRef));
+ augTypeBuilder.setBasePackageName(BindingMapping.getRootPackageName(module));
+ if (namespaceType.equals(BindingNamespaceType.Data)) {
+ augTypeBuilder.setWithBuilder(true);
+ }
annotateDeprecatedIfNecessary(augSchema.getStatus(), augTypeBuilder);
//produces getters for augTypeBuilder eventually
for (AugmentationSchema aug : schemaPathAugmentListEntry) {
//apply all uses
addImplementedInterfaceFromUses(aug, augTypeBuilder, genCtx);
- augSchemaNodeToMethods(module, augmentPackageName, augTypeBuilder, augTypeBuilder, aug.getChildNodes(),
- genCtx, schemaContext, verboseClassComments, typeProvider, genTypeBuilders);
+ augSchemaNodeToMethods(module, BindingMapping.getRootPackageName(module), augTypeBuilder, augTypeBuilder, aug.getChildNodes(),
+ genCtx, schemaContext, verboseClassComments, typeProvider, genTypeBuilders, namespaceType);
}
augmentBuilders.put(augTypeBuilder.getName(), augTypeBuilder);
return genCtx;
}
- //TODO: delete this method eventually when uses-augments & augmented choice cases are implemented
- /**
- * Returns a generated type builder for an augmentation.
- *
- * The name of the type builder is equal to the name of augmented node with
- * serial number as suffix.
- *
- * @param module
- * current module
- * @param augmentPackageName
- * string with contains the package name to which the augment
- * belongs
- * @param basePackageName
- * string with the package name to which the augmented node
- * belongs
- * @param targetTypeRef
- * target type
- * @param augSchema
- * augmentation schema which contains data about the child nodes
- * and uses of augment
- * @return generated type builder for augment in genCtx
- */
- @Deprecated
- static Map<Module, ModuleContext> addRawAugmentGenTypeDefinition(final Module module, final String augmentPackageName,
- final String basePackageName, final Type targetTypeRef, final AugmentationSchema augSchema,
- final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final Map<Module,
- ModuleContext> genCtx, final SchemaContext schemaContext, final boolean verboseClassComments, final
- TypeProvider typeProvider) {
-
- Map<String, GeneratedTypeBuilder> augmentBuilders = genTypeBuilders.computeIfAbsent(augmentPackageName, k -> new HashMap<>());
- String augIdentifier = getAugmentIdentifier(augSchema.getUnknownSchemaNodes());
-
- if (augIdentifier == null) {
- augIdentifier = augGenTypeName(augmentBuilders, targetTypeRef.getName());
- }
-
- GeneratedTypeBuilder augTypeBuilder = new GeneratedTypeBuilderImpl(augmentPackageName, augIdentifier);
-
- augTypeBuilder.addImplementsType(BindingTypes.TREE_NODE);
- augTypeBuilder.addImplementsType(parameterizedTypeFor(BindingTypes.INSTANTIABLE, augTypeBuilder));
- augTypeBuilder.addImplementsType(Types.augmentationTypeFor(targetTypeRef));
- annotateDeprecatedIfNecessary(augSchema.getStatus(), augTypeBuilder);
- augTypeBuilder = addImplementedInterfaceFromUses(augSchema, augTypeBuilder, genCtx);
-
- augTypeBuilder = augSchemaNodeToMethods(module, basePackageName, augTypeBuilder, augTypeBuilder, augSchema
- .getChildNodes(), genCtx, schemaContext, verboseClassComments, typeProvider, genTypeBuilders);
- augmentBuilders.put(augTypeBuilder.getName(), augTypeBuilder);
-
- if(!augSchema.getChildNodes().isEmpty()) {
- genCtx.get(module).addTypeToAugmentation(augTypeBuilder, augSchema);
-
- }
- genCtx.get(module).addAugmentType(augTypeBuilder);
- return genCtx;
- }
-
/**
* Adds the methods to <code>typeBuilder</code> what represents subnodes of
* node for which <code>typeBuilder</code> was created.
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) {
+ 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);
}
}
}
* DataNodeContainer} it can also implement nodes which are specified in
* <i>uses</i>.
*
- * @param packageName
- * string with the name of the package to which
- * <code>schemaNode</code> belongs.
+ * @param basePackageName
+ * string contains the module package name
* @param schemaNode
* schema node for which is created generated type builder
* @param parent
* @param schemaContext schema context
* @return generated type builder <code>schemaNode</code>
*/
- 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<Module, ModuleContext> genCtx,
final SchemaContext schemaContext, final boolean verboseClassComments, final Map<String, Map<String,
- GeneratedTypeBuilder>> 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);
+ 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));
+ if (schemaNode instanceof DerivableSchemaNode
+ && ((DerivableSchemaNode) schemaNode).isAddedByUses()) {
+ //TODO: The schema path of child node is not unique for YANG 1.1
+ final GeneratedTypeBuilder originalType =
+ findChildNodeByPath(((DerivableSchemaNode) schemaNode).getOriginal().get().getPath(), genCtx);
+ Preconditions.checkState(originalType != null, "Original type can not be null!");
+ it.addImplementsType(originalType.toInstance());
+ }
+
+ } else {
+ it.addImplementsType(BindingTypes.TREE_NODE);
}
if (schemaNode instanceof DataNodeContainer) {
genTypeBuilders, TypeProvider typeProvider, Map<Module, ModuleContext> genCtx) {
processUsesAugments(schemaContext, notification, module, genCtx, genTypeBuilders,
- verboseClassComments, typeProvider);
+ verboseClassComments, typeProvider, BindingNamespaceType.Data);
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);
// 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_");
* {@link BindingGeneratorImpl#genTypeBuilders genTypeBuilders}. If it isn't
* found it is created and added to <code>genTypeBuilders</code>.
*
- * @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
* </ul>
*
*/
- static GeneratedTypeBuilder addRawInterfaceDefinition(final String packageName, final SchemaNode schemaNode,
- final SchemaContext schemaContext, final String prefix, final boolean verboseClassComments,
- final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders) {
+ 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) {
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.");
schemaNodeName = new StringBuilder(prefix).append('_').append(schemaNodeName).toString();
}
+ 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);
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<QName>) schemaNode.getPath().getPathFromRoot());
newType.setModuleName(module.getName());
+ newType.setBasePackageName(BindingMapping.getRootPackageName(module));
+ newType.setWithBuilder(AuxiliaryGenUtils.hasBuilderClass(schemaNode, 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 Map<String, Map<String, GeneratedTypeBuilder>> 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);
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);
+ (ChoiceSchemaNode) node, genTypeBuilders, genCtx, typeProvider, namespaceType);
} else if (node instanceof AnyXmlSchemaNode || node instanceof AnyDataSchemaNode) {
resolveAnyNodeAsMethod(schemaContext, typeBuilder, genCtx, node, module, typeProvider);
}
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 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.");
if (!choiceNode.isAddedByUses()) {
- final String packageName = packageNameForGeneratedType(basePackageName, choiceNode.getPath(),
- BindingNamespaceType.Data);
- final GeneratedTypeBuilder choiceTypeBuilder = addRawInterfaceDefinition(packageName, choiceNode,
- schemaContext, "", verboseClasssComments, genTypeBuilders);
+ final GeneratedTypeBuilder choiceTypeBuilder = addRawInterfaceDefinition(basePackageName, choiceNode,
+ schemaContext, "", "", verboseClasssComments, genTypeBuilders, namespaceType);
constructGetter(parent, choiceNode.getQName().getLocalName(),
choiceNode.getDescription(), choiceTypeBuilder, choiceNode.getStatus());
- choiceTypeBuilder.addImplementsType(INSTANTIABLE);
+ 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);
+ 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 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);
+ 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());
+ if (!namespaceType.equals(BindingNamespaceType.Data)) {
+ getterName.append('_').append(BindingNamespaceType.Data);
+ }
+ final MethodSignatureBuilder getter = constructGetter(parent, getterName.toString(), node.getDescription(), genType, node.getStatus());
+ if (!namespaceType.equals(BindingNamespaceType.Data)) {
+ getter.setAccessModifier(AccessModifier.DEFAULT);
+ }
resolveDataSchemaNodes(module, basePackageName, genType, genType, node.getChildNodes(), genCtx,
- schemaContext, verboseClassComments, genTypeBuilders, typeProvider);
+ schemaContext, verboseClassComments, genTypeBuilders, typeProvider, 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 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);
+ 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());
for (final DataSchemaNode schemaNode : node.getChildNodes()) {
if (!schemaNode.isAugmenting()) {
addSchemaNodeToListBuilders(nodeName, basePackageName, schemaNode, genType, genTOBuilder, listKeys,
- module, typeProvider, schemaContext, genCtx, genTypeBuilders, verboseClassComments);
+ module, typeProvider, schemaContext, genCtx, genTypeBuilders, verboseClassComments, namespaceType);
}
}
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) {
- if (leaf == null || typeBuilder == null || leaf.isAddedByUses()) {
+ if (leaf == null || typeBuilder == null) {
return null;
}
* @param module module
* @param typeProvider type provider instance
* @param genCtx actual generated context
- * @param genCtx actual generated context
* @return boolean value
* <ul>
* <li>true - if <code>node</code>, <code>typeBuilder</code>,
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 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 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);
+ final GeneratedTypeBuilder caseTypeBuilder = addDefaultInterfaceDefinition(basePackageName, caseNode,
+ module, genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
caseTypeBuilder.addImplementsType(refChoiceType);
caseTypeBuilder.setParentTypeForBuilder(refChoiceType);
annotateDeprecatedIfNecessary(caseNode.getStatus(), caseTypeBuilder);
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);
+ verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
}
}
}
processUsesAugments(schemaContext, caseNode, module, genCtx, genTypeBuilders, verboseClassComments,
- typeProvider);
+ typeProvider, 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 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, 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 GeneratedTypeBuilder processDataSchemaNode(final Module module, final String basePackageName,
final GeneratedTypeBuilder childOf, final DataSchemaNode node, final SchemaContext schemaContext,
final boolean verboseClassComments, Map<Module, ModuleContext> genCtx, final Map<String, Map<String,
- GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider) {
+ GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider, final BindingNamespaceType namespaceType) {
- if (node.isAugmenting() || node.isAddedByUses()) {
+ if (node.isAugmenting()) {
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());
genCtx = groupingsToGenTypes(module, ((DataNodeContainer) node).getGroupings(), genCtx, schemaContext,
verboseClassComments, genTypeBuilders, typeProvider);
processUsesAugments(schemaContext, (DataNodeContainer) node, module, genCtx, genTypeBuilders,
- verboseClassComments, typeProvider);
+ verboseClassComments, typeProvider, namespaceType);
}
return genType;
}
private static Map<Module, ModuleContext> groupingToGenType(final String basePackageName, final GroupingDefinition grouping, final Module
module, Map<Module, ModuleContext> genCtx, final SchemaContext schemaContext, final boolean
verboseClassComments, Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider) {
- final String packageName = packageNameForGeneratedType(basePackageName, grouping.getPath(), BindingNamespaceType.Grouping);
- final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(packageName, grouping, module, genCtx,
- schemaContext, verboseClassComments, genTypeBuilders, 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);
+ schemaContext, verboseClassComments, genTypeBuilders, typeProvider, BindingNamespaceType.Grouping);
genCtx = groupingsToGenTypes(module, grouping.getGroupings(), genCtx, schemaContext, verboseClassComments,
genTypeBuilders, typeProvider);
genCtx = processUsesAugments(schemaContext, grouping, module, genCtx, genTypeBuilders, verboseClassComments,
- typeProvider);
+ typeProvider, BindingNamespaceType.Grouping);
return genCtx;
}
boolean verboseClassComments, final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders,
final TypeProvider typeProvider, Map<QName, GeneratedTOBuilderImpl> generatedIdentities) {
- final String packageName = BindingGeneratorUtil.packageNameForGeneratedType(basePackageName, identity.getPath(),
- BindingNamespaceType.Identity);
- final GeneratedTOBuilderImpl newType = new GeneratedTOBuilderImpl(packageName,
- identity.getQName().getLocalName());
+ //check first if identity has been resolved as base identity of some other one
+ GeneratedTOBuilderImpl newType = generatedIdentities.get(identity.getQName());
+
+ if (newType == null) {
+ final String packageName = BindingGeneratorUtil.packageNameForGeneratedType(basePackageName, identity.getPath(),
+ BindingNamespaceType.Identity);
+ newType = new GeneratedTOBuilderImpl(packageName, identity.getQName().getLocalName(), true, false);
+ }
final Set<IdentitySchemaNode> baseIdentities = identity.getBaseIdentities();
if (baseIdentities.size() == 0) {
newType.setAbstract(true);
newType.addComment(identity.getDescription());
newType.setDescription(createDescription(identity, newType.getFullyQualifiedName(), schemaContext,
- verboseClassComments));
+ verboseClassComments, BindingNamespaceType.Identity));
newType.setReference(identity.getReference());
newType.setModuleName(module.getName());
newType.setSchemaPath((List) identity.getPath().getPathFromRoot());
Code Review / mdsal.git / blobdiff