import java.util.List;
import org.opendaylight.mdsal.binding.model.api.AnnotationType;
import org.opendaylight.mdsal.binding.model.api.Type;
+import org.opendaylight.yangtools.concepts.Builder;
/**
* Annotation Type Builder Interface serves for creation and instantiation of
*
* @see AnnotationType
*/
-public interface AnnotationTypeBuilder extends Type {
+public interface AnnotationTypeBuilder extends Type, Builder<AnnotationType> {
/**
* The method creates new AnnotationTypeBuilder containing specified package
*
* @return <code>new</code> <i>immutable</i> instance of Annotation Type.
*/
- AnnotationType toInstance();
+ @Override
+ AnnotationType build();
}
import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
import org.opendaylight.mdsal.binding.model.api.Restrictions;
+import org.opendaylight.yangtools.concepts.Builder;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
/**
*
* @see GeneratedTransferObject
*/
-public interface GeneratedTOBuilder extends GeneratedTypeBuilderBase<GeneratedTOBuilder> {
+public interface GeneratedTOBuilder extends GeneratedTypeBuilderBase<GeneratedTOBuilder>,
+ Builder<GeneratedTransferObject> {
/**
* Add Generated Transfer Object from which will be extended current
*
* @return generated transfer object instance
*/
- GeneratedTransferObject toInstance();
+ @Override
+ GeneratedTransferObject build();
void setTypedef(boolean isTypedef);
package org.opendaylight.mdsal.binding.model.api.type.builder;
import org.opendaylight.mdsal.binding.model.api.GeneratedType;
+import org.opendaylight.yangtools.concepts.Builder;
/**
* Generated Type Builder interface is helper interface for building and
*
* @see GeneratedType
*/
-public interface GeneratedTypeBuilder extends GeneratedTypeBuilderBase<GeneratedTypeBuilder> {
+public interface GeneratedTypeBuilder extends GeneratedTypeBuilderBase<GeneratedTypeBuilder>, Builder<GeneratedType> {
/**
* Returns the <code>new</code> <i>immutable</i> instance of Generated Type.
*
* @return the <code>new</code> <i>immutable</i> instance of Generated Type.
*/
- GeneratedType toInstance();
+ @Override
+ GeneratedType build();
}
annotateDeprecatedIfNecessary(rpc.getStatus(), inType);
resolveDataSchemaNodes(module, basePackageName, inType, inType, input.getChildNodes());
genCtx.get(module).addChildNodeType(input, inType);
- final GeneratedType inTypeInstance = inType.toInstance();
+ final GeneratedType inTypeInstance = inType.build();
method.addParameter(inTypeInstance, "input");
}
annotateDeprecatedIfNecessary(rpc.getStatus(), outType);
resolveDataSchemaNodes(module, basePackageName, outType, outType, output.getChildNodes());
genCtx.get(module).addChildNodeType(output, outType);
- outTypeInstance = outType.toInstance();
+ outTypeInstance = outType.build();
}
final Type rpcRes = Types.parameterizedTypeFor(Types.typeForClass(RpcResult.class), outTypeInstance);
if (baseIdentities.isEmpty()) {
final GeneratedTOBuilder gto = typeProvider.newGeneratedTOBuilder(
BaseIdentity.class.getPackage().getName(), BaseIdentity.class.getSimpleName());
- newType.setExtendsType(gto.toInstance());
+ newType.setExtendsType(gto.build());
} else {
final IdentitySchemaNode baseIdentity = baseIdentities.iterator().next();
final Module baseIdentityParentModule = SchemaContextUtil.findParentModule(context, baseIdentity);
.getQNameModule());
final String returnTypeName = BindingMapping.getClassName(baseIdentity.getQName());
final GeneratedTransferObject gto = new CodegenGeneratedTOBuilder(returnTypePkgName, returnTypeName)
- .toInstance();
+ .build();
newType.setExtendsType(gto);
}
newType.setAbstract(true);
addRawAugmentGenTypeDefinition(module, augmentPackageName, augmentPackageName, targetType, augSchema);
} else {
- generateTypesFromAugmentedChoiceCases(module, augmentPackageName, targetTypeBuilder.toInstance(),
+ generateTypesFromAugmentedChoiceCases(module, augmentPackageName, targetTypeBuilder.build(),
(ChoiceSchemaNode) targetSchemaNode, augSchema.getChildNodes(), null);
}
}
packageName = packageNameForAugmentedGeneratedType(augmentPackageName,
((SchemaNode) usesNodeParent).getPath());
}
- addRawAugmentGenTypeDefinition(module, packageName, augmentPackageName, targetTypeBuilder.toInstance(),
+ addRawAugmentGenTypeDefinition(module, packageName, augmentPackageName, targetTypeBuilder.build(),
augSchema);
} else {
- generateTypesFromAugmentedChoiceCases(module, augmentPackageName, targetTypeBuilder.toInstance(),
+ generateTypesFromAugmentedChoiceCases(module, augmentPackageName, targetTypeBuilder.build(),
(ChoiceSchemaNode) targetSchemaNode, augSchema.getChildNodes(), usesNodeParent);
}
}
choiceTypeBuilder.addImplementsType(typeForClass(DataContainer.class));
annotateDeprecatedIfNecessary(choiceNode.getStatus(), choiceTypeBuilder);
genCtx.get(module).addChildNodeType(choiceNode, choiceTypeBuilder);
- generateTypesFromChoiceCases(module, basePackageName, choiceTypeBuilder.toInstance(), choiceNode);
+ generateTypesFromChoiceCases(module, basePackageName, choiceTypeBuilder.build(), choiceNode);
}
}
} else if (typeDef instanceof BitsTypeDefinition) {
GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, leaf, parentModule);
if (genTOBuilder != null) {
- returnType = genTOBuilder.toInstance();
+ returnType = genTOBuilder.build();
}
} else {
// It is constrained version of already declared type (inner declared type exists,
}
} else if (typeDef instanceof BitsTypeDefinition) {
final GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, node, parentModule);
- returnType = genTOBuilder.toInstance();
+ returnType = genTOBuilder.build();
} else {
final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(typeDef);
returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, node, restrictions);
final Set<Type> types = typeProvider.getAdditionalTypes().get(parentModule);
if (types == null) {
typeProvider.getAdditionalTypes().put(parentModule,
- Sets.newHashSet(unionBuilder.toInstance()));
+ Sets.newHashSet(unionBuilder.build()));
} else {
- types.add(unionBuilder.toInstance());
+ types.add(unionBuilder.build());
}
- return returnType.toInstance();
+ return returnType.build();
}
private GeneratedTOBuilder createUnionBuilder(final GeneratedTOBuilder genTOBuilder,
checkArgument(typeBuilder != null, "Generated Type Builder cannot be NULL.");
if (genTOBuilder != null) {
- final GeneratedTransferObject genTO = genTOBuilder.toInstance();
+ final GeneratedTransferObject genTO = genTOBuilder.build();
// Fake the 'getKey()' for items, this is equivalent to constructGetter()
final MethodSignatureBuilder getMethod = typeBuilder.addMethod(getterMethodName("key", genTO));
private GeneratedTypeBuilder addImplementedInterfaceFromUses(final DataNodeContainer dataNodeContainer,
final GeneratedTypeBuilder builder) {
for (final UsesNode usesNode : dataNodeContainer.getUses()) {
- final GeneratedType genType = findGroupingByPath(usesNode.getGroupingPath()).toInstance();
+ final GeneratedType genType = findGroupingByPath(usesNode.getGroupingPath()).build();
if (genType == null) {
throw new IllegalStateException("Grouping " + usesNode.getGroupingPath() + "is not resolved for "
+ builder.getName());
List<Type> result = new ArrayList<>();
if (moduleNode != null) {
- result.add(moduleNode.toInstance());
+ result.add(moduleNode.build());
}
for (GeneratedTOBuilder b : genTOs) {
- result.add(b.toInstance());
+ result.add(b.build());
}
for (Type b : typedefs.values()) {
if (b != null) {
}
}
for (GeneratedTypeBuilder b : childNodes.values()) {
- result.add(b.toInstance());
+ result.add(b.build());
}
for (GeneratedTypeBuilder b : groupings.values()) {
- result.add(b.toInstance());
+ result.add(b.build());
}
for (GeneratedTypeBuilder b : cases.values()) {
- result.add(b.toInstance());
+ result.add(b.build());
}
for (GeneratedTOBuilder b : identities.values()) {
- result.add(b.toInstance());
+ result.add(b.build());
}
for (GeneratedTypeBuilder b : topLevelNodes) {
- result.add(b.toInstance());
+ result.add(b.build());
}
for (GeneratedTypeBuilder b : augmentations) {
- result.add(b.toInstance());
+ result.add(b.build());
}
return result;
}
import java.util.Set;
import org.opendaylight.mdsal.binding.generator.api.BindingRuntimeTypes;
import org.opendaylight.mdsal.binding.model.api.Type;
-import org.opendaylight.mdsal.binding.model.api.type.builder.AnnotationTypeBuilder;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTOBuilder;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilderBase;
import org.opendaylight.mdsal.binding.model.api.type.builder.TypeMemberBuilder;
import org.opendaylight.mdsal.binding.yang.types.RuntimeTypeProvider;
+import org.opendaylight.yangtools.concepts.Builder;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DocumentedNode;
}
private static Type builtType(final Map<Type, Type> knownTypes, final Type type) {
- final Type existing = knownTypes.get(type);
- if (existing != null) {
- return existing;
- }
+ if (type instanceof Builder) {
+ final Type existing = knownTypes.get(type);
+ if (existing != null) {
+ return existing;
+ }
- final Type built;
- if (type instanceof AnnotationTypeBuilder) {
- built = ((AnnotationTypeBuilder) type).toInstance();
- } else if (type instanceof GeneratedTOBuilder) {
- built = ((GeneratedTOBuilder) type).toInstance();
- } else if (type instanceof GeneratedTypeBuilder) {
- built = ((GeneratedTypeBuilder) type).toInstance();
- } else {
- built = type;
+ final Type built = (Type) ((Builder<?>)type).build();
+ knownTypes.put(type, built);
+ return built;
}
-
- knownTypes.put(type, built);
- return built;
+ return type;
}
@Override
() -> new NullPointerException("Failed to find defined type for " + referencedType + " schema " + schema));
if (definedType instanceof GeneratedTypeBuilder) {
- return new SimpleEntry<>(((GeneratedTypeBuilder) definedType).toInstance(), schema);
+ return new SimpleEntry<>(((GeneratedTypeBuilder) definedType).build(), schema);
}
checkArgument(definedType instanceof GeneratedType, "Type %s is not a GeneratedType", referencedType);
return new SimpleEntry<>((GeneratedType) definedType, schema);
final Entry<Type,Type> caseIdentifier = new SimpleEntry<>(choiceType, caze);
final HashSet<Type> caseChildren = new HashSet<>();
if (caze instanceof GeneratedTypeBuilder) {
- caze = ((GeneratedTypeBuilder) caze).toInstance();
+ caze = ((GeneratedTypeBuilder) caze).build();
}
collectAllContainerTypes((GeneratedType) caze, caseChildren);
for (final Type caseChild : caseChildren) {
gpb.setFinal(gp.isFinal());
gpb.setStatic(gp.isStatic());
}
- return gtob.toInstance();
+ return gtob.build();
}
private boolean isLeafRefSelfReference(final LeafrefTypeDefinition leafref, final SchemaNode parentNode) {
genTOBuilder.setIsUnion(true);
addUnitsToGenTO(genTOBuilder, typedef.getUnits().orElse(null));
makeSerializable(genTOBuilder);
- returnType = genTOBuilder.toInstance();
+ returnType = genTOBuilder.build();
// union builder
final GeneratedTOBuilder unionBuilder = newGeneratedTOBuilder(genTOBuilder.getPackageName(),
genTOBuilder.getName() + "Builder");
method.setStatic(true);
Set<Type> types = additionalTypes.get(module);
if (types == null) {
- types = Sets.<Type> newHashSet(unionBuilder.toInstance());
+ types = Sets.<Type> newHashSet(unionBuilder.build());
additionalTypes.put(module, types);
} else {
- types.add(unionBuilder.toInstance());
+ types.add(unionBuilder.build());
}
} else if (innerTypeDefinition instanceof EnumTypeDefinition) {
// enums are automatically Serializable
genTOBuilder.setTypedef(true);
addUnitsToGenTO(genTOBuilder, typedef.getUnits().orElse(null));
makeSerializable(genTOBuilder);
- returnType = genTOBuilder.toInstance();
+ returnType = genTOBuilder.build();
} else {
final Type javaType = javaTypeForSchemaDefinitionType(innerTypeDefinition, typedef);
returnType = wrapJavaTypeIntoTO(basePackageName, typedef, javaType, module.getName());
addUnitsToGenTO(genTOBuilder, typedef.getUnits().orElse(null));
genTOBuilder.setTypedef(true);
makeSerializable(genTOBuilder);
- return genTOBuilder.toInstance();
+ return genTOBuilder.build();
}
/**
if (parentModule != null && parentModule.getName() != null) {
final Map<Optional<Revision>, Map<String, Type>> modulesByDate = genTypeDefsContextMap.get(parentModule.getName());
final Map<String, Type> genTOsMap = modulesByDate.get(parentModule.getRevision());
- genTOsMap.put(newTypeDef.getQName().getLocalName(), genTOBuilder.toInstance());
+ genTOsMap.put(newTypeDef.getQName().getLocalName(), genTOBuilder.build());
}
}
}
addUnitsToGenTO(genTOBuilder, typedef.getUnits().orElse(null));
makeSerializable(genTOBuilder);
- return genTOBuilder.toInstance();
+ return genTOBuilder.build();
}
/**
assertNotNull(unionTypeBuilder);
- GeneratedTransferObject unionType = unionTypeBuilder.toInstance();
+ GeneratedTransferObject unionType = unionTypeBuilder.build();
assertEquals("ComplexUnionType", unionType.getName());
unionTypeBuilder = provider.provideGeneratedTOBuilderForUnionTypeDef("test.package.name",
assertNotNull(unionTypeBuilder);
- unionType = unionTypeBuilder.toInstance();
+ unionType = unionTypeBuilder.build();
assertEquals("Union", unionType.getName());
unionTypeBuilder = provider.provideGeneratedTOBuilderForUnionTypeDef("test.package.name",
assertNotNull(unionTypeBuilder);
- unionType = unionTypeBuilder.toInstance();
+ unionType = unionTypeBuilder.build();
assertEquals("Union", unionType.getName());
}
assertNotNull(unionTypeBuilder);
- final GeneratedTransferObject unionType = unionTypeBuilder.toInstance();
+ final GeneratedTransferObject unionType = unionTypeBuilder.build();
assertEquals("ComplexStringIntUnionType", unionType.getName());
}
final GeneratedTOBuilder builder = new CodegenGeneratedTOBuilder("test.package", "TestBuilder");
CodegenTypeProvider.addUnitsToGenTO(builder, null);
- GeneratedTransferObject genTO = builder.toInstance();
+ GeneratedTransferObject genTO = builder.build();
assertTrue(genTO.getConstantDefinitions().isEmpty());
CodegenTypeProvider.addUnitsToGenTO(builder, "");
- genTO = builder.toInstance();
+ genTO = builder.build();
assertTrue(genTO.getConstantDefinitions().isEmpty());
CodegenTypeProvider.addUnitsToGenTO(builder, "125");
- genTO = builder.toInstance();
+ genTO = builder.build();
assertTrue(!genTO.getConstantDefinitions().isEmpty());
assertEquals(1, genTO.getConstantDefinitions().size());
assertEquals("_UNITS", genTO.getConstantDefinitions().get(0).getName());
final ArrayList<AnnotationType> a = new ArrayList<>();
for (final AnnotationTypeBuilder b : builder.annotationBuilders) {
- a.add(b.toInstance());
+ a.add(b.build());
}
this.annotations = ImmutableList.copyOf(a);
}
final ArrayList<GeneratedType> enclosedTypesList = new ArrayList<>(enclosedGenTypeBuilders.size() + enclosedGenTOBuilders.size());
for (final GeneratedTypeBuilder builder : enclosedGenTypeBuilders) {
if (builder != null) {
- enclosedTypesList.add(builder.toInstance());
+ enclosedTypesList.add(builder.build());
}
}
for (final GeneratedTOBuilder builder : enclosedGenTOBuilders) {
if (builder != null) {
- enclosedTypesList.add(builder.toInstance());
+ enclosedTypesList.add(builder.build());
}
}
return makeUnmodifiable(enclosedTypesList);
}
- protected static final List<AnnotationType> toUnmodifiableAnnotations(final List<AnnotationTypeBuilder> annotationBuilders) {
+ protected static final List<AnnotationType> toUnmodifiableAnnotations(
+ final List<AnnotationTypeBuilder> annotationBuilders) {
final List<AnnotationType> annotationList = new ArrayList<>(annotationBuilders.size());
for (final AnnotationTypeBuilder builder : annotationBuilders) {
- annotationList.add(builder.toInstance());
+ annotationList.add(builder.build());
}
return makeUnmodifiable(annotationList);
}
final List<AnnotationType> annotations = new ArrayList<>();
for (final AnnotationTypeBuilder annotBuilder : getAnnotationBuilders()) {
if (annotBuilder != null) {
- annotations.add(annotBuilder.toInstance());
+ annotations.add(annotBuilder.build());
}
}
public int hashCode() {
final int prime = 31;
int result = 1;
- result = (prime * result) + Objects.hashCode(getName());
- result = (prime * result) + Objects.hashCode(getReturnType());
+ result = prime * result + Objects.hashCode(getName());
+ result = prime * result + Objects.hashCode(getReturnType());
return result;
}
@Override
public AnnotationTypeBuilder addAnnotation(final String packageName, final String name) {
- if ((packageName != null) && (name != null)) {
+ if (packageName != null && name != null) {
final AnnotationTypeBuilder builder = new AnnotationTypeBuilderImpl(packageName, name);
if (!this.annotationBuilders.contains(builder)) {
this.annotationBuilders = LazyCollections.lazyAdd(this.annotationBuilders, builder);
@Override
public boolean addParameter(final String paramName, final String value) {
- if ((paramName != null) && (value != null)) {
+ if (paramName != null && value != null) {
final ParameterImpl param = new ParameterImpl(paramName, value);
return addParameter(param);
}
@Override
public boolean addParameters(final String paramName, final List<String> values) {
- if ((paramName != null) && (values != null)) {
+ if (paramName != null && values != null) {
final ParameterImpl param = new ParameterImpl(paramName, values);
return addParameter(param);
}
}
@Override
- public AnnotationType toInstance() {
+ public AnnotationType build() {
return new AnnotationTypeImpl(this.packageName, this.name, this.annotationBuilders, this.parameters);
}
public int hashCode() {
final int prime = 31;
int result = 1;
- result = (prime * result) + Objects.hashCode(this.name);
- result = (prime * result) + Objects.hashCode(this.packageName);
+ result = prime * result + Objects.hashCode(this.name);
+ result = prime * result + Objects.hashCode(this.packageName);
return result;
}
final List<AnnotationType> a = new ArrayList<>();
for (final AnnotationTypeBuilder builder : annotationBuilders) {
- a.add(builder.toInstance());
+ a.add(builder.build());
}
this.annotations = ImmutableList.copyOf(a);
public int hashCode() {
final int prime = 31;
int result = 1;
- result = (prime * result) + Objects.hashCode(this.name);
- result = (prime * result) + Objects.hashCode(this.packageName);
+ result = prime * result + Objects.hashCode(this.name);
+ result = prime * result + Objects.hashCode(this.packageName);
return result;
}
public int hashCode() {
final int prime = 31;
int result = 1;
- result = (prime * result) + Objects.hashCode(this.name);
+ result = prime * result + Objects.hashCode(this.name);
return result;
}
}
@Override
- public GeneratedTransferObject toInstance() {
+ public GeneratedTransferObject build() {
return new GTO(this);
}
}
@Override
- public GeneratedType toInstance() {
+ public GeneratedType build() {
return new GeneratedTypeImpl(this);
}
}
@Override
- public GeneratedTransferObject toInstance() {
+ public GeneratedTransferObject build() {
return new GTO(this);
}
}
@Override
- public GeneratedType toInstance() {
+ public GeneratedType build() {
return new GeneratedTypeImpl(this);
}
import java.util.ArrayList;
import java.util.List;
import org.junit.Test;
-import org.opendaylight.mdsal.binding.model.util.Types;
import org.opendaylight.mdsal.binding.model.api.AnnotationType;
import org.opendaylight.mdsal.binding.model.api.AnnotationType.Parameter;
import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTOBuilder;
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.Types;
public class AnnotationBuilderTest {
final AnnotationTypeBuilder annotDesc = genTypeBuilder.addAnnotation("javax.management", "Description");
annotDesc.addParameter("description", "some sort of interface");
- final GeneratedType genType = genTypeBuilder.toInstance();
+ final GeneratedType genType = genTypeBuilder.build();
assertNotNull(genType);
assertNotNull(genType.getAnnotations());
final AnnotationTypeBuilder annotManProp = methodBuilder.addAnnotation(
"org.springframework.jmx.export.annotation", "ManagedOperation");
- final List<String> typeValues = new ArrayList<String>();
+ final List<String> typeValues = new ArrayList<>();
typeValues.add("\"val1\"");
typeValues.add("\"val2\"");
typeValues.add("\"val3\"");
annotManProp.addParameters("types", typeValues);
- final GeneratedType genType = genTypeBuilder.toInstance();
+ final GeneratedType genType = genTypeBuilder.build();
assertNotNull(genType);
assertNotNull(genType.getAnnotations());
final AnnotationTypeBuilder annotManProp = propertyBuilder.addAnnotation(
"org.springframework.jmx.export.annotation", "ManagedOperation");
- final List<String> typeValues = new ArrayList<String>();
+ final List<String> typeValues = new ArrayList<>();
typeValues.add("\"val1\"");
typeValues.add("\"val2\"");
typeValues.add("\"val3\"");
annotManProp.addParameters("types", typeValues);
- final GeneratedTransferObject genTransObj = genTOBuilder.toInstance();
+ final GeneratedTransferObject genTransObj = genTOBuilder.build();
assertNotNull(genTransObj);
assertNotNull(genTransObj.getAnnotations());
genTypeBuilder.addAnnotation("javax.management", "MBean");
final AnnotationTypeBuilder annotNotify = genTypeBuilder.addAnnotation("javax.management", "NotificationInfo");
- final List<String> notifyList = new ArrayList<String>();
+ final List<String> notifyList = new ArrayList<>();
notifyList.add("\"my.notif.type\"");
annotNotify.addParameters("types", notifyList);
annotNotify.addParameter("description", "@Description(\"my notification\")");
- GeneratedTransferObject genTO = genTypeBuilder.toInstance();
+ GeneratedTransferObject genTO = genTypeBuilder.build();
assertNotNull(genTO);
assertNotNull(genTO.getAnnotations());
assertNotNull(annotationTypeBuilder.addAnnotation("my.package2", "MyName2"));
assertNull(annotationTypeBuilder.addAnnotation("my.package2", "MyName2"));
- AnnotationType annotationTypeInstance = annotationTypeBuilder.toInstance();
+ AnnotationType annotationTypeInstance = annotationTypeBuilder.build();
assertEquals(2, annotationTypeInstance.getAnnotations().size());
assertFalse(annotationTypeBuilder.equals(annotationTypeBuilder2));
assertFalse(annotationTypeBuilder.equals(annotationTypeBuilder3));
- AnnotationType instance = annotationTypeBuilder.toInstance();
- AnnotationType instance2 = annotationTypeBuilder2.toInstance();
- AnnotationType instance3 = annotationTypeBuilder3.toInstance();
- AnnotationType instance4 = annotationTypeBuilder4.toInstance();
+ AnnotationType instance = annotationTypeBuilder.build();
+ AnnotationType instance2 = annotationTypeBuilder2.build();
+ AnnotationType instance3 = annotationTypeBuilder3.build();
+ AnnotationType instance4 = annotationTypeBuilder4.build();
assertFalse(instance.equals(null));
assertFalse(instance.equals(new Object()));
annotationTypeBuilder.addParameter("myName2", "myValue2");
annotationTypeBuilder2.addParameter("myName", "myValue3");
- instance = annotationTypeBuilder.toInstance();
- instance2 = annotationTypeBuilder2.toInstance();
+ instance = annotationTypeBuilder.build();
+ instance2 = annotationTypeBuilder2.build();
Parameter parameter = instance.getParameter("myName");
Parameter parameter2 = instance.getParameter("myName2");
assertTrue(annotationTypeBuilder.hashCode() == annotationTypeBuilder4.hashCode());
assertTrue(annotationTypeBuilder.hashCode() == annotationTypeBuilder.hashCode());
- AnnotationType instance = annotationTypeBuilder.toInstance();
- AnnotationType instance2 = annotationTypeBuilder2.toInstance();
- AnnotationType instance3 = annotationTypeBuilder3.toInstance();
- AnnotationType instance4 = annotationTypeBuilder4.toInstance();
+ AnnotationType instance = annotationTypeBuilder.build();
+ AnnotationType instance2 = annotationTypeBuilder2.build();
+ AnnotationType instance3 = annotationTypeBuilder3.build();
+ AnnotationType instance4 = annotationTypeBuilder4.build();
assertFalse(instance.hashCode() == instance2.hashCode());
assertFalse(instance.hashCode() == instance3.hashCode());
annotationTypeBuilder.addParameter("myName2", "myValue2");
annotationTypeBuilder2.addParameter("myName", "myValue3");
- instance = annotationTypeBuilder.toInstance();
- instance2 = annotationTypeBuilder2.toInstance();
+ instance = annotationTypeBuilder.build();
+ instance2 = annotationTypeBuilder2.build();
Parameter parameter = instance.getParameter("myName");
Parameter parameter2 = instance.getParameter("myName2");
assertFalse(annotationTypeBuilder.addParameter("myName", "myValue"));
assertFalse(annotationTypeBuilder.addParameters("myName", new ArrayList<String>()));
- ArrayList<String> values = new ArrayList<String>();
+ ArrayList<String> values = new ArrayList<>();
values.add("myValue");
assertTrue(annotationTypeBuilder.addParameters("myName2", values));
- AnnotationType annotationTypeInstance = annotationTypeBuilder.toInstance();
+ AnnotationType annotationTypeInstance = annotationTypeBuilder.build();
assertTrue(annotationTypeInstance.containsParameters());
assertEquals(2, annotationTypeInstance.getParameters().size());
assertEquals(2, annotationTypeInstance.getParameterNames().size());
"AnnotationTypeBuilder [packageName=my.package, name=MyAnnotationName, annotationBuilders=[AnnotationTypeBuilder [packageName=my.package, name=MySubAnnotationName, annotationBuilders=[], parameters=[]]], parameters=[ParameterImpl [name=MyParameter, value=myValue, values=[]]]]",
annotationTypeBuilder.toString());
- AnnotationType annotationTypeInstance = annotationTypeBuilder.toInstance();
+ AnnotationType annotationTypeInstance = annotationTypeBuilder.build();
assertEquals("my.package.MyAnnotationName", annotationTypeInstance.getFullyQualifiedName());
assertEquals(
final AnnotationTypeBuilderImpl annotBuilderImpl = new AnnotationTypeBuilderImpl("org.opedaylight.yangtools.test", "AnnotationTest");
annotBuilderImpl.addAnnotation("org.opedaylight.yangtools.test.v1", "AnnotationTest2");
annotBuilderImpl.addAnnotation(null, "AnnotationTest2");
- assertFalse(annotBuilderImpl.toInstance().getAnnotations().isEmpty());
+ assertFalse(annotBuilderImpl.build().getAnnotations().isEmpty());
}
@Test
final AnnotationTypeBuilderImpl annotBuilderImpl = new AnnotationTypeBuilderImpl("org.opedaylight.yangtools.test", "AnnotationTest");
annotBuilderImpl.addParameter("testParam", "test value");
annotBuilderImpl.addParameter(null, "test value");
- final AnnotationType annotType = annotBuilderImpl.toInstance();
+ final AnnotationType annotType = annotBuilderImpl.build();
assertEquals(1, annotType.getParameters().size());
}
values.add("test3");
annotBuilderImpl.addParameters("testParam", values);
- AnnotationType annotType = annotBuilderImpl.toInstance();
+ AnnotationType annotType = annotBuilderImpl.build();
assertEquals(1, annotType.getParameters().size());
annotBuilderImpl.addParameters("testParam", null);
- annotType = annotBuilderImpl.toInstance();
+ annotType = annotBuilderImpl.build();
assertEquals(1, annotType.getParameters().size());
}
public void testMethodsForAnnotationTypeImpl() {
final AnnotationTypeBuilderImpl annotBuilderImpl = new AnnotationTypeBuilderImpl("org.opedaylight.yangtools.test", "AnnotationTest");
annotBuilderImpl.addParameter("testParam", "test value");
- final AnnotationType annotationType = annotBuilderImpl.toInstance();
+ final AnnotationType annotationType = annotBuilderImpl.build();
final AnnotationTypeBuilderImpl annotBuilderImpl2 = new AnnotationTypeBuilderImpl("org.opedaylight.yangtools.test", "AnnotationTest");
- final AnnotationType annotationType2 = annotBuilderImpl2.toInstance();
+ final AnnotationType annotationType2 = annotBuilderImpl2.build();
assertTrue(annotationType.containsParameters());
assertTrue(annotationType.getAnnotations().isEmpty());
annotBuilderImpl.addParameter("", "test value");
annotBuilderImpl.addParameter(null, "test value");
annotBuilderImpl.addParameter("", null);
- final AnnotationType annotationType = annotBuilderImpl.toInstance();
+ final AnnotationType annotationType = annotBuilderImpl.build();
final Parameter testParam = annotationType.getParameter("testParam");
assertEquals("testParam", testParam.getName());
*/
package org.opendaylight.mdsal.binding.model.util.generated.type.builder;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
import org.junit.Test;
-import org.opendaylight.mdsal.binding.model.util.Types;
import org.opendaylight.mdsal.binding.model.api.AccessModifier;
import org.opendaylight.mdsal.binding.model.api.GeneratedProperty;
+import org.opendaylight.mdsal.binding.model.util.Types;
public class GeneratedPropertyImplTest {
generatedPropertyBuilderImpl.setReturnType(Types.BOOLEAN);
GeneratedProperty instance = generatedPropertyBuilderImpl.toInstance(new CodegenGeneratedTypeBuilder("my.package",
- "myTypeName").toInstance());
+ "myTypeName").build());
assertNotNull(instance);
public void testSetExtendsType() {
final CodegenGeneratedTOBuilder genTOBuilder = new CodegenGeneratedTOBuilder("org.opendaylight.yangtools.test", "Test");
final CodegenGeneratedTOBuilder extendedTypeBuilder = new CodegenGeneratedTOBuilder("org.opendaylight.yangtools.test", "ExtendedType");
- final GeneratedTransferObject extendedType = extendedTypeBuilder.toInstance();
+ final GeneratedTransferObject extendedType = extendedTypeBuilder.build();
genTOBuilder.setExtendsType(extendedType);
- final GeneratedTransferObject genTO = genTOBuilder.toInstance();
+ final GeneratedTransferObject genTO = genTOBuilder.build();
assertEquals("ExtendedType", genTO.getSuperType().getName());
}
final GeneratedPropertyBuilderImpl propertyBuilder = new GeneratedPropertyBuilderImpl("testProperty");
genTOBuilder.addEqualsIdentity(propertyBuilder);
- final GeneratedTransferObject genTO = genTOBuilder.toInstance();
+ final GeneratedTransferObject genTO = genTOBuilder.build();
assertEquals(1, genTO.getEqualsIdentifiers().size());
assertEquals("testProperty", genTO.getEqualsIdentifiers().get(0).getName());
}
final GeneratedPropertyBuilderImpl propertyBuilder = new GeneratedPropertyBuilderImpl("testProperty");
genTOBuilder.addHashIdentity(propertyBuilder);
- final GeneratedTransferObject genTO = genTOBuilder.toInstance();
+ final GeneratedTransferObject genTO = genTOBuilder.build();
assertEquals(1, genTO.getHashCodeIdentifiers().size());
assertEquals("testProperty", genTO.getHashCodeIdentifiers().get(0).getName());
}
final GeneratedPropertyBuilderImpl propertyBuilder = new GeneratedPropertyBuilderImpl("testProperty");
genTOBuilder.addToStringProperty(propertyBuilder);
- final GeneratedTransferObject genTO = genTOBuilder.toInstance();
+ final GeneratedTransferObject genTO = genTOBuilder.build();
assertEquals(1, genTO.getToStringIdentifiers().size());
assertEquals("testProperty", genTO.getToStringIdentifiers().get(0).getName());
}
}
};
genTOBuilder.setRestrictions(restrictions);
- final GeneratedTransferObject genTO = genTOBuilder.toInstance();
+ final GeneratedTransferObject genTO = genTOBuilder.build();
assertNotNull(genTO.getRestrictions());
}
final GeneratedPropertyBuilderImpl propertyBuilder = new GeneratedPropertyBuilderImpl("testProperty");
genTOBuilder.setSUID(propertyBuilder);
- final GeneratedTransferObject genTO = genTOBuilder.toInstance();
+ final GeneratedTransferObject genTO = genTOBuilder.build();
assertEquals("testProperty", genTO.getSUID().getName());
}
genTOBuilder.setReference("http://tools.ietf.org/html/rfc6020");
genTOBuilder.setSchemaPath(SchemaPath.ROOT);
- final GeneratedTransferObject genTO = genTOBuilder.toInstance();
+ final GeneratedTransferObject genTO = genTOBuilder.build();
assertTrue(genTO.isTypedef());
assertTrue(genTO.isUnionType());
@Test
public void testMethodsOfGeneratedTransferObjectImpl() {
final CodegenGeneratedTOBuilder genTOBuilder = new CodegenGeneratedTOBuilder("org.opendaylight.yangtools.test", "Test");
- final GeneratedTransferObject genTO = genTOBuilder.toInstance();
+ final GeneratedTransferObject genTO = genTOBuilder.build();
assertNotNull(genTO.toString());
}
genTypeBuilder.setSUID(genTypeBuilder.addProperty("SUID"));
genTypeBuilder.addMethod("addCount");
- GeneratedTransferObject genTO = genTypeBuilder.toInstance();
+ GeneratedTransferObject genTO = genTypeBuilder.build();
genTypeBuilder.setExtendsType(genTO);
GeneratedPropertyBuilder property = genTypeBuilder
"org.opendaylight.controller", "AnnotClassCache");
genTypeBuilder1.setTypedef(true);
- GeneratedTransferObject genTO = genTypeBuilder1.toInstance();
+ GeneratedTransferObject genTO = genTypeBuilder1.build();
String toString = genTO.toString();
assertFalse(toString.contains("GeneratedTransferObject"));
"org.opendaylight.controller", "AnnotClassCache");
genTypeBuilder2.setTypedef(false);
- genTO = genTypeBuilder2.toInstance();
+ genTO = genTypeBuilder2.build();
toString = genTO.toString();
assertTrue(toString.contains("GeneratedTransferObject"));
assertEquals("Type (java.lang.String) myConstant myConstantValue", constant.toFormattedString());
- GeneratedType instance = generatedTypeBuilder.toInstance();
+ GeneratedType instance = generatedTypeBuilder.build();
List<Constant> constantDefinitions = instance.getConstantDefinitions();
assertNotNull(constantDefinitions);
assertEquals(2, constantDefinitions.size());
assertTrue(generatedTypeBuilder.containsProperty("myProperty2"));
assertFalse(generatedTypeBuilder.containsProperty("myProperty3"));
- GeneratedType instance = generatedTypeBuilder.toInstance();
+ GeneratedType instance = generatedTypeBuilder.build();
List<GeneratedProperty> properties = instance.getProperties();
assertEquals(2, properties.size());
@Test(expected = IllegalArgumentException.class)
public void addMethodIllegalArgumentTest() {
- CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
+ GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
generatedTypeBuilder.addMethod(null);
}
@Test
public void addMethodTest() {
- CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
+ GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
MethodSignatureBuilder methodBuilder = generatedTypeBuilder.addMethod("myMethodName");
MethodSignatureBuilder methodBuilder2 = generatedTypeBuilder.addMethod("myMethodName2");
assertTrue(generatedTypeBuilder.containsMethod("myMethodName2"));
assertFalse(generatedTypeBuilder.containsMethod("myMethodName3"));
- GeneratedType instance = generatedTypeBuilder.toInstance();
+ GeneratedType instance = generatedTypeBuilder.build();
List<MethodSignature> methodDefinitions = instance.getMethodDefinitions();
assertEquals(2, methodDefinitions.size());
@Test
public void addEnumerationTest() {
- CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
+ GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
EnumBuilder enumBuilder = generatedTypeBuilder.addEnumeration("myEnumName");
EnumBuilder enumBuilder2 = generatedTypeBuilder.addEnumeration("myEnumName2");
assertNotNull(enumBuilder);
assertNotNull(enumBuilder2);
- GeneratedType instance = generatedTypeBuilder.toInstance();
+ GeneratedType instance = generatedTypeBuilder.build();
List<Enumeration> enumerations = instance.getEnumerations();
assertEquals(2, enumerations.size());
@Test(expected = IllegalArgumentException.class)
public void addImplementsTypeIllegalArgumentTest() {
- CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
+ GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
generatedTypeBuilder.addImplementsType(null);
}
generatedTypeBuilder.addImplementsType(Types.typeForClass(Serializable.class)));
assertEquals(generatedTypeBuilder, generatedTypeBuilder.addImplementsType(Types.typeForClass(Runnable.class)));
- GeneratedType instance = generatedTypeBuilder.toInstance();
+ GeneratedType instance = generatedTypeBuilder.build();
List<Type> implementTypes = instance.getImplements();
assertEquals(2, implementTypes.size());
@Test
public void addEnclosingTransferObjectTest() {
- CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
+ GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
GeneratedTOBuilder enclosingTransferObject = generatedTypeBuilder.addEnclosingTransferObject("myTOName");
GeneratedTOBuilder enclosingTransferObject2 = generatedTypeBuilder.addEnclosingTransferObject("myTOName2");
assertNotNull(enclosingTransferObject);
assertNotNull(enclosingTransferObject2);
- GeneratedType instance = generatedTypeBuilder.toInstance();
+ GeneratedType instance = generatedTypeBuilder.build();
List<GeneratedType> enclosedTypes = instance.getEnclosedTypes();
assertEquals(3, enclosedTypes.size());
- assertTrue(enclosedTypes.contains(enclosingTransferObject.toInstance()));
- assertTrue(enclosedTypes.contains(enclosingTransferObject2.toInstance()));
+ assertTrue(enclosedTypes.contains(enclosingTransferObject.build()));
+ assertTrue(enclosedTypes.contains(enclosingTransferObject2.build()));
assertTrue(enclosedTypes.contains(new CodegenGeneratedTOBuilder(generatedTypeBuilder.getFullyQualifiedName(),
- "myTOName3").toInstance()));
+ "myTOName3").build()));
assertFalse(enclosedTypes.contains(new CodegenGeneratedTOBuilder(generatedTypeBuilder.getFullyQualifiedName(),
- "myTOName4").toInstance()));
+ "myTOName4").build()));
}
@Test
public void generatedTypeTest() {
- CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
+ GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder("my.package", "MyName");
generatedTypeBuilder.setDescription("My description ...");
generatedTypeBuilder.setModuleName("myModuleName");
"GeneratedTransferObject [packageName=my.package, name=MyName, comment=My comment.., annotations=[], implements=[], enclosedTypes=[], constants=[], enumerations=[], properties=, methods=[]]",
generatedTypeBuilder.toString());
- GeneratedType instance = generatedTypeBuilder.toInstance();
+ GeneratedType instance = generatedTypeBuilder.build();
assertEquals("My description ...", instance.getDescription());
assertEquals("myModuleName", instance.getModuleName());
val generic = new ReferencedTypeImpl(type.packageName, type.name)
val parametrizedReturnType = Types.parameterizedTypeFor(refType, generic)
tmpGenTO.addMethod(m.name).setReturnType(parametrizedReturnType)
- augmentField = tmpGenTO.toInstance.methodDefinitions.first.propertyFromGetter
+ augmentField = tmpGenTO.build.methodDefinitions.first.propertyFromGetter
}
}
}
val fieldName = method.getName().substring(prefix.length()).toFirstLower
val tmpGenTO = new CodegenGeneratedTOBuilder("foo", "foo")
tmpGenTO.addProperty(fieldName).setReturnType(method.returnType)
- return tmpGenTO.toInstance.properties.first
+ return tmpGenTO.build.properties.first
}
}
propBuilder.setReturnType(Types.typeForClass(Integer.class));
propBuilder.setReadOnly(false);
- final GeneratedTransferObject genTO = toBuilder.toInstance();
+ final GeneratedTransferObject genTO = toBuilder.build();
final TOGenerator clsGen = new TOGenerator();
final String outputStr = clsGen.generate(genTO);
propBuilder.setReturnType(Types.typeForClass(Integer.class));
propBuilder.setReadOnly(false);
toBuilder.addToStringProperty(propBuilder);
- final GeneratedTransferObject genTO = toBuilder.toInstance();
+ final GeneratedTransferObject genTO = toBuilder.build();
final TOGenerator clsGen = new TOGenerator();
assertEquals("", clsGen.generate(Types.typeForClass(String.class)));
assertNotNull(clsGen.generate(genTO));
@Test
public void test() throws IOException {
- final Set<GeneratedType> types = new HashSet<GeneratedType>();
+ final Set<GeneratedType> types = new HashSet<>();
GeneratedType t1 = createGeneratedType("org.opendaylight.controller.gen", "Type1");
GeneratedType t2 = createGeneratedType("org.opendaylight.controller.gen", "Type2");
GeneratedType t3 = createGeneratedType("org.opendaylight.controller.gen", "Type3");
types.add(t3);
GeneratedTypeBuilder gtb = new CodegenGeneratedTypeBuilder("org.opendaylight.controller.gen", "Type4");
gtb.addImplementsType(Types.augmentableTypeFor(gtb));
- types.add(gtb.toInstance());
+ types.add(gtb.build());
GeneratorJavaFile generator = new GeneratorJavaFile(types);
generator.generateToFile(new File(PATH));
assertTrue(filesList.contains("Type4Builder.java"));
}
- private static GeneratedType createGeneratedType(String pkgName, String name) {
+ private static GeneratedType createGeneratedType(final String pkgName, final String name) {
GeneratedTypeBuilder builder = new CodegenGeneratedTypeBuilder(pkgName, name);
builder.addImplementsType(BindingTypes.DATA_OBJECT);
- return builder.toInstance();
+ return builder.build();
}
}
Code Review / mdsal.git / commitdiff