*/
package org.opendaylight.mdsal.binding.model.api;
+import org.opendaylight.yangtools.concepts.Identifiable;
+
/**
* The Type interface defines the base type for all types defined in java. Each
* Type defined in java MUST contain name and package name, except of primitive
* types like int, byte etc. In case of mapping of primitive type the package
* name MUST be left as empty string.
*/
-public interface Type {
+public interface Type extends Identifiable<JavaTypeName> {
/**
* Returns name of the package that interface belongs to.
*
* @return name of the package that interface belongs to
*/
- String getPackageName();
+ default String getPackageName() {
+ return getIdentifier().packageName();
+ }
/**
* Returns name of the interface.
*
* @return name of the interface.
*/
- String getName();
+ default String getName() {
+ return getIdentifier().simpleName();
+ }
/**
* Returns fully qualified name of Type. <br>
*
* @return fully qualified name of Type.
*/
- String getFullyQualifiedName();
+ default String getFullyQualifiedName() {
+ return getIdentifier().toString();
+ }
}
--- /dev/null
+/*
+ * Copyright (c) 2018 Pantheon Technologies, s.r.o. 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.model.api.type.builder;
+
+import com.google.common.annotations.Beta;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
+
+/**
+ * Common interface for java type builders which allow attaching annotations to them.
+ */
+@Beta
+public interface AnnotableTypeBuilder {
+ /**
+ * The method creates new {@link AnnotationTypeBuilder} containing specified package name an annotation name.
+ *
+ * @param identifier JavaTypeName of the annotation
+ * @return a new instance of Annotation Type Builder.
+ */
+ AnnotationTypeBuilder addAnnotation(final JavaTypeName identifier);
+
+ /**
+ * The method creates new {@link AnnotationTypeBuilder} containing specified package name an annotation name.
+ * Neither the package name or annotation name can contain <code>null</code> references. In case that any
+ * of parameters contains <code>null</code> the method SHOULD thrown {@link IllegalArgumentException}
+ *
+ * @param packageName Package Name of Annotation Type
+ * @param simpleName Name of Annotation Type
+ * @return <code>new</code> instance of Annotation Type Builder.
+ * @throws NullPointerException if any of the arguments are null
+ * @throws IllegalArgumentException if any of the arguments is an empty string
+ */
+ default AnnotationTypeBuilder addAnnotation(final String packageName, final String simpleName) {
+ return addAnnotation(JavaTypeName.create(packageName, simpleName));
+ }
+}
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
/**
- * Enum Builder is interface that contains methods to build and instantiate
- * Enumeration definition.
+ * Enum Builder is interface that contains methods to build and instantiate Enumeration definition.
*
* @see Enumeration
*/
-public interface EnumBuilder extends Type {
+public interface EnumBuilder extends Type, AnnotableTypeBuilder {
- /**
- * The method creates new AnnotationTypeBuilder containing specified package
- * name an annotation name. <br>
- * Neither the package name or annotation name can contain <code>null</code>
- * references. In case that any of parameters contains <code>null</code> the
- * method SHOULD thrown {@link IllegalArgumentException}
- *
- * @param packageName
- * Package Name of Annotation Type
- * @param name
- * Name of Annotation Type
- * @return <code>new</code> instance of Annotation Type Builder.
- */
- AnnotationTypeBuilder addAnnotation(final String packageName, final String name);
+ void setDescription(final String description);
- /**
- *
- * @param definingType
- * @return
- */
Enumeration toInstance(final Type definingType);
/**
- * Updates this builder with data from <code>enumTypeDef</code>.
- * Specifically this data represents list of value-name pairs.
+ * Updates this builder with data from <code>enumTypeDef</code>. Specifically this data represents list
+ * of value-name pairs.
*
- * @param enumTypeDef
- * enum type definition as source of enum data for
- * <code>enumBuilder</code>
+ * @param enumTypeDef enum type definition as source of enum data for <code>enumBuilder</code>
*/
void updateEnumPairsFromEnumTypeDef(final EnumTypeDefinition enumTypeDef);
-
- /**
- * @param description
- */
- void setDescription(final String description);
-
}
import org.opendaylight.mdsal.binding.model.api.YangSourceDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-public interface GeneratedTypeBuilderBase<T extends GeneratedTypeBuilderBase<T>> extends Type {
+public interface GeneratedTypeBuilderBase<T extends GeneratedTypeBuilderBase<T>> extends Type, AnnotableTypeBuilder {
/**
* Adds new Enclosing Transfer Object into definition of Generated Type and
*/
T addComment(TypeComment comment);
- /**
- * The method creates new AnnotationTypeBuilder containing specified package
- * name an annotation name. <br>
- * Neither the package name or annotation name can contain <code>null</code>
- * references. In case that any of parameters contains <code>null</code> the
- * method SHOULD thrown {@link IllegalArgumentException}
- *
- * @param packageName
- * Package Name of Annotation Type
- * @param name
- * Name of Annotation Type
- * @return <code>new</code> instance of Annotation Type Builder.
- */
- AnnotationTypeBuilder addAnnotation(String packageName, String name);
-
boolean isAbstract();
/**
import org.opendaylight.mdsal.binding.model.api.AccessModifier;
import org.opendaylight.mdsal.binding.model.api.Type;
-public interface TypeMemberBuilder<T extends TypeMemberBuilder<T>> {
-
- /**
- * The method creates new AnnotationTypeBuilder containing specified package
- * name an annotation name. <br>
- * Neither the package name or annotation name can contain <code>null</code>
- * references. In case that any of parameters contains <code>null</code> the
- * method SHOULD thrown {@link IllegalArgumentException}
- *
- * @param packageName
- * Package Name of Annotation Type
- * @param name
- * Name of Annotation Type
- * @return <code>new</code> instance of Annotation Type Builder.
- */
- AnnotationTypeBuilder addAnnotation(final String packageName, final String name);
-
+public interface TypeMemberBuilder<T extends TypeMemberBuilder<T>> extends AnnotableTypeBuilder {
/**
* Returns the name of property.
*
String getName();
/**
- * Adds return Type into Builder definition for Generated Property. <br>
- * The return Type MUST NOT be <code>null</code>, otherwise the method
- * SHOULD throw {@link IllegalArgumentException}
+ * Adds return Type into Builder definition for Generated Property. The return Type MUST NOT be <code>null</code>,
+ * otherwise the method SHOULD throw {@link IllegalArgumentException}
*
* @param returnType
* Return Type of property.
T setAccessModifier(final AccessModifier modifier);
/**
- * Adds String definition of comment into Method Signature definition. <br>
- * The comment String MUST NOT contain any comment specific chars (i.e.
- * "/**" or "//") just plain String text description.
+ * Adds String definition of comment into Method Signature definition. The comment String MUST NOT contain any
+ * comment specific chars (i.e. "/**" or "//") just plain String text description.
*
- * @param comment
- * Comment String.
+ * @param comment Comment String.
*/
T setComment(final String comment);
/**
- * Sets the flag final for method signature. If this is set the method will
- * be prohibited from overriding. <br>
- * This setting is irrelevant for methods designated to be defined in
- * interface definitions because interface can't have final method.
+ * Sets the flag final for method signature. If this is set the method will be prohibited from overriding. This
+ * setting is irrelevant for methods designated to be defined in interface definitions because interfaces cannot
+ * have a final method.
*
- * @param isFinal
- * Is Final
+ * @param isFinal Is Final
*/
T setFinal(final boolean isFinal);
import com.google.common.base.Splitter;
import com.google.common.collect.Iterables;
import com.google.common.collect.Sets;
+import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
+import java.util.Deque;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import org.opendaylight.mdsal.binding.model.api.Constant;
import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
import org.opendaylight.mdsal.binding.model.api.GeneratedType;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.ParameterizedType;
import org.opendaylight.mdsal.binding.model.api.Restrictions;
import org.opendaylight.mdsal.binding.model.api.Type;
import org.opendaylight.mdsal.binding.model.util.ReferencedTypeImpl;
import org.opendaylight.mdsal.binding.model.util.TypeConstants;
import org.opendaylight.mdsal.binding.model.util.Types;
-import org.opendaylight.mdsal.binding.model.util.generated.type.builder.CodegenGeneratedTOBuilder;
import org.opendaylight.mdsal.binding.model.util.generated.type.builder.GeneratedPropertyBuilderImpl;
import org.opendaylight.mdsal.binding.yang.types.AbstractTypeProvider;
import org.opendaylight.mdsal.binding.yang.types.BaseYangTypes;
if (node.isAugmenting() || node.isAddedByUses()) {
return null;
}
- final String packageName = packageNameForGeneratedType(context.modulePackageName(), node.getPath());
- final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(packageName, node, childOf, context);
+ final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(context, node, childOf);
annotateDeprecatedIfNecessary(node.getStatus(), genType);
final Module module = context.module();
constructGetter(parent, Types.listTypeFor(genType), node);
final List<String> listKeys = listKeys(node);
- final String packageName = packageNameForGeneratedType(context.modulePackageName(), node.getPath());
- final GeneratedTOBuilder genTOBuilder = resolveListKeyTOBuilder(packageName, node);
+ final GeneratedTOBuilder genTOBuilder = resolveListKeyTOBuilder(context, node);
if (genTOBuilder != null) {
final Type identifierMarker = Types.parameterizedTypeFor(IDENTIFIER, genType);
final Type identifiableMarker = Types.parameterizedTypeFor(IDENTIFIABLE, genTOBuilder);
private Type createRpcContainer(final ModuleContext context, final String rpcName, final RpcDefinition rpc,
final ContainerSchemaNode schema) {
processUsesAugments(schema, context);
- final GeneratedTypeBuilder outType = addRawInterfaceDefinition(context.modulePackageName(), schema, rpcName);
+ final GeneratedTypeBuilder outType = addRawInterfaceDefinition(
+ JavaTypeName.create(context.modulePackageName(), rpcName + BindingMapping.getClassName(schema.getQName())),
+ schema);
addImplementedInterfaceFromUses(schema, outType);
outType.addImplementsType(DATA_OBJECT);
outType.addImplementsType(augmentable(outType));
if (identity == null) {
return;
}
- final String packageName = packageNameForGeneratedType(context.modulePackageName(), identity.getPath());
- final String genTypeName = BindingMapping.getClassName(identity.getQName());
- final GeneratedTOBuilder newType = typeProvider.newGeneratedTOBuilder(packageName, genTypeName);
+ final GeneratedTOBuilder newType = typeProvider.newGeneratedTOBuilder(JavaTypeName.create(
+ packageNameForGeneratedType(context.modulePackageName(), identity.getPath()),
+ BindingMapping.getClassName(identity.getQName())));
final Set<IdentitySchemaNode> baseIdentities = identity.getBaseIdentities();
if (baseIdentities.isEmpty()) {
- final GeneratedTOBuilder gto = typeProvider.newGeneratedTOBuilder(
- BaseIdentity.class.getPackage().getName(), BaseIdentity.class.getSimpleName());
+ final GeneratedTOBuilder gto = typeProvider.newGeneratedTOBuilder(JavaTypeName.create(BaseIdentity.class));
newType.setExtendsType(gto.build());
} else {
final IdentitySchemaNode baseIdentity = baseIdentities.iterator().next();
final QName qname = baseIdentity.getQName();
- final String returnTypePkgName = BindingMapping.getRootPackageName(qname.getModule());
- final String returnTypeName = BindingMapping.getClassName(baseIdentity.getQName());
- final GeneratedTransferObject gto = new CodegenGeneratedTOBuilder(returnTypePkgName, returnTypeName)
- .build();
+ final GeneratedTransferObject gto = typeProvider.newGeneratedTOBuilder(JavaTypeName.create(
+ BindingMapping.getRootPackageName(qname.getModule()), BindingMapping.getClassName(qname))).build();
newType.setExtendsType(gto);
}
newType.setAbstract(true);
for (final GroupingDefinition grouping : new GroupingDefinitionDependencySort().sort(groupings)) {
// Converts individual grouping to GeneratedType. Firstly generated type builder is created and every child
// node of grouping is resolved to the method.
- final String packageName = packageNameForGeneratedType(context.modulePackageName(), grouping.getPath());
- final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(packageName, grouping, context);
+ final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(context, grouping);
annotateDeprecatedIfNecessary(grouping.getStatus(), genType);
context.addGroupingType(grouping.getPath(), genType);
resolveDataSchemaNodes(context, genType, genType, grouping.getChildNodes());
private GeneratedTypeBuilder moduleTypeBuilder(final ModuleContext context, final String postfix) {
final Module module = context.module();
final String moduleName = BindingMapping.getClassName(module.getName()) + postfix;
- final GeneratedTypeBuilder moduleBuilder = typeProvider.newGeneratedTypeBuilder(context.modulePackageName(),
- moduleName);
+ final GeneratedTypeBuilder moduleBuilder = typeProvider.newGeneratedTypeBuilder(
+ JavaTypeName.create(context.modulePackageName(), moduleName));
moduleBuilder.setModuleName(moduleName);
addCodegenInformation(moduleBuilder, module);
}
if (!(targetSchemaNode instanceof ChoiceSchemaNode)) {
- final Type targetType = new ReferencedTypeImpl(targetTypeBuilder.getPackageName(),
- targetTypeBuilder.getName());
- addRawAugmentGenTypeDefinition(context, context.modulePackageName(), targetType, augSchema);
+ final Type targetType = new ReferencedTypeImpl(targetTypeBuilder.getIdentifier());
+ addRawAugmentGenTypeDefinition(context, targetType, augSchema);
} else {
generateTypesFromAugmentedChoiceCases(context, targetTypeBuilder.build(),
}
if (!(targetSchemaNode instanceof ChoiceSchemaNode)) {
- final String packageName;
if (usesNodeParent instanceof SchemaNode) {
- packageName = packageNameForAugmentedGeneratedType(context.modulePackageName(),
- ((SchemaNode) usesNodeParent).getPath());
+ addRawAugmentGenTypeDefinition(context,
+ packageNameForAugmentedGeneratedType(context.modulePackageName(),
+ ((SchemaNode) usesNodeParent).getPath()),
+ targetTypeBuilder.build(), augSchema);
} else {
- packageName = context.modulePackageName();
+ addRawAugmentGenTypeDefinition(context, targetTypeBuilder.build(), augSchema);
}
- addRawAugmentGenTypeDefinition(context, packageName, targetTypeBuilder.build(), augSchema);
} else {
generateTypesFromAugmentedChoiceCases(context, targetTypeBuilder.build(),
(ChoiceSchemaNode) targetSchemaNode, augSchema.getChildNodes(), usesNodeParent);
augTypeName = augGenTypeName(augmentBuilders, targetTypeRef.getName());
}
- final GeneratedTypeBuilder augTypeBuilder = typeProvider.newGeneratedTypeBuilder(augmentPackageName,
- augTypeName);
+ final GeneratedTypeBuilder augTypeBuilder = typeProvider.newGeneratedTypeBuilder(
+ JavaTypeName.create(augmentPackageName, augTypeName));
augTypeBuilder.addImplementsType(DATA_OBJECT);
augTypeBuilder.addImplementsType(Types.augmentationTypeFor(targetTypeRef));
return augTypeBuilder;
}
+ private GeneratedTypeBuilder addRawAugmentGenTypeDefinition(final ModuleContext context, final Type targetTypeRef,
+ final AugmentationSchemaNode augSchema) {
+ return addRawAugmentGenTypeDefinition(context, context.modulePackageName(), targetTypeRef, augSchema);
+ }
+
/**
*
* @param unknownSchemaNodes
checkArgument(choiceNode != null, "Choice Schema Node cannot be NULL.");
if (!choiceNode.isAddedByUses()) {
- final String packageName = packageNameForGeneratedType(context.modulePackageName(), choiceNode.getPath());
- final GeneratedTypeBuilder choiceTypeBuilder = addRawInterfaceDefinition(packageName, choiceNode);
+ final GeneratedTypeBuilder choiceTypeBuilder = addRawInterfaceDefinition(
+ JavaTypeName.create(packageNameForGeneratedType(context.modulePackageName(), choiceNode.getPath()),
+ BindingMapping.getClassName(choiceNode.getQName())), choiceNode);
constructGetter(parent, choiceTypeBuilder, choiceNode);
choiceTypeBuilder.addImplementsType(typeForClass(DataContainer.class));
annotateDeprecatedIfNecessary(choiceNode.getStatus(), choiceTypeBuilder);
for (final CaseSchemaNode caseNode : choiceNode.getCases().values()) {
if (caseNode != null && !caseNode.isAddedByUses() && !caseNode.isAugmenting()) {
- final String packageName = packageNameForGeneratedType(context.modulePackageName(), caseNode.getPath());
- final GeneratedTypeBuilder caseTypeBuilder = addDefaultInterfaceDefinition(packageName, caseNode,
- context);
+ final GeneratedTypeBuilder caseTypeBuilder = addDefaultInterfaceDefinition(context, caseNode);
caseTypeBuilder.addImplementsType(refChoiceType);
annotateDeprecatedIfNecessary(caseNode.getStatus(), caseTypeBuilder);
context.addCaseType(caseNode.getPath(), caseTypeBuilder);
for (final DataSchemaNode caseNode : augmentedNodes) {
if (caseNode != null) {
- final String packageName = packageNameForGeneratedType(context.modulePackageName(), caseNode.getPath());
- final GeneratedTypeBuilder caseTypeBuilder = addDefaultInterfaceDefinition(packageName, caseNode,
- context);
+ final GeneratedTypeBuilder caseTypeBuilder = addDefaultInterfaceDefinition(context, caseNode);
caseTypeBuilder.addImplementsType(targetType);
SchemaNode parent;
}
typeProvider.putReferencedType(leaf.getPath(), returnType);
} else if (typeDef instanceof UnionTypeDefinition) {
- GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, leaf, parentModule);
+ GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder((UnionTypeDefinition) typeDef, typeBuilder, leaf,
+ parentModule);
if (genTOBuilder != null) {
returnType = createReturnTypeForUnion(genTOBuilder, typeDef, typeBuilder, parentModule);
// Store the inner type within the union so that we can find the reference for it
context.addInnerTypedefType(typeDef.getPath(), returnType);
}
} else if (typeDef instanceof BitsTypeDefinition) {
- GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, leaf, parentModule);
+ GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder((BitsTypeDefinition) typeDef, typeBuilder, leaf,
+ parentModule);
if (genTOBuilder != null) {
returnType = genTOBuilder.build();
}
+ nodeParam);
}
- final Class<RoutingContext> clazz = RoutingContext.class;
- final AnnotationTypeBuilder rc = getter.addAnnotation(clazz.getPackage().getName(),
- clazz.getSimpleName());
+ final AnnotationTypeBuilder rc = getter.addAnnotation(JavaTypeName.create(RoutingContext.class));
final String packageName = packageNameForGeneratedType(basePackageName, identity.getPath());
final String genTypeName = BindingMapping.getClassName(identity.getQName().getLocalName());
rc.addParameter("value", packageName + "." + genTypeName + ".class");
final EnumTypeDefinition enumTypeDef = (EnumTypeDefinition) typeDef;
final EnumBuilder enumBuilder = resolveInnerEnumFromTypeDefinition(enumTypeDef, nodeName,
typeBuilder, context);
- returnType = new ReferencedTypeImpl(enumBuilder.getPackageName(), enumBuilder.getName());
+ returnType = new ReferencedTypeImpl(enumBuilder.getIdentifier());
typeProvider.putReferencedType(node.getPath(), returnType);
} else if (typeDef instanceof UnionTypeDefinition) {
- final GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, node, parentModule);
+ final GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder((UnionTypeDefinition)typeDef, typeBuilder,
+ node, parentModule);
if (genTOBuilder != null) {
returnType = createReturnTypeForUnion(genTOBuilder, typeDef, typeBuilder, parentModule);
}
} else if (typeDef instanceof BitsTypeDefinition) {
- final GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, node, parentModule);
+ final GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder((BitsTypeDefinition)typeDef, typeBuilder,
+ node, parentModule);
returnType = genTOBuilder.build();
} else {
final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(typeDef);
private Type createReturnTypeForUnion(final GeneratedTOBuilder genTOBuilder, final TypeDefinition<?> typeDef,
final GeneratedTypeBuilder typeBuilder, final Module parentModule) {
- final GeneratedTOBuilder returnType = typeProvider.newGeneratedTOBuilder(genTOBuilder.getPackageName(),
- genTOBuilder.getName());
+ final GeneratedTOBuilder returnType = typeProvider.newGeneratedTOBuilder(genTOBuilder.getIdentifier());
addCodegenInformation(returnType, parentModule, typeDef);
returnType.setSchemaPath(typeDef.getPath());
- final GeneratedTOBuilder unionBuilder = createUnionBuilder(genTOBuilder,typeBuilder);
+ final GeneratedTOBuilder unionBuilder = createUnionBuilder(genTOBuilder, typeBuilder);
final MethodSignatureBuilder method = unionBuilder.addMethod("getDefaultInstance");
private GeneratedTOBuilder createUnionBuilder(final GeneratedTOBuilder genTOBuilder,
final GeneratedTypeBuilder typeBuilder) {
- final String outerCls = Types.getOuterClassName(genTOBuilder);
- final StringBuilder name;
- if (outerCls != null) {
- name = new StringBuilder(outerCls);
- } else {
- name = new StringBuilder();
+ final StringBuilder sb = new StringBuilder();
+
+ // Append enclosing path hierarchy without dots
+ // TODO: JavaTypeName could be giving us a Stream<String> or similar, but there is no sense in generalizing
+ // unless there is another caller.
+ Optional<JavaTypeName> outerClass = genTOBuilder.getIdentifier().immediatelyEnclosingClass();
+ if (outerClass.isPresent()) {
+ final Deque<String> enclosingPath = new ArrayDeque<>();
+ do {
+ final JavaTypeName outerName = outerClass.get();
+ enclosingPath.push(outerName.simpleName());
+ outerClass = outerName.immediatelyEnclosingClass();
+ } while (outerClass.isPresent());
+
+ while (!enclosingPath.isEmpty()) {
+ sb.append(enclosingPath.pop());
+ }
}
- name.append(genTOBuilder.getName());
- name.append("Builder");
- final GeneratedTOBuilder unionBuilder = typeProvider.newGeneratedTOBuilder(typeBuilder.getPackageName(),
- name.toString());
+
+ sb.append(genTOBuilder.getName()).append("Builder");
+ final GeneratedTOBuilder unionBuilder = typeProvider.newGeneratedTOBuilder(
+ JavaTypeName.create(typeBuilder.getPackageName(), sb.toString()));
unionBuilder.setIsUnionBuilder(true);
return unionBuilder;
}
- private GeneratedTypeBuilder addDefaultInterfaceDefinition(final String packageName, final SchemaNode schemaNode,
- final ModuleContext context) {
- return addDefaultInterfaceDefinition(packageName, schemaNode, null, context);
+ private GeneratedTypeBuilder addDefaultInterfaceDefinition(final ModuleContext context,
+ final SchemaNode schemaNode) {
+ return addDefaultInterfaceDefinition(context, schemaNode, null);
+ }
+
+ private GeneratedTypeBuilder addDefaultInterfaceDefinition(final ModuleContext context,
+ final SchemaNode schemaNode, final GeneratedTypeBuilder childOf) {
+ final String packageName = packageNameForGeneratedType(context.modulePackageName(), schemaNode.getPath());
+ return addDefaultInterfaceDefinition(packageName, schemaNode, childOf, context);
}
+
/**
* Instantiates generated type builder with <code>packageName</code> and
* <code>schemaNode</code>.
*/
private GeneratedTypeBuilder addDefaultInterfaceDefinition(final String packageName, final SchemaNode schemaNode,
final Type parent, final ModuleContext context) {
- final GeneratedTypeBuilder it = addRawInterfaceDefinition(packageName, schemaNode, "");
+ final GeneratedTypeBuilder it = addRawInterfaceDefinition(
+ JavaTypeName.create(packageName, BindingMapping.getClassName(schemaNode.getQName())), schemaNode);
if (parent == null) {
it.addImplementsType(DATA_OBJECT);
} else {
* schema node which provide data about the schema node name
* @return generated type builder for <code>schemaNode</code>
*/
- private GeneratedTypeBuilder addRawInterfaceDefinition(final String packageName, final SchemaNode schemaNode) {
- return addRawInterfaceDefinition(packageName, schemaNode, "");
+ private GeneratedTypeBuilder addRawInterfaceDefinition(final ModuleContext context, final SchemaNode schemaNode,
+ final String prefix) {
+ return addRawInterfaceDefinition(
+ JavaTypeName.create(packageNameForGeneratedType(context.modulePackageName(), schemaNode.getPath()),
+ prefix + BindingMapping.getClassName(schemaNode.getQName())), schemaNode);
}
/**
* </ul>
*
*/
- private GeneratedTypeBuilder addRawInterfaceDefinition(final String packageName, final SchemaNode schemaNode,
- final String prefix) {
+ private GeneratedTypeBuilder addRawInterfaceDefinition(final JavaTypeName identifier, final SchemaNode schemaNode) {
checkArgument(schemaNode != null, "Data Schema Node cannot be NULL.");
- checkArgument(packageName != null, "Package Name for Generated Type cannot be NULL.");
checkArgument(schemaNode.getQName() != null, "QName for Data Schema Node cannot be NULL.");
final String schemaNodeName = schemaNode.getQName().getLocalName();
checkArgument(schemaNodeName != null, "Local Name of QName for Data Schema Node cannot be NULL.");
- String genTypeName;
- if (prefix == null) {
- genTypeName = BindingMapping.getClassName(schemaNodeName);
- } else {
- genTypeName = prefix + BindingMapping.getClassName(schemaNodeName);
- }
-
// FIXME: Validation of name conflict
- final GeneratedTypeBuilder newType = typeProvider.newGeneratedTypeBuilder(packageName, genTypeName);
+ final GeneratedTypeBuilder newType = typeProvider.newGeneratedTypeBuilder(identifier);
final Module module = findParentModule(schemaContext, schemaNode);
qnameConstant(newType, BindingMapping.QNAME_STATIC_FIELD_NAME, schemaNode.getQName());
newType.setSchemaPath(schemaNode.getPath());
newType.setModuleName(module.getName());
+ final String packageName = identifier.packageName();
+ final String simpleName = identifier.simpleName();
if (!genTypeBuilders.containsKey(packageName)) {
final Map<String, GeneratedTypeBuilder> builders = new HashMap<>();
- builders.put(genTypeName, newType);
+ builders.put(simpleName, newType);
genTypeBuilders.put(packageName, builders);
} else {
final Map<String, GeneratedTypeBuilder> builders = genTypeBuilders.get(packageName);
- if (!builders.containsKey(genTypeName)) {
- builders.put(genTypeName, newType);
+ if (!builders.containsKey(simpleName)) {
+ builders.put(simpleName, newType);
}
}
return newType;
getMethod.setReturnType(returnType);
if (node.getStatus() == Status.DEPRECATED) {
- getMethod.addAnnotation("", "Deprecated");
+ getMethod.addAnnotation("java.lang", "Deprecated");
}
addComment(getMethod, node);
* <code>list</code> or null if <code>list</code> is null or list of
* key definitions is null or empty.
*/
- private GeneratedTOBuilder resolveListKeyTOBuilder(final String packageName, final ListSchemaNode list) {
- GeneratedTOBuilder genTOBuilder = null;
+ private GeneratedTOBuilder resolveListKeyTOBuilder(final ModuleContext context, final ListSchemaNode list) {
if (list.getKeyDefinition() != null && !list.getKeyDefinition().isEmpty()) {
- final String listName = list.getQName().getLocalName() + "Key";
- final String genTOName = BindingMapping.getClassName(listName);
- genTOBuilder = typeProvider.newGeneratedTOBuilder(packageName, genTOName);
+ return typeProvider.newGeneratedTOBuilder(JavaTypeName.create(
+ packageNameForGeneratedType(context.modulePackageName(), list.getPath()),
+ BindingMapping.getClassName(list.getQName().getLocalName() + "Key")));
}
- return genTOBuilder;
+ return null;
+ }
+
+ /**
+ * Builds a GeneratedTOBuilder for a UnionType {@link UnionTypeDefinition}.
+ *
+ * If more then one generated TO builder is created for enclosing then all
+ * of the generated TO builders are added to <code>typeBuilder</code> as
+ * enclosing transfer objects.
+ *
+ * @param typeDef
+ * type definition which can be of type <code>UnionType</code> or
+ * <code>BitsTypeDefinition</code>
+ * @param typeBuilder
+ * generated type builder to which is added generated TO created
+ * from <code>typeDef</code>
+ * @param leaf
+ * string with name for generated TO builder
+ * @param parentModule
+ * parent module
+ * @return generated TO builder for <code>typeDef</code>
+ */
+ private GeneratedTOBuilder addTOToTypeBuilder(final UnionTypeDefinition typeDef,
+ final GeneratedTypeBuilder typeBuilder, final DataSchemaNode leaf, final Module parentModule) {
+ final List<GeneratedTOBuilder> types = typeProvider.provideGeneratedTOBuildersForUnionTypeDef(
+ typeBuilder.getIdentifier().createEnclosed(BindingMapping.getClassName(leaf.getQName())),
+ typeDef, leaf);
+
+ checkState(!types.isEmpty(), "No GeneratedTOBuilder objects generated from union %s", typeDef);
+ final List<GeneratedTOBuilder> genTOBuilders = new ArrayList<>(types);
+ final GeneratedTOBuilder 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);
+ processEnclosedTOBuilderes(typeBuilder, genTOBuilders);
+ return resultTOBuilder;
}
/**
- * Builds generated TO builders for <code>typeDef</code> of type
- * {@link UnionTypeDefinition} or {@link BitsTypeDefinition} which are
+ * Builds generated TO builders for <code>typeDef</code> of type {@link BitsTypeDefinition} which are
* also added to <code>typeBuilder</code> as enclosing transfer object.
*
* If more then one generated TO builder is created for enclosing then all
* parent module
* @return generated TO builder for <code>typeDef</code>
*/
- private GeneratedTOBuilder addTOToTypeBuilder(final TypeDefinition<?> typeDef,
+ private GeneratedTOBuilder addTOToTypeBuilder(final BitsTypeDefinition typeDef,
final GeneratedTypeBuilder typeBuilder, final DataSchemaNode leaf, final Module parentModule) {
- final String classNameFromLeaf = BindingMapping.getClassName(leaf.getQName());
- final List<GeneratedTOBuilder> genTOBuilders = new ArrayList<>();
- final String packageName = typeBuilder.getFullyQualifiedName();
- if (typeDef instanceof UnionTypeDefinition) {
- final List<GeneratedTOBuilder> types = typeProvider
- .provideGeneratedTOBuildersForUnionTypeDef(packageName, (UnionTypeDefinition) typeDef,
- classNameFromLeaf, leaf);
- 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 GeneratedTOBuilder genTOBuilder = typeProvider.provideGeneratedTOBuilderForBitsTypeDefinition(
+ typeBuilder.getIdentifier().createEnclosed(BindingMapping.getClassName(leaf.getQName())),
+ typeDef, parentModule.getName());
+ typeBuilder.addEnclosingTransferObject(genTOBuilder);
+ return genTOBuilder;
- final GeneratedPropertyBuilder genPropBuilder = resultTOBuilder.addProperty("value");
- genPropBuilder.setReturnType(Types.CHAR_ARRAY);
- resultTOBuilder.addEqualsIdentity(genPropBuilder);
- resultTOBuilder.addHashIdentity(genPropBuilder);
- resultTOBuilder.addToStringProperty(genPropBuilder);
+ }
- } else if (typeDef instanceof BitsTypeDefinition) {
- genTOBuilders.add(typeProvider.provideGeneratedTOBuilderForBitsTypeDefinition(
- packageName, typeDef, classNameFromLeaf, parentModule.getName()));
- }
- if (!genTOBuilders.isEmpty()) {
- for (final GeneratedTOBuilder genTOBuilder : genTOBuilders) {
- typeBuilder.addEnclosingTransferObject(genTOBuilder);
- }
- return genTOBuilders.get(0);
+ private static GeneratedTOBuilder processEnclosedTOBuilderes(final GeneratedTypeBuilder typeBuilder,
+ final List<GeneratedTOBuilder> genTOBuilders) {
+ for (final GeneratedTOBuilder genTOBuilder : genTOBuilders) {
+ typeBuilder.addEnclosingTransferObject(genTOBuilder);
}
- return null;
-
+ return genTOBuilders.get(0);
}
/**
private static void annotateDeprecatedIfNecessary(final Status status, final GeneratedTypeBuilder builder) {
if (status == Status.DEPRECATED) {
- builder.addAnnotation("", "Deprecated");
+ builder.addAnnotation("java.lang", "Deprecated");
}
}
}
import org.opendaylight.mdsal.binding.model.api.MethodSignature;
import org.opendaylight.mdsal.binding.model.api.ParameterizedType;
import org.opendaylight.mdsal.binding.model.api.Type;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
import org.opendaylight.mdsal.binding.model.util.ReferencedTypeImpl;
import org.opendaylight.yangtools.concepts.Immutable;
}
private static Type referencedType(final Class<?> type) {
- return new ReferencedTypeImpl(type.getPackage().getName(), type.getSimpleName());
- }
-
- static Type referencedType(final String type) {
- final int packageClassSeparator = type.lastIndexOf(DOT);
- return new ReferencedTypeImpl(type.substring(0, packageClassSeparator), type.substring(packageClassSeparator + 1));
+ return new ReferencedTypeImpl(JavaTypeName.create(type));
}
/**
return getTypeWithSchema(referencedType(type));
}
- public Entry<GeneratedType, WithStatus> getTypeWithSchema(final String type) {
- return getTypeWithSchema(referencedType(type));
- }
-
private Entry<GeneratedType, WithStatus> getTypeWithSchema(final Type referencedType) {
final WithStatus schema = runtimeTypes.findSchema(referencedType).orElseThrow(
() -> new NullPointerException("Failed to find schema for type " + referencedType));
return getEnumMapping(typeWithSchema);
}
- /**
- * See {@link #getEnumMapping(Class)}}
- */
- public BiMap<String, String> getEnumMapping(final String enumClass) {
- final Entry<GeneratedType, WithStatus> typeWithSchema = getTypeWithSchema(enumClass);
- return getEnumMapping(typeWithSchema);
- }
-
private static BiMap<String, String> getEnumMapping(final Entry<GeneratedType, WithStatus> typeWithSchema) {
final TypeDefinition<?> typeDef = (TypeDefinition<?>) typeWithSchema.getValue();
if (type instanceof ReferencedTypeImpl) {
return type;
}
- return new ReferencedTypeImpl(type.getPackageName(), type.getName());
+ return new ReferencedTypeImpl(type.getIdentifier());
}
private static Set<Type> collectAllContainerTypes(final GeneratedType type, final Set<Type> collection) {
import org.opendaylight.mdsal.binding.model.api.Enumeration;
import org.opendaylight.mdsal.binding.model.api.GeneratedProperty;
import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.Restrictions;
import org.opendaylight.mdsal.binding.model.api.Type;
import org.opendaylight.mdsal.binding.model.api.type.builder.EnumBuilder;
}
private GeneratedTransferObject shadedTOWithRestrictions(final GeneratedTransferObject gto, final Restrictions r) {
- final GeneratedTOBuilder gtob = newGeneratedTOBuilder(gto.getPackageName(), gto.getName());
+ final GeneratedTOBuilder gtob = newGeneratedTOBuilder(gto.getIdentifier());
final GeneratedTransferObject parent = gto.getSuperType();
if (parent != null) {
gtob.setExtendsType(parent);
Preconditions.checkArgument(identity != null, "Target identity '" + baseIdQName + "' do not exists");
final String basePackageName = BindingMapping.getRootPackageName(module.getQNameModule());
- final String packageName = BindingGeneratorUtil.packageNameForGeneratedType(basePackageName,
- identity.getPath());
- final String genTypeName = BindingMapping.getClassName(identity.getQName());
-
- final Type baseType = Types.typeForClass(Class.class);
- final Type paramType = Types.wildcardTypeFor(packageName, genTypeName);
- return Types.parameterizedTypeFor(baseType, paramType);
+ final JavaTypeName identifier = JavaTypeName.create(BindingGeneratorUtil.packageNameForGeneratedType(basePackageName,
+ identity.getPath()), BindingMapping.getClassName(identity.getQName()));
+ final Type paramType = Types.wildcardTypeFor(identifier);
+ return Types.parameterizedTypeFor(Types.typeForClass(Class.class), paramType);
}
/**
Preconditions.checkArgument(enumTypeDef.getQName().getLocalName() != null,
"Local Name in EnumTypeDefinition QName cannot be NULL!");
- final String enumerationName = BindingMapping.getClassName(enumName);
-
final Module module = findParentModule(schemaContext, parentNode);
- final String basePackageName = BindingMapping.getRootPackageName(module.getQNameModule());
-
- final AbstractEnumerationBuilder enumBuilder = newEnumerationBuilder(basePackageName, enumerationName);
+ final AbstractEnumerationBuilder enumBuilder = newEnumerationBuilder(JavaTypeName.create(
+ BindingMapping.getRootPackageName(module.getQNameModule()), BindingMapping.getClassName(enumName)));
addEnumDescription(enumBuilder, enumTypeDef);
enumTypeDef.getReference().ifPresent(enumBuilder::setReference);
enumBuilder.setModuleName(module.getName());
public abstract void addEnumDescription(EnumBuilder enumBuilder, EnumTypeDefinition enumTypeDef);
- public abstract AbstractEnumerationBuilder newEnumerationBuilder(String packageName, String name);
+ public abstract AbstractEnumerationBuilder newEnumerationBuilder(JavaTypeName identifier);
- public abstract GeneratedTOBuilder newGeneratedTOBuilder(String packageName, String name);
+ public abstract GeneratedTOBuilder newGeneratedTOBuilder(JavaTypeName identifier);
- public abstract GeneratedTypeBuilder newGeneratedTypeBuilder(String packageName, String name);
+ public abstract GeneratedTypeBuilder newGeneratedTypeBuilder(JavaTypeName identifier);
/**
* Converts the pattern constraints to the list of the strings which represents these constraints.
final List<Module> modulesSortedByDependency = ModuleDependencySort.sort(modules);
for (Module module : modulesSortedByDependency) {
- Map<Optional<Revision>, Map<String, Type>> dateTypeMap = genTypeDefsContextMap.get(module.getName());
- if (dateTypeMap == null) {
- dateTypeMap = new HashMap<>();
- }
+ Map<Optional<Revision>, Map<String, Type>> dateTypeMap = genTypeDefsContextMap.computeIfAbsent(
+ module.getName(), key -> new HashMap<>());
dateTypeMap.put(module.getRevision(), Collections.<String, Type>emptyMap());
genTypeDefsContextMap.put(module.getName(), dateTypeMap);
}
*/
private Type typedefToGeneratedType(final String basePackageName, final Module module,
final TypeDefinition<?> typedef) {
- final String moduleName = module.getName();
- final Optional<Revision> moduleRevision = module.getRevision();
- if (basePackageName != null && moduleName != null && typedef != null && typedef.getQName() != null) {
- final String typedefName = typedef.getQName().getLocalName();
- final TypeDefinition<?> innerTypeDefinition = typedef.getBaseType();
- // See generatedTypeForExtendedDefinitionType() above for rationale behind this special case.
- if (!(innerTypeDefinition instanceof LeafrefTypeDefinition)
- && !(innerTypeDefinition instanceof IdentityrefTypeDefinition)) {
- Type returnType = null;
- if (innerTypeDefinition.getBaseType() != null) {
- returnType = provideGeneratedTOFromExtendedType(typedef, innerTypeDefinition, basePackageName,
- module.getName());
- } else if (innerTypeDefinition instanceof UnionTypeDefinition) {
- final GeneratedTOBuilder genTOBuilder = provideGeneratedTOBuilderForUnionTypeDef(basePackageName,
- (UnionTypeDefinition) innerTypeDefinition, typedefName, typedef);
- genTOBuilder.setTypedef(true);
- genTOBuilder.setIsUnion(true);
- addUnitsToGenTO(genTOBuilder, typedef.getUnits().orElse(null));
- makeSerializable(genTOBuilder);
- returnType = genTOBuilder.build();
- // union builder
- final GeneratedTOBuilder unionBuilder = newGeneratedTOBuilder(genTOBuilder.getPackageName(),
- genTOBuilder.getName() + "Builder");
- unionBuilder.setIsUnionBuilder(true);
- final MethodSignatureBuilder method = unionBuilder.addMethod("getDefaultInstance");
- method.setReturnType(returnType);
- method.addParameter(Types.STRING, "defaultValue");
- method.setAccessModifier(AccessModifier.PUBLIC);
- method.setStatic(true);
- Set<Type> types = additionalTypes.get(module);
- if (types == null) {
- types = Sets.<Type> newHashSet(unionBuilder.build());
- additionalTypes.put(module, types);
- } else {
- types.add(unionBuilder.build());
- }
- } else if (innerTypeDefinition instanceof EnumTypeDefinition) {
- // enums are automatically Serializable
- final EnumTypeDefinition enumTypeDef = (EnumTypeDefinition) innerTypeDefinition;
- // TODO units for typedef enum
- returnType = provideTypeForEnum(enumTypeDef, typedefName, typedef);
- } else if (innerTypeDefinition instanceof BitsTypeDefinition) {
- final BitsTypeDefinition bitsTypeDefinition = (BitsTypeDefinition) innerTypeDefinition;
- final GeneratedTOBuilder genTOBuilder = provideGeneratedTOBuilderForBitsTypeDefinition(
- basePackageName, bitsTypeDefinition, typedefName, module.getName());
- genTOBuilder.setTypedef(true);
- addUnitsToGenTO(genTOBuilder, typedef.getUnits().orElse(null));
- makeSerializable(genTOBuilder);
- returnType = genTOBuilder.build();
- } else {
- final Type javaType = javaTypeForSchemaDefinitionType(innerTypeDefinition, typedef);
- returnType = wrapJavaTypeIntoTO(basePackageName, typedef, javaType, module.getName());
- }
- if (returnType != null) {
- final Map<Optional<Revision>, Map<String, Type>> modulesByDate =
- genTypeDefsContextMap.get(moduleName);
- Map<String, Type> typeMap = modulesByDate.get(moduleRevision);
- if (typeMap != null) {
- if (typeMap.isEmpty()) {
- typeMap = new HashMap<>(4);
- modulesByDate.put(moduleRevision, typeMap);
- }
- typeMap.put(typedefName, returnType);
- }
- return returnType;
+ final TypeDefinition<?> innerTypedef = typedef.getBaseType();
+
+ // See generatedTypeForExtendedDefinitionType() above for rationale behind this special case.
+ if (innerTypedef instanceof LeafrefTypeDefinition || innerTypedef instanceof IdentityrefTypeDefinition) {
+ return null;
+ }
+
+ final String typedefName = typedef.getQName().getLocalName();
+
+ final Type returnType;
+ if (innerTypedef.getBaseType() != null) {
+ returnType = provideGeneratedTOFromExtendedType(typedef, innerTypedef, basePackageName,
+ module.getName());
+ } else if (innerTypedef instanceof UnionTypeDefinition) {
+ final GeneratedTOBuilder genTOBuilder = provideGeneratedTOBuilderForUnionTypeDef(
+ JavaTypeName.create(basePackageName, BindingMapping.getClassName(typedef.getQName())),
+ (UnionTypeDefinition) innerTypedef, typedef);
+ genTOBuilder.setTypedef(true);
+ genTOBuilder.setIsUnion(true);
+ addUnitsToGenTO(genTOBuilder, typedef.getUnits().orElse(null));
+ makeSerializable(genTOBuilder);
+ returnType = genTOBuilder.build();
+
+ // Define a corresponding union builder. Typedefs are always anchored at a Java package root,
+ // so we are placing the builder alongside the union.
+ final GeneratedTOBuilder unionBuilder = newGeneratedTOBuilder(
+ JavaTypeName.create(genTOBuilder.getPackageName(), genTOBuilder.getName() + "Builder"));
+ unionBuilder.setIsUnionBuilder(true);
+ final MethodSignatureBuilder method = unionBuilder.addMethod("getDefaultInstance");
+ method.setReturnType(returnType);
+ method.addParameter(Types.STRING, "defaultValue");
+ method.setAccessModifier(AccessModifier.PUBLIC);
+ method.setStatic(true);
+ Set<Type> types = additionalTypes.get(module);
+ if (types == null) {
+ types = Sets.<Type> newHashSet(unionBuilder.build());
+ additionalTypes.put(module, types);
+ } else {
+ types.add(unionBuilder.build());
+ }
+ } else if (innerTypedef instanceof EnumTypeDefinition) {
+ // enums are automatically Serializable
+ final EnumTypeDefinition enumTypeDef = (EnumTypeDefinition) innerTypedef;
+ // TODO units for typedef enum
+ returnType = provideTypeForEnum(enumTypeDef, typedefName, typedef);
+ } else if (innerTypedef instanceof BitsTypeDefinition) {
+ final GeneratedTOBuilder genTOBuilder = provideGeneratedTOBuilderForBitsTypeDefinition(
+ JavaTypeName.create(basePackageName, BindingMapping.getClassName(typedef.getQName())),
+ (BitsTypeDefinition) innerTypedef, module.getName());
+ genTOBuilder.setTypedef(true);
+ addUnitsToGenTO(genTOBuilder, typedef.getUnits().orElse(null));
+ makeSerializable(genTOBuilder);
+ returnType = genTOBuilder.build();
+ } else {
+ final Type javaType = javaTypeForSchemaDefinitionType(innerTypedef, typedef);
+ returnType = wrapJavaTypeIntoTO(basePackageName, typedef, javaType, module.getName());
+ }
+ if (returnType != null) {
+ final Map<Optional<Revision>, Map<String, Type>> modulesByDate =
+ genTypeDefsContextMap.get(module.getName());
+ final Optional<Revision> moduleRevision = module.getRevision();
+ Map<String, Type> typeMap = modulesByDate.get(moduleRevision);
+ if (typeMap != null) {
+ if (typeMap.isEmpty()) {
+ typeMap = new HashMap<>(4);
+ modulesByDate.put(moduleRevision, typeMap);
}
+ typeMap.put(typedefName, returnType);
}
+ return returnType;
}
return null;
}
genTOBuilder.addHashIdentity(genPropBuilder);
genTOBuilder.addToStringProperty(genPropBuilder);
if (typedef.getStatus() == Status.DEPRECATED) {
- genTOBuilder.addAnnotation("", "Deprecated");
+ genTOBuilder.addAnnotation("java.lang", "Deprecated");
}
if (javaType instanceof ConcreteType && "String".equals(javaType.getName()) && typedef.getBaseType() != null) {
addStringRegExAsConstant(genTOBuilder, resolveRegExpressionsFromTypedef(typedef));
* Converts output list of generated TO builders to one TO builder (first
* from list) which contains the remaining builders as its enclosing TO.
*
- * @param basePackageName
- * string with name of package to which the module belongs
- * @param typedef
- * type definition which should be of type
- * <code>UnionTypeDefinition</code>
- * @param typeDefName
- * string with name for generated TO
- * @return generated TO builder with the list of enclosed generated TO
- * builders
+ * @param typeName new type identifier
+ * @param typedef type definition which should be of type {@link UnionTypeDefinition}
+ * @return generated TO builder with the list of enclosed generated TO builders
*/
- public GeneratedTOBuilder provideGeneratedTOBuilderForUnionTypeDef(final String basePackageName,
- final UnionTypeDefinition typedef, final String typeDefName, final SchemaNode parentNode) {
- final List<GeneratedTOBuilder> builders = provideGeneratedTOBuildersForUnionTypeDef(basePackageName,
- typedef, typeDefName, parentNode);
+ public GeneratedTOBuilder provideGeneratedTOBuilderForUnionTypeDef(final JavaTypeName typeName,
+ final UnionTypeDefinition typedef, final TypeDefinition<?> parentNode) {
+ final List<GeneratedTOBuilder> builders = provideGeneratedTOBuildersForUnionTypeDef(typeName, typedef,
+ parentNode);
Preconditions.checkState(!builders.isEmpty(), "No GeneratedTOBuilder objects generated from union %s", typedef);
final GeneratedTOBuilder resultTOBuilder = builders.remove(0);
* <code>typeDefName</code>. Every union type from <code>typedef</code> is
* added to generated TO builder as property.
*
- * @param basePackageName
- * string with name of package to which the module belongs
+ * @param typeName new type identifier
* @param typedef
* type definition which should be of type
* <code>UnionTypeDefinition</code>
- * @param typeDefName
- * string with name for generated TO
* @return generated TO builder which represents <code>typedef</code>
* @throws NullPointerException
* <ul>
* <li>if Qname of <code>typedef</code> is null</li>
* </ul>
*/
- public List<GeneratedTOBuilder> provideGeneratedTOBuildersForUnionTypeDef(final String basePackageName,
- final UnionTypeDefinition typedef, final String typeDefName, final SchemaNode parentNode) {
- Preconditions.checkNotNull(basePackageName, "Base Package Name cannot be NULL!");
+ public List<GeneratedTOBuilder> provideGeneratedTOBuildersForUnionTypeDef(final JavaTypeName typeName,
+ final UnionTypeDefinition typedef, final SchemaNode parentNode) {
Preconditions.checkNotNull(typedef, "Type Definition cannot be NULL!");
Preconditions.checkNotNull(typedef.getQName(), "Type definition QName cannot be NULL!");
final List<TypeDefinition<?>> unionTypes = typedef.getTypes();
final Module module = findParentModule(schemaContext, parentNode);
- final GeneratedTOBuilder unionGenTOBuilder;
- if (typeDefName != null && !typeDefName.isEmpty()) {
- final String typeName = BindingMapping.getClassName(typeDefName);
- unionGenTOBuilder = newGeneratedTOBuilder(basePackageName, typeName);
- unionGenTOBuilder.setSchemaPath(typedef.getPath());
- unionGenTOBuilder.setModuleName(module.getName());
- addCodegenInformation(unionGenTOBuilder, typedef);
- } else {
- unionGenTOBuilder = typedefToTransferObject(basePackageName, typedef, module.getName());
- }
+ final GeneratedTOBuilder unionGenTOBuilder = newGeneratedTOBuilder(typeName);
+ unionGenTOBuilder.setSchemaPath(typedef.getPath());
+ unionGenTOBuilder.setModuleName(module.getName());
+ addCodegenInformation(unionGenTOBuilder, typedef);
generatedTOBuilders.add(unionGenTOBuilder);
unionGenTOBuilder.setIsUnion(true);
resolveExtendedSubtypeAsUnion(unionGenTOBuilder, unionType, expressions, parentNode);
} else if (unionType instanceof UnionTypeDefinition) {
generatedTOBuilders.addAll(resolveUnionSubtypeAsUnion(unionGenTOBuilder,
- (UnionTypeDefinition) unionType, basePackageName, parentNode));
+ (UnionTypeDefinition) unionType, parentNode));
} else if (unionType instanceof EnumTypeDefinition) {
final Enumeration enumeration = addInnerEnumerationToTypeBuilder((EnumTypeDefinition) unionType,
unionTypeName, unionGenTOBuilder);
* <code>provideGeneratedTOBuildersForUnionTypeDef</code> method.
*/
private List<GeneratedTOBuilder> resolveUnionSubtypeAsUnion(final GeneratedTOBuilder parentUnionGenTOBuilder,
- final UnionTypeDefinition unionSubtype, final String basePackageName, final SchemaNode parentNode) {
- final String newTOBuilderName = provideAvailableNameForGenTOBuilder(parentUnionGenTOBuilder.getName());
+ final UnionTypeDefinition unionSubtype, final SchemaNode parentNode) {
+ final JavaTypeName newTOBuilderName = parentUnionGenTOBuilder.getIdentifier().createSibling(
+ provideAvailableNameForGenTOBuilder(parentUnionGenTOBuilder.getName()));
final List<GeneratedTOBuilder> subUnionGenTOBUilders = provideGeneratedTOBuildersForUnionTypeDef(
- basePackageName, unionSubtype, newTOBuilderName, parentNode);
+ newTOBuilderName, unionSubtype, parentNode);
final GeneratedPropertyBuilder propertyBuilder;
- propertyBuilder = parentUnionGenTOBuilder.addProperty(BindingMapping.getPropertyName(newTOBuilderName));
+ propertyBuilder = parentUnionGenTOBuilder.addProperty(BindingMapping.getPropertyName(
+ newTOBuilderName.simpleName()));
propertyBuilder.setReturnType(subUnionGenTOBUilders.get(0));
parentUnionGenTOBuilder.addEqualsIdentity(propertyBuilder);
parentUnionGenTOBuilder.addToStringProperty(propertyBuilder);
*/
private GeneratedTOBuilder typedefToTransferObject(final String basePackageName,
final TypeDefinition<?> typedef, final String moduleName) {
-
- final String packageName = BindingGeneratorUtil.packageNameForGeneratedType(basePackageName, typedef.getPath());
- final String typeDefTOName = typedef.getQName().getLocalName();
-
- if (packageName != null && typeDefTOName != null) {
- final String genTOName = BindingMapping.getClassName(typeDefTOName);
- final GeneratedTOBuilder newType = newGeneratedTOBuilder(packageName, genTOName);
- newType.setSchemaPath(typedef.getPath());
- newType.setModuleName(moduleName);
- addCodegenInformation(newType, typedef);
- return newType;
- }
- return null;
+ final GeneratedTOBuilder newType = newGeneratedTOBuilder(JavaTypeName.create(
+ BindingGeneratorUtil.packageNameForGeneratedType(basePackageName, typedef.getPath()),
+ BindingMapping.getClassName(typedef.getQName().getLocalName())));
+ newType.setSchemaPath(typedef.getPath());
+ newType.setModuleName(moduleName);
+ addCodegenInformation(newType, typedef);
+ return newType;
}
/**
* All the bits of the typeDef are added to returning generated TO as
* properties.
*
- * @param basePackageName
- * string with name of package to which the module belongs
+ * @param typeName new type identifier
* @param typeDef
* type definition from which is the generated TO builder created
- * @param typeDefName
- * string with the name for generated TO builder
* @return generated TO builder which represents <code>typeDef</code>
* @throws IllegalArgumentException
* <ul>
* <li>if <code>basePackageName</code> equals null</li>
* </ul>
*/
- public GeneratedTOBuilder provideGeneratedTOBuilderForBitsTypeDefinition(final String basePackageName,
- final TypeDefinition<?> typeDef, final String typeDefName, final String moduleName) {
-
- Preconditions.checkArgument(typeDef != null, "typeDef cannot be NULL!");
- Preconditions.checkArgument(basePackageName != null, "Base Package Name cannot be NULL!");
-
- if (typeDef instanceof BitsTypeDefinition) {
- final BitsTypeDefinition bitsTypeDefinition = (BitsTypeDefinition) typeDef;
-
- final String typeName = BindingMapping.getClassName(typeDefName);
- final GeneratedTOBuilder genTOBuilder = newGeneratedTOBuilder(basePackageName, typeName);
- genTOBuilder.setSchemaPath(typeDef.getPath());
- genTOBuilder.setModuleName(moduleName);
- genTOBuilder.setBaseType(typeDef);
- addCodegenInformation(genTOBuilder, typeDef);
-
- final List<Bit> bitList = bitsTypeDefinition.getBits();
- GeneratedPropertyBuilder genPropertyBuilder;
- for (Bit bit : bitList) {
- final String name = bit.getName();
- genPropertyBuilder = genTOBuilder.addProperty(BindingMapping.getPropertyName(name));
- genPropertyBuilder.setReadOnly(true);
- genPropertyBuilder.setReturnType(BaseYangTypes.BOOLEAN_TYPE);
-
- genTOBuilder.addEqualsIdentity(genPropertyBuilder);
- genTOBuilder.addHashIdentity(genPropertyBuilder);
- genTOBuilder.addToStringProperty(genPropertyBuilder);
- }
-
- return genTOBuilder;
+ public GeneratedTOBuilder provideGeneratedTOBuilderForBitsTypeDefinition(final JavaTypeName typeName,
+ final BitsTypeDefinition typeDef, final String moduleName) {
+ final GeneratedTOBuilder genTOBuilder = newGeneratedTOBuilder(typeName);
+ genTOBuilder.setSchemaPath(typeDef.getPath());
+ genTOBuilder.setModuleName(moduleName);
+ genTOBuilder.setBaseType(typeDef);
+ addCodegenInformation(genTOBuilder, typeDef);
+
+ final List<Bit> bitList = typeDef.getBits();
+ GeneratedPropertyBuilder genPropertyBuilder;
+ for (Bit bit : bitList) {
+ final String name = bit.getName();
+ genPropertyBuilder = genTOBuilder.addProperty(BindingMapping.getPropertyName(name));
+ genPropertyBuilder.setReadOnly(true);
+ genPropertyBuilder.setReturnType(BaseYangTypes.BOOLEAN_TYPE);
+
+ genTOBuilder.addEqualsIdentity(genPropertyBuilder);
+ genTOBuilder.addHashIdentity(genPropertyBuilder);
+ genTOBuilder.addToStringProperty(genPropertyBuilder);
}
- return null;
+
+ return genTOBuilder;
}
/**
Preconditions.checkArgument(innerExtendedType != null, "Extended type cannot be NULL!");
Preconditions.checkArgument(basePackageName != null, "String with base package name cannot be NULL!");
- final String typedefName = typedef.getQName().getLocalName();
- final String classTypedefName = BindingMapping.getClassName(typedefName);
- final String innerTypeDef = innerExtendedType.getQName().getLocalName();
- final GeneratedTOBuilder genTOBuilder = newGeneratedTOBuilder(basePackageName, classTypedefName);
+ final GeneratedTOBuilder genTOBuilder = newGeneratedTOBuilder(JavaTypeName.create(basePackageName,
+ BindingMapping.getClassName(typedef.getQName())));
genTOBuilder.setSchemaPath(typedef.getPath());
genTOBuilder.setModuleName(moduleName);
genTOBuilder.setTypedef(true);
final Restrictions r = BindingGeneratorUtil.getRestrictions(typedef);
genTOBuilder.setRestrictions(r);
if (typedef.getStatus() == Status.DEPRECATED) {
- genTOBuilder.addAnnotation("", "Deprecated");
+ genTOBuilder.addAnnotation("java.lang", "Deprecated");
}
if (baseTypeDefForExtendedType(innerExtendedType) instanceof UnionTypeDefinition) {
}
if (typeMap != null) {
+ final String innerTypeDef = innerExtendedType.getQName().getLocalName();
final Type type = typeMap.get(innerTypeDef);
if (type instanceof GeneratedTransferObject) {
genTOBuilder.setExtendsType((GeneratedTransferObject) type);
* integer suffix is incremented by one. If <code>name</code> contains no
* number suffix then number 1 is added.
*
- * @param name
- * string with name of augmented node
+ * @param name string with name of augmented node
* @return string with the number suffix incremented by one (or 1 is added)
*/
private static String provideAvailableNameForGenTOBuilder(final String name) {
import org.opendaylight.mdsal.binding.generator.spi.TypeProvider;
import org.opendaylight.mdsal.binding.model.api.Restrictions;
import org.opendaylight.mdsal.binding.model.api.Type;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.util.Types;
import org.opendaylight.yangtools.yang.binding.BindingMapping;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
/**
* <code>Type</code> representation of <code>binary</code> YANG type
*/
- public static final Type BINARY_TYPE = Types.primitiveType("byte[]", null);
+ public static final Type BINARY_TYPE = Types.typeForClass(byte[].class);
public static final Type INSTANCE_IDENTIFIER = Types.parameterizedTypeFor(Types
.typeForClass(InstanceIdentifier.class));
String typeName = type.getQName().getLocalName();
switch (typeName) {
case "binary":
- return restrictions == null ? Types.BYTE_ARRAY : Types.primitiveType("byte[]", restrictions);
+ return restrictions == null ? Types.BYTE_ARRAY : Types.typeForClass(byte[].class, restrictions);
case "decimal64":
return Types.typeForClass(BigDecimal.class, restrictions);
case "enumeration":
return Types.getDefaultRestrictions(min, max);
}
+ // FIXME: why do we even have this class?
public static final class UnionType implements Type {
@Override
public String getPackageName() {
return null;
}
+
@Override
public String getName() {
return "Union";
}
+
@Override
public String getFullyQualifiedName() {
return "Union";
}
+
+ @Override
+ public JavaTypeName getIdentifier() {
+ return null;
+ }
}
}
import java.util.List;
import java.util.Map;
import java.util.Optional;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.type.builder.EnumBuilder;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTOBuilder;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
}
@Override
- public GeneratedTOBuilder newGeneratedTOBuilder(final String packageName, final String name) {
- return new CodegenGeneratedTOBuilder(packageName, name);
+ public GeneratedTOBuilder newGeneratedTOBuilder(final JavaTypeName identifier) {
+ return new CodegenGeneratedTOBuilder(identifier);
}
@Override
- public GeneratedTypeBuilder newGeneratedTypeBuilder(final String packageName, final String name) {
- return new CodegenGeneratedTypeBuilder(packageName, name);
+ public GeneratedTypeBuilder newGeneratedTypeBuilder(final JavaTypeName identifier) {
+ return new CodegenGeneratedTypeBuilder(identifier);
}
@Override
- public AbstractEnumerationBuilder newEnumerationBuilder(final String packageName, final String name) {
- return new CodegenEnumerationBuilder(packageName, name);
+ public AbstractEnumerationBuilder newEnumerationBuilder(final JavaTypeName identifier) {
+ return new CodegenEnumerationBuilder(identifier);
}
}
import com.google.common.collect.ImmutableMap;
import java.util.List;
import java.util.Map;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.type.builder.EnumBuilder;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTOBuilder;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
}
@Override
- public GeneratedTOBuilder newGeneratedTOBuilder(final String packageName, final String name) {
- return new RuntimeGeneratedTOBuilder(packageName, name);
+ public GeneratedTOBuilder newGeneratedTOBuilder(final JavaTypeName identifier) {
+ return new RuntimeGeneratedTOBuilder(identifier);
}
@Override
- public GeneratedTypeBuilder newGeneratedTypeBuilder(final String packageName, final String name) {
- return new RuntimeGeneratedTypeBuilder(packageName, name);
+ public GeneratedTypeBuilder newGeneratedTypeBuilder(final JavaTypeName identifier) {
+ return new RuntimeGeneratedTypeBuilder(identifier);
}
@Override
- public AbstractEnumerationBuilder newEnumerationBuilder(final String packageName, final String name) {
- return new RuntimeEnumerationBuilder(packageName, name);
+ public AbstractEnumerationBuilder newEnumerationBuilder(final JavaTypeName identifier) {
+ return new RuntimeEnumerationBuilder(identifier);
}
}
assertEquals("Lf TO has incorrect number of occurences.", 1, lfLeafCounter);
assertEquals("Lf has incorrect package name.",
"org.opendaylight.yang.gen.v1.urn.bit.union.in.leaf.rev130626.ParentContainer",
- lfLeaf.getPackageName());
+ lfLeaf.getIdentifier().immediatelyEnclosingClass().get().toString());
assertEquals("Lf generated TO has incorrect number of properties", 3, lfLeaf.getProperties().size());
containsAttributes(lfLeaf, true, true, true, new NameTypePattern("string", "String"));
assertEquals("Lf1 TO has incorrect number of occurences.", 1, lf1LeafCounter);
assertEquals("Lf1 has incorrect package name.",
"org.opendaylight.yang.gen.v1.urn.bit.union.in.leaf.rev130626.ParentContainer",
- lf1Leaf.getPackageName());
+ lf1Leaf.getIdentifier().immediatelyEnclosingClass().get().toString());
assertEquals("Lf generated TO has incorrect number of properties", 4, lf1Leaf.getProperties().size());
containsAttributes(lf1Leaf, true, true, true, new NameTypePattern("uint32", "Long"));
assertEquals("Lf2 TO has incorrect number of occurences.", 1, lf2LeafCounter);
assertEquals("Lf2 has incorrect package name.",
"org.opendaylight.yang.gen.v1.urn.bit.union.in.leaf.rev130626.ParentContainer",
- lf2Leaf.getPackageName());
+ lf2Leaf.getIdentifier().immediatelyEnclosingClass().get().toString());
assertEquals("Lf generated TO has incorrect number of properties", 2, lf2Leaf.getProperties().size());
containsAttributes(lf2Leaf, true, true, true, new NameTypePattern("string", "String"));
assertEquals("BitLeaf has incorrect package name.",
"org.opendaylight.yang.gen.v1.urn.bit.union.in.leaf.rev130626.ParentContainer",
- bitLeaf.getPackageName());
+ bitLeaf.getIdentifier().immediatelyEnclosingClass().get().toString());
assertEquals("UnionLeaf has incorrect package name.",
"org.opendaylight.yang.gen.v1.urn.bit.union.in.leaf.rev130626.ParentContainer",
- bitLeaf.getPackageName());
+ unionLeaf.getIdentifier().immediatelyEnclosingClass().get().toString());
List<GeneratedProperty> propertiesBitLeaf = bitLeaf.getProperties();
GeneratedProperty firstBitProperty = null;
assertNotNull("Expected Referenced Enum LinkUpDownTrapEnable, but was NULL!", linkUpDownTrapEnable);
assertTrue("Expected LinkUpDownTrapEnable of type Enumeration", linkUpDownTrapEnable instanceof Enumeration);
- assertEquals(linkUpDownTrapEnable.getPackageName(),
- "org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev121115.interfaces.Interface");
+ assertEquals(
+ "org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev121115.interfaces.Interface",
+ linkUpDownTrapEnable.getIdentifier().immediatelyEnclosingClass().get().toString());
assertNotNull("Expected Referenced Enum OperStatus, but was NULL!", operStatus);
assertTrue("Expected OperStatus of type Enumeration", operStatus instanceof Enumeration);
- assertEquals(operStatus.getPackageName(),
- "org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev121115.interfaces.Interface");
+ assertEquals(
+ "org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev121115.interfaces.Interface",
+ operStatus.getIdentifier().immediatelyEnclosingClass().get().toString());
}
}
assertNotNull("Generated type for RPC test input wasn't generated", rpcTestInput);
assertEquals("RpcTestInput interface - incorrect number of occurences", 1, rpcTestInputCounter);
- assertEquals("RpcTestInput isn't in correct package",
- "org.opendaylight.yang.gen.v1.urn.grouping.uses.rpc.rev130718", rpcTestInput.getPackageName());
+ assertEquals("RpcTestInput isn't in correct package", "org.opendaylight.yang.gen.v1.urn.grouping.uses.rpc.rev130718",
+ rpcTestInput.getPackageName());
assertNotNull("Generated type for RPC test output wasn't generated", rpcTestOutput);
assertEquals("RpcTestOutput interface - incorrect number of occurences", 1, rpcTestOutputCounter);
import java.util.NoSuchElementException;
import org.junit.Test;
import org.opendaylight.mdsal.binding.model.api.Type;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.util.generated.type.builder.CodegenGeneratedTypeBuilder;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
final AbstractTypeProvider typeProvider = new RuntimeTypeProvider(schemaContext);
final SchemaPath refTypePath = SchemaPath.create(true, QName.create("", "cont1"), QName.create("", "list1"));
- final CodegenGeneratedTypeBuilder refType = new CodegenGeneratedTypeBuilder("org.opendaylight.yangtools.test",
- "TestType");
+ final CodegenGeneratedTypeBuilder refType = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("org.opendaylight.yangtools.test", "TestType"));
typeProvider.putReferencedType(refTypePath, refType);
final StringTypeDefinition stringType = BaseTypes.stringType();
import org.opendaylight.mdsal.binding.model.api.ConcreteType;
import org.opendaylight.mdsal.binding.model.api.Enumeration;
import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.ParameterizedType;
import org.opendaylight.mdsal.binding.model.api.Restrictions;
import org.opendaylight.mdsal.binding.model.api.Type;
import org.opendaylight.mdsal.binding.model.util.BindingGeneratorUtil;
import org.opendaylight.mdsal.binding.model.util.ReferencedTypeImpl;
import org.opendaylight.mdsal.binding.model.util.generated.type.builder.CodegenGeneratedTOBuilder;
+import org.opendaylight.yangtools.yang.binding.BindingMapping;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
final TypeDefinition<?> enumLeafTypedef = enumLeafNode.getType();
Type enumType = provider.javaTypeForSchemaDefinitionType(enumLeafTypedef, enumLeafNode);
- Type refType = new ReferencedTypeImpl(enumType.getPackageName(), enumType.getName());
+ Type refType = new ReferencedTypeImpl(enumType.getIdentifier());
provider.putReferencedType(enumLeafNode.getPath(), refType);
final LeafListSchemaNode enumListNode = provideLeafListNodeFromTopLevelContainer(this.testTypeProviderModule,
final TypeDefinition<?> enumLeafListTypedef = enumListNode.getType();
enumType = provider.javaTypeForSchemaDefinitionType(enumLeafListTypedef, enumListNode);
- refType = new ReferencedTypeImpl(enumType.getPackageName(), enumType.getPackageName());
+ refType = new ReferencedTypeImpl(enumType.getIdentifier());
provider.putReferencedType(enumListNode.getPath(), refType);
}
assertNotNull(unionTypeDef);
assertTrue(unionTypeDef.getBaseType() instanceof UnionTypeDefinition);
- GeneratedTOBuilder unionTypeBuilder = provider.provideGeneratedTOBuilderForUnionTypeDef("test.package.name",
- (UnionTypeDefinition)unionTypeDef.getBaseType(), "ComplexUnionType", unionTypeDef);
+ GeneratedTOBuilder unionTypeBuilder = provider.provideGeneratedTOBuilderForUnionTypeDef(
+ JavaTypeName.create("test.package.name", BindingMapping.getClassName(unionTypeDef.getQName())),
+ (UnionTypeDefinition)unionTypeDef.getBaseType(), unionTypeDef);
assertNotNull(unionTypeBuilder);
GeneratedTransferObject unionType = unionTypeBuilder.build();
- assertEquals("ComplexUnionType", unionType.getName());
-
- unionTypeBuilder = provider.provideGeneratedTOBuilderForUnionTypeDef("test.package.name",
- (UnionTypeDefinition)unionTypeDef.getBaseType(), "", unionTypeDef);
-
- assertNotNull(unionTypeBuilder);
-
- unionType = unionTypeBuilder.build();
- assertEquals("Union", unionType.getName());
-
- unionTypeBuilder = provider.provideGeneratedTOBuilderForUnionTypeDef("test.package.name",
- (UnionTypeDefinition)unionTypeDef.getBaseType(), null, unionTypeDef);
-
- assertNotNull(unionTypeBuilder);
-
- unionType = unionTypeBuilder.build();
- assertEquals("Union", unionType.getName());
+ assertEquals("ComplexUnion", unionType.getName());
}
@Test
assertNotNull(unionTypeDef);
assertTrue(unionTypeDef.getBaseType() instanceof UnionTypeDefinition);
final GeneratedTOBuilder unionTypeBuilder = provider.provideGeneratedTOBuilderForUnionTypeDef(
- "test.package.name",(UnionTypeDefinition)unionTypeDef.getBaseType(), "ComplexStringIntUnionType",
- unionTypeDef);
+ JavaTypeName.create("test.package.name", BindingMapping.getClassName(unionTypeDef.getQName())),
+ (UnionTypeDefinition)unionTypeDef.getBaseType(), unionTypeDef);
assertNotNull(unionTypeBuilder);
final GeneratedTransferObject unionType = unionTypeBuilder.build();
- assertEquals("ComplexStringIntUnionType", unionType.getName());
+ assertEquals("ComplexStringIntUnion", unionType.getName());
}
@Test
final Module baseYangTypes = resolveModule("test-type-provider");
- final TypeDefinition<?> aesIdentityrefType = resolveTypeDefinitionFromModule(baseYangTypes, "aes-identityref-type");
+ final TypeDefinition<?> aesIdentityrefType = resolveTypeDefinitionFromModule(baseYangTypes,
+ "aes-identityref-type");
assertNotNull(aesIdentityrefType);
final Type extType = provider.generatedTypeForExtendedDefinitionType(aesIdentityrefType, aesIdentityrefType);
assertEquals(null, extType);
}
- @Test(expected = IllegalArgumentException.class)
+ @Test(expected = NullPointerException.class)
public void provideGeneratedTOBuilderForBitsTypeDefinitionWithNullTypedefTest() {
final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
- provider.provideGeneratedTOBuilderForBitsTypeDefinition("", null, "", "");
- }
-
- @Test(expected = IllegalArgumentException.class)
- public void provideGeneratedTOBuilderForBitsTypeDefinitionWithBasePackageNullTest() {
- final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
- final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "foo", "yang-int8-type");
- final TypeDefinition<?> leafType = leaf.getType();
- provider.provideGeneratedTOBuilderForBitsTypeDefinition(null, leafType, "", "");
- }
-
- @Test
- public void provideGeneratedTOBuilderForBitsTypeDefinitionWithNonBitsTypedefTest() {
- final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
-
- final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "foo", "yang-int8-type");
- final TypeDefinition<?> leafType = leaf.getType();
- final Type type = provider.provideGeneratedTOBuilderForBitsTypeDefinition("", leafType, "", "");
-
- assertEquals(null, type);
+ provider.provideGeneratedTOBuilderForBitsTypeDefinition(JavaTypeName.create("foo", "foo"), null, "foo");
}
@Test
public void getConstructorPropertyNameTest() {
final TypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
- final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "foo", "yang-int8-type");
+ final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "foo",
+ "yang-int8-type");
final TypeDefinition<?> leafType = leaf.getType();
final String ctorPropertyName = provider.getConstructorPropertyName(leafType);
public void getParamNameFromTypeTest() {
final TypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
- final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "foo", "yang-int8-type");
+ final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "foo",
+ "yang-int8-type");
final TypeDefinition<?> leafType = leaf.getType();
final String paramName = provider.getParamNameFromType(leafType);
@Test
public void addUnitsToGenTOTest() {
- final GeneratedTOBuilder builder = new CodegenGeneratedTOBuilder("test.package", "TestBuilder");
+ final GeneratedTOBuilder builder = new CodegenGeneratedTOBuilder(
+ JavaTypeName.create("test.package", "TestBuilder"));
CodegenTypeProvider.addUnitsToGenTO(builder, null);
GeneratedTransferObject genTO = builder.build();
*/
package org.opendaylight.mdsal.binding.model.util;
-import java.util.Objects;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.Type;
/**
* It is used only as ancestor for other <code>Type</code>s
*/
public class AbstractBaseType implements Type {
-
- /**
- * Name of the package to which this <code>Type</code> belongs.
- */
- private final String packageName;
-
/**
* Name of this <code>Type</code>.
*/
- private final String name;
-
- @Override
- public String getPackageName() {
- return this.packageName;
- }
+ private final JavaTypeName identifier;
@Override
- public String getName() {
- return this.name;
- }
-
- @Override
- public String getFullyQualifiedName() {
- if (this.packageName.isEmpty()) {
- return this.name;
- } else {
- return this.packageName + "." + this.name;
- }
+ public final JavaTypeName getIdentifier() {
+ return this.identifier;
}
/**
- * Constructs the instance of this class with the concrete package name type
- * name.
+ * Constructs the instance of this class with a JavaTypeName.
*
- * @param pkName
- * string with the package name to which this <code>Type</code>
- * belongs
- * @param name
- * string with the name for this <code>Type</code>
+ * @param identifier for this <code>Type</code>
*/
- protected AbstractBaseType(final String pkName, final String name) {
- if (pkName == null) {
- throw new IllegalArgumentException("Package Name for Generated Type cannot be null!");
- }
- if (name == null) {
- throw new IllegalArgumentException("Name of Generated Type cannot be null!");
+ protected AbstractBaseType(final JavaTypeName identifier) {
+ if (identifier == null) {
+ throw new IllegalArgumentException("Identifier for Generated Type cannot be null!");
}
- this.packageName = pkName;
- this.name = name;
+ this.identifier = identifier;
}
@Override
public int hashCode() {
- final int prime = 31;
- int result = 1;
- result = (prime * result) + Objects.hashCode(this.name);
- result = (prime * result) + Objects.hashCode(this.packageName);
- return result;
+ return identifier.hashCode();
}
@Override
return false;
}
final Type other = (Type) obj;
- return Objects.equals(this.name, other.getName()) && Objects.equals(this.packageName, other.getPackageName());
+ return identifier.equals(other.getIdentifier());
}
@Override
public String toString() {
- if (this.packageName.isEmpty()) {
- return "Type (" + this.name + ")";
- }
- return "Type (" + this.packageName + "." + this.name + ")";
+ return "Type (" + getFullyQualifiedName() + ")";
}
}
*/
package org.opendaylight.mdsal.binding.model.util;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
+
/**
*
* Wraps combination of <code>packageName</code> and <code>name</code> to the
/**
* Creates instance of this class with concrete package name and type name
*
- * @param packageName
- * string with the package name
- * @param name
- * string with the name for referenced type
+ * @param identifier JavaTypeName of the referenced type
*/
- public ReferencedTypeImpl(final String packageName, final String name) {
- super(packageName, name);
+ public ReferencedTypeImpl(final JavaTypeName identifier) {
+ super(identifier);
}
@Override
*/
package org.opendaylight.mdsal.binding.model.util;
-import com.google.common.base.CharMatcher;
import com.google.common.base.Preconditions;
-import com.google.common.base.Splitter;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.google.common.collect.ImmutableRangeSet;
-import com.google.common.collect.Iterables;
import com.google.common.collect.Range;
import com.google.common.collect.RangeSet;
import java.util.Collections;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.Future;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.mdsal.binding.model.api.BaseTypeWithRestrictions;
import org.opendaylight.mdsal.binding.model.api.ConcreteType;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.ParameterizedType;
import org.opendaylight.mdsal.binding.model.api.Restrictions;
import org.opendaylight.mdsal.binding.model.api.Type;
new CacheLoader<Class<?>, ConcreteType>() {
@Override
public ConcreteType load(final Class<?> key) {
- //Nested class
- if (key.getEnclosingClass() != null) {
- return new ConcreteTypeImpl(key.getEnclosingClass().getName(), key.getSimpleName(), null);
- } else {
- return new ConcreteTypeImpl(key.getPackage().getName(), key.getSimpleName(), null);
- }
+ return new ConcreteTypeImpl(JavaTypeName.create(key), null);
}
};
private static final LoadingCache<Class<?>, ConcreteType> TYPE_CACHE =
public static final ConcreteType FUTURE = typeForClass(Future.class);
public static final ConcreteType STRING = typeForClass(String.class);
public static final ConcreteType VOID = typeForClass(Void.class);
- public static final ConcreteType BYTE_ARRAY = primitiveType("byte[]", null);
- public static final ConcreteType CHAR_ARRAY = primitiveType("char[]", null);
- private static final Splitter DOT_SPLITTER = Splitter.on('.');
+ public static final ConcreteType BYTE_ARRAY = typeForClass(byte[].class);
+ public static final ConcreteType CHAR_ARRAY = typeForClass(char[].class);
/**
* It is not desirable to create instance of this class
return VOID;
}
- /**
- * Creates the instance of type
- * {@link org.opendaylight.mdsal.binding.model.api.ConcreteType
- * ConcreteType} which represents primitive JAVA type for which package
- * doesn't exist.
- *
- * @param primitiveType
- * string containing programmatic construction based on
- * primitive type (e.g byte[])
- * @param restrictions
- * restrictions object
- * @return <code>ConcreteType</code> instance which represents programmatic
- * construction with primitive JAVA type
- */
- public static ConcreteType primitiveType(final String primitiveType, final Restrictions restrictions) {
- return new ConcreteTypeImpl("", primitiveType, restrictions);
- }
-
/**
* Returns an instance of {@link ConcreteType} describing the class
*
if (restrictions == null) {
return typeForClass(cls);
}
+
+ final JavaTypeName identifier = JavaTypeName.create(cls);
if (restrictions instanceof DefaultRestrictions) {
- return new ConcreteTypeImpl(cls.getPackage().getName(), cls.getSimpleName(), restrictions);
+ return new ConcreteTypeImpl(identifier, restrictions);
}
- return new BaseTypeWithRestrictionsImpl(cls.getPackage().getName(), cls.getSimpleName(), restrictions);
+ return new BaseTypeWithRestrictionsImpl(identifier, restrictions);
}
/**
}
/**
- * Creates instance of type
- * {@link org.opendaylight.mdsal.binding.model.api.WildcardType
- * WildcardType}
+ * Creates instance of type {@link org.opendaylight.mdsal.binding.model.api.WildcardType}.
*
- * @param packageName
- * string with the package name
- * @param typeName
- * string with the type name
- * @return <code>WildcardType</code> representation of
- * <code>packageName</code> and <code>typeName</code>
+ * @param identifier JavaTypeName of the type
+ * @return <code>WildcardType</code> representation of specified identifier
*/
- public static WildcardType wildcardTypeFor(final String packageName, final String typeName) {
- return new WildcardTypeImpl(packageName, typeName);
+ public static WildcardType wildcardTypeFor(final JavaTypeName identifier) {
+ return new WildcardTypeImpl(identifier);
}
/**
return parameterizedTypeFor(augmentation, valueType);
}
-
- public static @Nullable String getOuterClassName(final Type valueType) {
- final String pkgName = valueType.getPackageName();
- if (CharMatcher.javaUpperCase().indexIn(pkgName) >= 0) {
- // It is inner class.
- return Iterables.getLast(DOT_SPLITTER.split(pkgName));
- }
- return null;
+ public static @Nullable String getOuterClassName(final Type valueType) {
+ return valueType.getIdentifier().immediatelyEnclosingClass().map(Object::toString).orElse(null);
}
/**
* @param name
* string with the name of the type
*/
- private ConcreteTypeImpl(final String pkName, final String name, final Restrictions restrictions) {
- super(pkName, name);
+ ConcreteTypeImpl(final JavaTypeName identifier, final Restrictions restrictions) {
+ super(identifier);
this.restrictions = restrictions;
}
* @param name
* string with the name of the type
*/
- private BaseTypeWithRestrictionsImpl(final String pkName, final String name, final Restrictions restrictions) {
- super(pkName, name);
+ BaseTypeWithRestrictionsImpl(final JavaTypeName identifier, final Restrictions restrictions) {
+ super(identifier);
this.restrictions = Preconditions.checkNotNull(restrictions);
}
* array of actual parameters
*/
public ParametrizedTypeImpl(final Type rawType, final Type[] actTypes) {
- super(rawType.getPackageName(), rawType.getName());
+ super(rawType.getIdentifier());
this.rawType = rawType;
this.actualTypes = actTypes.clone();
}
-
}
/**
* @param typeName
* string with the name of type
*/
- public WildcardTypeImpl(final String packageName, final String typeName) {
- super(packageName, typeName);
+ WildcardTypeImpl(final JavaTypeName identifier) {
+ super(identifier);
}
}
import org.opendaylight.mdsal.binding.model.api.GeneratedType;
import org.opendaylight.mdsal.binding.model.api.MethodSignature;
import org.opendaylight.mdsal.binding.model.api.Type;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.type.builder.AnnotationTypeBuilder;
import org.opendaylight.mdsal.binding.model.api.type.builder.EnumBuilder;
import org.opendaylight.mdsal.binding.model.util.AbstractBaseType;
private List<Enumeration.Pair> values = ImmutableList.of();
private List<AnnotationTypeBuilder> annotationBuilders = ImmutableList.of();
- AbstractEnumerationBuilder(final String packageName, final String name) {
- super(packageName, name);
+ AbstractEnumerationBuilder(final JavaTypeName identifier) {
+ super(identifier);
}
@Override
- public final AnnotationTypeBuilder addAnnotation(final String packageName, final String name) {
- if (packageName != null && name != null) {
- final AnnotationTypeBuilder builder = new AnnotationTypeBuilderImpl(packageName, name);
- if (!annotationBuilders.contains(builder)) {
- annotationBuilders = LazyCollections.lazyAdd(annotationBuilders, builder);
- return builder;
- }
+ public final AnnotationTypeBuilder addAnnotation(final JavaTypeName identifier) {
+ final AnnotationTypeBuilder builder = new AnnotationTypeBuilderImpl(identifier);
+ if (!annotationBuilders.contains(builder)) {
+ annotationBuilders = LazyCollections.lazyAdd(annotationBuilders, builder);
+ return builder;
}
return null;
}
private final List<Pair> values;
private final List<AnnotationType> annotations;
- public AbstractEnumeration(final AbstractEnumerationBuilder builder, final Type definingType) {
- super(builder.getPackageName(), builder.getName());
+ AbstractEnumeration(final AbstractEnumerationBuilder builder, final Type definingType) {
+ super(builder.getIdentifier());
this.definingType = definingType;
this.values = ImmutableList.copyOf(builder.values);
import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
import org.opendaylight.mdsal.binding.model.api.ParameterizedType;
import org.opendaylight.mdsal.binding.model.api.Type;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedPropertyBuilder;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTOBuilder;
import org.opendaylight.mdsal.binding.model.api.type.builder.MethodSignatureBuilder;
private boolean isUnionTypeBuilder = false;
private TypeDefinition<?> baseType = null;
- AbstractGeneratedTOBuilder(final String packageName, final String name) {
- super(packageName, name);
+ AbstractGeneratedTOBuilder(final JavaTypeName identifier) {
+ super(identifier);
setAbstract(false);
}
import org.opendaylight.mdsal.binding.model.api.MethodSignature;
import org.opendaylight.mdsal.binding.model.api.Type;
import org.opendaylight.mdsal.binding.model.api.TypeComment;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.YangSourceDefinition;
import org.opendaylight.mdsal.binding.model.api.type.builder.AnnotationTypeBuilder;
import org.opendaylight.mdsal.binding.model.api.type.builder.EnumBuilder;
private final boolean isAbstract;
private final YangSourceDefinition definition;
- public AbstractGeneratedType(final AbstractGeneratedTypeBuilder<?> builder) {
- super(builder.getPackageName(), builder.getName());
+ AbstractGeneratedType(final AbstractGeneratedTypeBuilder<?> builder) {
+ super(builder.getIdentifier());
this.parent = builder.getParent();
this.comment = builder.getComment();
this.annotations = toUnmodifiableAnnotations(builder.getAnnotations());
this.definition = builder.getYangSourceDefinition().orElse(null);
}
- public AbstractGeneratedType(final Type parent, final String packageName, final String name,
- final
TypeComment comment, final List<AnnotationTypeBuilder> annotationBuilders, final boolean isAbstract,
+ AbstractGeneratedType(final Type parent, final JavaTypeName identifier, 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,
final List<Constant> constants, final List<MethodSignatureBuilder> methodBuilders,
final List<GeneratedPropertyBuilder> propertyBuilders) {
- super(packageName, name);
+ super(identifier);
this.parent = parent;
this.comment = comment;
this.annotations = toUnmodifiableAnnotations(annotationBuilders);
import java.util.Optional;
import org.opendaylight.mdsal.binding.model.api.AccessModifier;
import org.opendaylight.mdsal.binding.model.api.Constant;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.Type;
import org.opendaylight.mdsal.binding.model.api.TypeComment;
import org.opendaylight.mdsal.binding.model.api.YangSourceDefinition;
private boolean isAbstract;
private YangSourceDefinition yangSourceDefinition;
- protected AbstractGeneratedTypeBuilder(final String packageName, final String name) {
- super(packageName, name);
+ protected AbstractGeneratedTypeBuilder(final JavaTypeName identifier) {
+ super(identifier);
}
protected TypeComment getComment() {
protected abstract T thisInstance();
- abstract AbstractEnumerationBuilder newEnumerationBuilder(String packageName, String name);
+ abstract AbstractEnumerationBuilder newEnumerationBuilder(JavaTypeName identifier);
@Override
public GeneratedTOBuilder addEnclosingTransferObject(final String name) {
Preconditions.checkArgument(name != null, "Name for Enclosing Generated Transfer Object cannot be null!");
- final GeneratedTOBuilder builder = new CodegenGeneratedTOBuilder(getFullyQualifiedName(), name);
+ final GeneratedTOBuilder builder = new CodegenGeneratedTOBuilder(getIdentifier().createEnclosed(name));
Preconditions.checkArgument(!this.enclosedTransferObjects.contains(builder),
"This generated type already contains equal enclosing transfer object.");
}
@Override
- public AnnotationTypeBuilder addAnnotation(final String packageName, final String name) {
- Preconditions.checkArgument(packageName != null, "Package Name for Annotation Type cannot be null!");
- Preconditions.checkArgument(name != null, "Name of Annotation Type cannot be null!");
-
- final AnnotationTypeBuilder builder = new AnnotationTypeBuilderImpl(packageName, name);
+ public AnnotationTypeBuilder addAnnotation(final JavaTypeName identifier) {
+ final AnnotationTypeBuilder builder = new AnnotationTypeBuilderImpl(identifier);
Preconditions.checkArgument(!this.annotationBuilders.contains(builder),
"This generated type already contains equal annotation.");
@Override
public EnumBuilder addEnumeration(final String name) {
Preconditions.checkArgument(name != null, "Name of enumeration cannot be null!");
- final EnumBuilder builder = newEnumerationBuilder(getFullyQualifiedName(), name);
+ final EnumBuilder builder = newEnumerationBuilder(getIdentifier().createEnclosed(name));
Preconditions.checkArgument(!this.enumDefinitions.contains(builder),
"This generated type already contains equal enumeration.");
return false;
}
final AbstractGeneratedTypeBuilder<?> other = (AbstractGeneratedTypeBuilder<?>) obj;
- return Objects.equals(getName(), other.getName()) && Objects.equals(getPackageName(), other.getPackageName());
+ return getIdentifier().equals(other.getIdentifier());
}
}
import org.opendaylight.mdsal.binding.model.api.AccessModifier;
import org.opendaylight.mdsal.binding.model.api.AnnotationType;
import org.opendaylight.mdsal.binding.model.api.Type;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.type.builder.AnnotationTypeBuilder;
import org.opendaylight.mdsal.binding.model.api.type.builder.TypeMemberBuilder;
import org.opendaylight.yangtools.util.LazyCollections;
}
@Override
- public AnnotationTypeBuilder addAnnotation(final String packageName, final String name) {
- Preconditions.checkArgument(packageName != null, "Annotation Type cannot have package name null!");
- Preconditions.checkArgument(name != null, "Annotation Type cannot have name as null!");
-
- final AnnotationTypeBuilder builder = new AnnotationTypeBuilderImpl(packageName, name);
+ public AnnotationTypeBuilder addAnnotation(final JavaTypeName identifier) {
+ final AnnotationTypeBuilder builder = new AnnotationTypeBuilderImpl(identifier);
this.annotationBuilders = LazyCollections.lazyAdd(this.annotationBuilders, builder);
return builder;
}
*/
package org.opendaylight.mdsal.binding.model.util.generated.type.builder;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableList;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import org.opendaylight.mdsal.binding.model.api.AnnotationType;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.type.builder.AnnotationTypeBuilder;
import org.opendaylight.mdsal.binding.model.util.AbstractBaseType;
import org.opendaylight.yangtools.util.LazyCollections;
final class AnnotationTypeBuilderImpl extends AbstractBaseType implements AnnotationTypeBuilder {
- private final String packageName;
- private final String name;
private List<AnnotationTypeBuilder> annotationBuilders = Collections.emptyList();
private List<AnnotationType.Parameter> parameters = Collections.emptyList();
- public AnnotationTypeBuilderImpl(final String packageName, final String name) {
- super(packageName, name);
- this.packageName = packageName;
- this.name = name;
+ AnnotationTypeBuilderImpl(final JavaTypeName identifier) {
+ super(identifier);
}
@Override
public AnnotationTypeBuilder addAnnotation(final String packageName, final String name) {
if (packageName != null && name != null) {
- final AnnotationTypeBuilder builder = new AnnotationTypeBuilderImpl(packageName, name);
+ final AnnotationTypeBuilder builder = new AnnotationTypeBuilderImpl(JavaTypeName.create(packageName, name));
if (!this.annotationBuilders.contains(builder)) {
this.annotationBuilders = LazyCollections.lazyAdd(this.annotationBuilders, builder);
return builder;
}
private boolean addParameter(final ParameterImpl param) {
- if (!this.parameters.contains(param)) {
- this.parameters = LazyCollections.lazyAdd(this.parameters, param);
- return true;
- } else {
+ if (parameters.contains(param)) {
return false;
}
+ parameters = LazyCollections.lazyAdd(parameters, param);
+ return true;
}
@Override
@Override
public AnnotationType build() {
- return new AnnotationTypeImpl(this.packageName, this.name, this.annotationBuilders, this.parameters);
- }
-
- @Override
- public int hashCode() {
- final int prime = 31;
- int result = 1;
- result = prime * result + Objects.hashCode(this.name);
- result = prime * result + Objects.hashCode(this.packageName);
- return result;
+ return new AnnotationTypeImpl(getIdentifier(), this.annotationBuilders, this.parameters);
}
@Override
if (this == obj) {
return true;
}
- if (obj == null) {
- return false;
- }
- if (getClass() != obj.getClass()) {
+ if (obj == null || getClass() != obj.getClass()) {
return false;
}
- final AnnotationTypeBuilderImpl other = (AnnotationTypeBuilderImpl) obj;
- return Objects.equals(this.name, other.name) && Objects.equals(this.packageName, other.packageName);
+ return getIdentifier().equals(((AnnotationTypeBuilderImpl) obj).getIdentifier());
}
@Override
public String toString() {
final StringBuilder builder = new StringBuilder();
builder.append("AnnotationTypeBuilder [packageName=");
- builder.append(this.packageName);
+ builder.append(getPackageName());
builder.append(", name=");
- builder.append(this.name);
+ builder.append(getName());
builder.append(", annotationBuilders=");
builder.append(this.annotationBuilders);
builder.append(", parameters=");
}
private static final class AnnotationTypeImpl implements AnnotationType {
-
- private final String packageName;
- private final String name;
+ private final JavaTypeName identifier;
private final List<AnnotationType> annotations;
private final List<AnnotationType.Parameter> parameters;
private final List<String> paramNames;
- public AnnotationTypeImpl(final String packageName, final String name,
- final List<AnnotationTypeBuilder> annotationBuilders,
+ AnnotationTypeImpl(final JavaTypeName identifier, final List<AnnotationTypeBuilder> annotationBuilders,
final List<AnnotationType.Parameter> parameters) {
- this.packageName = packageName;
- this.name = name;
+ this.identifier = requireNonNull(identifier);
final List<AnnotationType> a = new ArrayList<>();
for (final AnnotationTypeBuilder builder : annotationBuilders) {
}
@Override
- public String getPackageName() {
- return this.packageName;
- }
-
- @Override
- public String getName() {
- return this.name;
- }
-
- @Override
- public String getFullyQualifiedName() {
- return this.packageName + "." + this.name;
+ public JavaTypeName getIdentifier() {
+ return identifier;
}
@Override
@Override
public int hashCode() {
- final int prime = 31;
- int result = 1;
- result = prime * result + Objects.hashCode(this.name);
- result = prime * result + Objects.hashCode(this.packageName);
- return result;
+ return identifier.hashCode();
}
@Override
if (this == obj) {
return true;
}
- if (obj == null) {
- return false;
- }
- if (getClass() != obj.getClass()) {
+ if (obj == null || getClass() != obj.getClass()) {
return false;
}
final AnnotationTypeImpl other = (AnnotationTypeImpl) obj;
- return Objects.equals(this.name, other.name) && Objects.equals(this.packageName, other.packageName);
+ return identifier.equals(other.identifier);
}
@Override
public String toString() {
final StringBuilder builder = new StringBuilder();
builder.append("AnnotationType [packageName=");
- builder.append(this.packageName);
+ builder.append(getPackageName());
builder.append(", name=");
- builder.append(this.name);
+ builder.append(getName());
builder.append(", annotations=");
builder.append(this.annotations);
builder.append(", parameters=");
import org.opendaylight.mdsal.binding.model.api.Enumeration;
import org.opendaylight.mdsal.binding.model.api.Type;
import org.opendaylight.mdsal.binding.model.api.TypeComment;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.YangSourceDefinition;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
private String moduleName;
private SchemaPath schemaPath;
- public CodegenEnumerationBuilder(final String packageName, final String name) {
- super(packageName, name);
+ public CodegenEnumerationBuilder(final JavaTypeName identifier) {
+ super(identifier);
}
@Override
import org.opendaylight.mdsal.binding.model.api.GeneratedProperty;
import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
import org.opendaylight.mdsal.binding.model.api.Restrictions;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedPropertyBuilder;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
private String moduleName;
private SchemaPath schemaPath;
- public CodegenGeneratedTOBuilder(final String packageName, final String name) {
- super(packageName, name);
+ public CodegenGeneratedTOBuilder(final JavaTypeName identifier) {
+ super(identifier);
}
@Override
}
@Override
- AbstractEnumerationBuilder newEnumerationBuilder(final String packageName, final String name) {
- return new CodegenEnumerationBuilder(packageName, name);
+ AbstractEnumerationBuilder newEnumerationBuilder(final JavaTypeName identifier) {
+ return new CodegenEnumerationBuilder(identifier);
}
private static final class GTO extends AbstractGeneratedTransferObject {
import org.opendaylight.mdsal.binding.model.api.GeneratedType;
import org.opendaylight.mdsal.binding.model.api.TypeComment;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
private String moduleName;
private SchemaPath schemaPath;
- public CodegenGeneratedTypeBuilder(final String packageName, final String name) {
- super(packageName, name);
+ public CodegenGeneratedTypeBuilder(final JavaTypeName identifier) {
+ super(identifier);
setAbstract(true);
}
}
@Override
- AbstractEnumerationBuilder newEnumerationBuilder(final String packageName, final String name) {
- return new CodegenEnumerationBuilder(packageName, name);
+ AbstractEnumerationBuilder newEnumerationBuilder(final JavaTypeName identifier) {
+ return new CodegenEnumerationBuilder(identifier);
}
@Override
import org.opendaylight.mdsal.binding.model.api.Enumeration;
import org.opendaylight.mdsal.binding.model.api.Type;
import org.opendaylight.mdsal.binding.model.api.TypeComment;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.YangSourceDefinition;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
public final class RuntimeEnumerationBuilder extends AbstractEnumerationBuilder {
- public RuntimeEnumerationBuilder(final String packageName, final String name) {
- super(packageName, name);
+ public RuntimeEnumerationBuilder(final JavaTypeName identifier) {
+ super(identifier);
}
@Override
import org.opendaylight.mdsal.binding.model.api.GeneratedProperty;
import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
import org.opendaylight.mdsal.binding.model.api.Restrictions;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedPropertyBuilder;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
public final class RuntimeGeneratedTOBuilder extends AbstractGeneratedTOBuilder {
-
- public RuntimeGeneratedTOBuilder(final String packageName, final String name) {
- super(packageName, name);
+ public RuntimeGeneratedTOBuilder(final JavaTypeName identifier) {
+ super(identifier);
}
@Override
}
@Override
- AbstractEnumerationBuilder newEnumerationBuilder(final String packageName, final String name) {
- return new RuntimeEnumerationBuilder(packageName, name);
+ AbstractEnumerationBuilder newEnumerationBuilder(final JavaTypeName identifier) {
+ return new RuntimeEnumerationBuilder(identifier);
}
private static final class GTO extends AbstractGeneratedTransferObject {
import org.opendaylight.mdsal.binding.model.api.GeneratedType;
import org.opendaylight.mdsal.binding.model.api.TypeComment;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
public final class RuntimeGeneratedTypeBuilder extends AbstractGeneratedTypeBuilder<GeneratedTypeBuilder> implements
GeneratedTypeBuilder {
- public RuntimeGeneratedTypeBuilder(final String packageName, final String name) {
- super(packageName, name);
+ public RuntimeGeneratedTypeBuilder(final JavaTypeName identifier) {
+ super(identifier);
setAbstract(true);
}
}
@Override
- AbstractEnumerationBuilder newEnumerationBuilder(final String packageName, final String name) {
- return new RuntimeEnumerationBuilder(packageName, name);
+ AbstractEnumerationBuilder newEnumerationBuilder(final JavaTypeName identifier) {
+ return new RuntimeEnumerationBuilder(identifier);
}
@Override
+++ /dev/null
-/*
- * Copyright (c) 2014 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.model.util;
-
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotEquals;
-import static org.junit.Assert.assertTrue;
-
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-
-public class AbstractBaseTypeTest {
-
- @Rule
- public ExpectedException expException = ExpectedException.none();
-
- @Test
- public void testgetFullyQualifiedName() {
- AbstractBaseType baseType = new AbstractBaseType("", "");
- assertTrue(baseType.getFullyQualifiedName().isEmpty());
- }
-
- @Test
- public void testCreateAbstractBaseTypeWithNullPackagename() {
- expException.expect(IllegalArgumentException.class);
- expException.expectMessage("Package Name for Generated Type cannot be null!");
- new AbstractBaseType(null, "Test");
- }
-
- @Test
- public void testCreateAbstractBaseTypeWithNullTypeName() {
- expException.expect(IllegalArgumentException.class);
- expException.expectMessage("Name of Generated Type cannot be null!");
- new AbstractBaseType("org.opendaylight.yangtools.test", null);
- }
-
- @Test
- public void testHashCode() {
- AbstractBaseType baseType1 = new AbstractBaseType("org.opendaylight.yangtools.test", "Test");
- AbstractBaseType baseType2 = new AbstractBaseType("org.opendaylight.yangtools.test", "Test2");
- assertNotEquals(baseType1.hashCode(), baseType2.hashCode());
- }
-
- @Test
- public void testToString() {
- AbstractBaseType baseType = new AbstractBaseType("org.opendaylight.yangtools.test", "Test");
- assertTrue(baseType.toString().contains("org.opendaylight.yangtools.test.Test"));
- baseType = new AbstractBaseType("", "Test");
- assertTrue(baseType.toString().contains("Test"));
- }
-
- @Test
- public void testEquals() {
- AbstractBaseType baseType1 = new AbstractBaseType("org.opendaylight.yangtools.test", "Test");
- AbstractBaseType baseType2 = new AbstractBaseType("org.opendaylight.yangtools.test", "Test2");
- AbstractBaseType baseType3 = null;
- AbstractBaseType baseType4 = new AbstractBaseType("org.opendaylight.yangtools.test", "Test");
- AbstractBaseType baseType5 = new AbstractBaseType("org.opendaylight.yangtools.test1", "Test");
-
- assertFalse(baseType1.equals(baseType2));
- assertFalse(baseType1.equals(baseType3));
- assertTrue(baseType1.equals(baseType4));
- assertFalse(baseType1.equals(baseType5));
- assertFalse(baseType1.equals(null));
- }
-}
import org.junit.rules.ExpectedException;
import org.opendaylight.mdsal.binding.model.api.AccessModifier;
import org.opendaylight.mdsal.binding.model.api.Restrictions;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
import org.opendaylight.mdsal.binding.model.api.type.builder.MethodSignatureBuilder;
import org.opendaylight.mdsal.binding.model.util.generated.type.builder.CodegenGeneratedTypeBuilder;
assertNotNull(restriction);
// test method computeDefaultSUID
- GeneratedTypeBuilder genTypeBuilder = new CodegenGeneratedTypeBuilder("org.opendaylight.yangtools.test", "TestType");
+ GeneratedTypeBuilder genTypeBuilder = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("org.opendaylight.yangtools.test", "TestType"));
genTypeBuilder.addMethod("testMethod");
genTypeBuilder.addAnnotation("org.opendaylight.yangtools.test.annotation", "AnnotationTest");
genTypeBuilder.addEnclosingTransferObject("testObject");
genTypeBuilder.addProperty("newProp");
- GeneratedTypeBuilder genType = new CodegenGeneratedTypeBuilder("org.opendaylight.yangtools.test", "Type2");
+ GeneratedTypeBuilder genType = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("org.opendaylight.yangtools.test", "Type2"));
genTypeBuilder.addImplementsType(genType);
long computedSUID = BindingGeneratorUtil.computeDefaultSUID(genTypeBuilder);
- GeneratedTypeBuilder genTypeBuilder2 = new CodegenGeneratedTypeBuilder("org.opendaylight.yangtools.test2", "TestType2");
+ GeneratedTypeBuilder genTypeBuilder2 = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("org.opendaylight.yangtools.test2", "TestType2"));
long computedSUID2 = BindingGeneratorUtil.computeDefaultSUID(genTypeBuilder2);
assertNotEquals(computedSUID, computedSUID2);
@Test
public void computeDefaultSUIDTest() {
- CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
+ CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("my.package", "MyName"));
MethodSignatureBuilder method = generatedTypeBuilder.addMethod("myMethodName");
method.setAccessModifier(AccessModifier.PUBLIC);
import static org.junit.Assert.assertTrue;
import org.junit.Test;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
public class ReferencedTypeImplTest {
@Test
public void testCreateNewReferencedType() {
- ReferencedTypeImpl refType = new ReferencedTypeImpl("org.opendaylight.yangtools.test", "RefTypeTest");
+ ReferencedTypeImpl refType = new ReferencedTypeImpl(
+ JavaTypeName.create("org.opendaylight.yangtools.test", "RefTypeTest"));
assertEquals("RefTypeTest", refType.getName());
}
@Test
public void testToStringMethod() {
- ReferencedTypeImpl refType = new ReferencedTypeImpl("org.opendaylight.yangtools.test", "RefTypeTest");
+ ReferencedTypeImpl refType = new ReferencedTypeImpl(
+ JavaTypeName.create("org.opendaylight.yangtools.test", "RefTypeTest"));
assertTrue(refType.toString().contains("RefTypeTest"));
}
}
--- /dev/null
+/*
+ * Copyright (c) 2014 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.model.util;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
+
+public class TypeNameTest {
+
+ @Rule
+ public ExpectedException expException = ExpectedException.none();
+
+ @Test
+ public void testHashCode() {
+ JavaTypeName baseType1 = JavaTypeName.create("org.opendaylight.yangtools.test", "Test");
+ JavaTypeName baseType2 = JavaTypeName.create("org.opendaylight.yangtools.test", "Test2");
+ assertNotEquals(baseType1.hashCode(), baseType2.hashCode());
+ }
+
+ @Test
+ public void testToString() {
+ JavaTypeName baseType = JavaTypeName.create("org.opendaylight.yangtools.test", "Test");
+ assertTrue(baseType.toString().contains("org.opendaylight.yangtools.test.Test"));
+ baseType = JavaTypeName.create(byte[].class);
+ assertTrue(baseType.toString().contains("byte[]"));
+ }
+
+ @Test
+ public void testEquals() {
+ JavaTypeName baseType1 = JavaTypeName.create("org.opendaylight.yangtools.test", "Test");
+ JavaTypeName baseType2 = JavaTypeName.create("org.opendaylight.yangtools.test", "Test2");
+ JavaTypeName baseType3 = null;
+ JavaTypeName baseType4 = JavaTypeName.create("org.opendaylight.yangtools.test", "Test");
+ JavaTypeName baseType5 = JavaTypeName.create("org.opendaylight.yangtools.test1", "Test");
+
+ assertFalse(baseType1.equals(baseType2));
+ assertFalse(baseType1.equals(baseType3));
+ assertTrue(baseType1.equals(baseType4));
+ assertFalse(baseType1.equals(baseType5));
+ assertFalse(baseType1.equals(null));
+ }
+}
import org.opendaylight.mdsal.binding.model.api.ConcreteType;
import org.opendaylight.mdsal.binding.model.api.ParameterizedType;
import org.opendaylight.mdsal.binding.model.api.Type;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.WildcardType;
public class TypesTest {
@Test
public void testPrimitiveType() {
- final Type primitiveType = Types.primitiveType("newType", null);
- assertEquals("newType", primitiveType.getName());
- assertNotNull(primitiveType);
+ final Type primitiveType = Types.typeForClass(String[].class);
+ assertEquals("String[]", primitiveType.getName());
}
@Test
public void testMapTypeFor() {
final ParameterizedType mapType = Types.mapTypeFor(null, null);
assertEquals("Map", mapType.getName());
- assertNotNull(mapType);
}
@Test
public void testSetTypeFor() {
final ParameterizedType setType = Types.setTypeFor(null);
assertEquals("Set", setType.getName());
- assertNotNull(setType);
}
@Test
public void testListTypeFor() {
final ParameterizedType listType = Types.listTypeFor(null);
assertEquals("List", listType.getName());
- assertNotNull(listType);
}
@Test
public void testWildcardTypeFor() {
- final WildcardType wildcardType = Types.wildcardTypeFor("org.opendaylight.yangtools.test", "WildcardTypeTest");
+ final WildcardType wildcardType = Types.wildcardTypeFor(JavaTypeName.create("org.opendaylight.yangtools.test",
+ "WildcardTypeTest"));
assertEquals("WildcardTypeTest", wildcardType.getName());
- assertNotNull(wildcardType);
}
@Test
package org.opendaylight.mdsal.binding.model.util.generated.type.builder;
import java.io.Serializable;
-
import org.junit.Test;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.util.Types;
public class AbstractGeneratedTypeBuilderTest {
@Test(expected = IllegalArgumentException.class)
public void addPropertyIllegalArgumentTest() {
- CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
+ CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("my.package", "MyName"));
generatedTypeBuilder.addProperty(null);
}
@Test(expected = IllegalArgumentException.class)
public void addPropertyIllegalArgumentTest2() {
- CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
+ CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("my.package", "MyName"));
generatedTypeBuilder.addProperty("myName");
generatedTypeBuilder.addProperty("myName");
@Test(expected = IllegalArgumentException.class)
public void addEnclosingTransferObjectArgumentTest() {
- CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
+ CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("my.package", "MyName"));
- generatedTypeBuilder.addEnclosingTransferObject(new CodegenGeneratedTOBuilder("my.package", "myName"));
- generatedTypeBuilder.addEnclosingTransferObject(new CodegenGeneratedTOBuilder("my.package", "myName"));
+ generatedTypeBuilder.addEnclosingTransferObject(new CodegenGeneratedTOBuilder(
+ JavaTypeName.create("my.package", "myName")));
+ generatedTypeBuilder.addEnclosingTransferObject(new CodegenGeneratedTOBuilder(
+ JavaTypeName.create("my.package", "myName")));
}
@Test(expected = IllegalArgumentException.class)
public void addEnclosingTransferObjectArgumentTest2() {
- CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
+ CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("my.package", "MyName"));
generatedTypeBuilder.addEnclosingTransferObject("myName");
generatedTypeBuilder.addEnclosingTransferObject("myName");
@Test(expected = IllegalArgumentException.class)
public void addImplementsTypeIllegalArgumentTest() {
- CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
+ CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("my.package", "MyName"));
generatedTypeBuilder.addImplementsType(Types.typeForClass(Serializable.class));
generatedTypeBuilder.addImplementsType(Types.typeForClass(Serializable.class));
@Test(expected = IllegalArgumentException.class)
public void addConstantIllegalArgumentTest() {
- CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
+ CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("my.package", "MyName"));
generatedTypeBuilder.addConstant(Types.STRING, "myName", "Value");
generatedTypeBuilder.addConstant(Types.BOOLEAN, "myName", true);
@Test(expected = IllegalArgumentException.class)
public void addAnnotationIllegalArgumentTest() {
- CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
+ CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("my.package", "MyName"));
generatedTypeBuilder.addAnnotation("my.package", "myName");
generatedTypeBuilder.addAnnotation("my.package", "myName");
@Test(expected = IllegalArgumentException.class)
public void addEnumerationIllegalArgumentTest() {
- CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
+ CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("my.package", "MyName"));
generatedTypeBuilder.addEnumeration("myName");
generatedTypeBuilder.addEnumeration("myName");
}
-
}
import org.junit.Test;
import org.opendaylight.mdsal.binding.model.api.MethodSignature;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
public class AbstractTypeMemberTest {
@Test
public void testMethodsForAbstractTypeMemberBuilder() {
final MethodSignatureBuilderImpl methodSignatureBuilderImpl = new MethodSignatureBuilderImpl("TestProperty");
- final CodegenGeneratedTypeBuilder typeBuilderImpl = new CodegenGeneratedTypeBuilder("org.opendaylight.yangtools.test", "TestType");
- final CodegenGeneratedTypeBuilder typeBuilderImpl2 = new CodegenGeneratedTypeBuilder("org.opendaylight.yangtools.test", "TestType2");
+ final CodegenGeneratedTypeBuilder typeBuilderImpl = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("org.opendaylight.yangtools.test", "TestType"));
+ final CodegenGeneratedTypeBuilder typeBuilderImpl2 = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("org.opendaylight.yangtools.test", "TestType2"));
methodSignatureBuilderImpl.setComment("test comment");
methodSignatureBuilderImpl.setFinal(true);
methodSignatureBuilderImpl.setStatic(true);
import org.opendaylight.mdsal.binding.model.api.AnnotationType.Parameter;
import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
import org.opendaylight.mdsal.binding.model.api.GeneratedType;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.type.builder.AnnotationTypeBuilder;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedPropertyBuilder;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTOBuilder;
@Test
public void generatedTypeAnnotationTest() {
- final GeneratedTypeBuilder genTypeBuilder = new CodegenGeneratedTypeBuilder("org.opendaylight.controller",
- "AnnotInterface");
+ final GeneratedTypeBuilder genTypeBuilder = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("org.opendaylight.controller", "AnnotInterface"));
genTypeBuilder.addAnnotation("javax.management", "MXBean");
final AnnotationTypeBuilder annotDesc = genTypeBuilder.addAnnotation("javax.management", "Description");
@Test
public void methodSignatureAnnotationTest() {
- final GeneratedTypeBuilder genTypeBuilder = new CodegenGeneratedTypeBuilder("org.opendaylight.controller",
- "TransferObject");
+ final GeneratedTypeBuilder genTypeBuilder = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("org.opendaylight.controller", "TransferObject"));
final MethodSignatureBuilder methodBuilder = genTypeBuilder.addMethod("simpleMethod");
methodBuilder.setReturnType(Types.typeForClass(Integer.class));
annotManAttr.addParameter("persistPolicy", "\"OnUpdate\"");
final AnnotationTypeBuilder annotManProp = methodBuilder.addAnnotation(
- "org.springframework.jmx.export.annotation", "ManagedOperation");
+ "org.springframework.jmx.export.annotation", "ManagedOperation");
final List<String> typeValues = new ArrayList<>();
typeValues.add("\"val1\"");
@Test
public void generatedPropertyAnnotationTest() {
- final GeneratedTOBuilder genTOBuilder = new CodegenGeneratedTOBuilder("org.opendaylight.controller",
- "AnnotInterface");
+ final GeneratedTOBuilder genTOBuilder = new CodegenGeneratedTOBuilder(
+ JavaTypeName.create("org.opendaylight.controller", "AnnotInterface"));
final GeneratedPropertyBuilder propertyBuilder = genTOBuilder.addProperty("simpleProperty");
propertyBuilder.setReturnType(Types.typeForClass(Integer.class));
@Test
public void generatedTransfeObjectAnnotationTest() {
- final GeneratedTOBuilder genTypeBuilder = new CodegenGeneratedTOBuilder("org.opendaylight.controller",
- "AnnotClassCache");
+ final GeneratedTOBuilder genTypeBuilder = new CodegenGeneratedTOBuilder(
+ JavaTypeName.create("org.opendaylight.controller", "AnnotClassCache"));
genTypeBuilder.addAnnotation("javax.management", "MBean");
final AnnotationTypeBuilder annotNotify = genTypeBuilder.addAnnotation("javax.management", "NotificationInfo");
@Test
public void annotationTypeBuilderAddAnnotationTest() {
- AnnotationTypeBuilder annotationTypeBuilder = new AnnotationTypeBuilderImpl("my.package", "MyName");
+ AnnotationTypeBuilder annotationTypeBuilder = new AnnotationTypeBuilderImpl(
+ JavaTypeName.create("my.package", "MyName"));
assertNull(annotationTypeBuilder.addAnnotation("my.package", null));
assertNull(annotationTypeBuilder.addAnnotation(null, "MyName"));
- assertNotNull(annotationTypeBuilder.addAnnotation("", ""));
+ assertNotNull(annotationTypeBuilder.addAnnotation("java.lang", "Deprecated"));
assertNotNull(annotationTypeBuilder.addAnnotation("my.package2", "MyName2"));
assertNull(annotationTypeBuilder.addAnnotation("my.package2", "MyName2"));
@Test
public void annotationTypeBuilderEqualsTest() {
- AnnotationTypeBuilder annotationTypeBuilder = new AnnotationTypeBuilderImpl("my.package", "MyName");
- AnnotationTypeBuilder annotationTypeBuilder2 = new AnnotationTypeBuilderImpl("my.package2", "MyName");
- AnnotationTypeBuilder annotationTypeBuilder3 = new AnnotationTypeBuilderImpl("my.package", "MyName2");
- AnnotationTypeBuilder annotationTypeBuilder4 = new AnnotationTypeBuilderImpl("my.package", "MyName");
+ AnnotationTypeBuilder annotationTypeBuilder = new AnnotationTypeBuilderImpl(
+ JavaTypeName.create("my.package", "MyName"));
+ AnnotationTypeBuilder annotationTypeBuilder2 = new AnnotationTypeBuilderImpl(
+ JavaTypeName.create("my.package2", "MyName"));
+ AnnotationTypeBuilder annotationTypeBuilder3 = new AnnotationTypeBuilderImpl(
+ JavaTypeName.create("my.package", "MyName2"));
+ AnnotationTypeBuilder annotationTypeBuilder4 = new AnnotationTypeBuilderImpl(
+ JavaTypeName.create("my.package", "MyName"));
assertFalse(annotationTypeBuilder.equals(null));
assertFalse(annotationTypeBuilder.equals(new Object()));
@Test
public void annotationTypeBuilderHashCodeTest() {
- AnnotationTypeBuilder annotationTypeBuilder = new AnnotationTypeBuilderImpl("my.package", "MyName");
- AnnotationTypeBuilder annotationTypeBuilder2 = new AnnotationTypeBuilderImpl("my.package2", "MyName");
- AnnotationTypeBuilder annotationTypeBuilder3 = new AnnotationTypeBuilderImpl("my.package", "MyName2");
- AnnotationTypeBuilder annotationTypeBuilder4 = new AnnotationTypeBuilderImpl("my.package", "MyName");
+ AnnotationTypeBuilder annotationTypeBuilder = new AnnotationTypeBuilderImpl(
+ JavaTypeName.create("my.package", "MyName"));
+ AnnotationTypeBuilder annotationTypeBuilder2 = new AnnotationTypeBuilderImpl(
+ JavaTypeName.create("my.package2", "MyName"));
+ AnnotationTypeBuilder annotationTypeBuilder3 = new AnnotationTypeBuilderImpl(
+ JavaTypeName.create("my.package", "MyName2"));
+ AnnotationTypeBuilder annotationTypeBuilder4 = new AnnotationTypeBuilderImpl(
+ JavaTypeName.create("my.package", "MyName"));
assertFalse(annotationTypeBuilder.hashCode() == annotationTypeBuilder2.hashCode());
assertFalse(annotationTypeBuilder.hashCode() == annotationTypeBuilder3.hashCode());
@Test
public void annotationTypeBuilderAddParameterTest() {
- AnnotationTypeBuilder annotationTypeBuilder = new AnnotationTypeBuilderImpl("my.package", "MyName");
+ AnnotationTypeBuilder annotationTypeBuilder = new AnnotationTypeBuilderImpl(
+ JavaTypeName.create("my.package", "MyName"));
assertFalse(annotationTypeBuilder.addParameter(null, "myValue"));
assertFalse(annotationTypeBuilder.addParameter("myName", null));
@Test
public void annotationTypeBuilderToStringTest() {
- AnnotationTypeBuilder annotationTypeBuilder = new AnnotationTypeBuilderImpl("my.package", "MyAnnotationName");
+ AnnotationTypeBuilder annotationTypeBuilder = new AnnotationTypeBuilderImpl(
+ JavaTypeName.create("my.package", "MyAnnotationName"));
annotationTypeBuilder.addAnnotation("my.package", "MySubAnnotationName");
annotationTypeBuilder.addParameter("MyParameter", "myValue");
}
public void testAddAnnotation() {
- final AnnotationTypeBuilderImpl annotBuilderImpl = new AnnotationTypeBuilderImpl("org.opedaylight.yangtools.test", "AnnotationTest");
+ final AnnotationTypeBuilderImpl annotBuilderImpl = new AnnotationTypeBuilderImpl(
+ JavaTypeName.create("org.opedaylight.yangtools.test", "AnnotationTest"));
annotBuilderImpl.addAnnotation("org.opedaylight.yangtools.test.v1", "AnnotationTest2");
annotBuilderImpl.addAnnotation(null, "AnnotationTest2");
assertFalse(annotBuilderImpl.build().getAnnotations().isEmpty());
@Test
public void testAddParameterMethod() {
- final AnnotationTypeBuilderImpl annotBuilderImpl = new AnnotationTypeBuilderImpl("org.opedaylight.yangtools.test", "AnnotationTest");
+ final AnnotationTypeBuilderImpl annotBuilderImpl = new AnnotationTypeBuilderImpl(
+ JavaTypeName.create("org.opedaylight.yangtools.test", "AnnotationTest"));
annotBuilderImpl.addParameter("testParam", "test value");
annotBuilderImpl.addParameter(null, "test value");
final AnnotationType annotType = annotBuilderImpl.build();
@Test
public void testAddParametersMethod() {
- final AnnotationTypeBuilderImpl annotBuilderImpl = new AnnotationTypeBuilderImpl("org.opedaylight.yangtools.test", "AnnotationTest");
+ final AnnotationTypeBuilderImpl annotBuilderImpl = new AnnotationTypeBuilderImpl(
+ JavaTypeName.create("org.opedaylight.yangtools.test", "AnnotationTest"));
final List<String> values = new ArrayList<>();
values.add("test1");
@Test
public void testHashCode() {
- final AnnotationTypeBuilderImpl annotBuilderImpl = new AnnotationTypeBuilderImpl("org.opedaylight.yangtools.test", "AnnotationTest");
- final AnnotationTypeBuilderImpl annotBuilderImpl2 = new AnnotationTypeBuilderImpl("org.opedaylight.yangtools.test", "AnnotationTest2");
+ final AnnotationTypeBuilderImpl annotBuilderImpl = new AnnotationTypeBuilderImpl(
+ JavaTypeName.create("org.opedaylight.yangtools.test", "AnnotationTest"));
+ final AnnotationTypeBuilderImpl annotBuilderImpl2 = new AnnotationTypeBuilderImpl(
+ JavaTypeName.create("org.opedaylight.yangtools.test", "AnnotationTest2"));
assertFalse(annotBuilderImpl.hashCode() == annotBuilderImpl2.hashCode());
}
@Test
public void testEquals() {
- final AnnotationTypeBuilderImpl annotBuilderImpl = new AnnotationTypeBuilderImpl("org.opedaylight.yangtools.test", "AnnotationTest");
- final AnnotationTypeBuilderImpl annotBuilderImpl2 = new AnnotationTypeBuilderImpl("org.opedaylight.yangtools.test", "AnnotationTest");
+ final AnnotationTypeBuilderImpl annotBuilderImpl = new AnnotationTypeBuilderImpl(
+ JavaTypeName.create("org.opedaylight.yangtools.test", "AnnotationTest"));
+ final AnnotationTypeBuilderImpl annotBuilderImpl2 = new AnnotationTypeBuilderImpl(
+ JavaTypeName.create("org.opedaylight.yangtools.test", "AnnotationTest"));
final AnnotationTypeBuilderImpl annotBuilderImpl3 = annotBuilderImpl2;
assertTrue(annotBuilderImpl.equals(annotBuilderImpl2));
@Test
public void testToString() {
- final AnnotationTypeBuilderImpl annotBuilderImpl = new AnnotationTypeBuilderImpl("org.opedaylight.yangtools.test", "AnnotationTest");
+ final AnnotationTypeBuilderImpl annotBuilderImpl = new AnnotationTypeBuilderImpl(
+ JavaTypeName.create("org.opedaylight.yangtools.test", "AnnotationTest"));
assertNotNull(annotBuilderImpl.toString());
}
@Test
public void testMethodsForAnnotationTypeImpl() {
- final AnnotationTypeBuilderImpl annotBuilderImpl = new AnnotationTypeBuilderImpl("org.opedaylight.yangtools.test", "AnnotationTest");
+ final AnnotationTypeBuilderImpl annotBuilderImpl = new AnnotationTypeBuilderImpl(
+ JavaTypeName.create("org.opedaylight.yangtools.test", "AnnotationTest"));
annotBuilderImpl.addParameter("testParam", "test value");
final AnnotationType annotationType = annotBuilderImpl.build();
- final AnnotationTypeBuilderImpl annotBuilderImpl2 = new AnnotationTypeBuilderImpl("org.opedaylight.yangtools.test", "AnnotationTest");
+ final AnnotationTypeBuilderImpl annotBuilderImpl2 = new AnnotationTypeBuilderImpl(
+ JavaTypeName.create("org.opedaylight.yangtools.test", "AnnotationTest"));
final AnnotationType annotationType2 = annotBuilderImpl2.build();
assertTrue(annotationType.containsParameters());
@Test
public void testMethodsForParameterImpl() {
- final AnnotationTypeBuilderImpl annotBuilderImpl = new AnnotationTypeBuilderImpl("org.opedaylight.yangtools.test", "AnnotationTest");
+ final AnnotationTypeBuilderImpl annotBuilderImpl = new AnnotationTypeBuilderImpl(
+ JavaTypeName.create("org.opedaylight.yangtools.test", "AnnotationTest"));
annotBuilderImpl.addParameter("testParam", "test value");
annotBuilderImpl.addParameter("testParam", "test value");
annotBuilderImpl.addParameter("", "test value");
import static org.junit.Assert.assertTrue;
import org.junit.Test;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
public class ConstantImplTest {
@Test
public void testMethodsOfConstantImpl() {
- final CodegenGeneratedTypeBuilder definingType = new CodegenGeneratedTypeBuilder("org.opendaylight.yangtools.test",
- "DefiningType");
- final CodegenGeneratedTypeBuilder type = new CodegenGeneratedTypeBuilder("org.opendaylight.yangtools.test.v1",
- "BaseType");
+ final CodegenGeneratedTypeBuilder definingType = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("org.opendaylight.yangtools.test", "DefiningType"));
+ final CodegenGeneratedTypeBuilder type = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("org.opendaylight.yangtools.test.v1", "BaseType"));
final ConstantImpl constImpl = new ConstantImpl(definingType, type, "IpAddress", "127.0.0.1");
final ConstantImpl constImpl2 = new ConstantImpl(definingType, type, "IpAddress", "127.0.0.1");
final ConstantImpl constImpl3 = new ConstantImpl(definingType, type, "IpAddress", "127.0.0.0");
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.mdsal.binding.model.api.Enumeration;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
@Before
public void setup() {
- enumerationBuilder = new CodegenEnumerationBuilder(packageName, name);
+ enumerationBuilder = new CodegenEnumerationBuilder(JavaTypeName.create(packageName, name));
enumerationBuilder.setDescription(DESCRIPTION);
enumerationBuilder.setModuleName(moduleName);
enumerationBuilder.setReference(reference);
enumerationBuilder.setSchemaPath(SchemaPath.create(true, qName));
enumerationBuilder.addValue(valueName, valueName, value, Status.CURRENT, valueDescription, null);
enumerationBuilder.addAnnotation(packageName, "TestAnnotation");
- enumerationBuilderSame = new CodegenEnumerationBuilder(packageName, name);
- enumerationBuilderOtherName = new CodegenEnumerationBuilder(packageName, "SomeOtherName");
- enumerationBuilderOtherPackage = new CodegenEnumerationBuilder("org.opendaylight.other", name);
+ enumerationBuilderSame = new CodegenEnumerationBuilder(JavaTypeName.create(packageName, name));
+ enumerationBuilderOtherName = new CodegenEnumerationBuilder(JavaTypeName.create(packageName, "SomeOtherName"));
+ enumerationBuilderOtherPackage = new CodegenEnumerationBuilder(JavaTypeName.create("org.opendaylight.other", name));
enumeration = enumerationBuilder.toInstance(enumerationBuilder);
}
- @Test
+ @Test(expected = IllegalArgumentException.class)
public void testAddNullAnnotation() {
- assertNull(enumerationBuilder.addAnnotation(null, null));
+ assertNull(enumerationBuilder.addAnnotation(null));
+ }
+
+ @Test(expected = NullPointerException.class)
+ public void testAddNullAnnotationPackage() {
assertNull(enumerationBuilder.addAnnotation(null, "test"));
+ }
+
+ @Test(expected = NullPointerException.class)
+ public void testAddNullAnnotationName() {
assertNull(enumerationBuilder.addAnnotation(packageName, null));
}
final Enumeration enumerationSame = enumerationBuilderSame.toInstance(enumerationBuilderSame);
assertEquals(enumeration, enumerationSame);
- final CodegenEnumerationBuilder enumerationBuilderSame1 = new CodegenEnumerationBuilder(packageName, name);
+ final CodegenEnumerationBuilder enumerationBuilderSame1 = new CodegenEnumerationBuilder(
+ JavaTypeName.create(packageName, name));
final Enumeration enumerationSame1 = enumerationBuilderSame1.toInstance(enumerationBuilderSame1);
enumerationBuilderSame1.addValue(valueName, valueName, 14, Status.CURRENT, valueDescription, null);
// Enums are equal thanks to same package name and local name
"public enum " + name + " {\n" +
"\t TestValue " + "(12 );\n" +
"}";
- final String s = "Enumeration [packageName="+packageName+", definingType="+packageName+"."+name+", name="+name+
- ", values=[EnumPair [name=TestValue, mappedName=TestValue, value=12]]]";
+ final String s = "Enumeration [packageName=" + packageName + ", definingType=" + packageName + "." + name
+ + ", name=" + name + ", values=[EnumPair [name=TestValue, mappedName=TestValue, value=12]]]";
assertEquals(s, enumeration.toString());
assertEquals(formattedString, enumeration.toFormattedString());
import org.junit.Test;
import org.opendaylight.mdsal.binding.model.api.AccessModifier;
import org.opendaylight.mdsal.binding.model.api.GeneratedProperty;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.util.Types;
public class GeneratedPropertyImplTest {
generatedPropertyBuilderImpl.setAccessModifier(AccessModifier.PUBLIC);
generatedPropertyBuilderImpl.setReturnType(Types.BOOLEAN);
- GeneratedProperty instance = generatedPropertyBuilderImpl.toInstance(new CodegenGeneratedTypeBuilder("my.package",
- "myTypeName").build());
+ GeneratedProperty instance = generatedPropertyBuilderImpl.toInstance(new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("my.package", "myTypeName")).build());
assertNotNull(instance);
assertEquals(AccessModifier.PUBLIC, instance.getAccessModifier());
assertEquals(Types.BOOLEAN, instance.getReturnType());
- assertEquals(
- "GeneratedPropertyImpl [name=myPropertyName, annotations=[], comment=myComment, parent=my.package.myTypeName, returnType=Type (java.lang.Boolean), isFinal=true, isReadOnly=false, modifier=PUBLIC]",
- instance.toString());
-
+ assertEquals("GeneratedPropertyImpl [name=myPropertyName, annotations=[], comment=myComment, "
+ + "parent=my.package.myTypeName, returnType=Type (java.lang.Boolean), isFinal=true, isReadOnly=false, "
+ + "modifier=PUBLIC]", instance.toString());
}
@Test
import org.junit.Test;
import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
import org.opendaylight.mdsal.binding.model.api.Restrictions;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.type.builder.MethodSignatureBuilder;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
@Test
public void testCreateNewInstance() {
- final CodegenGeneratedTOBuilder genTOBuilder = new CodegenGeneratedTOBuilder("org.opendaylight.yangtools.test", "Test");
+ final CodegenGeneratedTOBuilder genTOBuilder = new CodegenGeneratedTOBuilder(
+ JavaTypeName.create("org.opendaylight.yangtools.test", "Test"));
assertNotNull(genTOBuilder);
}
@Test
public void testSetExtendsType() {
- final CodegenGeneratedTOBuilder genTOBuilder = new CodegenGeneratedTOBuilder("org.opendaylight.yangtools.test", "Test");
- final CodegenGeneratedTOBuilder extendedTypeBuilder = new CodegenGeneratedTOBuilder("org.opendaylight.yangtools.test", "ExtendedType");
+ final CodegenGeneratedTOBuilder genTOBuilder = new CodegenGeneratedTOBuilder(
+ JavaTypeName.create("org.opendaylight.yangtools.test", "Test"));
+ final CodegenGeneratedTOBuilder extendedTypeBuilder = new CodegenGeneratedTOBuilder(
+ JavaTypeName.create("org.opendaylight.yangtools.test", "ExtendedType"));
final GeneratedTransferObject extendedType = extendedTypeBuilder.build();
genTOBuilder.setExtendsType(extendedType);
final GeneratedTransferObject genTO = genTOBuilder.build();
@Test
public void testAddMethod() {
- final CodegenGeneratedTOBuilder genTOBuilder = new CodegenGeneratedTOBuilder("org.opendaylight.yangtools.test", "Test");
+ final CodegenGeneratedTOBuilder genTOBuilder = new CodegenGeneratedTOBuilder(
+ JavaTypeName.create("org.opendaylight.yangtools.test", "Test"));
final MethodSignatureBuilder methodSignatureBuilder = genTOBuilder.addMethod("testMethod");
assertEquals(methodSignatureBuilder, genTOBuilder.getMethodDefinitions().get(0));
assertEquals("testMethod", genTOBuilder.getMethodDefinitions().get(0).getName());
@Test
public void testAddEqualsIdentity() {
- final CodegenGeneratedTOBuilder genTOBuilder = new CodegenGeneratedTOBuilder("org.opendaylight.yangtools.test", "Test");
+ final CodegenGeneratedTOBuilder genTOBuilder = new CodegenGeneratedTOBuilder(
+ JavaTypeName.create("org.opendaylight.yangtools.test", "Test"));
final GeneratedPropertyBuilderImpl propertyBuilder = new GeneratedPropertyBuilderImpl("testProperty");
genTOBuilder.addEqualsIdentity(propertyBuilder);
@Test
public void testAddHashIdentity() {
- final CodegenGeneratedTOBuilder genTOBuilder = new CodegenGeneratedTOBuilder("org.opendaylight.yangtools.test", "Test");
+ final CodegenGeneratedTOBuilder genTOBuilder = new CodegenGeneratedTOBuilder(
+ JavaTypeName.create("org.opendaylight.yangtools.test", "Test"));
final GeneratedPropertyBuilderImpl propertyBuilder = new GeneratedPropertyBuilderImpl("testProperty");
genTOBuilder.addHashIdentity(propertyBuilder);
@Test
public void testAddToStringProperty() {
- final CodegenGeneratedTOBuilder genTOBuilder = new CodegenGeneratedTOBuilder("org.opendaylight.yangtools.test", "Test");
+ final CodegenGeneratedTOBuilder genTOBuilder = new CodegenGeneratedTOBuilder(
+ JavaTypeName.create("org.opendaylight.yangtools.test", "Test"));
final GeneratedPropertyBuilderImpl propertyBuilder = new GeneratedPropertyBuilderImpl("testProperty");
genTOBuilder.addToStringProperty(propertyBuilder);
@Test
public void testSetRestrictions() {
- final CodegenGeneratedTOBuilder genTOBuilder = new CodegenGeneratedTOBuilder("org.opendaylight.yangtools.test", "Test");
+ final CodegenGeneratedTOBuilder genTOBuilder = new CodegenGeneratedTOBuilder(
+ JavaTypeName.create("org.opendaylight.yangtools.test", "Test"));
final Restrictions restrictions = new Restrictions() {
@Override
@Test
public void testSetSUID() {
- final CodegenGeneratedTOBuilder genTOBuilder = new CodegenGeneratedTOBuilder("org.opendaylight.yangtools.test", "Test");
+ final CodegenGeneratedTOBuilder genTOBuilder = new CodegenGeneratedTOBuilder(
+ JavaTypeName.create("org.opendaylight.yangtools.test", "Test"));
final GeneratedPropertyBuilderImpl propertyBuilder = new GeneratedPropertyBuilderImpl("testProperty");
genTOBuilder.setSUID(propertyBuilder);
@Test
public void testToStringMethod() {
- final CodegenGeneratedTOBuilder genTOBuilder = new CodegenGeneratedTOBuilder("org.opendaylight.yangtools.test", "Test");
+ final CodegenGeneratedTOBuilder genTOBuilder = new CodegenGeneratedTOBuilder(
+ JavaTypeName.create("org.opendaylight.yangtools.test", "Test"));
assertNotNull(genTOBuilder.toString());
}
@Test
public void testSetterMethods() {
- final CodegenGeneratedTOBuilder genTOBuilder = new CodegenGeneratedTOBuilder("org.opendaylight.yangtools.test", "Test");
+ final CodegenGeneratedTOBuilder genTOBuilder = new CodegenGeneratedTOBuilder(
+ JavaTypeName.create("org.opendaylight.yangtools.test", "Test"));
genTOBuilder.setTypedef(true);
genTOBuilder.setIsUnion(true);
genTOBuilder.setIsUnionBuilder(true);
@Test
public void testMethodsOfGeneratedTransferObjectImpl() {
- final CodegenGeneratedTOBuilder genTOBuilder = new CodegenGeneratedTOBuilder("org.opendaylight.yangtools.test", "Test");
+ final CodegenGeneratedTOBuilder genTOBuilder = new CodegenGeneratedTOBuilder(
+ JavaTypeName.create("org.opendaylight.yangtools.test", "Test"));
final GeneratedTransferObject genTO = genTOBuilder.build();
assertNotNull(genTO.toString());
import org.junit.Test;
import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedPropertyBuilder;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTOBuilder;
@Test
public void testBuilder() {
final GeneratedTOBuilder genTypeBuilder = new CodegenGeneratedTOBuilder(
- "org.opendaylight.controller", "AnnotClassCache");
+ JavaTypeName.create("org.opendaylight.controller", "AnnotClassCache"));
genTypeBuilder.setSUID(genTypeBuilder.addProperty("SUID"));
genTypeBuilder.addMethod("addCount");
@Test
public void testToString() {
final GeneratedTOBuilder genTypeBuilder = new CodegenGeneratedTOBuilder(
- "org.opendaylight.controller", "AnnotClassCache");
+ JavaTypeName.create("org.opendaylight.controller", "AnnotClassCache"));
String toString = genTypeBuilder.toString();
assertTrue(toString.contains("GeneratedTransferObject"));
}
@Test
public void testTransferBuilderToString() {
final GeneratedTOBuilder genTypeBuilder1 = new CodegenGeneratedTOBuilder(
- "org.opendaylight.controller", "AnnotClassCache");
+ JavaTypeName.create("org.opendaylight.controller", "AnnotClassCache"));
genTypeBuilder1.setTypedef(true);
GeneratedTransferObject genTO = genTypeBuilder1.build();
assertFalse(toString.contains("GeneratedTransferObject"));
final GeneratedTOBuilder genTypeBuilder2 = new CodegenGeneratedTOBuilder(
- "org.opendaylight.controller", "AnnotClassCache");
+ JavaTypeName.create("org.opendaylight.controller", "AnnotClassCache"));
genTypeBuilder2.setTypedef(false);
genTO = genTypeBuilder2.build();
import org.opendaylight.mdsal.binding.model.api.GeneratedType;
import org.opendaylight.mdsal.binding.model.api.MethodSignature;
import org.opendaylight.mdsal.binding.model.api.Type;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.type.builder.EnumBuilder;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedPropertyBuilder;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTOBuilder;
@Test
public void addConstantTest() {
- GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
+ GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("my.package", "MyName"));
// assertNotNull(generatedTypeBuilder.addComment("My comment ..."));
// generatedTypeBuilder.addConstant(Types.typeForClass(String.class),
// "myConstant", "myConstantValue");
Constant constant2 = generatedTypeBuilder.addConstant(
- Types.primitiveType("int", BindingGeneratorUtil.getRestrictions(null)), "myIntConstant", 1);
+ Types.typeForClass(int.class, BindingGeneratorUtil.getRestrictions(null)), "myIntConstant", 1);
Constant constant3 = new ConstantImpl(generatedTypeBuilder, Types.typeForClass(String.class), "myConstant",
"myConstantValue");
@Test(expected = IllegalArgumentException.class)
public void addConstantIllegalArgumentTest() {
- GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
- generatedTypeBuilder.addConstant(Types.typeForClass(String.class), null, "myConstantValue");
+ new CodegenGeneratedTypeBuilder(JavaTypeName.create("my.package", "MyName")).addConstant(
+ Types.typeForClass(String.class), null, "myConstantValue");
}
@Test(expected = IllegalArgumentException.class)
public void addConstantIllegalArgumentTest2() {
- GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
- generatedTypeBuilder.addConstant(null, "myConstantName", "myConstantValue");
+ new CodegenGeneratedTypeBuilder(JavaTypeName.create("my.package", "MyName")).addConstant(null, "myConstantName",
+ "myConstantValue");
}
@Test
public void generatedTypeBuilderEqualsAndHashCodeTest() {
- CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
- CodegenGeneratedTypeBuilder generatedTypeBuilder2 = new CodegenGeneratedTypeBuilder("my.package", "MyName");
- CodegenGeneratedTypeBuilder generatedTypeBuilder3 = new CodegenGeneratedTypeBuilder("my.package", "MyName2");
- CodegenGeneratedTypeBuilder generatedTypeBuilder4 = new CodegenGeneratedTypeBuilder("my.package2", "MyName");
+ CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("my.package", "MyName"));
+ CodegenGeneratedTypeBuilder generatedTypeBuilder2 = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("my.package", "MyName"));
+ CodegenGeneratedTypeBuilder generatedTypeBuilder3 = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("my.package", "MyName2"));
+ CodegenGeneratedTypeBuilder generatedTypeBuilder4 = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("my.package2", "MyName"));
assertFalse(generatedTypeBuilder.equals(null));
assertFalse(generatedTypeBuilder.equals(new Object()));
@Test
public void addPropertyTest() {
- CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
+ CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("my.package", "MyName"));
GeneratedPropertyBuilder propertyBuilder = generatedTypeBuilder.addProperty("myProperty");
GeneratedPropertyBuilder propertyBuilder2 = generatedTypeBuilder.addProperty("myProperty2");
@Test(expected = IllegalArgumentException.class)
public void addMethodIllegalArgumentTest() {
- GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
- generatedTypeBuilder.addMethod(null);
+ new CodegenGeneratedTypeBuilder(JavaTypeName.create("my.package", "MyName")).addMethod(null);
}
@Test
public void addMethodTest() {
- GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
+ GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("my.package", "MyName"));
MethodSignatureBuilder methodBuilder = generatedTypeBuilder.addMethod("myMethodName");
MethodSignatureBuilder methodBuilder2 = generatedTypeBuilder.addMethod("myMethodName2");
@Test(expected = IllegalArgumentException.class)
public void addEnumerationIllegalArgumentTest() {
- CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
-
- generatedTypeBuilder.addEnumeration(null);
+ new CodegenGeneratedTypeBuilder(JavaTypeName.create("my.package", "MyName")).addEnumeration(null);
}
@Test
public void addEnumerationTest() {
- GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
+ GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("my.package", "MyName"));
EnumBuilder enumBuilder = generatedTypeBuilder.addEnumeration("myEnumName");
EnumBuilder enumBuilder2 = generatedTypeBuilder.addEnumeration("myEnumName2");
assertTrue(enumerations.contains(enumBuilder.toInstance(instance)));
assertTrue(enumerations.contains(enumBuilder2.toInstance(instance)));
- assertFalse(enumerations.contains(new CodegenEnumerationBuilder("my.package", "myEnumName3").toInstance(instance)));
+ assertFalse(enumerations.contains(new CodegenEnumerationBuilder(JavaTypeName.create("my.package", "myEnumName3"))
+ .toInstance(instance)));
}
@Test(expected = IllegalArgumentException.class)
public void addImplementsTypeIllegalArgumentTest() {
- GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
-
- generatedTypeBuilder.addImplementsType(null);
+ new CodegenGeneratedTypeBuilder(JavaTypeName.create("my.package", "MyName")).addImplementsType(null);
}
@Test
public void addImplementsTypeTest() {
- CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
+ CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("my.package", "MyName"));
assertEquals(generatedTypeBuilder,
generatedTypeBuilder.addImplementsType(Types.typeForClass(Serializable.class)));
assertTrue(implementTypes.contains(Types.typeForClass(Serializable.class)));
assertTrue(implementTypes.contains(Types.typeForClass(Runnable.class)));
assertFalse(implementTypes.contains(Types.typeForClass(Throwable.class)));
-
}
@Test(expected = IllegalArgumentException.class)
public void addEnclosingTransferObjectIllegalArgumentTest() {
- CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
-
- generatedTypeBuilder.addEnclosingTransferObject((String) null);
+ new CodegenGeneratedTypeBuilder(JavaTypeName.create("my.package", "MyName"))
+ .addEnclosingTransferObject((String) null);
}
@Test(expected = IllegalArgumentException.class)
public void addEnclosingTransferObjectIllegalArgumentTest2() {
- CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
-
- generatedTypeBuilder.addEnclosingTransferObject((GeneratedTOBuilder) null);
+ new CodegenGeneratedTypeBuilder(JavaTypeName.create("my.package", "MyName"))
+ .addEnclosingTransferObject((GeneratedTOBuilder) null);
}
@Test
public void addEnclosingTransferObjectTest() {
- GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
+ GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("my.package", "MyName"));
GeneratedTOBuilder enclosingTransferObject = generatedTypeBuilder.addEnclosingTransferObject("myTOName");
GeneratedTOBuilder enclosingTransferObject2 = generatedTypeBuilder.addEnclosingTransferObject("myTOName2");
- assertEquals(generatedTypeBuilder, generatedTypeBuilder.addEnclosingTransferObject(new CodegenGeneratedTOBuilder(
- generatedTypeBuilder.getFullyQualifiedName(), "myTOName3")));
+ assertEquals(generatedTypeBuilder, generatedTypeBuilder.addEnclosingTransferObject(
+ new CodegenGeneratedTOBuilder(generatedTypeBuilder.getIdentifier().createEnclosed("myTOName3"))));
assertNotNull(enclosingTransferObject);
assertNotNull(enclosingTransferObject2);
assertTrue(enclosedTypes.contains(enclosingTransferObject.build()));
assertTrue(enclosedTypes.contains(enclosingTransferObject2.build()));
- assertTrue(enclosedTypes.contains(new CodegenGeneratedTOBuilder(generatedTypeBuilder.getFullyQualifiedName(),
- "myTOName3").build()));
- assertFalse(enclosedTypes.contains(new CodegenGeneratedTOBuilder(generatedTypeBuilder.getFullyQualifiedName(),
- "myTOName4").build()));
-
+ assertTrue(enclosedTypes.contains(new CodegenGeneratedTOBuilder(
+ generatedTypeBuilder.getIdentifier().createEnclosed("myTOName3")).build()));
+ assertFalse(enclosedTypes.contains(new CodegenGeneratedTOBuilder(
+ generatedTypeBuilder.getIdentifier().createEnclosed("myTOName4")).build()));
}
@Test
public void generatedTypeTest() {
- GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
+ GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("my.package", "MyName"));
generatedTypeBuilder.setDescription("My description ...");
generatedTypeBuilder.setModuleName("myModuleName");
assertNotNull(generatedTypeBuilder.addComment(TypeComments.javadoc("My comment..").get()));
assertEquals(
- "GeneratedTransferObject [packageName=my.package, name=MyName, comment=My comment.., annotations=[], implements=[], enclosedTypes=[], constants=[], enumerations=[], properties=, methods=[]]",
- generatedTypeBuilder.toString());
+ "GeneratedTransferObject [packageName=my.package, name=MyName, comment=My comment.., annotations=[], "
+ + "implements=[], enclosedTypes=[], constants=[], enumerations=[], properties=, methods=[]]",
+ generatedTypeBuilder.toString());
GeneratedType instance = generatedTypeBuilder.build();
import org.junit.Test;
import org.opendaylight.mdsal.binding.model.api.MethodSignature;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
public class MethodSignatureBuilderImplTest {
@Test
public void testAddParameterMethod() {
final MethodSignatureBuilderImpl signatureBuilderImpl = new MethodSignatureBuilderImpl("testMethod");
- final CodegenGeneratedTypeBuilder ipAddressType = new CodegenGeneratedTypeBuilder("org.opendaylight.yangtools.test", "IpAddress");
+ final CodegenGeneratedTypeBuilder ipAddressType = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("org.opendaylight.yangtools.test", "IpAddress"));
signatureBuilderImpl.addParameter(ipAddressType, "ipAddress");
final MethodSignature methodSignature = signatureBuilderImpl.toInstance(null);
assertEquals("ipAddress", methodSignature.getParameters().get(0).getName());
final MethodSignatureBuilderImpl signatureBuilderImpl4 = new MethodSignatureBuilderImpl(null);
final MethodSignatureBuilderImpl signatureBuilderImpl5 = signatureBuilderImpl;
final MethodSignatureBuilderImpl signatureBuilderImpl6 = new MethodSignatureBuilderImpl("testMethod");
- final CodegenGeneratedTypeBuilder returnType = new CodegenGeneratedTypeBuilder("org.opendaylight.yangtools.test", "Address");
+ final CodegenGeneratedTypeBuilder returnType = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("org.opendaylight.yangtools.test", "Address"));
signatureBuilderImpl6.setReturnType(returnType);
assertEquals(signatureBuilderImpl.hashCode(), signatureBuilderImpl2.hashCode());
import org.opendaylight.mdsal.binding.model.api.GeneratedProperty
import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject
import org.opendaylight.mdsal.binding.model.api.GeneratedType
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName
import org.opendaylight.mdsal.binding.model.api.MethodSignature
import org.opendaylight.mdsal.binding.model.api.Type
import org.opendaylight.mdsal.binding.model.api.ParameterizedType
new(GeneratedType genType) {
super(genType)
this.properties = propertiesFromMethods(createMethods)
- addImport(Builder.simpleName, Builder.package.name)
+ addImport(Builder)
}
/**
} else if (implementedIfc.fullyQualifiedName == Augmentable.name) {
for (m : Augmentable.methods) {
if (m.name == GET_AUGMENTATION_METHOD_NAME) {
- val fullyQualifiedName = m.returnType.name
- val pkg = fullyQualifiedName.package
- val name = fullyQualifiedName.name
- val tmpGenTO = new CodegenGeneratedTOBuilder(pkg, name)
- val refType = new ReferencedTypeImpl(pkg, name)
- val generic = new ReferencedTypeImpl(type.packageName, type.name)
+ val identifier = JavaTypeName.create(m.returnType)
+ val tmpGenTO = new CodegenGeneratedTOBuilder(identifier)
+ val refType = new ReferencedTypeImpl(identifier)
+ val generic = new ReferencedTypeImpl(type.identifier)
val parametrizedReturnType = Types.parameterizedTypeFor(refType, generic)
tmpGenTO.addMethod(m.name).setReturnType(parametrizedReturnType)
augmentField = tmpGenTO.build.methodDefinitions.first.propertyFromGetter
elements.get(0)
}
- /**
- * Returns the name of the package from <code>fullyQualifiedName</code>.
- *
- * @param fullyQualifiedName string with fully qualified type name (package + type)
- * @return string with the package name
- */
- def private String getPackage(String fullyQualifiedName) {
- val lastDotIndex = fullyQualifiedName.lastIndexOf(Constants.DOT)
- return if (lastDotIndex == -1) "" else fullyQualifiedName.substring(0, lastDotIndex)
- }
-
- /**
- * Returns the name of tye type from <code>fullyQualifiedName</code>
- *
- * @param fullyQualifiedName string with fully qualified type name (package + type)
- * @return string with the name of the type
- */
- def private String getName(String fullyQualifiedName) {
- val lastDotIndex = fullyQualifiedName.lastIndexOf(Constants.DOT)
- return if (lastDotIndex == -1) fullyQualifiedName else fullyQualifiedName.substring(lastDotIndex + 1)
- }
-
/**
* Creates set of generated property instances from getter <code>methods</code>.
*
}
if (method.name.startsWith(prefix)) {
val fieldName = method.getName().substring(prefix.length()).toFirstLower
- val tmpGenTO = new CodegenGeneratedTOBuilder("foo", "foo")
+ val tmpGenTO = new CodegenGeneratedTOBuilder(JavaTypeName.create("foo", "foo"))
tmpGenTO.addProperty(fieldName).setReturnType(method.returnType)
return tmpGenTO.build.properties.first
}
}
- override isLocalInnerClass(String importedTypePackageName) {
+ override isLocalInnerClass(JavaTypeName name) {
// Builders do not have inner types
return false;
}
import org.opendaylight.mdsal.binding.model.api.GeneratedProperty;
import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
import org.opendaylight.mdsal.binding.model.api.GeneratedType;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.MethodSignature;
import org.opendaylight.mdsal.binding.model.api.ParameterizedType;
import org.opendaylight.mdsal.binding.model.api.Type;
* @throws IllegalArgumentException
* if <code>genType</code> equals <code>null</code>
*/
- static Map<String, String> createImports(final GeneratedType genType) {
+ static Map<String, JavaTypeName> createImports(final GeneratedType genType) {
if (genType == null) {
throw new IllegalArgumentException("Generated Type cannot be NULL!");
}
- final Map<String, String> imports = new LinkedHashMap<>();
+ final Map<String, JavaTypeName> imports = new LinkedHashMap<>();
List<GeneratedType> childGeneratedTypes = genType.getEnclosedTypes();
if (!childGeneratedTypes.isEmpty()) {
* </ul>
*/
static void putTypeIntoImports(final GeneratedType parentGenType, final Type type,
- final Map<String, String> imports) {
+ final Map<String, JavaTypeName> imports) {
checkArgument(parentGenType != null, "Parent Generated Type parameter MUST be specified and cannot be "
+ "NULL!");
checkArgument(parentGenType.getName() != null, "Parent Generated Type name cannot be NULL!");
return;
}
if (!imports.containsKey(typeName)) {
- imports.put(typeName, typePackageName);
+ imports.put(typeName, type.getIdentifier());
}
if (type instanceof ParameterizedType) {
final ParameterizedType paramType = (ParameterizedType) type;
/**
* Creates the map which maps the type name to package name and contains
* only package names for enclosed types of <code>genType</code> and
- * recursivelly their enclosed types.
+ * recursively their enclosed types.
*
* @param genType
* JAVA <code>Type</code> for which is the map created
* @return map of the package names for all the enclosed types and
- * recursivelly their enclosed types
+ * recursively their enclosed types
*/
static Map<String, String> createChildImports(final GeneratedType genType) {
Map<String, String> childImports = new LinkedHashMap<>();
- List<GeneratedType> childGeneratedTypes = genType.getEnclosedTypes();
- if (!childGeneratedTypes.isEmpty()) {
- for (GeneratedType genTypeChild : childGeneratedTypes) {
- createChildImports(genTypeChild);
- childImports.put(genTypeChild.getName(), genTypeChild.getPackageName());
- }
+ for (GeneratedType genTypeChild : genType.getEnclosedTypes()) {
+ createChildImports(genTypeChild);
+ childImports.put(genTypeChild.getName(), genTypeChild.getPackageName());
}
return childImports;
}
* </ul>
*/
static String getExplicitType(final GeneratedType parentGenType, final Type type,
- final Map<String, String> imports) {
-
+ final Map<String, JavaTypeName> imports) {
checkArgument(type != null, "Type parameter MUST be specified and cannot be NULL!");
- checkArgument(type.getName() != null, "Type name cannot be NULL!");
- checkArgument(type.getPackageName() != null, "Type cannot have Package Name referenced as NULL!");
checkArgument(imports != null, "Imports Map cannot be NULL!");
- final String typePackageName = type.getPackageName();
- final String typeName = type.getName();
- final String importedPackageName = imports.get(typeName);
- final StringBuilder builder;
-
- if (typePackageName.equals(importedPackageName)) {
- builder = new StringBuilder(type.getName());
+ final JavaTypeName importedType = imports.get(type.getName());
+ final StringBuilder builder = new StringBuilder();
+ if (type.getIdentifier().equals(importedType)) {
+ builder.append(type.getName());
addActualTypeParameters(builder, type, parentGenType, imports);
if (builder.toString().equals("Void")) {
return "void";
}
} else {
- builder = new StringBuilder();
- if (!typePackageName.isEmpty()) {
- builder.append(typePackageName).append(Constants.DOT).append(type.getName());
- } else {
- builder.append(type.getName());
- }
if (type.equals(Types.voidType())) {
return "void";
}
+ builder.append(type.getFullyQualifiedName());
addActualTypeParameters(builder, type, parentGenType, imports);
}
return builder.toString();
* parameters</li> <li>else only <code>builder</code></li>
*/
private static StringBuilder addActualTypeParameters(final StringBuilder builder, final Type type,
- final GeneratedType parentGenType, final Map<String, String> imports) {
+ final GeneratedType parentGenType, final Map<String, JavaTypeName> imports) {
if (type instanceof ParameterizedType) {
final ParameterizedType pType = (ParameterizedType) type;
final Type[] pTypes = pType.getActualTypeArguments();
* @return string with all actual type parameters from <code>pTypes</code>
*/
private static String getParameters(final GeneratedType parentGenType, final Type[] pTypes,
- final Map<String, String> availableImports) {
+ final Map<String, JavaTypeName> availableImports) {
if (pTypes == null || pTypes.length == 0) {
return "?";
import org.opendaylight.mdsal.binding.model.api.GeneratedProperty;
import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
import org.opendaylight.mdsal.binding.model.api.GeneratedType;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.Restrictions;
import org.opendaylight.mdsal.binding.model.api.Type;
import org.opendaylight.mdsal.binding.model.util.Types;
*/
class JavaFileTemplate {
// Hidden to well-define operations
- private final Map<String, String> importMap = new HashMap<>();
+ private final Map<String, JavaTypeName> importMap = new HashMap<>();
protected final GeneratedType type;
return importMap.entrySet().stream()
.filter(e -> isDefaultVisible(e.getValue()))
.sorted((e1, e2) -> {
- final int cmp = e1.getValue().compareTo(e2.getValue());
- return cmp != 0 ? cmp : e1.getKey().compareTo(e2.getKey());
+ return e1.getValue().toString().compareTo(e2.getValue().toString());
})
- .map(e -> "import " + e.getValue() + "." + e.getKey() + ";\n")
+ .map(e -> "import " + e.getValue() + ";\n")
.collect(Collectors.joining());
}
return importedName(Types.typeForClass(cls));
}
- final void addImport(final String className, final String packageName) {
- importMap.put(className, packageName);
+ final void addImport(final Class<?> cls) {
+ final JavaTypeName name = JavaTypeName.create(cls);
+ importMap.put(name.simpleName(), name);
}
final void addImports(final JavaFileTemplate from) {
}
// Exposed for BuilderTemplate
- boolean isLocalInnerClass(final String importedTypePackageName) {
- return type.getFullyQualifiedName().equals(importedTypePackageName);
+ boolean isLocalInnerClass(final JavaTypeName name) {
+ final Optional<JavaTypeName> optEnc = name.immediatelyEnclosingClass();
+ return optEnc.isPresent() && type.getIdentifier().equals(optEnc.get());
}
- private boolean isDefaultVisible(final String prefix) {
- return !hasSamePackage(prefix) || !isLocalInnerClass(prefix);
+ private boolean isDefaultVisible(final JavaTypeName name) {
+ return !hasSamePackage(name) || !isLocalInnerClass(name);
}
/**
* @param importedTypePackageName the package name of imported type
* @return true if the packages are the same false otherwise
*/
- private boolean hasSamePackage(final String importedTypePackageName) {
- return type.getPackageName().equals(importedTypePackageName);
+ private boolean hasSamePackage(final JavaTypeName name) {
+ return type.getPackageName().equals(name.packageName());
}
}
import static org.opendaylight.mdsal.binding.model.util.Types.getOuterClassName;
import com.google.common.base.Preconditions;
+import com.google.common.io.BaseEncoding
import java.beans.ConstructorProperties
import org.opendaylight.mdsal.binding.model.api.GeneratedProperty
import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject
new(GeneratedTransferObject genType) {
super(genType)
if (isBaseEncodingImportRequired) {
- addImport("BaseEncoding","com.google.common.io")
+ addImport(BaseEncoding)
}
}
import org.junit.Test;
import org.opendaylight.mdsal.binding.model.api.GeneratedProperty;
import org.opendaylight.mdsal.binding.model.api.GeneratedType;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.MethodSignature;
import org.opendaylight.mdsal.binding.model.api.Type;
private static final String PROPERTIES_FIELD_NAME = "properties";
private static final String TEST = "test";
+ private static final JavaTypeName TYPE_NAME = JavaTypeName.create(TEST, TEST);
@Test
public void basicTest() {
private static GeneratedType mockGenTypeMoreMeth(final String methodeName) {
final GeneratedType genType = spy(GeneratedType.class);
+ doReturn(TYPE_NAME).when(genType).getIdentifier();
doReturn(TEST).when(genType).getName();
doReturn(TEST).when(genType).getPackageName();
private static GeneratedType mockGenType(final String methodeName) {
final GeneratedType genType = spy(GeneratedType.class);
+ doReturn(TYPE_NAME).when(genType).getIdentifier();
doReturn(TEST).when(genType).getName();
doReturn(TEST).when(genType).getPackageName();
final MethodSignature methSign = mock(MethodSignature.class);
doReturn(methodeName).when(methSign).getName();
final Type methType = mock(Type.class);
- doReturn(TEST).when(methType).getName();
- doReturn(TEST).when(methType).getPackageName();
+ doReturn(TYPE_NAME).when(methType).getIdentifier();
doReturn(methType).when(methSign).getReturnType();
return methSign;
}
import org.opendaylight.mdsal.binding.model.api.GeneratedProperty;
import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
import org.opendaylight.mdsal.binding.model.api.GeneratedType;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.MethodSignature;
import org.opendaylight.mdsal.binding.model.api.ParameterizedType;
import org.opendaylight.mdsal.binding.model.api.Type;
public class GeneratorUtilTest {
+ private static final JavaTypeName ANNOTATION = JavaTypeName.create("tst.package", "tstAnnotationName");
+ private static final JavaTypeName PARAMETERIZED_TYPE = JavaTypeName.create("tst.package", "tstParametrizedType");
+ private static final JavaTypeName TYPE = JavaTypeName.create("tst.package", "tstName");
private final GeneratedType generatedType = mock(GeneratedType.class);
private final GeneratedTransferObject enclosedType = mock(GeneratedTransferObject.class);
doReturn("tst.package").when(parameterizedType).getPackageName();
doReturn("tstParametrizedType").when(parameterizedType).getName();
+ doReturn(PARAMETERIZED_TYPE).when(parameterizedType).getIdentifier();
doReturn("tst.package").when(type).getPackageName();
doReturn("tstName").when(type).getName();
+ doReturn(TYPE).when(type).getIdentifier();
doReturn(parameterizedType).when(property).getReturnType();
doReturn(new Type[] { type }).when(parameterizedType).getActualTypeArguments();
doReturn(ImmutableList.of(property)).when(enclosedType).getProperties();
doReturn(true).when(property).isReadOnly();
doReturn("tst.package").when(enclosedType).getPackageName();
doReturn("tstName").when(enclosedType).getName();
+ doReturn(TYPE).when(enclosedType).getIdentifier();
+
doReturn(ImmutableList.of(parameter)).when(methodSignature).getParameters();
doReturn("tst.package").when(annotationType).getPackageName();
doReturn("tstAnnotationName").when(annotationType).getName();
+ doReturn(ANNOTATION).when(annotationType).getIdentifier();
doReturn(type).when(parameter).getType();
doReturn(type).when(methodSignature).getReturnType();
@Test
public void createImportsTest() throws Exception {
- final Map<String, String> generated = createImports(generatedType);
+ final Map<String, JavaTypeName> generated = createImports(generatedType);
assertNotNull(generated);
- assertTrue(generated.get("tstAnnotationName").equals("tst.package"));
+ assertEquals(JavaTypeName.create("tst.package", "tstAnnotationName"), generated.get("tstAnnotationName"));
}
@Test(expected = IllegalArgumentException.class)
import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
import org.opendaylight.mdsal.binding.model.api.GeneratedType;
import org.opendaylight.mdsal.binding.model.api.Type;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedPropertyBuilder;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTOBuilder;
import org.opendaylight.mdsal.binding.model.util.Types;
*/
@Test
public void defaultConstructorNotPresentInValueTypeTest() {
- final GeneratedTOBuilder toBuilder = new CodegenGeneratedTOBuilder("simple.pack", "DefCtor");
+ final GeneratedTOBuilder toBuilder = new CodegenGeneratedTOBuilder(JavaTypeName.create("simple.pack", "DefCtor"));
GeneratedPropertyBuilder propBuilder = toBuilder.addProperty("foo");
propBuilder.setReturnType(Types.typeForClass(String.class));
@Test
public void toStringTest() {
- final GeneratedTOBuilder toBuilder = new CodegenGeneratedTOBuilder("simple.pack", "DefCtor");
+ final GeneratedTOBuilder toBuilder = new CodegenGeneratedTOBuilder(JavaTypeName.create("simple.pack", "DefCtor"));
GeneratedPropertyBuilder propBuilder = toBuilder.addProperty("foo");
propBuilder.setReturnType(Types.typeForClass(String.class));
import org.junit.Test;
import org.opendaylight.mdsal.binding.java.api.generator.GeneratorJavaFile;
import org.opendaylight.mdsal.binding.model.api.GeneratedType;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
import org.opendaylight.mdsal.binding.model.util.BindingTypes;
import org.opendaylight.mdsal.binding.model.util.Types;
types.add(t1);
types.add(t2);
types.add(t3);
- GeneratedTypeBuilder gtb = new CodegenGeneratedTypeBuilder("org.opendaylight.controller.gen", "Type4");
+ GeneratedTypeBuilder gtb = new CodegenGeneratedTypeBuilder(
+ JavaTypeName.create("org.opendaylight.controller.gen", "Type4"));
gtb.addImplementsType(Types.augmentableTypeFor(gtb));
types.add(gtb.build());
GeneratorJavaFile generator = new GeneratorJavaFile(types);
}
private static GeneratedType createGeneratedType(final String pkgName, final String name) {
- GeneratedTypeBuilder builder = new CodegenGeneratedTypeBuilder(pkgName, name);
+ GeneratedTypeBuilder builder = new CodegenGeneratedTypeBuilder(JavaTypeName.create(pkgName, name));
builder.addImplementsType(BindingTypes.DATA_OBJECT);
return builder.build();
}
Code Review / mdsal.git / commitdiff