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;
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;
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;
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;
import org.opendaylight.mdsal.binding.javav2.spec.structural.Augmentable;
import org.opendaylight.mdsal.binding.javav2.util.BindingMapping;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
import org.opendaylight.yangtools.yang.model.api.AnyDataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
static GeneratedTypeBuilder moduleToDataType(final Module module, final Map<Module, ModuleContext> genCtx, final boolean verboseClassComments) {
Preconditions.checkArgument(module != null, "Module reference cannot be NULL.");
- final GeneratedTypeBuilder moduleDataTypeBuilder = moduleTypeBuilder(module, "Data", verboseClassComments);
+ final GeneratedTypeBuilder moduleDataTypeBuilder = moduleTypeBuilder(module, "Data", verboseClassComments,
+ genCtx.get(module));
addImplementedInterfaceFromUses(module, moduleDataTypeBuilder, genCtx);
moduleDataTypeBuilder.addImplementsType(BindingTypes.TREE_ROOT);
moduleDataTypeBuilder.addComment(module.getDescription());
* if <code>module</code> 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);
if (schemaNodes != null && parent != null) {
for (final DataSchemaNode schemaNode : schemaNodes) {
- if (!schemaNode.isAugmenting()) {
+ if (resolveDataSchemaNodesCheck(module, schemaContext, schemaNode)) {
addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode, parent, childOf, module, genCtx,
schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
}
return parent;
}
+ static boolean resolveDataSchemaNodesCheck(final Module module, final SchemaContext schemaContext,
+ final DataSchemaNode schemaNode) {
+ if (!schemaNode.isAugmenting()) {
+ return true;
+ } else if (schemaNode.isAugmenting()) {
+ final QName qname = schemaNode.getPath().getLastComponent();
+ final Module originalModule = schemaContext.findModuleByNamespaceAndRevision(qname.getNamespace(),
+ qname.getRevision());
+ if (module.equals(originalModule)) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
static GeneratedTypeBuilder addDefaultInterfaceDefinition(final String basePackageName, final SchemaNode
schemaNode, final Module module, final Map<Module, ModuleContext> genCtx, final SchemaContext schemaContext,
final boolean verboseClassComments, final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders,
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 BindingNamespaceType namespaceType) {
- final String basePackageName = BindingMapping.getRootPackageName(module);
- for (final UsesNode usesNode : node.getUses()) {
- Map<SchemaPath, List<AugmentationSchema>> augmentationsGrouped =
- usesNode.getAugmentations().stream().collect(Collectors.groupingBy(AugmentationSchema::getTargetPath));
- for (Map.Entry<SchemaPath, List<AugmentationSchema>> schemaPathAugmentListEntry : augmentationsGrouped.entrySet()) {
- genCtx = AugmentToGenType.usesAugmentationToGenTypes(schemaContext, basePackageName,
- schemaPathAugmentListEntry.getValue(), module,
- usesNode, node, genCtx, genTypeBuilders, verboseClassComments, typeProvider, namespaceType);
- for (AugmentationSchema augSchema : schemaPathAugmentListEntry.getValue()) {
- genCtx = processUsesAugments(schemaContext, augSchema, module, genCtx, genTypeBuilders,
- verboseClassComments, typeProvider, namespaceType);
- }
- }
- }
- return genCtx;
- }
-
- private static QName createQNameFromSuperNode(final Object node, final SchemaNode superChildNode) {
+ private static QName createQNameFromSuperNode(final Module module, final Object node, final SchemaNode superChildNode) {
QName childNodeQName = null;
if (node instanceof Module) {
- childNodeQName = QName.create(((Module)node).getNamespace(), ((Module)node).getRevision(),
+ childNodeQName = QName.create(((Module) node).getNamespace(), ((Module) node).getRevision(),
superChildNode.getQName().getLocalName());
} else if (node instanceof SchemaNode) {
- childNodeQName = QName.create(((SchemaNode)node).getQName(), superChildNode.getQName().getLocalName());
+ childNodeQName = QName.create(((SchemaNode) node).getQName(), superChildNode.getQName().getLocalName());
+ } else if (node instanceof AugmentationSchema) {
+ childNodeQName = QName.create(module.getNamespace(), module.getRevision(), superChildNode.getQName().getLocalName());
} else {
throw new IllegalArgumentException("Not support node type:" + node.toString());
}
return childNodeQName;
}
- static void addUsesImplements(final SchemaNode superNode, final Module superModule,
+ private static void addUsesImplements(final SchemaNode superNode, final Module superModule,
final Object node, final Module module, final SchemaContext schemaContext,
- Map<Module, ModuleContext> genCtx, final BindingNamespaceType namespaceType) {
-
+ final Map<Module, ModuleContext> genCtx, final BindingNamespaceType namespaceType) {
if (superNode instanceof DataNodeContainer) {
- for (DataSchemaNode superChildNode : ((DataNodeContainer)superNode).getChildNodes()) {
+ for (final DataSchemaNode superChildNode : ((DataNodeContainer) superNode).getChildNodes()) {
if (superChildNode instanceof DataNodeContainer || superChildNode instanceof ChoiceSchemaNode) {
- final QName childQName = createQNameFromSuperNode(node, superChildNode);
- DataSchemaNode childNode = ((DataNodeContainer)node).getDataChildByName(childQName);
+ final QName childQName = createQNameFromSuperNode(module, node, superChildNode);
+ final DataSchemaNode childNode = ((DataNodeContainer) node).getDataChildByName(childQName);
Preconditions.checkNotNull(childNode, node.toString() + "->" + childQName.toString());
final GeneratedTypeBuilder type = genCtx.get(module).getChildNode(childNode.getPath());
final GeneratedTypeBuilder superType = genCtx.get(superModule).getChildNode(superChildNode.getPath());
- //TODO:delete this after supporting uses augment
- if (type == null || superType == null) {
- return;
- }
Preconditions.checkNotNull(type, module.toString() + "->" + childNode.getPath().toString());
Preconditions.checkNotNull(superType, superModule.toString() + "->" + superChildNode.getPath().toString());
type.addImplementsType(superType);
}
}
} else if (superNode instanceof ChoiceSchemaNode) {
- for (ChoiceCaseNode superCaseNode : ((ChoiceSchemaNode)superNode).getCases()) {
- final QName childQName = createQNameFromSuperNode(node, superCaseNode);
- ChoiceCaseNode caseNode = ((ChoiceSchemaNode)node).getCaseNodeByName(childQName);
+ for (final ChoiceCaseNode superCaseNode : ((ChoiceSchemaNode) superNode).getCases()) {
+ final QName childQName = createQNameFromSuperNode(module, node, superCaseNode);
+ final ChoiceCaseNode caseNode = ((ChoiceSchemaNode) node).getCaseNodeByName(childQName);
Preconditions.checkNotNull(caseNode, node.toString() + "->" + childQName.toString());
final GeneratedTypeBuilder type = genCtx.get(module).getCase(caseNode.getPath());
.findFirst().orElse(null);
} else {
//FIXME: Schema path is not unique for Yang 1.1, findDataSchemaNode always does search from data node first.
- groupingNode = SchemaContextUtil.findDataSchemaNode(schemaContext, usesNode.getGroupingPath());
+ final Iterable<QName> 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())).findFirst().orElse(null);
+ if (groupingNode == null) {
+ groupingNode = SchemaContextUtil.findDataSchemaNode(schemaContext, usesNode.getGroupingPath());
+ }
}
Preconditions.checkNotNull(groupingNode, module.toString() + "->"
+ usesNode.getGroupingPath().toString());
}
static Map<Module, ModuleContext> processUsesImplements(final Object node, final Module module,
- final SchemaContext schemaContext, Map<Module, ModuleContext> genCtx, final BindingNamespaceType namespaceType) {
+ final SchemaContext schemaContext, final Map<Module, ModuleContext> genCtx, final BindingNamespaceType namespaceType) {
if (node instanceof DataNodeContainer) {
- for (final UsesNode usesNode : ((DataNodeContainer)node).getUses()) {
+ 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 null;
}
- static GeneratedTypeBuilder findKeyByPath(final SchemaPath path, final Map<Module, ModuleContext> genCtx) {
- for (final ModuleContext ctx : genCtx.values()) {
- final GeneratedTypeBuilder result = ctx.getKeyType(path);
- if (result != null) {
- return result;
- }
- }
- return null;
- }
-
static Map<Module, ModuleContext> addRawAugmentGenTypeDefinition(final Module module, final String augmentPackageName,
- final Type targetTypeRef, final List<AugmentationSchema> schemaPathAugmentListEntry,
+ final Type targetTypeRef, final
SchemaNode targetNode, final List<AugmentationSchema> schemaPathAugmentListEntry,
final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final Map<Module, ModuleContext> genCtx,
final SchemaContext schemaContext, final boolean verboseClassComments, final TypeProvider typeProvider,
final BindingNamespaceType namespaceType) {
//pick augmentation grouped by augmentation target, there is always at least one
final AugmentationSchema augSchema = schemaPathAugmentListEntry.get(0);
- Map<String, GeneratedTypeBuilder> augmentBuilders = genTypeBuilders.computeIfAbsent(
+ final Map<String, GeneratedTypeBuilder> augmentBuilders = genTypeBuilders.computeIfAbsent(
augmentPackageName, k -> new HashMap<>());
//this requires valid semantics in YANG model
String augIdentifier = null;
- for (AugmentationSchema aug : schemaPathAugmentListEntry) {
+ for (final AugmentationSchema aug : schemaPathAugmentListEntry) {
augIdentifier = getAugmentIdentifier(aug.getUnknownSchemaNodes());
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();
}
- GeneratedTypeBuilderImpl augTypeBuilder = new GeneratedTypeBuilderImpl(augmentPackageName, augIdentifier,
- false, isTypeNormalized);
+ final GeneratedTypeBuilderImpl augTypeBuilder = new GeneratedTypeBuilderImpl(augmentPackageName, augIdentifier,
+ true, false, genCtx.get(module));
augTypeBuilder.addImplementsType(BindingTypes.TREE_NODE);
augTypeBuilder.addImplementsType(parameterizedTypeFor(BindingTypes.INSTANTIABLE, augTypeBuilder));
annotateDeprecatedIfNecessary(augSchema.getStatus(), augTypeBuilder);
//produces getters for augTypeBuilder eventually
- for (AugmentationSchema aug : schemaPathAugmentListEntry) {
+ for (final AugmentationSchema aug : schemaPathAugmentListEntry) {
//apply all uses
addImplementedInterfaceFromUses(aug, augTypeBuilder, genCtx);
augSchemaNodeToMethods(module, BindingMapping.getRootPackageName(module), augTypeBuilder, augTypeBuilder, aug.getChildNodes(),
}
GeneratedTypeBuilder it = addRawInterfaceDefinition(basePackageName, schemaNode, schemaContext, "", suffix,
- verboseClassComments, genTypeBuilders, namespaceType);
+ verboseClassComments, genTypeBuilders, namespaceType, genCtx.get(module));
if (namespaceType.equals(BindingNamespaceType.Data)) {
if (parent == null) {
it.addImplementsType(BindingTypes.TREE_NODE);
return it;
}
- static GeneratedTypeBuilder resolveNotification(final GeneratedTypeBuilder listenerInterface, String
+ static GeneratedTypeBuilder resolveNotification(final GeneratedTypeBuilder listenerInterface, final String
parentName, final String basePackageName, final NotificationDefinition notification, final Module module,
- final SchemaContext schemaContext, final boolean verboseClassComments, Map<String, Map<String, GeneratedTypeBuilder>>
- genTypeBuilders, TypeProvider typeProvider, Map<Module, ModuleContext> genCtx) {
-
- processUsesAugments(schemaContext, notification, module, genCtx, genTypeBuilders,
- verboseClassComments, typeProvider, BindingNamespaceType.Data);
-
+ final SchemaContext schemaContext, final boolean verboseClassComments, final Map<String, Map<String, GeneratedTypeBuilder>>
+ genTypeBuilders, final TypeProvider typeProvider, final Map<Module, ModuleContext> genCtx) {
final GeneratedTypeBuilder notificationInterface = addDefaultInterfaceDefinition
(basePackageName, notification, null, module, genCtx, schemaContext,
verboseClassComments, genTypeBuilders, typeProvider, BindingNamespaceType.Data);
static GeneratedTypeBuilder addRawInterfaceDefinition(final String basePackageName, final SchemaNode schemaNode,
final SchemaContext schemaContext, final String prefix, final String suffix,
final boolean verboseClassComments, final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders,
- final BindingNamespaceType namespaceType) {
+ final BindingNamespaceType namespaceType, final ModuleContext context) {
Preconditions.checkArgument(schemaNode != null, "Data Schema Node cannot be NULL.");
Preconditions.checkArgument(basePackageName != null, "Base package Name for Generated Type cannot be NULL.");
}
final String packageName = packageNameForGeneratedType(basePackageName, schemaNode.getPath(), namespaceType);
- final GeneratedTypeBuilderImpl newType = new GeneratedTypeBuilderImpl(packageName, schemaNodeName);
+ 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());
listToGenType(module, basePackageName, typeBuilder, childOf, (ListSchemaNode) node, schemaContext,
verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType);
} else if (node instanceof ChoiceSchemaNode) {
- choiceToGenType(module, schemaContext, verboseClassComments, basePackageName, childOf,
+ choiceToGenType(module, schemaContext, verboseClassComments, basePackageName, typeBuilder,
(ChoiceSchemaNode) node, genTypeBuilders, genCtx, typeProvider, namespaceType);
} else if (node instanceof AnyXmlSchemaNode || node instanceof AnyDataSchemaNode) {
resolveAnyNodeAsMethod(schemaContext, typeBuilder, genCtx, node, module, typeProvider);
checkArgument(choiceNode != null, "Choice Schema Node cannot be NULL.");
final GeneratedTypeBuilder choiceTypeBuilder = addRawInterfaceDefinition(basePackageName, choiceNode,
- schemaContext, "", "", verboseClasssComments, genTypeBuilders, namespaceType);
+ schemaContext, "", "", verboseClasssComments, genTypeBuilders, namespaceType, genCtx.get(module));
constructGetter(parent, choiceNode.getQName().getLocalName(),
choiceNode.getDescription(), choiceTypeBuilder, choiceNode.getStatus());
if (namespaceType.equals(BindingNamespaceType.Data)) {
final GeneratedTypeBuilder genType = processDataSchemaNode(module, basePackageName, childOf, node,
schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType);
if (genType != null) {
- StringBuilder getterName = new StringBuilder(node.getQName().getLocalName());
- final MethodSignatureBuilder getter = constructGetter(parent, getterName.toString(), node.getDescription(), genType, node.getStatus());
+ final 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, namespaceType);
processUsesImplements(node, module, schemaContext, genCtx, namespaceType);
Type getterReturnType = Types.listTypeFor(genType);
if (namespaceType.equals(BindingNamespaceType.Grouping)) {
getterReturnType = Types.listTypeFor(wildcardTypeFor(genType.getPackageName(), genType.getName(),
- true, true));
+ true, true, null));
}
constructGetter(parent, nodeName, node.getDescription(), getterReturnType, node.getStatus());
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);
+ final GeneratedTypeBuilder genTypeBuilder = resolveListKeyTypeBuilder(packageName, node, genCtx.get(module));
for (final DataSchemaNode schemaNode : node.getChildNodes()) {
- if (!schemaNode.isAugmenting()) {
+ if (resolveDataSchemaNodesCheck(module, schemaContext, schemaNode)) {
addSchemaNodeToListTypeBuilders(nodeName, basePackageName, schemaNode, genType, genTypeBuilder, listKeys,
module, typeProvider, schemaContext, genCtx, genTypeBuilders, verboseClassComments, namespaceType);
}
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);
+ final GeneratedTOBuilder genTOBuilder = resolveListKeyTOBuilder(packageName, node, genCtx.get(module));
for (final DataSchemaNode schemaNode : node.getChildNodes()) {
- if (!schemaNode.isAugmenting()) {
+ 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);
// serialVersionUID
if (genTOBuilder != null) {
Type returnKeyType = keyType;
if (namespaceType.equals(BindingNamespaceType.Grouping)) {
returnKeyType = wildcardTypeFor(keyType.getPackageName(), keyType.getName(),
- true, true);
+ true, true, null);
}
constructGetter(typeBuilder, "key", "Returns Primary Key of Yang List Type", returnKeyType, Status.CURRENT);
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)) {
+ final 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);
((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();
}
// 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) {
}
final String leafGetterName;
- if (!"".equals(nodeName)) {
- StringBuilder sb = new StringBuilder(nodeName)
- .append('_')
- .append(leafName);
+ if ("key".equals(leafName.toLowerCase())) {
+ final StringBuilder sb = new StringBuilder(leafName)
+ .append('_').append("RESERVED_WORD");
leafGetterName = sb.toString();
} else {
leafGetterName = leafName;
}
-
constructGetter(typeBuilder, leafGetterName, leafDesc, returnType, leaf.getStatus());
return returnType;
}
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);
}
for (final ChoiceCaseNode caseNode : caseNodes) {
- if (caseNode != null && !caseNode.isAugmenting()) {
+ if (caseNode != null && resolveDataSchemaNodesCheck(module, schemaContext, caseNode)) {
final GeneratedTypeBuilder caseTypeBuilder = addDefaultInterfaceDefinition(basePackageName, caseNode,
module, genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
caseTypeBuilder.addImplementsType(refChoiceType);
resolveDataSchemaNodes(module, basePackageName, caseTypeBuilder, childOfType, caseChildNodes,
genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
} else {
- resolveDataSchemaNodes(module, basePackageName, caseTypeBuilder, moduleToDataType(module,
- genCtx, verboseClassComments), caseChildNodes, genCtx, schemaContext,
- verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
+ 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, namespaceType);
}
}
anyDesc = "";
}
- Type returnType = Types.DOCUMENT;
+ final Type returnType = Types.DOCUMENT;
constructGetter(typeBuilder, anyName, anyDesc, returnType, node.getStatus());
return returnType;
returnType = mc.getTypedefs().get(typeDef.getPath());
} else if (typeDef instanceof EnumTypeDefinition && typeDef.getBaseType() == null) {
// Annonymous enumeration (already generated, since it is inherited via uses).
- LeafSchemaNode originalLeaf = (LeafSchemaNode) SchemaNodeUtils.getRootOriginalIfPossible(leaf);
- QName qname = originalLeaf.getQName();
+ final LeafSchemaNode originalLeaf = (LeafSchemaNode) SchemaNodeUtils.getRootOriginalIfPossible(leaf);
+ final QName qname = originalLeaf.getQName();
final Module enumModule = schemaContext.findModuleByNamespaceAndRevision(qname.getNamespace(),
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(nodeName, toBuilder, leaf, returnType, isReadOnly);
}
@SuppressWarnings({ "rawtypes", "unchecked" })
private static GeneratedTypeBuilder processDataSchemaNode(final Module module, final String basePackageName,
final GeneratedTypeBuilder childOf, final DataSchemaNode node, final SchemaContext schemaContext,
- final boolean verboseClassComments, Map<Module, ModuleContext> genCtx, final Map<String, Map<String,
+ final boolean verboseClassComments, final Map<Module, ModuleContext> genCtx, final Map<String, Map<String,
GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider, final BindingNamespaceType namespaceType) {
- if (node.isAugmenting()) {
- return null;
- }
-
final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(basePackageName, node, childOf, module,
genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
genType.addComment(node.getDescription());
genType.setParentTypeForBuilder(childOf);
if (node instanceof DataNodeContainer) {
genCtx.get(module).addChildNodeType(node, genType);
- processUsesAugments(schemaContext, (DataNodeContainer) node, module, genCtx, genTypeBuilders,
- verboseClassComments, typeProvider, namespaceType);
}
return genType;
}
*/
static Map<Module, ModuleContext> groupingsToGenTypes(final Module module, final Collection<GroupingDefinition>
groupings, Map<Module, ModuleContext> genCtx, final SchemaContext schemaContext, final boolean
- verboseClassComments, Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider) {
+ verboseClassComments, final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider) {
final String basePackageName = BindingMapping.getRootPackageName(module);
final List<GroupingDefinition> groupingsSortedByDependencies = new GroupingDefinitionDependencySort()
.sort(groupings);
*/
private static Map<Module, ModuleContext> groupingToGenType(final String basePackageName, final GroupingDefinition grouping, final Module
module, Map<Module, ModuleContext> genCtx, final SchemaContext schemaContext, final boolean
- verboseClassComments, Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider) {
+ verboseClassComments, final Map<String, Map<String, GeneratedTypeBuilder>> 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, genType);
resolveDataSchemaNodes(module, basePackageName, genType, genType, grouping.getChildNodes(), genCtx,
schemaContext, verboseClassComments, genTypeBuilders, typeProvider, BindingNamespaceType.Grouping);
- genCtx = processUsesAugments(schemaContext, grouping, module, genCtx, genTypeBuilders, verboseClassComments,
- typeProvider, BindingNamespaceType.Grouping);
genCtx = processUsesImplements(grouping, module, schemaContext, genCtx, BindingNamespaceType.Grouping);
return genCtx;
}
* @return returns generated context
*/
static Map<Module, ModuleContext> identityToGenType(final Module module, final String basePackageName,
- final IdentitySchemaNode identity, final SchemaContext schemaContext, Map<Module, ModuleContext> genCtx,
- boolean verboseClassComments) {
+ final IdentitySchemaNode identity, final SchemaContext schemaContext, final Map<Module, ModuleContext> genCtx,
+ final boolean verboseClassComments) {
resolveIdentitySchemaNode(basePackageName, schemaContext, identity, module, verboseClassComments, genCtx);
return genCtx;
final String packageName = BindingGeneratorUtil.packageNameForGeneratedType(basePackageName, identity.getPath(),
BindingNamespaceType.Identity);
- newType = new GeneratedTOBuilderImpl(packageName, identity.getQName().getLocalName(), true, false);
+ newType = new GeneratedTOBuilderImpl(packageName, identity.getQName().getLocalName(), true, false,
+ genCtx.get(module));
final Set<IdentitySchemaNode> baseIdentities = identity.getBaseIdentities();
if (baseIdentities.size() == 0) {
//no base - abstract
final GeneratedTOBuilderImpl gto = new GeneratedTOBuilderImpl(BaseIdentity.class.getPackage().getName(),
- BaseIdentity.class.getSimpleName());
+ BaseIdentity.class.getSimpleName(), genCtx.get(module));
newType.setExtendsType(gto.toInstance());
} else {
//one base - inheritance
final IdentitySchemaNode baseIdentity = baseIdentities.iterator().next();
- GeneratedTOBuilder baseType = resolveIdentitySchemaNode(basePackageName, schemaContext,
+ final GeneratedTOBuilder baseType = resolveIdentitySchemaNode(basePackageName, schemaContext,
baseIdentity, module, verboseClassComments, genCtx);
newType.setExtendsType(baseType.toInstance());
}
Code Review / mdsal.git / blobdiff