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("\\.");
+
+ /**
+ * Constant with the concrete name of identifier.
+ */
+ private static final String AUGMENT_IDENTIFIER_NAME = "augment-identifier";
+ private static final char NEW_LINE = '\n';
private final Map<Module, ModuleContext> genCtx = new HashMap<>();
/**
* Constant with the concrete name of namespace.
*/
- private final static String YANG_EXT_NAMESPACE = "urn:opendaylight:yang:extension:yang-ext";
-
- /**
- * Constant with the concrete name of identifier.
- */
- private final static String AUGMENT_IDENTIFIER_NAME = "augment-identifier";
+ private static final String YANG_EXT_NAMESPACE = "urn:opendaylight:yang:extension:yang-ext";
/**
* Resolves generated types from <code>context</code> schema nodes of all
final String packageName = packageNameForGeneratedType(basePackageName, node.getPath());
final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(packageName, node, childOf);
genType.addComment(node.getDescription());
+ genType.setDescription(createDescription(node, genType.getFullyQualifiedName()));
+ genType.setModuleName(module.getName());
+ genType.setReference(node.getReference());
+ genType.setSchemaPath(node.getPath().getPathFromRoot());
if (node instanceof DataNodeContainer) {
genCtx.get(module).addChildNodeType(node, genType);
groupingsToGenTypes(module, ((DataNodeContainer) node).getGroupings());
addImplementedInterfaceFromUses(module, moduleDataTypeBuilder);
moduleDataTypeBuilder.addImplementsType(DATA_ROOT);
moduleDataTypeBuilder.addComment(module.getDescription());
+ moduleDataTypeBuilder.setDescription(createDescription(module));
+ moduleDataTypeBuilder.setReference(module.getReference());
return moduleDataTypeBuilder;
}
final String basePackageName = BindingMapping.getRootPackageName(module.getQNameModule());
final GeneratedTypeBuilder interfaceBuilder = moduleTypeBuilder(module, "Service");
interfaceBuilder.addImplementsType(Types.typeForClass(RpcService.class));
+ interfaceBuilder.setDescription(createDescription(rpcDefinitions, module.getName(), module.getModuleSourcePath()));
+
for (RpcDefinition rpc : rpcDefinitions) {
if (rpc != null) {
final String rpcName = BindingMapping.getClassName(rpc.getQName());
listenerInterface.addImplementsType(BindingTypes.NOTIFICATION_LISTENER);
final String basePackageName = BindingMapping.getRootPackageName(module.getQNameModule());
+
+
for (NotificationDefinition notification : notifications) {
if (notification != null) {
processUsesAugments(notification, module);
.setComment(notification.getDescription()).setReturnType(Types.VOID);
}
}
+ listenerInterface.setDescription(createDescription(notifications, module.getName(), module.getModuleSourcePath()));
genCtx.get(module).addTopLevelNodeType(listenerInterface);
}
}
newType.setAbstract(true);
newType.addComment(identity.getDescription());
- newType.setDescription(identity.getDescription());
+ newType.setDescription(createDescription(identity, newType.getFullyQualifiedName()));
newType.setReference(identity.getReference());
newType.setModuleName(module.getName());
newType.setSchemaPath(identity.getPath().getPathFromRoot());
final String moduleName = BindingMapping.getClassName(module.getName()) + postfix;
final GeneratedTypeBuilderImpl moduleBuilder = new GeneratedTypeBuilderImpl(packageName, moduleName);
- moduleBuilder.setDescription(module.getDescription());
+ moduleBuilder.setDescription(createDescription(module));
moduleBuilder.setReference(module.getReference());
moduleBuilder.setModuleName(moduleName);
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;
}
} 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);
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) {
// 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());
- }
+ Module unionModule = schemaContext.findModuleByNamespaceAndRevision(qname.getNamespace(),
+ qname.getRevision());
final ModuleContext mc = genCtx.get(unionModule);
returnType = mc.getTypedefs().get(typeDef.getPath());
} else {
}
} 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);
// FIXME: Validation of name conflict
final GeneratedTypeBuilderImpl newType = new GeneratedTypeBuilderImpl(packageName, genTypeName);
+ final Module module = findParentModule(schemaContext, schemaNode);
qnameConstant(newType, BindingMapping.QNAME_STATIC_FIELD_NAME, schemaNode.getQName());
newType.addComment(schemaNode.getDescription());
- newType.setDescription(schemaNode.getDescription());
+ newType.setDescription(createDescription(schemaNode, newType.getFullyQualifiedName()));
newType.setReference(schemaNode.getReference());
newType.setSchemaPath(schemaNode.getPath().getPathFromRoot());
-
- final Module module = findParentModule(schemaContext, schemaNode);
newType.setModuleName(module.getName());
if (!genTypeBuilders.containsKey(packageName)) {
throw new IllegalStateException("Grouping " + usesNode.getGroupingPath() + "is not resolved for "
+ builder.getName());
}
+
builder.addImplementsType(genType);
- builder.addComment(genType.getComment());
+ /*
+ builder.addComment(genType.getDescription());
+ builder.setDescription(genType.getDescription());
+ builder.setModuleName(genType.getModuleName());
+ builder.setReference(genType.getReference());
+ builder.setSchemaPath(genType.getSchemaPath());
+ */
}
}
return builder;
}
+ private boolean isNullOrEmpty(final Collection<?> list) {
+ return (list == null || list.isEmpty() ? true : false);
+ }
+
+ 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) {
+ 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(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);
+
+ 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 String[] namespace = Iterables.toArray(BSDOT_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)) {
+ 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(linkToBuilderClass);
+ if (schemaNode instanceof ListSchemaNode) {
+ sb.append("@see ");
+ sb.append(linkToKeyClass);
+ }
+ 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) {
+ return true;
+ }
+ return false;
+ }
+
+ private boolean isNullOrEmpty(final String string) {
+ return (string == null || string.isEmpty() ? true : 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>");
+
+ return sb.toString();
+ }
+
private GeneratedTypeBuilder findChildNodeByPath(final SchemaPath path) {
for (ModuleContext ctx : genCtx.values()) {
GeneratedTypeBuilder result = ctx.getChildNode(path);
Code Review / yangtools.git / blobdiff