import static com.google.common.base.Preconditions.checkState;
import static org.opendaylight.yangtools.binding.generator.util.BindingGeneratorUtil.computeDefaultSUID;
import static org.opendaylight.yangtools.binding.generator.util.BindingGeneratorUtil.packageNameForGeneratedType;
-import static org.opendaylight.yangtools.binding.generator.util.BindingGeneratorUtil.parseToValidParamName;
import static org.opendaylight.yangtools.binding.generator.util.BindingTypes.DATA_OBJECT;
import static org.opendaylight.yangtools.binding.generator.util.BindingTypes.DATA_ROOT;
import static org.opendaylight.yangtools.binding.generator.util.BindingTypes.IDENTIFIABLE;
import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.findDataSchemaNode;
import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.findNodeInSchemaContext;
import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.findParentModule;
-
+import com.google.common.base.Preconditions;
import com.google.common.base.Splitter;
import com.google.common.collect.Iterables;
import com.google.common.collect.Sets;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
-import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
+import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
public class BindingGeneratorImpl implements BindingGenerator {
private static final Logger LOG = LoggerFactory.getLogger(BindingGeneratorImpl.class);
+ private static final Splitter COLON_SPLITTER = Splitter.on(':');
+ private static final Splitter BSDOT_SPLITTER = Splitter.on("\\.");
+ private static final char NEW_LINE = '\n';
+ private static final String QNAME_FQCN = QName.class.getName();
+
+ /**
+ * Constant with the concrete name of identifier.
+ */
+ private static final String AUGMENT_IDENTIFIER_NAME = "augment-identifier";
+
+ /**
+ * Constant with the concrete name of namespace.
+ */
+ private static final String YANG_EXT_NAMESPACE = "urn:opendaylight:yang:extension:yang-ext";
private final Map<Module, ModuleContext> genCtx = new HashMap<>();
+ /**
+ * When set to true, generated classes will include javadoc comments which
+ * are useful for users.
+ */
+ private final boolean verboseClassComments;
+
/**
* Outer key represents the package name. Outer value represents map of all
* builders in the same package. Inner key represents the schema node name
private SchemaContext schemaContext;
/**
- * Constant with the concrete name of namespace.
+ * Create a new binding generator with verboe comments.
+ *
+ * @deprecated Use {@link #BindingGeneratorImpl(boolean)} instead.
*/
- private final static String YANG_EXT_NAMESPACE = "urn:opendaylight:yang:extension:yang-ext";
+ @Deprecated
+ public BindingGeneratorImpl() {
+ this(true);
+ }
/**
- * Constant with the concrete name of identifier.
+ * Create a new binding generator.
+ *
+ * @param verboseClassComments generate verbose comments
*/
- private final static String AUGMENT_IDENTIFIER_NAME = "augment-identifier";
-
- private final char NEW_LINE = '\n';
-
- private final char TAB = '\t';
+ public BindingGeneratorImpl(final boolean verboseClassComments) {
+ this.verboseClassComments = verboseClassComments;
+ }
/**
* Resolves generated types from <code>context</code> schema nodes of all
* <ul>
* <li>are generated from <code>context</code> schema nodes and</li>
* <li>are also part of some of the module in <code>modules</code>
- * set</li>.
+ * set.</li>
* </ul>
* @throws IllegalArgumentException
* <ul>
schemaContext = context;
typeProvider = new TypeProviderImpl(context);
- Module[] modulesArray = new Module[context.getModules().size()];
+ final Module[] modulesArray = new Module[context.getModules().size()];
context.getModules().toArray(modulesArray);
final List<Module> contextModules = ModuleDependencySort.sort(modulesArray);
genTypeBuilders = new HashMap<>();
- for (Module contextModule : contextModules) {
+ for (final Module contextModule : contextModules) {
moduleToGenTypes(contextModule, context);
}
- for (Module contextModule : contextModules) {
+ for (final Module contextModule : contextModules) {
allAugmentsToGenTypes(contextModule);
}
final List<Type> filteredGenTypes = new ArrayList<>();
- for (Module m : modules) {
+ for (final Module m : modules) {
final ModuleContext ctx = checkNotNull(genCtx.get(m), "Module context not found for module %s", m);
filteredGenTypes.addAll(ctx.getGeneratedTypes());
final Set<Type> additionalTypes = ((TypeProviderImpl) typeProvider).getAdditionalTypes().get(m);
final List<TypeDefinition<?>> typeDefinitions = it.allTypedefs();
checkState(typeDefinitions != null, "Type Definitions for module «module.name» cannot be NULL.");
- for (TypeDefinition<?> typedef : typeDefinitions) {
+ for (final TypeDefinition<?> typedef : typeDefinitions) {
if (typedef != null) {
final Type type = ((TypeProviderImpl) typeProvider).generatedTypeForExtendedDefinitionType(typedef,
typedef);
if (type != null) {
- genCtx.get(module).addTypedefType(typedef.getPath(), type);
+ final ModuleContext ctx = genCtx.get(module);
+ ctx.addTypedefType(typedef.getPath(), type);
+ ctx.addTypeToSchema(type,typedef);
}
}
}
return null;
}
final String packageName = packageNameForGeneratedType(basePackageName, node.getPath());
- final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(packageName, node, childOf);
+ final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(packageName, node, childOf, module);
genType.addComment(node.getDescription());
genType.setDescription(createDescription(node, genType.getFullyQualifiedName()));
genType.setModuleName(module.getName());
genType.addImplementsType(identifiableMarker);
}
- for (DataSchemaNode schemaNode : node.getChildNodes()) {
+ for (final DataSchemaNode schemaNode : node.getChildNodes()) {
if (!schemaNode.isAugmenting()) {
addSchemaNodeToListBuilders(basePackageName, schemaNode, genType, genTOBuilder, listKeys, module);
}
private void processUsesAugments(final DataNodeContainer node, final Module module) {
final String basePackageName = BindingMapping.getRootPackageName(module.getQNameModule());
- for (UsesNode usesNode : node.getUses()) {
- for (AugmentationSchema augment : usesNode.getAugmentations()) {
+ for (final UsesNode usesNode : node.getUses()) {
+ for (final AugmentationSchema augment : usesNode.getAugmentations()) {
usesAugmentationToGenTypes(basePackageName, augment, module, usesNode, node);
processUsesAugments(augment, module);
}
final String basePackageName = BindingMapping.getRootPackageName(module.getQNameModule());
final List<AugmentationSchema> augmentations = resolveAugmentations(module);
- for (AugmentationSchema augment : augmentations) {
+ for (final AugmentationSchema augment : augmentations) {
augmentationToGenTypes(basePackageName, augment, module);
}
}
checkState(module.getAugmentations() != null, "Augmentations Set cannot be NULL.");
final Set<AugmentationSchema> augmentations = module.getAugmentations();
- List<AugmentationSchema> sortedAugmentations = new ArrayList<>(augmentations);
+ final List<AugmentationSchema> sortedAugmentations = new ArrayList<>(augmentations);
Collections.sort(sortedAugmentations, Comparators.AUGMENT_COMP);
return sortedAugmentations;
interfaceBuilder.addImplementsType(Types.typeForClass(RpcService.class));
interfaceBuilder.setDescription(createDescription(rpcDefinitions, module.getName(), module.getModuleSourcePath()));
- for (RpcDefinition rpc : rpcDefinitions) {
+ for (final RpcDefinition rpc : rpcDefinitions) {
if (rpc != null) {
final String rpcName = BindingMapping.getClassName(rpc.getQName());
- final String rpcMethodName = parseToValidParamName(rpcName);
+ final String rpcMethodName = BindingMapping.getPropertyName(rpcName);
final String rpcComment = rpc.getDescription();
final MethodSignatureBuilder method = interfaceBuilder.addMethod(rpcMethodName);
final ContainerSchemaNode input = rpc.getInput();
- for (NotificationDefinition notification : notifications) {
+ for (final NotificationDefinition notification : notifications) {
if (notification != null) {
processUsesAugments(notification, module);
final GeneratedTypeBuilder notificationInterface = addDefaultInterfaceDefinition(basePackageName,
- notification, BindingTypes.DATA_OBJECT);
+ notification, BindingTypes.DATA_OBJECT, module);
notificationInterface.addImplementsType(NOTIFICATION);
genCtx.get(module).addChildNodeType(notification, notificationInterface);
final String basePackageName = BindingMapping.getRootPackageName(module.getQNameModule());
if (schemaIdentities != null && !schemaIdentities.isEmpty()) {
- for (IdentitySchemaNode identity : schemaIdentities) {
+ for (final IdentitySchemaNode identity : schemaIdentities) {
identityToGenType(module, basePackageName, identity, context);
}
}
newType.setDescription(createDescription(identity, newType.getFullyQualifiedName()));
newType.setReference(identity.getReference());
newType.setModuleName(module.getName());
- SchemaPath path = identity.getPath();
newType.setSchemaPath(identity.getPath().getPathFromRoot());
final QName qname = identity.getQName();
private static Constant qnameConstant(final GeneratedTypeBuilderBase<?> toBuilder, final String constantName,
final QName name) {
- StringBuilder sb = new StringBuilder("org.opendaylight.yangtools.yang.common.QName");
+ final StringBuilder sb = new StringBuilder(QNAME_FQCN);
+ sb.append(".cachedReference(");
+ sb.append(QNAME_FQCN);
sb.append(".create(");
sb.append('"');
sb.append(name.getNamespace());
sb.append(name.getFormattedRevision());
sb.append("\",\"");
sb.append(name.getLocalName());
- sb.append("\");");
+ sb.append("\"))");
return toBuilder.addConstant(typeForClass(QName.class), constantName, sb.toString());
}
final String basePackageName = BindingMapping.getRootPackageName(module.getQNameModule());
final List<GroupingDefinition> groupingsSortedByDependencies = new GroupingDefinitionDependencySort()
.sort(groupings);
- for (GroupingDefinition grouping : groupingsSortedByDependencies) {
+ for (final GroupingDefinition grouping : groupingsSortedByDependencies) {
groupingToGenType(basePackageName, grouping, module);
}
}
*/
private void groupingToGenType(final String basePackageName, final GroupingDefinition grouping, final Module module) {
final String packageName = packageNameForGeneratedType(basePackageName, grouping.getPath());
- final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(packageName, grouping);
+ final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(packageName, grouping, module);
genCtx.get(module).addGroupingType(grouping.getPath(), genType);
resolveDataSchemaNodes(module, basePackageName, genType, genType, grouping.getChildNodes());
groupingsToGenTypes(module, grouping.getGroupings());
throw new NullPointerException("Target type not yet generated: " + targetSchemaNode);
}
- if (!(targetSchemaNode instanceof ChoiceNode)) {
- String packageName = augmentPackageName;
+ if (!(targetSchemaNode instanceof ChoiceSchemaNode)) {
+ final String packageName = augmentPackageName;
final Type targetType = new ReferencedTypeImpl(targetTypeBuilder.getPackageName(),
targetTypeBuilder.getName());
addRawAugmentGenTypeDefinition(module, packageName, augmentPackageName, targetType, augSchema);
} else {
generateTypesFromAugmentedChoiceCases(module, augmentPackageName, targetTypeBuilder.toInstance(),
- (ChoiceNode) targetSchemaNode, augSchema.getChildNodes());
+ (ChoiceSchemaNode) targetSchemaNode, augSchema.getChildNodes());
}
}
processUsesAugments(augSchema, module);
final SchemaPath targetPath = augSchema.getTargetPath();
- SchemaNode targetSchemaNode = findOriginalTargetFromGrouping(targetPath, usesNode);
+ final SchemaNode targetSchemaNode = findOriginalTargetFromGrouping(targetPath, usesNode);
if (targetSchemaNode == null) {
throw new IllegalArgumentException("augment target not found: " + targetPath);
}
throw new NullPointerException("Target type not yet generated: " + targetSchemaNode);
}
- if (!(targetSchemaNode instanceof ChoiceNode)) {
+ if (!(targetSchemaNode instanceof ChoiceSchemaNode)) {
String packageName = augmentPackageName;
if (usesNodeParent instanceof SchemaNode) {
packageName = packageNameForGeneratedType(augmentPackageName, ((SchemaNode) usesNodeParent).getPath(),
augSchema);
} else {
generateTypesFromAugmentedChoiceCases(module, augmentPackageName, targetTypeBuilder.toInstance(),
- (ChoiceNode) targetSchemaNode, augSchema.getChildNodes());
+ (ChoiceSchemaNode) targetSchemaNode, augSchema.getChildNodes());
}
}
* @return node from its original location in grouping
*/
private DataSchemaNode findOriginalTargetFromGrouping(final SchemaPath targetPath, final UsesNode parentUsesNode) {
- SchemaNode targetGrouping = findNodeInSchemaContext(schemaContext, parentUsesNode.getGroupingPath()
+ final SchemaNode targetGrouping = findNodeInSchemaContext(schemaContext, parentUsesNode.getGroupingPath()
.getPathFromRoot());
if (!(targetGrouping instanceof GroupingDefinition)) {
throw new IllegalArgumentException("Failed to generate code for augment in " + parentUsesNode);
}
- GroupingDefinition grouping = (GroupingDefinition) targetGrouping;
+ final GroupingDefinition grouping = (GroupingDefinition) targetGrouping;
SchemaNode result = grouping;
- for (QName node : targetPath.getPathFromRoot()) {
+ for (final QName node : targetPath.getPathFromRoot()) {
// finding by local name is valid, grouping cannot contain nodes
// with same name and different namespace
if (result instanceof DataNodeContainer) {
result = ((DataNodeContainer) result).getDataChildByName(node.getLocalName());
- } else if (result instanceof ChoiceNode) {
- result = ((ChoiceNode) result).getCaseNodeByName(node.getLocalName());
+ } else if (result instanceof ChoiceSchemaNode) {
+ result = ((ChoiceSchemaNode) result).getCaseNodeByName(node.getLocalName());
}
}
if (result == null) {
}
boolean fromUses = ((DataSchemaNode) result).isAddedByUses();
- Iterator<UsesNode> groupingUses = grouping.getUses().iterator();
+ final Iterator<UsesNode> groupingUses = grouping.getUses().iterator();
while (groupingUses.hasNext() && fromUses) {
result = findOriginalTargetFromGrouping(targetPath, groupingUses.next());
if (result != null) {
augSchemaNodeToMethods(module, basePackageName, augTypeBuilder, augTypeBuilder, augSchema.getChildNodes());
augmentBuilders.put(augTypeName, augTypeBuilder);
- genCtx.get(module).addTargetToAugmentation(targetTypeRef, augTypeBuilder);
+ if(!augSchema.getChildNodes().isEmpty()) {
+ genCtx.get(module).addTargetToAugmentation(targetTypeRef, augTypeBuilder);
+ genCtx.get(module).addTypeToAugmentation(augTypeBuilder, augSchema);
+
+ }
genCtx.get(module).addAugmentType(augTypeBuilder);
- genCtx.get(module).addTypeToAugmentation(augTypeBuilder, augSchema);
return augTypeBuilder;
}
* @return nodeParameter of UnknownSchemaNode
*/
private String getAugmentIdentifier(final List<UnknownSchemaNode> unknownSchemaNodes) {
- for (UnknownSchemaNode unknownSchemaNode : unknownSchemaNodes) {
+ for (final UnknownSchemaNode unknownSchemaNode : unknownSchemaNodes) {
final QName nodeType = unknownSchemaNode.getNodeType();
if (AUGMENT_IDENTIFIER_NAME.equals(nodeType.getLocalName())
&& YANG_EXT_NAMESPACE.equals(nodeType.getNamespace().toString())) {
private GeneratedTypeBuilder resolveDataSchemaNodes(final Module module, final String basePackageName,
final GeneratedTypeBuilder parent, final GeneratedTypeBuilder childOf, final Iterable<DataSchemaNode> schemaNodes) {
if (schemaNodes != null && parent != null) {
- for (DataSchemaNode schemaNode : schemaNodes) {
+ for (final DataSchemaNode schemaNode : schemaNodes) {
if (!schemaNode.isAugmenting() && !schemaNode.isAddedByUses()) {
addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode, parent, childOf, module);
}
final GeneratedTypeBuilder typeBuilder, final GeneratedTypeBuilder childOf,
final Iterable<DataSchemaNode> schemaNodes) {
if ((schemaNodes != null) && (typeBuilder != null)) {
- for (DataSchemaNode schemaNode : schemaNodes) {
+ for (final DataSchemaNode schemaNode : schemaNodes) {
if (!schemaNode.isAugmenting()) {
addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode, typeBuilder, childOf, module);
}
containerToGenType(module, basePackageName, typeBuilder, childOf, (ContainerSchemaNode) node);
} else if (node instanceof ListSchemaNode) {
listToGenType(module, basePackageName, typeBuilder, childOf, (ListSchemaNode) node);
- } else if (node instanceof ChoiceNode) {
- choiceToGeneratedType(module, basePackageName, typeBuilder, (ChoiceNode) node);
+ } else if (node instanceof ChoiceSchemaNode) {
+ choiceToGeneratedType(module, basePackageName, typeBuilder, (ChoiceSchemaNode) node);
} else {
// TODO: anyxml not yet supported
LOG.debug("Unable to add schema node {} as method in {}: unsupported type of node.", node.getClass(),
* </ul>
*/
private void choiceToGeneratedType(final Module module, final String basePackageName,
- final GeneratedTypeBuilder parent, final ChoiceNode choiceNode) {
+ final GeneratedTypeBuilder parent, final ChoiceSchemaNode choiceNode) {
checkArgument(basePackageName != null, "Base Package Name cannot be NULL.");
checkArgument(choiceNode != null, "Choice Schema Node cannot be NULL.");
* </ul>
*/
private void generateTypesFromChoiceCases(final Module module, final String basePackageName,
- final Type refChoiceType, final ChoiceNode choiceNode) {
+ final Type refChoiceType, final ChoiceSchemaNode choiceNode) {
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.");
return;
}
- for (ChoiceCaseNode caseNode : caseNodes) {
+ for (final ChoiceCaseNode caseNode : caseNodes) {
if (caseNode != null && !caseNode.isAddedByUses() && !caseNode.isAugmenting()) {
final String packageName = packageNameForGeneratedType(basePackageName, caseNode.getPath());
- final GeneratedTypeBuilder caseTypeBuilder = addDefaultInterfaceDefinition(packageName, caseNode);
+ final GeneratedTypeBuilder caseTypeBuilder = addDefaultInterfaceDefinition(packageName, caseNode, module);
caseTypeBuilder.addImplementsType(refChoiceType);
genCtx.get(module).addCaseType(caseNode.getPath(), caseTypeBuilder);
genCtx.get(module).addChoiceToCaseMapping(refChoiceType, caseTypeBuilder, caseNode);
final Iterable<DataSchemaNode> caseChildNodes = caseNode.getChildNodes();
if (caseChildNodes != null) {
- Object parentNode = null;
final SchemaPath nodeSp = choiceNode.getPath();
- parentNode = findDataSchemaNode(schemaContext, nodeSp.getParent());
+ final Object parentNode = findDataSchemaNode(schemaContext, nodeSp.getParent());
SchemaNode parent;
if (parentNode instanceof AugmentationSchema) {
final SchemaPath sp = choiceNode.getPath();
parent = findDataSchemaNode(schemaContext, sp.getParent());
}
+ Preconditions.checkState(parent != null, "Could not find Choice node parent "+choiceNode.getPath().getParent());
GeneratedTypeBuilder childOfType = findChildNodeByPath(parent.getPath());
if (childOfType == null) {
childOfType = findGroupingByPath(parent.getPath());
resolveDataSchemaNodes(module, basePackageName, caseTypeBuilder, childOfType, caseChildNodes);
}
}
-
processUsesAugments(caseNode, module);
}
}
* </ul>
*/
private void generateTypesFromAugmentedChoiceCases(final Module module, final String basePackageName,
- final Type targetType, final ChoiceNode targetNode, final Iterable<DataSchemaNode> augmentedNodes) {
+ final Type targetType, final ChoiceSchemaNode targetNode, final Iterable<DataSchemaNode> augmentedNodes) {
checkArgument(basePackageName != null, "Base Package Name cannot be NULL.");
checkArgument(targetType != null, "Referenced Choice Type cannot be NULL.");
checkArgument(augmentedNodes != null, "Set of Choice Case Nodes cannot be NULL.");
- for (DataSchemaNode caseNode : augmentedNodes) {
+ for (final DataSchemaNode caseNode : augmentedNodes) {
if (caseNode != null) {
final String packageName = packageNameForGeneratedType(basePackageName, caseNode.getPath());
- final GeneratedTypeBuilder caseTypeBuilder = addDefaultInterfaceDefinition(packageName, caseNode);
+ final GeneratedTypeBuilder caseTypeBuilder = addDefaultInterfaceDefinition(packageName, caseNode, module);
caseTypeBuilder.addImplementsType(targetType);
SchemaNode parent = null;
} else if (typeDef instanceof BitsTypeDefinition) {
genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, leaf, parentModule);
if (genTOBuilder != null) {
- returnType = new ReferencedTypeImpl(genTOBuilder.getPackageName(), genTOBuilder.getName());
+ returnType = genTOBuilder.toInstance();
}
} else {
final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(typeDef);
private void processContextRefExtension(final LeafSchemaNode leaf, final MethodSignatureBuilder getter,
final Module module) {
- for (UnknownSchemaNode node : leaf.getUnknownSchemaNodes()) {
+ for (final UnknownSchemaNode node : leaf.getUnknownSchemaNodes()) {
final QName nodeType = node.getNodeType();
if ("context-reference".equals(nodeType.getLocalName())) {
final String nodeParam = node.getNodeParameter();
IdentitySchemaNode identity = null;
String basePackageName = null;
- final Iterable<String> splittedElement = Splitter.on(':').split(nodeParam);
+ final Iterable<String> splittedElement = COLON_SPLITTER.split(nodeParam);
final Iterator<String> iterator = splittedElement.iterator();
final int length = Iterables.size(splittedElement);
if (length == 1) {
identity = findIdentityByName(module.getIdentities(), iterator.next());
basePackageName = BindingMapping.getRootPackageName(module.getQNameModule());
} else if (length == 2) {
- String prefix = iterator.next();
+ final String prefix = iterator.next();
final Module dependentModule = findModuleFromImports(module.getImports(), prefix);
if (dependentModule == null) {
throw new IllegalArgumentException("Failed to process context-reference: unknown prefix "
}
private IdentitySchemaNode findIdentityByName(final Set<IdentitySchemaNode> identities, final String name) {
- for (IdentitySchemaNode id : identities) {
+ for (final IdentitySchemaNode id : identities) {
if (id.getQName().getLocalName().equals(name)) {
return id;
}
}
private Module findModuleFromImports(final Set<ModuleImport> imports, final String prefix) {
- for (ModuleImport imp : imports) {
+ for (final ModuleImport imp : imports) {
if (imp.getPrefix().equals(prefix)) {
return schemaContext.findModuleByName(imp.getModuleName(), imp.getRevision());
}
if (typeDef instanceof UnionTypeDefinition) {
// GeneratedType for this type definition should be already
// created
- QName qname = typeDef.getQName();
- Module unionModule = null;
- String prefix = qname.getPrefix();
- if (prefix == null || prefix.isEmpty() || prefix.equals(module.getPrefix())) {
- unionModule = module;
- } else {
- unionModule = findModuleFromImports(module.getImports(), qname.getPrefix());
- }
+ final QName qname = typeDef.getQName();
+ final Module unionModule = schemaContext.findModuleByNamespaceAndRevision(qname.getNamespace(),
+ qname.getRevision());
final ModuleContext mc = genCtx.get(unionModule);
returnType = mc.getTypedefs().get(typeDef.getPath());
} else {
}
final String leafName = leaf.getQName().getLocalName();
final String leafDesc = leaf.getDescription();
- final GeneratedPropertyBuilder propBuilder = toBuilder.addProperty(parseToValidParamName(leafName));
+ final GeneratedPropertyBuilder propBuilder = toBuilder.addProperty(BindingMapping.getPropertyName(leafName));
propBuilder.setReadOnly(isReadOnly);
propBuilder.setReturnType(returnType);
propBuilder.setComment(leafDesc);
}
} else if (typeDef instanceof BitsTypeDefinition) {
final GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, node, parentModule);
- returnType = new ReferencedTypeImpl(genTOBuilder.getPackageName(), genTOBuilder.getName());
+ returnType = genTOBuilder.toInstance();
} else {
final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(typeDef);
returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, node, restrictions);
genTOBuilder.setIsUnion(true);
((TypeProviderImpl) typeProvider).addUnitsToGenTO(genTOBuilder, typeDef.getUnits());
- // union builder
- final GeneratedTOBuilder unionBuilder = new GeneratedTOBuilderImpl(typeBuilder.getPackageName(),
- genTOBuilder.getName() + "Builder");
- unionBuilder.setIsUnionBuilder(true);
+
+
+ final GeneratedTOBuilder unionBuilder = createUnionBuilder(genTOBuilder,typeBuilder);
+
+
final MethodSignatureBuilder method = unionBuilder.addMethod("getDefaultInstance");
method.setReturnType(returnType);
method.addParameter(Types.STRING, "defaultValue");
return returnType.toInstance();
}
- private GeneratedTypeBuilder addDefaultInterfaceDefinition(final String packageName, final SchemaNode schemaNode) {
- return addDefaultInterfaceDefinition(packageName, schemaNode, null);
+ private GeneratedTOBuilder createUnionBuilder(final GeneratedTOBuilder genTOBuilder, final GeneratedTypeBuilder typeBuilder) {
+
+ final String outerCls = Types.getOuterClassName(genTOBuilder);
+ final StringBuilder name;
+ if(outerCls != null) {
+ name = new StringBuilder(outerCls);
+ } else {
+ name = new StringBuilder();
+ }
+ name.append(genTOBuilder.getName());
+ name.append("Builder");
+ final GeneratedTOBuilderImpl unionBuilder = new GeneratedTOBuilderImpl(typeBuilder.getPackageName(),name.toString());
+ unionBuilder.setIsUnionBuilder(true);
+ return unionBuilder;
+ }
+
+ private GeneratedTypeBuilder addDefaultInterfaceDefinition(final String packageName, final SchemaNode schemaNode,
+ final Module module) {
+ return addDefaultInterfaceDefinition(packageName, schemaNode, null, module);
}
/**
* <code>schemaNode</code>.
*
* The new builder always implements
- * {@link org.opendaylight.yangtools.yang.binding.DataObject DataObject}.<br />
+ * {@link org.opendaylight.yangtools.yang.binding.DataObject DataObject}.<br>
* If <code>schemaNode</code> is instance of GroupingDefinition it also
* implements {@link org.opendaylight.yangtools.yang.binding.Augmentable
- * Augmentable}.<br />
+ * Augmentable}.<br>
* If <code>schemaNode</code> is instance of
* {@link org.opendaylight.yangtools.yang.model.api.DataNodeContainer
* DataNodeContainer} it can also implement nodes which are specified in
* @return generated type builder <code>schemaNode</code>
*/
private GeneratedTypeBuilder addDefaultInterfaceDefinition(final String packageName, final SchemaNode schemaNode,
- final Type parent) {
+ final Type parent, final Module module) {
final GeneratedTypeBuilder it = addRawInterfaceDefinition(packageName, schemaNode, "");
if (parent == null) {
it.addImplementsType(DATA_OBJECT);
}
if (schemaNode instanceof DataNodeContainer) {
+ groupingsToGenTypes(module, ((DataNodeContainer) schemaNode).getGroupings());
addImplementedInterfaceFromUses((DataNodeContainer) schemaNode, it);
}
} else {
method.append("get");
}
- String name = BindingMapping.toFirstUpper(BindingMapping.getPropertyName(localName));
+ final String name = BindingMapping.toFirstUpper(BindingMapping.getPropertyName(localName));
method.append(name);
return method.toString();
}
resolveLeafListSchemaNode(typeBuilder, (LeafListSchemaNode) schemaNode);
} else if (schemaNode instanceof ContainerSchemaNode) {
containerToGenType(module, basePackageName, typeBuilder, typeBuilder, (ContainerSchemaNode) schemaNode);
- } else if (schemaNode instanceof ChoiceNode) {
- choiceToGeneratedType(module, basePackageName, typeBuilder, (ChoiceNode) schemaNode);
+ } else if (schemaNode instanceof ChoiceSchemaNode) {
+ choiceToGeneratedType(module, basePackageName, typeBuilder, (ChoiceSchemaNode) schemaNode);
} else if (schemaNode instanceof ListSchemaNode) {
listToGenType(module, basePackageName, typeBuilder, typeBuilder, (ListSchemaNode) schemaNode);
}
checkArgument(typeBuilder != null, "Generated Type Builder cannot be NULL.");
if (genTOBuilder != null) {
- GeneratedTransferObject genTO = genTOBuilder.toInstance();
+ final GeneratedTransferObject genTO = genTOBuilder.toInstance();
constructGetter(typeBuilder, "key", "Returns Primary Key of Yang List Type", genTO);
genCtx.get(module).addGeneratedTOBuilder(genTOBuilder);
}
private List<String> listKeys(final ListSchemaNode list) {
final List<String> listKeys = new ArrayList<>();
- List<QName> keyDefinition = list.getKeyDefinition();
+ final List<QName> keyDefinition = list.getKeyDefinition();
if (keyDefinition != null) {
- for (QName keyDef : keyDefinition) {
+ for (final QName keyDef : keyDefinition) {
listKeys.add(keyDef.getLocalName());
}
}
genTOBuilders.addAll(types);
GeneratedTOBuilder resultTOBuilder = null;
- if (!types.isEmpty()) {
- resultTOBuilder = types.remove(0);
- for (GeneratedTOBuilder genTOBuilder : types) {
- resultTOBuilder.addEnclosingTransferObject(genTOBuilder);
- }
+ if (types.isEmpty()) {
+ throw new IllegalStateException("No GeneratedTOBuilder objects generated from union " + typeDef);
+ }
+ resultTOBuilder = types.remove(0);
+ for (final GeneratedTOBuilder genTOBuilder : types) {
+ resultTOBuilder.addEnclosingTransferObject(genTOBuilder);
}
final GeneratedPropertyBuilder genPropBuilder = resultTOBuilder.addProperty("value");
- genPropBuilder.setReturnType(Types.primitiveType("char[]", null));
+ genPropBuilder.setReturnType(Types.CHAR_ARRAY);
resultTOBuilder.addEqualsIdentity(genPropBuilder);
resultTOBuilder.addHashIdentity(genPropBuilder);
resultTOBuilder.addToStringProperty(genPropBuilder);
packageName, typeDef, classNameFromLeaf, parentModule.getName()));
}
if (genTOBuilders != null && !genTOBuilders.isEmpty()) {
- for (GeneratedTOBuilder genTOBuilder : genTOBuilders) {
+ for (final GeneratedTOBuilder genTOBuilder : genTOBuilders) {
typeBuilder.addEnclosingTransferObject(genTOBuilder);
}
return genTOBuilders.get(0);
*/
private GeneratedTypeBuilder addImplementedInterfaceFromUses(final DataNodeContainer dataNodeContainer,
final GeneratedTypeBuilder builder) {
- for (UsesNode usesNode : dataNodeContainer.getUses()) {
+ for (final UsesNode usesNode : dataNodeContainer.getUses()) {
if (usesNode.getGroupingPath() != null) {
final GeneratedType genType = findGroupingByPath(usesNode.getGroupingPath()).toInstance();
if (genType == null) {
private String createDescription(final Set<? extends SchemaNode> schemaNodes, final String moduleName, final String moduleSourcePath) {
final StringBuilder sb = new StringBuilder();
- final String yangSnipet = YangTemplate.generateYangSnipet(schemaNodes);
if (!isNullOrEmpty(schemaNodes)) {
final SchemaNode node = schemaNodes.iterator().next();
if (node instanceof RpcDefinition) {
sb.append("Interface for implementing the following YANG RPCs defined in module <b>" + moduleName + "</b>");
- }
- else if (node instanceof NotificationDefinition) {
+ } else if (node instanceof NotificationDefinition) {
sb.append("Interface for receiving the following YANG notifications defined in module <b>" + moduleName + "</b>");
}
}
sb.append(NEW_LINE);
- sb.append("<br />(Source path: <i>");
+ sb.append("<br>(Source path: <i>");
sb.append(moduleSourcePath);
sb.append("</i>):");
sb.append(NEW_LINE);
- sb.append("<pre>");
- sb.append(NEW_LINE);
- sb.append(yangSnipet);
- sb.append("</pre>");
- sb.append(NEW_LINE);
+
+ if (verboseClassComments) {
+ sb.append("<pre>");
+ sb.append(NEW_LINE);
+ sb.append(YangTemplate.generateYangSnipet(schemaNodes));
+ sb.append("</pre>");
+ sb.append(NEW_LINE);
+ }
return sb.toString();
}
private String createDescription(final SchemaNode schemaNode, final String fullyQualifiedName) {
final StringBuilder sb = new StringBuilder();
- final Module module = findParentModule(schemaContext, schemaNode);
- final String yangSnipet = YangTemplate.generateYangSnipet(schemaNode);
final String formattedDescription = YangTemplate.formatToParagraph(schemaNode.getDescription(), 0);
- final StringBuilder linkToBuilderClass = new StringBuilder();
- final StringBuilder linkToKeyClass = new StringBuilder();
- final Splitter splitter = Splitter.on("\\.");
- final String[] namespace = Iterables.toArray(splitter.split(fullyQualifiedName), String.class);
- String className = namespace[namespace.length - 1];
-
- if (hasBuilderClass(schemaNode)) {
- linkToBuilderClass.append(className);
- linkToBuilderClass.append("Builder");
-
- if (schemaNode instanceof ListSchemaNode) {
- linkToKeyClass.append(className);
- linkToKeyClass.append("Key");
- }
- }
if (!isNullOrEmpty(formattedDescription)) {
sb.append(formattedDescription);
sb.append(NEW_LINE);
}
- sb.append("<p>");
- sb.append("This class represents the following YANG schema fragment defined in module <b>");
- sb.append(module.getName());
- sb.append("</b>");
- sb.append(NEW_LINE);
- sb.append("<br />(Source path: <i>");
- sb.append(module.getModuleSourcePath());
- sb.append("</i>):");
- sb.append(NEW_LINE);
- sb.append("<pre>");
- sb.append(NEW_LINE);
- sb.append(yangSnipet);
- sb.append("</pre>");
- sb.append(NEW_LINE);
- sb.append("The schema path to identify an instance is");
- sb.append(NEW_LINE);
- sb.append("<i>");
- sb.append(YangTemplate.formatSchemaPath(module.getName(), schemaNode.getPath().getPathFromRoot()));
- sb.append("</i>");
- sb.append(NEW_LINE);
- if (hasBuilderClass(schemaNode)) {
+ if (verboseClassComments) {
+ final Module module = findParentModule(schemaContext, schemaNode);
+ final StringBuilder linkToBuilderClass = new StringBuilder();
+ final String[] namespace = Iterables.toArray(BSDOT_SPLITTER.split(fullyQualifiedName), String.class);
+ final String className = namespace[namespace.length - 1];
+
+ if (hasBuilderClass(schemaNode)) {
+ linkToBuilderClass.append(className);
+ linkToBuilderClass.append("Builder");
+ }
+
+ sb.append("<p>");
+ sb.append("This class represents the following YANG schema fragment defined in module <b>");
+ sb.append(module.getName());
+ sb.append("</b>");
+ sb.append(NEW_LINE);
+ sb.append("<br>(Source path: <i>");
+ sb.append(module.getModuleSourcePath());
+ sb.append("</i>):");
+ sb.append(NEW_LINE);
+ sb.append("<pre>");
+ sb.append(NEW_LINE);
+ sb.append(YangTemplate.generateYangSnipet(schemaNode));
+ sb.append("</pre>");
+ sb.append(NEW_LINE);
+ sb.append("The schema path to identify an instance is");
sb.append(NEW_LINE);
- sb.append("<p>To create instances of this class use " + "{@link " + linkToBuilderClass + "}.");
+ sb.append("<i>");
+ sb.append(YangTemplate.formatSchemaPath(module.getName(), schemaNode.getPath().getPathFromRoot()));
+ sb.append("</i>");
sb.append(NEW_LINE);
- sb.append("@see ");
- sb.append(linkToBuilderClass);
- if (schemaNode instanceof ListSchemaNode) {
+
+ if (hasBuilderClass(schemaNode)) {
+ sb.append(NEW_LINE);
+ sb.append("<p>To create instances of this class use " + "{@link " + linkToBuilderClass + "}.");
+ sb.append(NEW_LINE);
sb.append("@see ");
- sb.append(linkToKeyClass);
+ sb.append(linkToBuilderClass);
+ sb.append(NEW_LINE);
+ if (schemaNode instanceof ListSchemaNode) {
+ final List<QName> keyDef = ((ListSchemaNode)schemaNode).getKeyDefinition();
+ if (keyDef != null && !keyDef.isEmpty()) {
+ sb.append("@see ");
+ sb.append(className);
+ sb.append("Key");
+ }
+ sb.append(NEW_LINE);
+ }
}
- sb.append(NEW_LINE);
}
return sb.toString();
private boolean hasBuilderClass(final SchemaNode schemaNode) {
if (schemaNode instanceof ContainerSchemaNode || schemaNode instanceof ListSchemaNode ||
- schemaNode instanceof RpcDefinition || schemaNode instanceof NotificationDefinition)
+ schemaNode instanceof RpcDefinition || schemaNode instanceof NotificationDefinition) {
return true;
+ }
return false;
}
private String createDescription(final Module module) {
final StringBuilder sb = new StringBuilder();
- final String yangSnipet = YangTemplate.generateYangSnipet(module);
final String formattedDescription = YangTemplate.formatToParagraph(module.getDescription(), 0);
if (!isNullOrEmpty(formattedDescription)) {
sb.append(formattedDescription);
sb.append(NEW_LINE);
}
- sb.append("<p>");
- sb.append("This class represents the following YANG schema fragment defined in module <b>");
- sb.append(module.getName());
- sb.append("</b>");
- sb.append(NEW_LINE);
- sb.append("<br />Source path: <i>");
- sb.append(module.getModuleSourcePath());
- sb.append("</i>):");
- sb.append(NEW_LINE);
- sb.append("<pre>");
- sb.append(NEW_LINE);
- sb.append(yangSnipet);
- sb.append("</pre>");
+
+ if (verboseClassComments) {
+ sb.append("<p>");
+ sb.append("This class represents the following YANG schema fragment defined in module <b>");
+ sb.append(module.getName());
+ sb.append("</b>");
+ sb.append(NEW_LINE);
+ sb.append("<br>Source path: <i>");
+ sb.append(module.getModuleSourcePath());
+ sb.append("</i>):");
+ sb.append(NEW_LINE);
+ sb.append("<pre>");
+ sb.append(NEW_LINE);
+ sb.append(YangTemplate.generateYangSnipet(module));
+ sb.append("</pre>");
+ }
return sb.toString();
}
private GeneratedTypeBuilder findChildNodeByPath(final SchemaPath path) {
- for (ModuleContext ctx : genCtx.values()) {
- GeneratedTypeBuilder result = ctx.getChildNode(path);
+ for (final ModuleContext ctx : genCtx.values()) {
+ final GeneratedTypeBuilder result = ctx.getChildNode(path);
if (result != null) {
return result;
}
}
private GeneratedTypeBuilder findGroupingByPath(final SchemaPath path) {
- for (ModuleContext ctx : genCtx.values()) {
- GeneratedTypeBuilder result = ctx.getGrouping(path);
+ for (final ModuleContext ctx : genCtx.values()) {
+ final GeneratedTypeBuilder result = ctx.getGrouping(path);
if (result != null) {
return result;
}
}
private GeneratedTypeBuilder findCaseByPath(final SchemaPath path) {
- for (ModuleContext ctx : genCtx.values()) {
- GeneratedTypeBuilder result = ctx.getCase(path);
+ for (final ModuleContext ctx : genCtx.values()) {
+ final GeneratedTypeBuilder result = ctx.getCase(path);
if (result != null) {
return result;
}