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.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.context.ModuleContext;
import org.opendaylight.mdsal.binding.javav2.generator.spi.TypeProvider;
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.MethodSignatureBuilder;
import org.opendaylight.mdsal.binding.javav2.spec.runtime.BindingNamespaceType;
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.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
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
@Beta
final class AuxiliaryGenUtils {
- private static final Splitter BSDOT_SPLITTER = Splitter.on("\\.");
+ private static final Splitter BSDOT_SPLITTER = Splitter.on(".");
private static final char NEW_LINE = '\n';
private static final Pattern UNICODE_CHAR_PATTERN = Pattern.compile("\\\\+u");
}
}
- private static boolean hasBuilderClass(final SchemaNode schemaNode) {
- if (schemaNode instanceof ContainerSchemaNode || schemaNode instanceof ListSchemaNode ||
- schemaNode instanceof RpcDefinition || schemaNode instanceof NotificationDefinition) {
- return true;
- }
- return false;
- }
-
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));
* @return string with the name of the getter method for
* <code>methodName</code> in JAVA method format
*/
- private static String getterMethodName(final String localName, final Type returnType) {
+ @VisibleForTesting
+ static String getterMethodName(final String localName, final Type returnType) {
final StringBuilder method = new StringBuilder();
if (BOOLEAN.equals(returnType)) {
method.append("is");
} else {
method.append("get");
}
- // underscore used as separator for distinction of method parts in convertIdentifier()
- method.append('_').append(localName);
- return JavaIdentifierNormalizer.normalizeSpecificIdentifier(method.toString(), JavaIdentifier.METHOD);
- }
-
- static String createDescription(final SchemaNode schemaNode, final String fullyQualifiedName,
- final SchemaContext schemaContext, final boolean verboseClassComments) {
- final StringBuilder sb = new StringBuilder();
- final String nodeDescription = encodeAngleBrackets(schemaNode.getDescription());
- final String formattedDescription = YangTextTemplate.formatToParagraph(nodeDescription, 0);
-
- if (!Strings.isNullOrEmpty(formattedDescription)) {
- sb.append(formattedDescription);
- sb.append(NEW_LINE);
- }
-
- if (verboseClassComments) {
- final Module module = SchemaContextUtil.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("<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) && !(schemaNode instanceof OperationDefinition)) {
- 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 List<QName> keyDef = ((ListSchemaNode)schemaNode).getKeyDefinition();
- if (keyDef != null && !keyDef.isEmpty()) {
- sb.append("@see ");
- sb.append(className);
- sb.append("Key");
- }
- 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());
- 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);
+ return method.append(JavaIdentifierNormalizer.normalizeSpecificIdentifier(localName, JavaIdentifier.CLASS))
+ .toString();
}
- 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));
}
- private static boolean isNullOrEmpty(final Collection<?> list) {
+ @VisibleForTesting
+ static boolean isNullOrEmpty(final Collection<?> list) {
return list == null || list.isEmpty();
}
* <code>enumTypeDef</code>
*/
static EnumBuilder resolveInnerEnumFromTypeDefinition(final EnumTypeDefinition enumTypeDef, final QName enumName,
- final Map<Module, ModuleContext> genCtx, final GeneratedTypeBuilder typeBuilder, final Module module) {
+ final Map<Module, ModuleContext> genCtx, final GeneratedTypeBuilder typeBuilder, final Module module) {
if (enumTypeDef != null && typeBuilder != null && enumTypeDef.getQName().getLocalName() != null) {
- final EnumBuilder enumBuilder = typeBuilder.addEnumeration(enumName.getLocalName());
- final String enumTypedefDescription = encodeAngleBrackets(enumTypeDef.getDescription());
+ final EnumBuilder enumBuilder = typeBuilder.addEnumeration(enumName.getLocalName(), genCtx.get(module));
+ final String enumTypedefDescription = encodeAngleBrackets(enumTypeDef.getDescription().orElse(null));
enumBuilder.setDescription(enumTypedefDescription);
enumBuilder.updateEnumPairsFromEnumTypeDef(enumTypeDef);
final ModuleContext ctx = genCtx.get(module);
*/
static GeneratedTOBuilder addTOToTypeBuilder(final TypeDefinition<?> typeDef, final GeneratedTypeBuilder
typeBuilder, final DataSchemaNode leaf, final Module parentModule, final TypeProvider typeProvider,
- final SchemaContext schemaContext) {
+ final SchemaContext schemaContext, ModuleContext context, final Map<Module, ModuleContext> genCtx) {
final String classNameFromLeaf = leaf.getQName().getLocalName();
GeneratedTOBuilder genTOBuilder = null;
final String packageName = typeBuilder.getFullyQualifiedName();
genTOBuilder = ((TypeProviderImpl) typeProvider)
.provideGeneratedTOBuilderForUnionTypeDef(packageName, ((UnionTypeDefinition) typeDef),
classNameFromLeaf, leaf, schemaContext,
- ((TypeProviderImpl) typeProvider).getGenTypeDefsContextMap());
+ ((TypeProviderImpl) typeProvider).getGenTypeDefsContextMap(), context);
} else if (typeDef instanceof BitsTypeDefinition) {
genTOBuilder = (((TypeProviderImpl) typeProvider)).provideGeneratedTOBuilderForBitsTypeDefinition(
- packageName, typeDef, classNameFromLeaf, parentModule.getName());
+ packageName, typeDef, classNameFromLeaf, parentModule.getName(), context);
}
if (genTOBuilder != null) {
typeBuilder.addEnclosingTransferObject(genTOBuilder);
+ genCtx.get(parentModule).addInnerTypedefType(typeDef.getPath(), genTOBuilder);
return genTOBuilder;
}
return null;
@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());
- returnType.setDescription(typedefDescription);
- returnType.setReference(typeDef.getReference());
+ 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());
genTOBuilder.setTypedef(true);
genTOBuilder.setIsUnion(true);
- TypeProviderImpl.addUnitsToGenTO(genTOBuilder, typeDef.getUnits());
+ TypeProviderImpl.addUnitsToGenTO(genTOBuilder, typeDef.getUnits().orElse(null));
return returnType.toInstance();
}
static boolean isInnerType(final LeafSchemaNode leaf, final TypeDefinition<?> type) {
- if (leaf.getPath().equals(type.getPath())) {
- return true;
- }
- if (leaf.getPath().equals(type.getPath().getParent())) {
- return true;
- }
+ return leaf.getPath().equals(type.getPath()) || leaf.getPath().equals(type.getPath().getParent());
- return false;
}
/**
* <code>list</code> or empty TO builder if <code>list</code> is null or list of
* key definitions is null or empty.
*/
- static GeneratedTOBuilder resolveListKeyTOBuilder(final String packageName, final ListSchemaNode list) {
+ static GeneratedTOBuilder resolveListKeyTOBuilder(final String packageName, final ListSchemaNode list,
+ ModuleContext context) {
GeneratedTOBuilder genTOBuilder = null;
if ((list.getKeyDefinition() != null) && (!list.getKeyDefinition().isEmpty())) {
// underscore used as separator for distinction of class name parts
final String genTOName =
new StringBuilder(list.getQName().getLocalName()).append('_').append(BindingNamespaceType.Key)
.toString();
- genTOBuilder = new GeneratedTOBuilderImpl(packageName, genTOName);
+ genTOBuilder = new GeneratedTOBuilderImpl(packageName, genTOName, context);
}
return genTOBuilder;
}
+ static GeneratedTypeBuilder resolveListKeyTypeBuilder(final String packageName, final ListSchemaNode list,
+ ModuleContext context) {
+ GeneratedTypeBuilder genTypeBuilder = null;
+ if ((list.getKeyDefinition() != null) && (!list.getKeyDefinition().isEmpty())) {
+ // underscore used as separator for distinction of class name parts
+ final String genTOName =
+ new StringBuilder(list.getQName().getLocalName()).append('_').append(BindingNamespaceType.Key)
+ .toString();
+ genTypeBuilder = new GeneratedTypeBuilderImpl(packageName, genTOName, context);
+ }
+ return genTypeBuilder;
+ }
+
/**
* Converts <code>leaf</code> schema node to property of generated TO
* builder.
* <li>true - other cases</li>
* </ul>
*/
- static boolean resolveLeafSchemaNodeAsProperty(final GeneratedTOBuilder toBuilder, final LeafSchemaNode leaf,
+ static boolean resolveLeafSchemaNodeAsProperty(final String nodeName, final GeneratedTOBuilder toBuilder, final LeafSchemaNode leaf,
final Type returnType, final boolean isReadOnly) {
if (returnType == null) {
return false;
}
final String leafName = leaf.getQName().getLocalName();
- final String leafDesc = encodeAngleBrackets(leaf.getDescription());
+ final String leafGetterName;
+
+ if ("key".equals(leafName.toLowerCase())) {
+ StringBuilder sb = new StringBuilder(leafName)
+ .append('_').append("RESERVED_WORD");
+ leafGetterName = sb.toString();
+ } else {
+ leafGetterName = leafName;
+ }
+
+ final String leafDesc = encodeAngleBrackets(leaf.getDescription().orElse(null));
final GeneratedPropertyBuilder propBuilder =
- toBuilder.addProperty(JavaIdentifierNormalizer.normalizeSpecificIdentifier(leafName, JavaIdentifier.METHOD));
+ toBuilder.addProperty(JavaIdentifierNormalizer.normalizeSpecificIdentifier(leafGetterName, JavaIdentifier.METHOD));
propBuilder.setReadOnly(isReadOnly);
propBuilder.setReturnType(returnType);
propBuilder.setComment(leafDesc);
Code Review / mdsal.git / blobdiff