package org.opendaylight.mdsal.binding.javav2.generator.impl;
+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.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 com.google.common.collect.Sets;
-import java.util.ArrayList;
+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.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.NonJavaCharsConverter;
+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.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.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.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.GeneratedTypeBuilder;
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.util.BindingMapping;
+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.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");
}
- final String name = BindingMapping.toFirstUpper(NonJavaCharsConverter.convertIdentifier(BindingMapping.getPropertyName
- (localName), JavaIdentifier.METHOD));
- method.append(name);
- return method.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 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);
- sb.append(encodeAngleBrackets(yangTemplateForNode.render(schemaNode).body()));
- 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)) {
- 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);
+ 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 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);
- sb.append(encodeAngleBrackets(yangTemplateForModule.render(module).body()));
- sb.append("</pre>");
- }
-
- return replaceAllIllegalChars(sb);
+ @VisibleForTesting
+ static boolean isNullOrEmpty(final Collection<?> list) {
+ return list == null || list.isEmpty();
}
/**
}
/**
- * @param unknownSchemaNodes unknows schema nodes
+ * @param unknownSchemaNodes unknown schema nodes
* @return nodeParameter of UnknownSchemaNode
*/
static String getAugmentIdentifier(final List<UnknownSchemaNode> unknownSchemaNodes) {
* <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 String enumerationName = BindingMapping.getClassName(enumName);
- final EnumBuilder enumBuilder = typeBuilder.addEnumeration(enumerationName);
- 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);
- ModuleContext ctx = genCtx.get(module);
+ final ModuleContext ctx = genCtx.get(module);
ctx.addInnerTypedefType(enumTypeDef.getPath(), enumBuilder);
return enumBuilder;
}
*/
static GeneratedTOBuilder addTOToTypeBuilder(final TypeDefinition<?> typeDef, final GeneratedTypeBuilder
typeBuilder, final DataSchemaNode leaf, final Module parentModule, final TypeProvider typeProvider,
- final SchemaContext schemaContext) {
- final String classNameFromLeaf = BindingMapping.getClassName(leaf.getQName());
- final List<GeneratedTOBuilder> genTOBuilders = new ArrayList<>();
+ final SchemaContext schemaContext, ModuleContext context, final Map<Module, ModuleContext> genCtx) {
+ final String classNameFromLeaf = leaf.getQName().getLocalName();
+ GeneratedTOBuilder genTOBuilder = null;
final String packageName = typeBuilder.getFullyQualifiedName();
if (typeDef instanceof UnionTypeDefinition) {
- final List<GeneratedTOBuilder> types = ((TypeProviderImpl) typeProvider)
- .provideGeneratedTOBuildersForUnionTypeDef(packageName, ((UnionTypeDefinition) typeDef),
- classNameFromLeaf, leaf, schemaContext, ((TypeProviderImpl) typeProvider).getGenTypeDefsContextMap());
- genTOBuilders.addAll(types);
-
- GeneratedTOBuilder resultTOBuilder;
- if (types.isEmpty()) {
- throw new IllegalStateException("No GeneratedTOBuilder objects generated from union " + typeDef);
- }
- resultTOBuilder = types.remove(0);
- for (final GeneratedTOBuilder genTOBuilder : types) {
- resultTOBuilder.addEnclosingTransferObject(genTOBuilder);
- }
-
- final GeneratedPropertyBuilder genPropBuilder = resultTOBuilder.addProperty("value");
- genPropBuilder.setReturnType(Types.CHAR_ARRAY);
- resultTOBuilder.addEqualsIdentity(genPropBuilder);
- resultTOBuilder.addHashIdentity(genPropBuilder);
- resultTOBuilder.addToStringProperty(genPropBuilder);
-
+ genTOBuilder = ((TypeProviderImpl) typeProvider)
+ .provideGeneratedTOBuilderForUnionTypeDef(packageName, ((UnionTypeDefinition) typeDef),
+ classNameFromLeaf, leaf, schemaContext,
+ ((TypeProviderImpl) typeProvider).getGenTypeDefsContextMap(), context);
} else if (typeDef instanceof BitsTypeDefinition) {
- genTOBuilders.add((((TypeProviderImpl) typeProvider)).provideGeneratedTOBuilderForBitsTypeDefinition(
- packageName, typeDef, classNameFromLeaf, parentModule.getName()));
+ genTOBuilder = (((TypeProviderImpl) typeProvider)).provideGeneratedTOBuilderForBitsTypeDefinition(
+ packageName, typeDef, classNameFromLeaf, parentModule.getName(), context);
}
- if (!genTOBuilders.isEmpty()) {
- for (final GeneratedTOBuilder genTOBuilder : genTOBuilders) {
- typeBuilder.addEnclosingTransferObject(genTOBuilder);
- }
- return genTOBuilders.get(0);
+ 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 GeneratedTOBuilderImpl returnType = new GeneratedTOBuilderImpl(genTOBuilder.getPackageName(),
- genTOBuilder.getName());
- final String typedefDescription = encodeAngleBrackets(typeDef.getDescription());
+ final GeneratedTypeBuilder typeBuilder, final Module parentModule, final TypeProvider typeProvider,
+ final boolean verboseClassComments) {
+ final GeneratedTOBuilderImpl returnType = (GeneratedTOBuilderImpl) genTOBuilder;
- 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));
- final GeneratedTOBuilder unionBuilder = createUnionBuilder(genTOBuilder,typeBuilder);
+ return returnType.toInstance();
+ }
+ static boolean isInnerType(final LeafSchemaNode leaf, final TypeDefinition<?> type) {
+ return leaf.getPath().equals(type.getPath()) || leaf.getPath().equals(type.getPath().getParent());
- final MethodSignatureBuilder method = unionBuilder.addMethod("getDefaultInstance");
- method.setReturnType(returnType);
- method.addParameter(Types.STRING, "defaultValue");
- method.setAccessModifier(AccessModifier.PUBLIC);
- method.setStatic(true);
+ }
- final Set<Type> types = ((TypeProviderImpl) typeProvider).getAdditionalTypes().get(parentModule);
- if (types == null) {
- ((TypeProviderImpl) typeProvider).getAdditionalTypes().put(parentModule,
- Sets.newHashSet(unionBuilder.toInstance()));
- } else {
- types.add(unionBuilder.toInstance());
+ /**
+ * Generates for the <code>list</code> which contains any list keys special
+ * generated TO builder.
+ *
+ * @param packageName
+ * string with package name to which the list belongs
+ * @param list
+ * schema node of list
+ * @return generated TO builder which represents the keys of the
+ * <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,
+ 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, context);
}
- return returnType.toInstance();
+ return genTOBuilder;
}
- private static GeneratedTOBuilder createUnionBuilder(final GeneratedTOBuilder genTOBuilder, final GeneratedTypeBuilder typeBuilder) {
- final String outerCls = Types.getOuterClassName(genTOBuilder);
- final StringBuilder name;
- if (outerCls != null) {
- name = new StringBuilder(outerCls);
- } else {
- name = new StringBuilder();
+ 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);
}
- name.append(genTOBuilder.getName());
- name.append("Builder");
- final GeneratedTOBuilderImpl unionBuilder = new GeneratedTOBuilderImpl(typeBuilder.getPackageName(),name.toString());
- unionBuilder.setIsUnionBuilder(true);
- return unionBuilder;
+ return genTypeBuilder;
}
- static boolean isInnerType(final LeafSchemaNode leaf, final TypeDefinition<?> type) {
- if (leaf.getPath().equals(type.getPath())) {
- return true;
+ /**
+ * Converts <code>leaf</code> schema node to property of generated TO
+ * builder.
+ *
+ * @param toBuilder
+ * generated TO builder to which is <code>leaf</code> added as
+ * property
+ * @param leaf
+ * leaf schema node which is added to <code>toBuilder</code> as
+ * property
+ * @param returnType
+ * property type
+ * @param isReadOnly
+ * boolean value which says if leaf property is|isn't read only
+ * @return boolean value
+ * <ul>
+ * <li>false - if <code>leaf</code>, <code>toBuilder</code> or leaf
+ * name equals null or if leaf is added by <i>uses</i>.</li>
+ * <li>true - other cases</li>
+ * </ul>
+ */
+ static boolean resolveLeafSchemaNodeAsProperty(final String nodeName, final GeneratedTOBuilder toBuilder, final LeafSchemaNode leaf,
+ final Type returnType, final boolean isReadOnly) {
+
+ if (returnType == null) {
+ return false;
}
- if (leaf.getPath().equals(type.getPath().getParent())) {
- return true;
+ final String leafName = leaf.getQName().getLocalName();
+ final String leafGetterName;
+
+ if ("key".equals(leafName.toLowerCase())) {
+ StringBuilder sb = new StringBuilder(leafName)
+ .append('_').append("RESERVED_WORD");
+ leafGetterName = sb.toString();
+ } else {
+ leafGetterName = leafName;
}
- return false;
+ final String leafDesc = encodeAngleBrackets(leaf.getDescription().orElse(null));
+ final GeneratedPropertyBuilder propBuilder =
+ toBuilder.addProperty(JavaIdentifierNormalizer.normalizeSpecificIdentifier(leafGetterName, JavaIdentifier.METHOD));
+ propBuilder.setReadOnly(isReadOnly);
+ propBuilder.setReturnType(returnType);
+ propBuilder.setComment(leafDesc);
+ toBuilder.addEqualsIdentity(propBuilder);
+ toBuilder.addHashIdentity(propBuilder);
+ toBuilder.addToStringProperty(propBuilder);
+ return true;
+ }
+
+ static void checkModuleAndModuleName(final Module module) {
+ checkArgument(module != null, "Module reference cannot be NULL.");
+ checkArgument(module.getName() != null, "Module name cannot be NULL.");
}
@VisibleForTesting