import com.google.common.annotations.Beta;
import java.util.List;
+import java.util.Optional;
/**
* Every Java interface has to be specified with:
*
* @return comment string associated with Generated Type.
*/
- String getComment();
+ TypeComment getComment();
/**
* Returns List of annotation definitions associated with generated type.
* Returns parent type for data schema node builder
*/
Type getParentTypeForBuilder();
+
+ /**
+ * Returns the YANG definition of this type, if available.
+ *
+ * @return YANG source definition, or empty when unavailable.
+ */
+ Optional<YangSourceDefinition> getYangSourceDefinition();
}
*/
String getPackageNameForBuilder();
+ /**
+ * Returns base package name that builder class belongs to.
+ *
+ * @return base package name that builder class belongs to
+ */
+ String getBasePackageName();
+
+
}
--- /dev/null
+/*
+ * Copyright (c) 2018 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.javav2.model.api;
+
+import com.google.common.annotations.Beta;
+import org.eclipse.jdt.annotation.NonNullByDefault;
+
+/**
+ * Dedicated type for holding a class comment. It exposes a javadoc-encoded string.
+ *
+ * @author Robert Varga
+ */
+@Beta
+@FunctionalInterface
+@NonNullByDefault
+public interface TypeComment {
+
+ /**
+ * Return a javadoc snippet. This snippet is guaranteed to be safe for direct inclusion in a Java block comment.
+ *
+ * @return Javadoc snippet.
+ */
+ String getJavadoc();
+}
--- /dev/null
+/*
+ * Copyright (c) 2018 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.javav2.model.api;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
+
+import com.google.common.annotations.Beta;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import java.util.List;
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.opendaylight.yangtools.yang.model.api.DocumentedNode;
+import org.opendaylight.yangtools.yang.model.api.Module;
+import org.opendaylight.yangtools.yang.model.api.SchemaNode;
+
+/**
+ * DTO capturing the YANG source definition which lead to a {@link GeneratedType} being emitted.
+ *
+ * @author Robert Varga
+ */
+@Beta
+@NonNullByDefault
+public abstract class YangSourceDefinition {
+ public static final class Multiple extends YangSourceDefinition {
+ private final List<? extends SchemaNode> nodes;
+
+ Multiple(final Module module, final Collection<? extends SchemaNode> nodes) {
+ super(module);
+ this.nodes = ImmutableList.copyOf(nodes);
+ }
+
+ /**
+ * Return the defining SchemaNodes.
+ *
+ * @return defining SchemaNodes, guaranteed to be non-empty
+ */
+ public List<? extends SchemaNode> getNodes() {
+ return nodes;
+ }
+ }
+
+ public static final class Single extends YangSourceDefinition {
+ private final DocumentedNode node;
+
+ Single(final Module module, final DocumentedNode node) {
+ super(module);
+ this.node = requireNonNull(node);
+ }
+
+ public DocumentedNode getNode() {
+ return node;
+ }
+ }
+
+ private final Module module;
+
+ private YangSourceDefinition(final Module module) {
+ this.module = requireNonNull(module);
+ }
+
+ public static YangSourceDefinition of(final Module module) {
+ return new Single(module, module);
+ }
+
+ public static YangSourceDefinition of(final Module module, final SchemaNode node) {
+ return new Single(module, node);
+ }
+
+ public static YangSourceDefinition of(final Module module, final Collection<? extends SchemaNode> nodes) {
+ checkArgument(!nodes.isEmpty());
+ return new Multiple(module, nodes);
+ }
+
+ /**
+ * Return the defining YANG module.
+ *
+ * @return Defining YANG module.
+ */
+ public final Module getModule() {
+ return module;
+ }
+}
import com.google.common.annotations.Beta;
import java.util.List;
+import java.util.Optional;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.javav2.generator.context.ModuleContext;
import org.opendaylight.mdsal.binding.javav2.model.api.Constant;
import org.opendaylight.mdsal.binding.javav2.model.api.Type;
+import org.opendaylight.mdsal.binding.javav2.model.api.TypeComment;
+import org.opendaylight.mdsal.binding.javav2.model.api.YangSourceDefinition;
import org.opendaylight.yangtools.yang.common.QName;
@Beta
* @param comment
* Comment String.
*/
- T addComment(String comment);
+ T addComment(TypeComment comment);
/**
* The method creates new AnnotationTypeBuilder containing specified package
List<GeneratedPropertyBuilder> getProperties();
+ /**
+ * Returns the YANG definition of this type, if available.
+ *
+ * @return YANG source definition, or empty when unavailable.
+ */
+ Optional<YangSourceDefinition> getYangSourceDefinition();
+
/**
* Add new Generated Property definition for Generated Transfer Object
* Builder and returns Generated Property Builder for specifying Property. <br>
*/
void setReference(String reference);
+ /**
+ * Set the YANG source definition.
+ *
+ * @param definition YANG source definition, must not be null
+ */
+ void setYangSourceDefinition(@NonNull YangSourceDefinition definition);
}
import static com.google.common.base.Preconditions.checkArgument;
import static org.opendaylight.mdsal.binding.javav2.generator.util.BindingGeneratorUtil.encodeAngleBrackets;
-import static org.opendaylight.mdsal.binding.javav2.generator.util.BindingGeneratorUtil.replacePackageTopNamespace;
import static org.opendaylight.mdsal.binding.javav2.generator.util.Types.BOOLEAN;
import com.google.common.annotations.Beta;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Splitter;
-import com.google.common.base.Strings;
-import com.google.common.collect.Iterables;
import java.util.Collection;
import java.util.List;
import java.util.Map;
-import java.util.Set;
import java.util.regex.Pattern;
import org.opendaylight.mdsal.binding.javav2.generator.context.ModuleContext;
-import org.opendaylight.mdsal.binding.javav2.generator.impl.txt.yangTemplateForModule;
-import org.opendaylight.mdsal.binding.javav2.generator.impl.txt.yangTemplateForNode;
-import org.opendaylight.mdsal.binding.javav2.generator.impl.txt.yangTemplateForNodes;
-import org.opendaylight.mdsal.binding.javav2.generator.impl.util.YangTextTemplate;
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.JavaIdentifier;
import org.opendaylight.mdsal.binding.javav2.generator.util.JavaIdentifierNormalizer;
+import org.opendaylight.mdsal.binding.javav2.generator.util.TypeComments;
import org.opendaylight.mdsal.binding.javav2.generator.util.Types;
-import org.opendaylight.mdsal.binding.javav2.generator.util.YangSnippetCleaner;
import org.opendaylight.mdsal.binding.javav2.generator.util.generated.type.builder.GeneratedTOBuilderImpl;
import org.opendaylight.mdsal.binding.javav2.generator.util.generated.type.builder.GeneratedTypeBuilderImpl;
import org.opendaylight.mdsal.binding.javav2.generator.yang.types.TypeProviderImpl;
import org.opendaylight.mdsal.binding.javav2.model.api.Constant;
import org.opendaylight.mdsal.binding.javav2.model.api.Type;
+import org.opendaylight.mdsal.binding.javav2.model.api.YangSourceDefinition;
import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.EnumBuilder;
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.GeneratedTypeBuilderBase;
import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.MethodSignatureBuilder;
import org.opendaylight.mdsal.binding.javav2.spec.runtime.BindingNamespaceType;
-import org.opendaylight.mdsal.binding.javav2.util.BindingMapping;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
-import org.opendaylight.yangtools.yang.model.api.OperationDefinition;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
-import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
/**
* Auxiliary util class for {@link GenHelperUtil} class
}
}
- public static boolean hasBuilderClass(final SchemaNode schemaNode, final BindingNamespaceType namespaceType) {
- return (namespaceType.equals(BindingNamespaceType.Data)
- && (schemaNode instanceof ContainerSchemaNode || schemaNode instanceof ListSchemaNode
- || schemaNode instanceof RpcDefinition || schemaNode instanceof NotificationDefinition
- || schemaNode instanceof CaseSchemaNode));
- }
-
static Constant qNameConstant(final GeneratedTypeBuilderBase<?> toBuilder, final String constantName,
final QName name) {
return toBuilder.addConstant(Types.typeForClass(QName.class), constantName, name);
* <code>interfaceBuilder</code>
*/
static MethodSignatureBuilder constructGetter(final GeneratedTypeBuilder interfaceBuilder,
- final String schemaNodeName, final String comment, final Type returnType, final Status status) {
+ final String schemaNodeName, final String comment, final Type returnType, final Status status) {
final MethodSignatureBuilder getMethod = interfaceBuilder
.addMethod(getterMethodName(schemaNodeName, returnType));
} else {
method.append("get");
}
- return method.append(JavaIdentifierNormalizer.normalizeSpecificIdentifier(localName, JavaIdentifier.CLASS)).toString();
+ return method.append(JavaIdentifierNormalizer.normalizeSpecificIdentifier(localName, JavaIdentifier.CLASS))
+ .toString();
}
- static String createDescription(final SchemaNode schemaNode, final String fullyQualifiedName,
- final SchemaContext schemaContext, final boolean verboseClassComments,
- final BindingNamespaceType namespaceType) {
- final StringBuilder sb = new StringBuilder();
- final String nodeDescription = encodeAngleBrackets(schemaNode.getDescription().orElse(null));
- final String formattedDescription = YangTextTemplate.formatToParagraph(nodeDescription, 0);
-
- if (!Strings.isNullOrEmpty(formattedDescription)) {
- sb.append(formattedDescription);
- sb.append(NEW_LINE);
- }
-
- final Module module = SchemaContextUtil.findParentModule(schemaContext, schemaNode);
- 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("<pre>");
- sb.append(NEW_LINE);
- String formedYang = YangSnippetCleaner.clean(yangTemplateForNode.render(schemaNode, module).body());
- sb.append(encodeAngleBrackets(formedYang));
- 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(YangTextTemplate.formatSchemaPath(module.getName(), schemaNode.getPath().getPathFromRoot()));
- sb.append("</i>");
- sb.append(NEW_LINE);
-
- if (hasBuilderClass(schemaNode, namespaceType) && !(schemaNode instanceof OperationDefinition)) {
- final StringBuilder linkToBuilderClass = new StringBuilder();
- final String basePackageName = BindingMapping.getRootPackageName(module);
-
- linkToBuilderClass
- .append(replacePackageTopNamespace(basePackageName, fullyQualifiedName,
- namespaceType, BindingNamespaceType.Builder))
- .append("Builder");
- 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);
- sb.append(NEW_LINE);
- if (schemaNode instanceof ListSchemaNode) {
- final StringBuilder linkToKeyClass = new StringBuilder();
-
- final String[] namespace = Iterables.toArray(BSDOT_SPLITTER.split(fullyQualifiedName), String.class);
- final String className = namespace[namespace.length - 1];
-
- linkToKeyClass.append(BindingGeneratorUtil.packageNameForSubGeneratedType(basePackageName, schemaNode,
- BindingNamespaceType.Key))
- .append('.')
- .append(className)
- .append("Key");
-
- final List<QName> keyDef = ((ListSchemaNode)schemaNode).getKeyDefinition();
- if (keyDef != null && !keyDef.isEmpty()) {
- sb.append("@see ");
- sb.append(linkToKeyClass);
- }
- sb.append(NEW_LINE);
- }
- }
- }
-
- return replaceAllIllegalChars(sb);
- }
-
- static String createDescription(final Module module, final boolean verboseClassComments) {
- final StringBuilder sb = new StringBuilder();
- final String moduleDescription = encodeAngleBrackets(module.getDescription().orElse(null));
- final String formattedDescription = YangTextTemplate.formatToParagraph(moduleDescription, 0);
-
- if (!Strings.isNullOrEmpty(formattedDescription)) {
- sb.append(formattedDescription);
- sb.append(NEW_LINE);
- }
-
- 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("<pre>");
- sb.append(NEW_LINE);
- String formedYang = YangSnippetCleaner.clean(yangTemplateForModule.render(module).body());
- sb.append(encodeAngleBrackets(formedYang));
- sb.append("</pre>");
- }
-
- return replaceAllIllegalChars(sb);
- }
-
- static String createDescription(final Set<? extends SchemaNode> schemaNodes, final Module module, final
- boolean verboseClassComments) {
- final StringBuilder sb = new StringBuilder();
-
- 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>" + module.getName() + "</b>");
- } else if (node instanceof NotificationDefinition) {
- sb.append("Interface for receiving the following YANG notifications defined in module <b>" + module.getName() + "</b>");
- }
- }
- sb.append(NEW_LINE);
-
- if (verboseClassComments) {
- sb.append("<pre>");
- sb.append(NEW_LINE);
- sb.append(encodeAngleBrackets(yangTemplateForNodes.render(schemaNodes, module).body()));
- sb.append("</pre>");
- sb.append(NEW_LINE);
- }
-
- return replaceAllIllegalChars(sb);
+ public static boolean hasBuilderClass(final SchemaNode schemaNode, final BindingNamespaceType namespaceType) {
+ return (namespaceType.equals(BindingNamespaceType.Data)
+ && (schemaNode instanceof ContainerSchemaNode || schemaNode instanceof ListSchemaNode
+ || schemaNode instanceof RpcDefinition || schemaNode instanceof NotificationDefinition
+ || schemaNode instanceof CaseSchemaNode));
}
@VisibleForTesting
@SuppressWarnings({ "unchecked", "rawtypes" })
static Type createReturnTypeForUnion(final GeneratedTOBuilder genTOBuilder, final TypeDefinition<?> typeDef,
- final GeneratedTypeBuilder typeBuilder, final Module parentModule, final TypeProvider typeProvider) {
+ final GeneratedTypeBuilder typeBuilder, final Module parentModule, final TypeProvider typeProvider,
+ final boolean verboseClassComments) {
final GeneratedTOBuilderImpl returnType = (GeneratedTOBuilderImpl) genTOBuilder;
- final String typedefDescription = encodeAngleBrackets(typeDef.getDescription().orElse(null));
- returnType.setDescription(typedefDescription);
- returnType.setReference(typeDef.getReference().orElse(null));
+ if (verboseClassComments) {
+ returnType.setYangSourceDefinition(YangSourceDefinition.of(parentModule, typeDef));
+ TypeComments.description(typeDef).ifPresent(returnType::addComment);
+ typeDef.getDescription().ifPresent(returnType::setDescription);
+ typeDef.getReference().ifPresent(returnType::setReference);
+ }
returnType.setSchemaPath((List) typeDef.getPath().getPathFromRoot());
returnType.setModuleName(parentModule.getName());
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.constructGetter;
-import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.createDescription;
import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.createReturnTypeForUnion;
import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.getAugmentIdentifier;
import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.isInnerType;
import static org.opendaylight.mdsal.binding.javav2.generator.util.BindingGeneratorUtil.packageNameForGeneratedType;
import static org.opendaylight.mdsal.binding.javav2.generator.util.BindingTypes.IDENTIFIABLE;
import static org.opendaylight.mdsal.binding.javav2.generator.util.BindingTypes.IDENTIFIER;
-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.mdsal.binding.javav2.generator.util.Types.wildcardTypeFor;
import org.opendaylight.mdsal.binding.javav2.generator.util.JavaIdentifier;
import org.opendaylight.mdsal.binding.javav2.generator.util.JavaIdentifierNormalizer;
import org.opendaylight.mdsal.binding.javav2.generator.util.ReferencedTypeImpl;
+import org.opendaylight.mdsal.binding.javav2.generator.util.TypeComments;
import org.opendaylight.mdsal.binding.javav2.generator.util.Types;
import org.opendaylight.mdsal.binding.javav2.generator.util.generated.type.builder.GeneratedPropertyBuilderImpl;
import org.opendaylight.mdsal.binding.javav2.generator.util.generated.type.builder.GeneratedTOBuilderImpl;
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;
+import org.opendaylight.mdsal.binding.javav2.model.api.YangSourceDefinition;
import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.EnumBuilder;
import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedPropertyBuilder;
import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedTOBuilder;
genCtx.get(module));
addImplementedInterfaceFromUses(module, moduleDataTypeBuilder, genCtx);
moduleDataTypeBuilder.addImplementsType(BindingTypes.TREE_ROOT);
- moduleDataTypeBuilder.addComment(module.getDescription().orElse(null));
- moduleDataTypeBuilder.setDescription(createDescription(module, verboseClassComments));
- moduleDataTypeBuilder.setReference(module.getReference().orElse(null));
+
+ if (verboseClassComments) {
+ moduleDataTypeBuilder.setYangSourceDefinition(YangSourceDefinition.of(module));
+ TypeComments.description(module).ifPresent(moduleDataTypeBuilder::addComment);
+ module.getDescription().ifPresent(moduleDataTypeBuilder::setDescription);
+ module.getReference().ifPresent(moduleDataTypeBuilder::setReference);
+ }
+
return moduleDataTypeBuilder;
}
final String moduleName = new StringBuilder(module.getName()).append('_').append(postfix).toString();
final GeneratedTypeBuilderImpl moduleBuilder = new GeneratedTypeBuilderImpl(packageName, moduleName, context);
- moduleBuilder.setDescription(createDescription(module, verboseClassComments));
- moduleBuilder.setReference(module.getReference().orElse(null));
+ if (verboseClassComments) {
+ moduleBuilder.setYangSourceDefinition(YangSourceDefinition.of(module));
+ TypeComments.description(module).ifPresent(moduleBuilder::addComment);
+ module.getDescription().ifPresent(moduleBuilder::setDescription);
+ module.getReference().ifPresent(moduleBuilder::setReference);
+ }
moduleBuilder.setModuleName(moduleName);
return moduleBuilder;
}
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().orElse(null));
- newType.setDescription(createDescription(schemaNode, newType.getFullyQualifiedName(), schemaContext,
- verboseClassComments, namespaceType));
- newType.setReference(schemaNode.getReference().orElse(null));
+ if (verboseClassComments) {
+ newType.setYangSourceDefinition(YangSourceDefinition.of(module, schemaNode));
+ TypeComments.description(schemaNode).ifPresent(newType::addComment);
+ schemaNode.getDescription().ifPresent(newType::setDescription);
+ schemaNode.getReference().ifPresent(newType::setReference);
+ }
newType.setSchemaPath((List<QName>) schemaNode.getPath().getPathFromRoot());
newType.setModuleName(module.getName());
newType.setBasePackageName(BindingMapping.getRootPackageName(module));
schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType);
} else if (node instanceof LeafListSchemaNode) {
resolveLeafListSchemaNode(schemaContext, typeBuilder, (LeafListSchemaNode) node, module,
- typeProvider, genCtx);
+ typeProvider, genCtx, verboseClassComments);
} else if (node instanceof LeafSchemaNode) {
resolveLeafSchemaNodeAsMethod("", schemaContext, typeBuilder, genCtx, (LeafSchemaNode) node, module,
- typeProvider);
+ typeProvider, verboseClassComments);
} else if (node instanceof ListSchemaNode) {
listToGenType(module, basePackageName, typeBuilder, childOf, (ListSchemaNode) node, schemaContext,
verboseClassComments, genCtx, genTypeBuilders, typeProvider, 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) {
+ final Module module, final TypeProvider typeProvider, final boolean verboseClassComments) {
if (leaf == null || typeBuilder == null) {
return null;
}
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);
+ returnType = createReturnTypeForUnion(genTOBuilder, typeDef, typeBuilder, parentModule,
+ typeProvider, verboseClassComments);
}
} else if (typeDef instanceof BitsTypeDefinition) {
final GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, leaf, parentModule,
*/
private static boolean resolveLeafListSchemaNode(final SchemaContext schemaContext, final GeneratedTypeBuilder
typeBuilder, final LeafListSchemaNode node, final Module module, final TypeProvider typeProvider,
- final Map<Module, ModuleContext> genCtx) {
+ final Map<Module, ModuleContext> genCtx, final boolean verboseClassComments) {
if (node == null || typeBuilder == null) {
return false;
}
final GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, node, parentModule,
typeProvider, schemaContext, genCtx.get(module), genCtx);
if (genTOBuilder != null) {
- returnType = createReturnTypeForUnion(genTOBuilder, typeDef, typeBuilder, parentModule, typeProvider);
+ returnType = createReturnTypeForUnion(genTOBuilder, typeDef, typeBuilder, parentModule,
+ typeProvider, verboseClassComments);
}
} else if (typeDef instanceof BitsTypeDefinition) {
final GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, node, parentModule,
final QName leafQName = leaf.getQName();
final Type type = resolveLeafSchemaNodeAsMethod(nodeName, schemaContext, typeBuilder, genCtx, leaf, module,
- typeProvider);
+ typeProvider, verboseClassComments);
if (listKeys.contains(leafQName)) {
if (type == null) {
resolveLeafSchemaNodeAsProperty(nodeName, schemaContext, typeProvider, genCtx, genTOBuilder, leaf, true,
} else {
if (schemaNode instanceof LeafListSchemaNode) {
resolveLeafListSchemaNode(schemaContext, typeBuilder, (LeafListSchemaNode) schemaNode, module,
- typeProvider, genCtx);
+ typeProvider, genCtx, verboseClassComments);
} else if (schemaNode instanceof ContainerSchemaNode) {
containerToGenType(module, basePackageName, typeBuilder, typeBuilder, (ContainerSchemaNode) schemaNode,
schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType);
}
private static void addSchemaNodeToListTypeBuilders(final String nodeName, final String basePackageName,
- final DataSchemaNode schemaNode, final GeneratedTypeBuilder typeBuilder,
- final GeneratedTypeBuilder genTypeBuilder, 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 BindingNamespaceType namespaceType) {
+ final DataSchemaNode schemaNode, final GeneratedTypeBuilder typeBuilder,
+ final GeneratedTypeBuilder genTypeBuilder, 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 BindingNamespaceType namespaceType) {
checkArgument(schemaNode != null, "Data Schema Node cannot be NULL.");
checkArgument(typeBuilder != null, "Generated Type Builder cannot be NULL.");
final LeafSchemaNode leaf = (LeafSchemaNode) schemaNode;
final QName leafQName = leaf.getQName();
final Type type = resolveLeafSchemaNodeAsMethod(nodeName, schemaContext, typeBuilder, genCtx, leaf, module,
- typeProvider);
+ typeProvider, verboseClassComments);
if (listKeys.contains(leafQName)) {
resolveLeafSchemaNodeAsMethod(nodeName, schemaContext, genTypeBuilder, genCtx, leaf, module,
- typeProvider);
+ typeProvider, verboseClassComments);
}
} else {
if (schemaNode instanceof LeafListSchemaNode) {
resolveLeafListSchemaNode(schemaContext, typeBuilder, (LeafListSchemaNode) schemaNode, module,
- typeProvider, genCtx);
+ typeProvider, genCtx, verboseClassComments);
} else if (schemaNode instanceof ContainerSchemaNode) {
containerToGenType(module, basePackageName, typeBuilder, typeBuilder, (ContainerSchemaNode) schemaNode,
schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType);
final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(basePackageName, node, childOf, module,
genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
- genType.addComment(node.getDescription().orElse(null));
annotateDeprecatedIfNecessary(node.getStatus(), genType);
- genType.setDescription(createDescription(node, genType.getFullyQualifiedName(), schemaContext,
- verboseClassComments, namespaceType));
genType.setModuleName(module.getName());
- genType.setReference(node.getReference().orElse(null));
+ if (verboseClassComments) {
+ genType.setYangSourceDefinition(YangSourceDefinition.of(module, node));
+ TypeComments.description(node).ifPresent(genType::addComment);
+ node.getDescription().ifPresent(genType::setDescription);
+ node.getReference().ifPresent(genType::setReference);
+ }
genType.setSchemaPath((List) node.getPath().getPathFromRoot());
genType.setParentTypeForBuilder(childOf);
if (node instanceof DataNodeContainer) {
}
newType.setAbstract(true);
- newType.addComment(identity.getDescription().orElse(null));
- newType.setDescription(createDescription(identity, newType.getFullyQualifiedName(), schemaContext,
- verboseClassComments, BindingNamespaceType.Identity));
- newType.setReference(identity.getReference().orElse(null));
- newType.setModuleName(module.getName());
+
+ if (verboseClassComments) {
+ newType.setYangSourceDefinition(YangSourceDefinition.of(module));
+ TypeComments.description(module).ifPresent(newType::addComment);
+ module.getDescription().ifPresent(newType::setDescription);
+ module.getReference().ifPresent(newType::setReference);
+ }
newType.setSchemaPath((List) identity.getPath().getPathFromRoot());
qNameConstant(newType, BindingMapping.QNAME_STATIC_FIELD_NAME, identity.getQName());
package org.opendaylight.mdsal.binding.javav2.generator.impl;
import static com.google.common.base.Preconditions.checkArgument;
-import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.createDescription;
import static org.opendaylight.mdsal.binding.javav2.generator.impl.GenHelperUtil.groupingsToGenTypes;
import static org.opendaylight.mdsal.binding.javav2.generator.impl.GenHelperUtil.moduleTypeBuilder;
import static org.opendaylight.mdsal.binding.javav2.generator.impl.GenHelperUtil.processUsesImplements;
import java.util.Set;
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.TypeComments;
import org.opendaylight.mdsal.binding.javav2.generator.yang.types.TypeProviderImpl;
import org.opendaylight.mdsal.binding.javav2.model.api.Type;
+import org.opendaylight.mdsal.binding.javav2.model.api.YangSourceDefinition;
import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedTypeBuilder;
import org.opendaylight.mdsal.binding.javav2.spec.runtime.BindingNamespaceType;
import org.opendaylight.mdsal.binding.javav2.util.BindingMapping;
}
}
- if (tiedNotifications != null) {
- listenerInterface.setDescription(createDescription(ImmutableSet.<NotificationDefinition>builder()
- .addAll(notifications).addAll(tiedNotifications).build(), module, verboseClassComments));
- } else {
- listenerInterface.setDescription(createDescription(notifications, module, verboseClassComments));
+ if (verboseClassComments) {
+ if (tiedNotifications != null) {
+ listenerInterface.setYangSourceDefinition(YangSourceDefinition.of(module,
+ ImmutableSet.<NotificationDefinition>builder().addAll(notifications).addAll(tiedNotifications)
+ .build()));
+ } else {
+ listenerInterface.setYangSourceDefinition(YangSourceDefinition.of(module, notifications));
+ }
+ listenerInterface.addComment(TypeComments.javadoc(
+ "Interface for receiving the following YANG notifications defined in module <b>" + module.getName()
+ + "</b>").get());
}
genCtx.get(module).addTopLevelNodeType(listenerInterface);
import static com.google.common.base.Preconditions.checkState;
import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.annotateDeprecatedIfNecessary;
import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.checkModuleAndModuleName;
-import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.createDescription;
import static org.opendaylight.mdsal.binding.javav2.generator.impl.GenHelperUtil.addImplementedInterfaceFromUses;
import static org.opendaylight.mdsal.binding.javav2.generator.impl.GenHelperUtil.addRawInterfaceDefinition;
import static org.opendaylight.mdsal.binding.javav2.generator.impl.GenHelperUtil.moduleTypeBuilder;
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.BindingTypes;
+import org.opendaylight.mdsal.binding.javav2.generator.util.TypeComments;
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.YangSourceDefinition;
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.runtime.BindingNamespaceType;
final String basePackageName = interfaceBuilder.getPackageName();
- interfaceBuilder.setDescription(createDescription(operation, interfaceBuilder.getFullyQualifiedName(),
- schemaContext, verboseClassComments, namespaceType));
+ if (verboseClassComments) {
+ interfaceBuilder.addComment(TypeComments.javadoc(
+ "Interface for implementing the following YANG Operation defined in module <b>" + module.getName() + "</b>")
+ .get());
+ interfaceBuilder.setYangSourceDefinition(YangSourceDefinition.of(module, operation));
+ }
+
final String operationComment = encodeAngleBrackets(operation.getDescription().orElse(null));
final MethodSignatureBuilder operationMethod = interfaceBuilder.addMethod("invoke");
final String typedefDescription = encodeAngleBrackets(typedef.getDescription().orElse(null));
genTOBuilder.setDescription(typedefDescription);
- genTOBuilder.setReference(typedef.getReference().orElse(null));
+ typedef.getReference().ifPresent(genTOBuilder::setReference);
genTOBuilder.setSchemaPath((List) typedef.getPath().getPathFromRoot());
genTOBuilder.setModuleName(moduleName);
genTOBuilder.setTypedef(true);
final String typedefDescription = encodeAngleBrackets(typedef.getDescription().orElse(null));
newType.setDescription(typedefDescription);
- newType.setReference(typedef.getReference().orElse(null));
+ typedef.getReference().ifPresent(newType::setReference);
newType.setSchemaPath((List) typedef.getPath().getPathFromRoot());
newType.setModuleName(moduleName);
final String typedefDescription = encodeAngleBrackets(typeDef.getDescription().orElse(null));
genTOBuilder.setDescription(typedefDescription);
- genTOBuilder.setReference(typeDef.getReference().orElse(null));
+ typeDef.getReference().ifPresent(genTOBuilder::setReference);
genTOBuilder.setSchemaPath((List) typeDef.getPath().getPathFromRoot());
genTOBuilder.setModuleName(moduleName);
genTOBuilder.setBaseType(typeDef);
context);
final String typedefDescription = encodeAngleBrackets(typedef.getDescription().orElse(null));
unionGenTOBuilder.setDescription(typedefDescription);
- unionGenTOBuilder.setReference(typedef.getReference().orElse(null));
+ typedef.getReference().ifPresent(unionGenTOBuilder::setReference);
unionGenTOBuilder.setSchemaPath((List) typedef.getPath().getPathFromRoot());
unionGenTOBuilder.setModuleName(module.getName());
assertEquals("getClazz", AuxiliaryGenUtils.getterMethodName("clazz", Types.CLASS));
}
- @Test
- public void createDescriptionWithSchemaNodeTest() {
- final SchemaContext schemaContext = YangParserTestUtils.parseYangResource("/generator/test-list.yang");
- final ListSchemaNode containerSchemaNode =
- (ListSchemaNode) schemaContext.getModules().iterator().next().getChildNodes().iterator().next();
- final String fullyQualifiedName =
- "org.opendaylight.mdsal.gen.javav2.urn.test.simple.test.list.rev170314.data.MyList";
-
- final String result = AuxiliaryGenUtils.createDescription(containerSchemaNode, fullyQualifiedName,
- schemaContext, true, BindingNamespaceType.Data);
- assertNotNull(result);
- assertTrue(result.contains("list my-list"));
- assertTrue(result.contains("leaf key"));
- assertTrue(result.contains("leaf key1"));
- assertTrue(result.contains("leaf key2"));
- assertTrue(result.contains("leaf foo"));
- assertTrue(result.contains("@see org.opendaylight.mdsal.gen.javav2.urn.test.simple.test.list.rev170314.dto.MyListBuilder"));
- assertTrue(result.contains("@see org.opendaylight.mdsal.gen.javav2.urn.test.simple.test.list.rev170314.key.my_list.MyListKey"));
- }
-
- @Test
- public void createDescriptionWithSchemaNodeWithDescriptionTest() {
- final SchemaContext schemaContext =
- YangParserTestUtils.parseYangResource("/base/test-leaf-with-description.yang");
- final LeafSchemaNode containerSchemaNode =
- (LeafSchemaNode) schemaContext.getModules().iterator().next().getChildNodes().iterator().next();
- final String fullyQualifiedName = "test.base.cont.with.leaf.MyList";
-
- final String result = AuxiliaryGenUtils.createDescription(containerSchemaNode, fullyQualifiedName,
- schemaContext, true, BindingNamespaceType.Data);
- assertNotNull(result);
- assertTrue(result.contains("I am leaf."));
- }
-
- @Test
- public void createDescriptionTest() {
- final SchemaContext schemaContext = YangParserTestUtils.parseYangResource("/base/test-module.yang");
- final String result = AuxiliaryGenUtils.createDescription(schemaContext.getModules().iterator().next(), true);
- assertNotNull(result);
- assertTrue(result.contains("Base test module description"));
- assertTrue(result.contains("test-module"));
- }
-
- @Test
- public void createDescriptionWithSchemaNodesTest() {
- final SchemaContext schemaContext = YangParserTestUtils.parseYangResource("/base/test-rpc-and-notification.yang");
- final Module module = schemaContext.getModules().iterator().next();
- Set<SchemaNode> schemaNodes = new HashSet<>();
- schemaNodes.add(module.getRpcs().iterator().next());
-
- String result = AuxiliaryGenUtils.createDescription(schemaNodes, module, true);
- assertNotNull(result);
- assertTrue(result.contains(
- "Interface for implementing the following YANG RPCs defined in module <b>test-rpc-and-notification-module</b>"));
- assertTrue(result.contains("rpc my-rpc"));
- assertTrue(!result.contains("notification my-notification"));
-
- schemaNodes = new HashSet<>();
- schemaNodes.add(module.getNotifications().iterator().next());
-
- result = AuxiliaryGenUtils.createDescription(schemaNodes, module, true);
- assertNotNull(result);
- assertTrue(result.contains(
- "Interface for receiving the following YANG notifications defined in module <b>test-rpc-and-notification-module</b>"));
- assertTrue(!result.contains("rpc my-rpc"));
- assertTrue(result.contains("notification my-notification"));
- }
-
@Test
public void isNullOrEmptyIsNullTest() {
assertTrue(AuxiliaryGenUtils.isNullOrEmpty(null));
final TypeDefinition<? extends TypeDefinition<?>> typeDef = leafSchemaNode.getType();
final Type result = AuxiliaryGenUtils.createReturnTypeForUnion(addTOToBuilder("/base/test-union.yang"), typeDef,
- typeBuilder, schemaContext.getModules().iterator().next(), typeProvider);
+ typeBuilder, schemaContext.getModules().iterator().next(), typeProvider, false);
assertNotNull(result);
}
assertEquals(3, test_i[0]);
}
- @Test
- public void generateTypesDescriptionsTest() {
- final BindingGenerator bg = new BindingGeneratorImpl(true);
- final SchemaContext context = YangParserTestUtils.parseYangResourceDirectory("/base/with_import/");
- assertNotNull(context);
-
- final List<Type> generateTypes = bg.generateTypes(context, context.getModules());
- assertNotNull(generateTypes);
- assertTrue(!generateTypes.isEmpty());
-
- for (final Type type : generateTypes) {
- if (type.getName().equals("TestData")) {
- final String description = ((GeneratedType) type).getDescription().get();
- description
- .contains(" import test-import { prefix \"imported-test\"; revision-date 2017-04-21; }\n\n");
- description.contains(" revision 2017-02-06;\n\n");
- description.contains(" typedef my-type {\n type int8;\n }");
- description.contains(" container *my-cont {\n }\n");
- }
- }
- }
-
@Test
public void generateTypesIdentityTest() throws Exception {
final BindingGenerator bg = new BindingGeneratorImpl(true);
import java.util.Iterator;
import java.util.List;
import java.util.Optional;
+import java.util.regex.Pattern;
import org.opendaylight.mdsal.binding.javav2.model.api.AccessModifier;
import org.opendaylight.mdsal.binding.javav2.model.api.Restrictions;
import org.opendaylight.mdsal.binding.javav2.model.api.Type;
private static final CharMatcher GT_MATCHER = CharMatcher.is('>');
private static final CharMatcher LT_MATCHER = CharMatcher.is('<');
+ private static final Pattern UNICODE_CHAR_PATTERN = Pattern.compile("\\\\+u");
private static final Interner<String> PACKAGE_INTERNER = Interners.newWeakInterner();
private static final Comparator<TypeMemberBuilder<?>> SUID_MEMBER_COMPARATOR =
return def.getRangeConstraint();
}
+ public static String replaceAllIllegalChars(final CharSequence stringBuilder){
+ final String ret = UNICODE_CHAR_PATTERN.matcher(stringBuilder).replaceAll("\\\\\\\\u");
+ return ret.isEmpty() ? "" : ret;
+ }
+
}
/*
- * Copyright (c) 2017 Cisco Systems, Inc. and others. All rights reserved.
+ * Copyright (c) 2018 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.mdsal.binding.javav2.generator.impl.util;
+package org.opendaylight.mdsal.binding.javav2.generator.util;
import com.google.common.annotations.Beta;
import com.google.common.base.CharMatcher;
* Util class
*/
@Beta
-public final class YangTextTemplate {
+public final class FormattingUtils {
private static final CharMatcher NEWLINE_OR_TAB = CharMatcher.anyOf("\n\t");
@RegEx
private static final String SPACES_REGEX = " +";
private static final Pattern SPACES_PATTERN = Pattern.compile(SPACES_REGEX);
- private YangTextTemplate() {
+ private FormattingUtils() {
throw new UnsupportedOperationException("Util class");
}
--- /dev/null
+/*
+ * Copyright (c) 2018 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.javav2.generator.util;
+
+import static org.opendaylight.mdsal.binding.javav2.generator.util.BindingGeneratorUtil.replaceAllIllegalChars;
+import static org.opendaylight.mdsal.binding.javav2.generator.util.FormattingUtils.formatToParagraph;
+
+import com.google.common.annotations.Beta;
+import com.google.common.escape.Escaper;
+import com.google.common.escape.Escapers;
+import java.util.Optional;
+import java.util.regex.Pattern;
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.opendaylight.mdsal.binding.javav2.model.api.TypeComment;
+import org.opendaylight.yangtools.yang.model.api.DocumentedNode;
+
+/**
+ * Utility methods for creating {@link TypeComment}s.
+ */
+@Beta
+@NonNullByDefault
+public final class TypeComments {
+ private static final Escaper ENTITY_ESCAPER = Escapers.builder()
+ .addEscape('<', "<")
+ .addEscape('>', ">")
+ .addEscape('&', "&")
+ .addEscape('@', "@").build();
+ private static final Pattern TAIL_COMMENT_PATTERN = Pattern.compile("*/", Pattern.LITERAL);
+
+ /**
+ * Create a {@link TypeComment} for a javadoc-compliant text snippet. This snippet must be eligible for direct
+ * inclusion in a Java comment without further escaping.
+ *
+ * @param javadoc Pre-formatted javadoc snippet
+ * @return {@link TypeComment}, or empty if the snippet was empty
+ */
+ public static Optional<TypeComment> javadoc(final String javadoc) {
+ return javadoc.isEmpty() ? Optional.empty() : Optional.of(() -> javadoc);
+ }
+
+ /**
+ * Create a {@link TypeComment} for a {@link DocumentedNode}'s description string.
+ *
+ * @param node Documented node containing the description to be processed
+ * @return {@link TypeComment}, or empty if the node's description was empty or non-present.
+ */
+ public static Optional<TypeComment> description(final DocumentedNode node) {
+ final String description = node.getDescription().orElse("");
+ return description.isEmpty() ? Optional.empty() : Optional.of(() -> replaceAllIllegalChars(
+ formatToParagraph(
+ TAIL_COMMENT_PATTERN.matcher(ENTITY_ESCAPER.escape(description)).replaceAll("*/"), 0)));
+ }
+}
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.stream.Collectors;
import org.opendaylight.mdsal.binding.javav2.generator.util.AbstractBaseType;
import org.opendaylight.mdsal.binding.javav2.model.api.AnnotationType;
import org.opendaylight.mdsal.binding.javav2.model.api.GeneratedType;
import org.opendaylight.mdsal.binding.javav2.model.api.MethodSignature;
import org.opendaylight.mdsal.binding.javav2.model.api.Type;
+import org.opendaylight.mdsal.binding.javav2.model.api.TypeComment;
+import org.opendaylight.mdsal.binding.javav2.model.api.YangSourceDefinition;
import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.AnnotationTypeBuilder;
import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.EnumBuilder;
import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedPropertyBuilder;
private final Type parent;
private final Type parentTypeForBuilder;
- private final String comment;
+ private final TypeComment comment;
private final List<AnnotationType> annotations;
private final List<Type> implementsTypes;
private final List<Enumeration> enumerations;
private final List<GeneratedType> enclosedTypes;
private final List<GeneratedProperty> properties;
private final boolean isAbstract;
+ private final YangSourceDefinition definition;
public AbstractGeneratedType(final AbstractGeneratedTypeBuilder<?> builder) {
super(builder.getPackageName(), builder.getName(), true, null);
builder.getEnclosedTransferObjects());
this.properties = toUnmodifiableProperties(builder.getProperties());
this.isAbstract = builder.isAbstract();
+ this.definition = builder.getYangSourceDefinition().orElse(null);
}
- public AbstractGeneratedType(final Type parent, final String packageName, final String name, final String comment,
+ public AbstractGeneratedType(final Type parent, final String packageName, final String name, final TypeComment comment,
final List<AnnotationTypeBuilder> annotationBuilders, final boolean isAbstract,
final List<Type> implementsTypes, final List<GeneratedTypeBuilder> enclosedGenTypeBuilders,
final List<GeneratedTOBuilder> enclosedGenTOBuilders, final List<EnumBuilder> enumBuilders,
this.enclosedTypes = toUnmodifiableEnclosedTypes(enclosedGenTypeBuilders, enclosedGenTOBuilders);
this.properties = toUnmodifiableProperties(propertyBuilders);
this.isAbstract = isAbstract;
+ this.definition = null;
}
protected static final <T> List<T> makeUnmodifiable(final List<T> list) {
}
@Override
- public String getComment() {
+ public final TypeComment getComment() {
return this.comment;
}
return this.properties;
}
+ @Override
+ public final Optional<YangSourceDefinition> getYangSourceDefinition() {
+ return Optional.ofNullable(definition);
+ }
+
@Override
public String toString() {
final StringBuilder builder = new StringBuilder();
} else {
builder.append(", parent=null");
}
- builder.append(", comment=");
- builder.append(this.comment);
+ final TypeComment comment = getComment();
+ if (comment != null) {
+ builder.append(", comment=");
+ builder.append(comment.getJavadoc());
+ }
builder.append(", annotations=");
builder.append(this.annotations);
builder.append(", enclosedTypes=");
import com.google.common.collect.ImmutableList;
import java.util.List;
import java.util.Objects;
+import java.util.Optional;
import org.opendaylight.mdsal.binding.javav2.generator.context.ModuleContext;
import org.opendaylight.mdsal.binding.javav2.generator.util.AbstractBaseType;
import org.opendaylight.mdsal.binding.javav2.model.api.AccessModifier;
import org.opendaylight.mdsal.binding.javav2.model.api.Constant;
import org.opendaylight.mdsal.binding.javav2.model.api.Type;
+import org.opendaylight.mdsal.binding.javav2.model.api.TypeComment;
+import org.opendaylight.mdsal.binding.javav2.model.api.YangSourceDefinition;
import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.AnnotationTypeBuilder;
import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.EnumBuilder;
import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedPropertyBuilder;
private final List<GeneratedTypeBuilder> enclosedTypes = ImmutableList.of();
private List<GeneratedTOBuilder> enclosedTransferObjects = ImmutableList.of();
private List<GeneratedPropertyBuilder> properties = ImmutableList.of();
- private String comment = "";
+ private TypeComment comment;
private boolean isAbstract;
private Type parentTypeForBuilder;
+ private YangSourceDefinition yangSourceDefinition;
protected AbstractGeneratedTypeBuilder(final String packageName, final String name, ModuleContext context) {
super(packageName, name, context);
super(packageName, name, isPkNameNormalized, isTypeNormalized, context);
}
- protected String getComment() {
- return comment;
+ protected TypeComment getComment() {
+ return this.comment;
}
protected List<AnnotationTypeBuilder> getAnnotations() {
}
@Override
- public T addComment(final String comment) {
- this.comment = comment;
+ public T addComment(final TypeComment comment) {
+ this.comment = Preconditions.checkNotNull(comment);
return thisInstance();
}
return false;
}
+ @Override
+ public Optional<YangSourceDefinition> getYangSourceDefinition() {
+ return Optional.ofNullable(yangSourceDefinition);
+ }
+
+
+ @Override
+ public void setYangSourceDefinition(final YangSourceDefinition definition) {
+ yangSourceDefinition = Preconditions.checkNotNull(definition);
+ }
+
@Override
public int hashCode() {
return Objects.hash(getName(), getPackageName());
import org.opendaylight.mdsal.binding.javav2.model.api.GeneratedType;
import org.opendaylight.mdsal.binding.javav2.model.api.MethodSignature;
import org.opendaylight.mdsal.binding.javav2.model.api.Type;
+import org.opendaylight.mdsal.binding.javav2.model.api.TypeComment;
+import org.opendaylight.mdsal.binding.javav2.model.api.YangSourceDefinition;
import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.AnnotationTypeBuilder;
import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.EnumBuilder;
import org.opendaylight.yangtools.util.LazyCollections;
}
@Override
- public String getComment() {
+ public TypeComment getComment() {
//noop
return null;
}
public Type getParentTypeForBuilder() {
return null;
}
+
+ @Override
+ public Optional<YangSourceDefinition> getYangSourceDefinition() {
+ // TODO Auto-generated method stub
+ return Optional.empty();
+ }
}
}
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;
+import org.opendaylight.mdsal.binding.javav2.model.api.TypeComment;
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.MethodSignatureBuilder;
builder.append(getPackageName());
builder.append(", name=");
builder.append(getName());
- builder.append(", comment=");
builder.append(", annotations=");
builder.append(getAnnotations());
- builder.append(getComment());
+ final TypeComment comment = getComment();
+ if (comment != null) {
+ builder.append(", comment=");
+ builder.append(comment.getJavadoc());
+ }
builder.append(", extends=");
builder.append(getSuperType());
builder.append(", implements=");
import org.opendaylight.mdsal.binding.javav2.generator.util.BindingGeneratorUtil;
import org.opendaylight.mdsal.binding.javav2.model.api.GeneratedType;
import org.opendaylight.mdsal.binding.javav2.model.api.GeneratedTypeForBuilder;
+import org.opendaylight.mdsal.binding.javav2.model.api.TypeComment;
import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedTypeBuilder;
import org.opendaylight.mdsal.binding.javav2.spec.runtime.BindingNamespaceType;
import org.opendaylight.yangtools.yang.common.QName;
builder.append(getPackageName());
builder.append(", name=");
builder.append(getName());
- builder.append(", comment=");
- builder.append(getComment());
+ final TypeComment comment = getComment();
+ if (comment != null) {
+ builder.append(", comment=");
+ builder.append(comment.getJavadoc());
+ }
builder.append(", annotations=");
builder.append(getAnnotations());
builder.append(", implements=");
public String getPackageNameForBuilder() {
return this.builderPackageName;
}
+
+ @Override
+ public String getBasePackageName() {
+ return this.basePackageName;
+ }
}
}
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-binding2-util</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-model-export</artifactId>
+ </dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-test-util</artifactId>
import com.google.common.base.Strings;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
+import java.util.Collection;
import java.util.List;
import java.util.Optional;
import java.util.StringTokenizer;
import java.util.function.Function;
import java.util.regex.Pattern;
+import org.opendaylight.mdsal.binding.javav2.generator.util.BindingGeneratorUtil;
import org.opendaylight.mdsal.binding.javav2.generator.util.Types;
+import org.opendaylight.mdsal.binding.javav2.generator.util.YangSnippetCleaner;
+import org.opendaylight.mdsal.binding.javav2.java.api.yang.txt.yangTemplateForModule;
+import org.opendaylight.mdsal.binding.javav2.java.api.yang.txt.yangTemplateForNode;
+import org.opendaylight.mdsal.binding.javav2.java.api.yang.txt.yangTemplateForNodes;
import org.opendaylight.mdsal.binding.javav2.model.api.AccessModifier;
import org.opendaylight.mdsal.binding.javav2.model.api.ConcreteType;
import org.opendaylight.mdsal.binding.javav2.model.api.GeneratedProperty;
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.GeneratedTypeForBuilder;
import org.opendaylight.mdsal.binding.javav2.model.api.MethodSignature;
import org.opendaylight.mdsal.binding.javav2.model.api.Restrictions;
import org.opendaylight.mdsal.binding.javav2.model.api.Type;
+import org.opendaylight.mdsal.binding.javav2.model.api.TypeComment;
import org.opendaylight.mdsal.binding.javav2.model.api.TypeMember;
+import org.opendaylight.mdsal.binding.javav2.model.api.YangSourceDefinition;
+import org.opendaylight.mdsal.binding.javav2.model.api.YangSourceDefinition.Multiple;
+import org.opendaylight.mdsal.binding.javav2.model.api.YangSourceDefinition.Single;
+import org.opendaylight.mdsal.binding.javav2.spec.runtime.BindingNamespaceType;
import org.opendaylight.yangtools.concepts.Builder;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.DocumentedNode;
+import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
+import org.opendaylight.yangtools.yang.model.api.SchemaNode;
public final class TextTemplateUtil {
private static final CharMatcher GT_MATCHER = CharMatcher.is('>');
private static final CharMatcher LT_MATCHER = CharMatcher.is('<');
private static final Splitter NL_SPLITTER = Splitter.on(NL_MATCHER);
+ private static final Splitter BSDOT_SPLITTER = Splitter.on(".");
private static final Pattern TAIL_COMMENT_PATTERN = Pattern.compile("*/", Pattern.LITERAL);
private static final Pattern MULTIPLE_SPACES_PATTERN = Pattern.compile(" +");
*/
public static String formatDataForJavaDoc(final GeneratedType type, final String additionalComment) {
final StringBuilder javaDoc = new StringBuilder();
- if (type.getDescription().isPresent()) {
- javaDoc.append(type.getDescription())
- .append(NEW_LINE)
- .append(NEW_LINE)
- .append(NEW_LINE);
- }
- javaDoc.append(additionalComment);
+ javaDoc.append(formatDataForJavaDoc(type)).append(additionalComment);
return javaDoc.toString();
}
+ private static void appendSnippet(final StringBuilder sb, final GeneratedType type) {
+ Optional<YangSourceDefinition> optDef = type.getYangSourceDefinition();
+ if (optDef.isPresent()) {
+ YangSourceDefinition def = optDef.get();
+ sb.append(NEW_LINE);
+
+ if (def instanceof Single) {
+ DocumentedNode node = ((Single) def).getNode();
+ sb.append("<p>\n")
+ .append("This class represents the following YANG schema fragment defined in module <b>")
+ .append(def.getModule().getName()).append("</b>\n")
+ .append("<pre>\n")
+ .append(encodeAngleBrackets(encodeJavadocSymbols(
+ YangSnippetCleaner.clean(generateYangSnippet(node, def.getModule())))))
+ .append("</pre>");
+
+ if (node instanceof SchemaNode) {
+ sb.append("The schema path to identify an instance is\n")
+ .append("<i>")
+ .append(formatSchemaPath(def.getModule().getName(), ((SchemaNode) node).getPath().getPathFromRoot()))
+ .append("</i>\n");
+
+ if (hasBuilderClass(type)) {
+ final String builderName = new StringBuilder()
+ .append(((GeneratedTypeForBuilder) type).getPackageNameForBuilder())
+ .append(".").append(type.getName()).append("Builder").toString();
+
+ sb.append("\n<p>To create instances of this class use {@link ").append(builderName)
+ .append("}.\n")
+ .append("@see ").append(builderName).append('\n');
+ if (node instanceof ListSchemaNode) {
+ final StringBuilder linkToKeyClass = new StringBuilder();
+
+ final String[] namespace = Iterables.toArray(
+ BSDOT_SPLITTER.split(type.getFullyQualifiedName()), String.class);
+ final String className = namespace[namespace.length - 1];
+
+ linkToKeyClass.append(BindingGeneratorUtil.packageNameForSubGeneratedType(
+ ((GeneratedTypeForBuilder) type).getBasePackageName(), (SchemaNode) node,
+ BindingNamespaceType.Key)).append('.').append(className).append("Key");
+
+ List<QName> keyDef = ((ListSchemaNode) node).getKeyDefinition();
+ if (keyDef != null && !keyDef.isEmpty()) {
+ sb.append("@see ").append(linkToKeyClass);
+ }
+ sb.append('\n');
+ }
+ }
+ }
+ } else if (def instanceof Multiple) {
+ sb.append("<pre>\n");
+ sb.append(encodeAngleBrackets(encodeJavadocSymbols(
+ YangSnippetCleaner.clean(generateYangSnippet(((Multiple) def).getNodes(), def.getModule())))));
+ sb.append("</pre>\n");
+ }
+ }
+ }
+
+ /**
+ * Generate a YANG snippet for specified SchemaNode.
+ *
+ * @param node node for which to generate a snippet
+ * @return YANG snippet
+ */
+ private static String generateYangSnippet(final DocumentedNode node, final Module module) {
+ if (node instanceof Module) {
+ return yangTemplateForModule.render((Module) node).body();
+ } else if (node instanceof SchemaNode) {
+ return yangTemplateForNode.render((SchemaNode) node, module).body();
+ }
+
+ throw new IllegalArgumentException("Not supported.");
+ }
+
+ private static String generateYangSnippet(final Collection<? extends SchemaNode> nodes, final Module module) {
+ return yangTemplateForNodes.render(nodes, module).body();
+ }
+
+ public static boolean hasBuilderClass(final GeneratedType type) {
+ return type instanceof GeneratedTypeForBuilder;
+ }
+
+ public static String formatSchemaPath(final String moduleName, final Iterable<QName> schemaPath) {
+ final StringBuilder sb = new StringBuilder();
+ sb.append(moduleName);
+
+ QName currentElement = Iterables.getFirst(schemaPath, null);
+ for (final QName pathElement : schemaPath) {
+ sb.append('/');
+ if (!currentElement.getNamespace().equals(pathElement.getNamespace())) {
+ currentElement = pathElement;
+ sb.append(pathElement);
+ } else {
+ sb.append(pathElement.getLocalName());
+ }
+ }
+ return sb.toString();
+ }
+
/**
* Returns properties names in formatted string
* @param properties list of given properties
* @return formatted type description
*/
public static String formatDataForJavaDoc(final GeneratedType type) {
- return type.getDescription().map(TextTemplateUtil::encodeJavadocSymbols).orElse("");
+ final StringBuilder javaDoc = new StringBuilder();
+ final TypeComment comment = type.getComment();
+ if (comment != null) {
+ javaDoc.append(comment.getJavadoc())
+ .append(NEW_LINE)
+ .append(NEW_LINE)
+ .append(NEW_LINE);
+ }
+
+ appendSnippet(javaDoc, type);
+
+ return javaDoc.toString();
}
/**
* parameters to render desired output code. *
***********************************************************@
-@import org.opendaylight.mdsal.binding.javav2.generator.impl.util.YangTextTemplate
+@import org.opendaylight.mdsal.binding.javav2.generator.util.FormattingUtils
@import org.opendaylight.yangtools.yang.model.api.Module
@import org.opendaylight.yangtools.yang.model.api.DocumentedNode
@import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement
@yangTemplateWriteExtension(node.asInstanceOf[ExtensionDefinition])
}
@if(node.isInstanceOf[FeatureDefinition]) {
- @yangTemplateWriteFeature(node.asInstanceOf[FeatureDefinition])
+ @yangTemplateWriteFeature(node.asInstanceOf[FeatureDefinition])
}
@if(node.isInstanceOf[GroupingDefinition]) {
@yangTemplateWriteGroupingDef(node.asInstanceOf[GroupingDefinition], module)
@import org.opendaylight.yangtools.yang.model.api.RpcDefinition
@import org.opendaylight.yangtools.yang.model.api.SchemaNode
-@(nodes: Set[_ <: SchemaNode], module: Module)
+@(nodes: Collection[_ <: SchemaNode], module: Module)
@if(nodes != null) {
@for(node <- nodes) {
@if(node.isInstanceOf[NotificationDefinition]) {
* parameters to render desired output code. *
***********************************************************@
-@import org.opendaylight.mdsal.binding.javav2.generator.impl.util.YangTextTemplate
+@import org.opendaylight.mdsal.binding.javav2.generator.util.FormattingUtils
@import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode
@import org.opendaylight.yangtools.yang.model.api.Module
@import org.opendaylight.yangtools.yang.model.api.Status
@(augments: Set[_ <: AugmentationSchemaNode], module: Module)
@for(augment <- augments) {
@if(augment != null) {
- augment "@{YangTextTemplate.formatToAugmentPath(augment.getTargetPath().getPathFromRoot())}" {
+ augment "@{FormattingUtils.formatToAugmentPath(augment.getTargetPath().getPathFromRoot())}" {
@if(augment.getWhenCondition() != null && !augment.getWhenCondition().toString().isEmpty()) {
when "@augment.getWhenCondition().toString()";
}
/*
- * Copyright (c) 2017 Cisco Systems, Inc. and others. All rights reserved.
+ * Copyright (c) 2018 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.mdsal.binding.javav2.generator.impl;
+package org.opendaylight.mdsal.binding.javav2.java.api.generator;
import static org.junit.Assert.assertTrue;
import java.util.Set;
import org.junit.Before;
import org.junit.Test;
-import org.opendaylight.mdsal.binding.javav2.generator.impl.txt.yangTemplateForModule;
import org.opendaylight.mdsal.binding.javav2.generator.util.YangSnippetCleaner;
+import org.opendaylight.mdsal.binding.javav2.java.api.yang.txt.yangTemplateForModule;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
Code Review / mdsal.git / commitdiff