package org.opendaylight.mdsal.binding.model.api;
/**
- * Interface Contact is designed to hold and model java constant. In Java there
- * are no constant keywords instead of the constant is defined as static final
- * field with assigned value. For this purpose the Constant interface contains
- * methods {@link #getType()} to provide wrapped return Type of Constant,
- * {@link #getName()} the Name of constant and the {@link #getValue()} for
- * providing of value assigned to Constant. To determine of which type the
- * constant value is it is recommended firstly to retrieve Type from constant.
- * The Type interface holds base information like java package name and java
- * type name (e.g. fully qualified name). From this string user should be able
- * to determine to which type can be {@link #getValue()} type typecasted to
- * unbox and provide value assigned to constant.
+ * Interface Contact is designed to hold and model java constant. In Java there are no constant keywords instead of the
+ * constant is defined as static final field with assigned value. For this purpose the Constant interface contains
+ * methods {@link #getType()} to provide wrapped return Type of Constant, {@link #getName()} the Name of constant and
+ * the {@link #getValue()} for providing of value assigned to Constant. To determine of which type the constant value is
+ * it is recommended firstly to retrieve Type from constant. The Type interface holds base information like java package
+ * name and java type name (e.g. fully qualified name). From this string user should be able to determine to which type
+ * can be {@link #getValue()} type typecasted to unbox and provide value assigned to constant.
*/
public interface Constant {
-
- /**
- * Returns the Type that declares constant.
- *
- * @return the Type that declares constant.
- */
- Type getDefiningType();
-
/**
* Returns the return Type (or just Type) of the Constant.
*
* Interface provide methods for reading data of enumeration class.
*/
public interface Enumeration extends GeneratedType {
- /**
- * Returns list of annotation definitions associated with enumeration type.
- *
- * @return list of annotation definitions associated with enumeration type.
- */
- @Override
- List<AnnotationType> getAnnotations();
-
- @Override
- Type getParentType();
-
/**
* Returns list of the couples - name and value.
*
* no need to specify the scope of visibility.
*/
public interface GeneratedType extends Type, DocumentedType {
- /**
- * Returns the parent type if Generated Type is defined as enclosing type, otherwise returns <code>null</code>.
- *
- * @return the parent type if Generated Type is defined as enclosing type, otherwise returns <code>null</code>
- */
- Type getParentType();
-
/**
* Returns comment string associated with Generated Type.
*
* @return the name of member.
*/
String getName();
-
- /**
- * Returns the Type that declares member.
- *
- * @return the Type that declares member.
- */
- Type getDefiningType();
}
package org.opendaylight.mdsal.binding.model.api.type.builder;
import org.opendaylight.mdsal.binding.model.api.Constant;
-import org.opendaylight.mdsal.binding.model.api.Type;
public interface ConstantBuilder {
void assignValue(Object value);
- Constant toInstance(Type definingType);
+ Constant toInstance();
}
void setDescription(String description);
- Enumeration toInstance(Type definingType);
+ Enumeration toInstance();
/**
* Updates this builder with data from <code>enumTypeDef</code>. Specifically this data represents list
package org.opendaylight.mdsal.binding.model.api.type.builder;
import org.opendaylight.mdsal.binding.model.api.GeneratedProperty;
-import org.opendaylight.mdsal.binding.model.api.Type;
/**
* Generated Property Builder is interface that contains methods to build and instantiate Generated Property definition.
* as <code>null</code> reference the method SHOULD thrown
* {@link IllegalArgumentException}.
*
- * @param definingType Defining Type of Generated Property
* @return <code>new</code> <i>immutable</i> instance of Generated Property.
*/
- GeneratedProperty toInstance(Type definingType);
+ GeneratedProperty toInstance();
}
final EnumBuilder enumBuilder = typeBuilder.addEnumeration(BindingMapping.getClassName(enumName));
typeProvider.addEnumDescription(enumBuilder, enumTypeDef);
enumBuilder.updateEnumPairsFromEnumTypeDef(enumTypeDef);
- final Enumeration ret = enumBuilder.toInstance(typeBuilder);
+ final Enumeration ret = enumBuilder.toInstance();
context.addTypeToSchema(ret, enumTypeDef);
context.addInnerTypedefType(enumTypeDef.getPath(), ret);
return ret;
enumBuilder.setModuleName(module.getName());
enumBuilder.setSchemaPath(enumTypeDef.getPath());
enumBuilder.updateEnumPairsFromEnumTypeDef(enumTypeDef);
- return enumBuilder.toInstance(null);
+ return enumBuilder.toInstance();
}
/**
addEnumDescription(enumBuilder, enumTypeDef);
enumBuilder.updateEnumPairsFromEnumTypeDef(enumTypeDef);
- return enumBuilder.toInstance(enumBuilder);
+ return enumBuilder.toInstance();
}
public abstract void addEnumDescription(EnumBuilder enumBuilder, EnumTypeDefinition enumTypeDef);
}
abstract static class AbstractEnumeration extends AbstractBaseType implements Enumeration {
-
- private final Type definingType;
- private final List<Pair> values;
private final List<AnnotationType> annotations;
+ private final List<Pair> values;
- AbstractEnumeration(final AbstractEnumerationBuilder builder, final Type definingType) {
+ AbstractEnumeration(final AbstractEnumerationBuilder builder) {
super(builder.getIdentifier());
- this.definingType = definingType;
this.values = ImmutableList.copyOf(builder.values);
final ArrayList<AnnotationType> a = new ArrayList<>();
this.annotations = ImmutableList.copyOf(a);
}
- @Override
- public final Type getParentType() {
- return this.definingType;
- }
-
@Override
public final List<Pair> getValues() {
return this.values;
final StringBuilder builder = new StringBuilder();
builder.append("Enumeration [packageName=");
builder.append(getPackageName());
- if (this.definingType != null) {
- builder.append(", definingType=");
- builder.append(this.definingType.getPackageName());
- builder.append(".");
- builder.append(this.definingType.getName());
- } else {
- builder.append(", definingType= null");
- }
builder.append(", name=");
builder.append(getName());
builder.append(", values=");
abstract class AbstractGeneratedType extends AbstractBaseType implements GeneratedType {
- private final Type parent;
private final TypeComment comment;
private final List<AnnotationType> annotations;
private final List<Type> implementsTypes;
AbstractGeneratedType(final AbstractGeneratedTypeBuilder<?> builder) {
super(builder.getIdentifier());
- this.parent = builder.getParent();
this.comment = builder.getComment();
this.annotations = toUnmodifiableAnnotations(builder.getAnnotations());
this.implementsTypes = makeUnmodifiable(builder.getImplementsTypes());
this.definition = builder.getYangSourceDefinition().orElse(null);
}
- AbstractGeneratedType(final Type parent, final JavaTypeName identifier, final TypeComment comment,
+ AbstractGeneratedType(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(identifier);
- this.parent = parent;
this.comment = comment;
this.annotations = toUnmodifiableAnnotations(annotationBuilders);
this.implementsTypes = makeUnmodifiable(implementsTypes);
protected final List<Enumeration> toUnmodifiableEnumerations(final List<EnumBuilder> enumBuilders) {
final List<Enumeration> enums = new ArrayList<>(enumBuilders.size());
for (final EnumBuilder enumBuilder : enumBuilders) {
- enums.add(enumBuilder.toInstance(this));
+ enums.add(enumBuilder.toInstance());
}
return makeUnmodifiable(enums);
}
final List<GeneratedPropertyBuilder> methodBuilders) {
final List<GeneratedProperty> methods = new ArrayList<>(methodBuilders.size());
for (final GeneratedPropertyBuilder methodBuilder : methodBuilders) {
- methods.add(methodBuilder.toInstance(this));
+ methods.add(methodBuilder.toInstance());
}
return makeUnmodifiable(methods);
}
- @Override
- public final Type getParentType() {
- return this.parent;
- }
-
@Override
public final TypeComment getComment() {
return this.comment;
builder.append(getPackageName());
builder.append(", name=");
builder.append(getName());
- if (this.parent != null) {
- builder.append(", parent=");
- builder.append(this.parent.getFullyQualifiedName());
- } else {
- builder.append(", parent=null");
- }
builder.append(", comment=");
builder.append(this.comment);
builder.append(", annotations=");
checkArgument(!containsConstant(name),
"This generated type already contains a \"%s\" constant", name);
- final Constant constant = new ConstantImpl(this, type, name, value);
+ final Constant constant = new ConstantImpl(type, name, value);
this.constants = LazyCollections.lazyAdd(this.constants, constant);
return constant;
}
private final String name;
private final TypeMemberComment comment;
- private final Type definingType;
private final Type returnType;
private final List<AnnotationType> annotations;
private final boolean isFinal;
private final boolean isStatic;
private final AccessModifier accessModifier;
- protected AbstractTypeMember(final
Type definingType, final String name, final List<AnnotationType> annotations,
+ protected AbstractTypeMember(final String name, final List<AnnotationType> annotations,
final TypeMemberComment comment, final AccessModifier accessModifier, final Type returnType,
final boolean isFinal, final boolean isStatic) {
- this.definingType = definingType;
this.name = name;
this.annotations = annotations;
this.comment = comment;
return comment;
}
- @Override
- public Type getDefiningType() {
- return this.definingType;
- }
-
@Override
public AccessModifier getAccessModifier() {
return this.accessModifier;
@Override
public String toString() {
- final StringBuilder builder = new StringBuilder()
+ return new StringBuilder()
.append("AbstractTypeMember [name=").append(getName())
.append(", comment=").append(getComment())
- .append(", definingType=");
- if (getDefiningType() != null) {
- builder.append(getDefiningType().getPackageName()).append('.').append(getDefiningType().getName());
- } else {
- builder.append(" null");
- }
- return builder.append(", returnType=").append(getReturnType())
+ .append(", returnType=").append(getReturnType())
.append(", annotations=").append(getAnnotations())
- .append(']').toString();
+ .append(']')
+ .toString();
}
}
import java.util.Optional;
import org.opendaylight.mdsal.binding.model.api.Enumeration;
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;
import org.opendaylight.yangtools.yang.common.QName;
}
@Override
- public Enumeration toInstance(final Type definingType) {
- return new EnumerationImpl(this, definingType);
+ public Enumeration toInstance() {
+ return new EnumerationImpl(this);
}
@Override
private final String moduleName;
private final SchemaPath schemaPath;
- EnumerationImpl(final CodegenEnumerationBuilder builder, final Type definingType) {
- super(builder, definingType);
+ EnumerationImpl(final CodegenEnumerationBuilder builder) {
+ super(builder);
this.description = builder.description;
this.moduleName = builder.moduleName;
this.schemaPath = builder.schemaPath;
if (builder.suid == null) {
this.suid = null;
} else {
- this.suid = builder.suid.toInstance(GTO.this);
+ this.suid = builder.suid.toInstance();
}
}
import org.opendaylight.mdsal.binding.model.api.Type;
final class ConstantImpl implements Constant {
-
- private final Type definingType;
private final Type type;
private final String name;
private final Object value;
- ConstantImpl(final Type definingType, final Type type, final String name, final Object value) {
- this.definingType = definingType;
+ ConstantImpl(final Type type, final String name, final Object value) {
this.type = type;
this.name = name;
this.value = value;
}
- @Override
- public Type getDefiningType() {
- return this.definingType;
- }
-
@Override
public Type getType() {
return this.type;
builder.append(this.name);
builder.append(", value=");
builder.append(this.value);
- if (this.definingType != null) {
- builder.append(", definingType=");
- builder.append(this.definingType.getPackageName());
- builder.append(".");
- builder.append(this.definingType.getName());
- } else {
- builder.append(", definingType= null");
- }
builder.append("]");
return builder.toString();
}
import java.util.List;
import org.opendaylight.mdsal.binding.model.api.AnnotationType;
import org.opendaylight.mdsal.binding.model.api.GeneratedProperty;
-import org.opendaylight.mdsal.binding.model.api.Type;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedPropertyBuilder;
public final class GeneratedPropertyBuilderImpl extends AbstractTypeMemberBuilder<GeneratedPropertyBuilder>
}
@Override
- public GeneratedProperty toInstance(final Type definingType) {
+ public GeneratedProperty toInstance() {
final List<AnnotationType> annotations = toAnnotationTypes();
- return new GeneratedPropertyImpl(definingType, getName(), annotations, getComment(), getAccessModifier(),
- getReturnType(), isFinal(), isStatic(), this.readOnly, this.value);
+ return new GeneratedPropertyImpl(getName(), annotations, getComment(), getAccessModifier(), getReturnType(),
+ isFinal(), isStatic(), this.readOnly, this.value);
}
@Override
private final String value;
private final boolean readOnly;
- GeneratedPropertyImpl(final Type definingType, final String name, final List<AnnotationType> annotations,
- final TypeMemberComment comment, final AccessModifier accessModifier, final Type returnType,
- final boolean isFinal, final boolean isStatic, final boolean isReadOnly, final String value) {
- super(definingType, name, annotations, comment, accessModifier, returnType, isFinal, isStatic);
+ GeneratedPropertyImpl(final String name, final List<AnnotationType> annotations, final TypeMemberComment comment,
+ final AccessModifier accessModifier, final Type returnType, final boolean isFinal, final boolean isStatic,
+ final boolean isReadOnly, final String value) {
+ super(name, annotations, comment, accessModifier, returnType, isFinal, isStatic);
this.value = value;
this.readOnly = isReadOnly;
}
@Override
public String toString() {
- final StringBuilder builder = new StringBuilder()
+ return new StringBuilder()
.append("GeneratedPropertyImpl [name=").append(getName())
.append(", annotations=").append(getAnnotations())
.append(", comment=").append(getComment())
- .append(", parent=");
- if (getDefiningType() != null) {
- builder.append(getDefiningType().getPackageName()).append(".").append(getDefiningType().getName());
- } else {
- builder.append("null");
- }
- return builder.append(", returnType=").append(getReturnType())
+ .append(", returnType=").append(getReturnType())
.append(", isFinal=").append(isFinal())
.append(", isReadOnly=").append(readOnly)
.append(", modifier=").append(getAccessModifier())
- .append(']').toString();
+ .append(']')
+ .toString();
}
}
@Override
public MethodSignature toInstance(final Type definingType) {
final List<AnnotationType> annotations = toAnnotationTypes();
- return new MethodSignatureImpl(definingType, getName(), annotations, getComment(), getAccessModifier(),
- getReturnType(), this.unmodifiableParams, isFinal(), this.isAbstract, isStatic(), isDefault, mechanics);
+ return new MethodSignatureImpl(getName(), annotations, getComment(), getAccessModifier(), getReturnType(),
+ unmodifiableParams, isFinal(), isAbstract, isStatic(), isDefault, mechanics);
}
@Override
private final boolean isDefault;
@VisibleForTesting
- MethodSignatureImpl(final
Type definingType, final String name, final List<AnnotationType> annotations,
- final TypeMemberComment comment, final AccessModifier accessModifier, final Type returnType,
- final List<Parameter> params, final boolean isFinal, final boolean isAbstract, final boolean isStatic) {
- this(definingType, name, annotations, comment, accessModifier, returnType, params, isFinal, isAbstract,
- isStatic, false, ValueMechanics.NORMAL);
+ MethodSignatureImpl(final String name, final List<AnnotationType> annotations,
+ final TypeMemberComment comment, final AccessModifier accessModifier, final Type returnType,
+
final List<Parameter> params, final boolean isFinal, final boolean isAbstract, final boolean isStatic) {
+ this(name, annotations, comment, accessModifier, returnType, params, isFinal, isAbstract, isStatic, false,
+ ValueMechanics.NORMAL);
}
- MethodSignatureImpl(final
Type definingType, final String name, final List<AnnotationType> annotations,
+ MethodSignatureImpl(final String name, final List<AnnotationType> annotations,
final TypeMemberComment comment, final AccessModifier accessModifier, final Type returnType,
final List<Parameter> params, final boolean isFinal, final boolean isAbstract, final boolean isStatic,
final boolean isDefault, final ValueMechanics mechanics) {
- super(definingType, name, annotations, comment, accessModifier, returnType, isFinal, isStatic);
+ super(name, annotations, comment, accessModifier, returnType, isFinal, isStatic);
this.params = params;
this.isAbstract = isAbstract;
this.isDefault = isDefault;
@Override
public String toString() {
- final StringBuilder builder = new StringBuilder()
+ return new StringBuilder()
.append("MethodSignatureImpl [name=").append(getName())
.append(", comment=").append(getComment())
- .append(", definingType=");
-
- final Type defType = getDefiningType();
- if (defType != null) {
- builder.append(defType.getPackageName()).append('.').append(defType.getName());
- } else {
- builder.append(" null");
- }
-
- return builder
.append(", returnType=").append(getReturnType())
.append(", params=").append(this.params)
.append(", annotations=").append(getAnnotations())
- .append(']').toString();
+ .append(']')
+ .toString();
}
}
import java.util.Optional;
import org.opendaylight.mdsal.binding.model.api.Enumeration;
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;
import org.opendaylight.yangtools.yang.common.QName;
}
@Override
- public Enumeration toInstance(final Type definingType) {
- return new EnumerationImpl(this, definingType);
+ public Enumeration toInstance() {
+ return new EnumerationImpl(this);
}
@Override
}
private static final class EnumerationImpl extends AbstractEnumeration {
- EnumerationImpl(final RuntimeEnumerationBuilder builder, final Type definingType) {
- super(builder, definingType);
+ EnumerationImpl(final RuntimeEnumerationBuilder builder) {
+ super(builder);
}
@Override
assertTrue(genProperty.isFinal());
assertTrue(genProperty.isStatic());
assertEquals(genProperty.hashCode(), genProperty2.hashCode());
- assertTrue(genProperty.toString().contains("org.opendaylight.yangtools.test.TestType"));
+ assertEquals("MethodSignatureImpl [name=TestProperty, comment=TypeMemberComment{contract=test comment}, "
+ + "returnType=null, params=[], annotations=[]]", genProperty.toString());
assertNotNull(genProperty.toString());
assertTrue(genProperty.equals(genProperty2));
assertFalse(genProperty.equals(null));
import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
public class ConstantImplTest {
-
@Test
public void testMethodsOfConstantImpl() {
- 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");
+ final ConstantImpl constImpl = new ConstantImpl(type, "IpAddress", "127.0.0.1");
+ final ConstantImpl constImpl2 = new ConstantImpl(type, "IpAddress", "127.0.0.1");
+ final ConstantImpl constImpl3 = new ConstantImpl(type, "IpAddress", "127.0.0.0");
final ConstantImpl constImpl4 = constImpl;
- final ConstantImpl constImpl5 = new ConstantImpl(definingType, type, null, "127.0.0.0");
- final ConstantImpl constImpl6 = new ConstantImpl(definingType, type, "IpAddress", null);
+ final ConstantImpl constImpl5 = new ConstantImpl(type, null, "127.0.0.0");
+ final ConstantImpl constImpl6 = new ConstantImpl(type, "IpAddress", null);
- assertEquals("DefiningType", constImpl.getDefiningType().getName());
assertEquals("BaseType", constImpl.getType().getName());
assertEquals("IpAddress", constImpl.getName());
assertEquals("127.0.0.1", constImpl.getValue());
assertTrue(constImpl.toFormattedString().contains("GeneratedTransferObject"));
assertTrue(constImpl.toString().contains("GeneratedTransferObject"));
assertEquals(constImpl.hashCode(), constImpl2.hashCode());
- assertNotNull(constImpl.getDefiningType());
assertNotNull(constImpl.getType());
assertNotNull(constImpl.getName());
assertNotNull(constImpl.getValue());
enumerationBuilderOtherName = new CodegenEnumerationBuilder(JavaTypeName.create(packageName, "SomeOtherName"));
enumerationBuilderOtherPackage = new CodegenEnumerationBuilder(JavaTypeName.create("org.opendaylight.other",
name));
- enumeration = enumerationBuilder.toInstance(enumerationBuilder);
+ enumeration = enumerationBuilder.toInstance();
}
@Test(expected = NullPointerException.class)
assertEquals(name, enumeration.getName());
assertEquals(packageName, enumeration.getPackageName());
assertEquals(null, enumeration.getComment());
- assertEquals(enumerationBuilder, enumeration.getParentType());
assertEquals(DESCRIPTION, enumeration.getDescription());
assertEquals(moduleName, enumeration.getModuleName());
assertEquals(packageName + '.' + name, enumeration.getFullyQualifiedName());
assertEquals(enumeration, enumeration);
assertNotEquals(enumeration, "string");
- final Enumeration enumerationOtherPackage = enumerationBuilderOtherPackage
- .toInstance(enumerationBuilderOtherPackage);
+ final Enumeration enumerationOtherPackage = enumerationBuilderOtherPackage.toInstance();
assertNotEquals(enumeration, enumerationOtherPackage);
- final Enumeration enumerationOtherName = enumerationBuilderOtherName.toInstance(enumerationBuilderOtherName);
+ final Enumeration enumerationOtherName = enumerationBuilderOtherName.toInstance();
assertNotEquals(enumeration, enumerationOtherName);
enumerationBuilderSame.addValue(valueName, valueName, value, Status.CURRENT, valueDescription, null);
- final Enumeration enumerationSame = enumerationBuilderSame.toInstance(enumerationBuilderSame);
+ final Enumeration enumerationSame = enumerationBuilderSame.toInstance();
assertEquals(enumeration, enumerationSame);
final CodegenEnumerationBuilder enumerationBuilderSame1 = new CodegenEnumerationBuilder(
JavaTypeName.create(packageName, name));
- final Enumeration enumerationSame1 = enumerationBuilderSame1.toInstance(enumerationBuilderSame1);
+ final Enumeration enumerationSame1 = enumerationBuilderSame1.toInstance();
enumerationBuilderSame1.addValue(valueName, valueName, 14, Status.CURRENT, valueDescription, null);
// Enums are equal thanks to same package name and local name
assertEquals(enumeration, enumerationSame1);
@Test
public void testEnumerationToString() {
- final String formattedString = "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]]]";
-
- assertEquals(s, enumeration.toString());
- assertEquals(formattedString, enumeration.toFormattedString());
+ assertEquals("Enumeration [packageName=" + packageName + ", name=" + name
+ + ", values=[EnumPair [name=TestValue, mappedName=TestValue, value=12]]]", enumeration.toString());
+ assertEquals("public enum " + name + " {\n"
+ + "\t TestValue " + "(12 );\n"
+ + "}", enumeration.toFormattedString());
assertEquals("EnumerationBuilderImpl [packageName=org.opendaylight.test, name=TestName, "
+ "values=[EnumPair [name=TestValue, mappedName=TestValue, value=12]]]",
+ "(java.lang.Boolean), isFinal=true, isReadOnly=false, modifier=PUBLIC]",
generatedPropertyBuilderImpl.toString());
- GeneratedProperty instance = generatedPropertyBuilderImpl.toInstance(null);
+ GeneratedProperty instance = generatedPropertyBuilderImpl.toInstance();
assertNotNull(instance);
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.api.TypeMemberComment;
import org.opendaylight.mdsal.binding.model.util.Types;
generatedPropertyBuilderImpl.setAccessModifier(AccessModifier.PUBLIC);
generatedPropertyBuilderImpl.setReturnType(Types.BOOLEAN);
- GeneratedProperty instance = generatedPropertyBuilderImpl.toInstance(new CodegenGeneratedTypeBuilder(
- JavaTypeName.create("my.package", "myTypeName")).build());
+ GeneratedProperty instance = generatedPropertyBuilderImpl.toInstance();
assertNotNull(instance);
assertEquals("GeneratedPropertyImpl [name=myPropertyName, annotations=[], "
+ "comment=TypeMemberComment{contract=myComment}, "
- + "parent=my.package.myTypeName, returnType=Type (java.lang.Boolean), isFinal=true, isReadOnly=false, "
+ + "returnType=Type (java.lang.Boolean), isFinal=true, isReadOnly=false, "
+ "modifier=PUBLIC]", instance.toString());
}
generatedPropertyBuilderImpl3.setReturnType(Types.BOOLEAN);
generatedPropertyBuilderImpl4.setReturnType(Types.STRING);
- final GeneratedProperty property = generatedPropertyBuilderImpl.toInstance(null);
- final GeneratedProperty property2 = generatedPropertyBuilderImpl2.toInstance(null);
- final GeneratedProperty property3 = generatedPropertyBuilderImpl3.toInstance(null);
- final GeneratedProperty property4 = generatedPropertyBuilderImpl4.toInstance(null);
+ final GeneratedProperty property = generatedPropertyBuilderImpl.toInstance();
+ final GeneratedProperty property2 = generatedPropertyBuilderImpl2.toInstance();
+ final GeneratedProperty property3 = generatedPropertyBuilderImpl3.toInstance();
+ final GeneratedProperty property4 = generatedPropertyBuilderImpl4.toInstance();
assertNotNull(property);
assertNotNull(property2);
propertyBuilderImpl.setValue("new value");
propertyBuilderImpl.setReadOnly(true);
- final GeneratedProperty genProperty = propertyBuilderImpl.toInstance(null);
+ final GeneratedProperty genProperty = propertyBuilderImpl.toInstance();
assertNotNull(genProperty);
assertNotNull(propertyBuilderImpl.toString());
@Test
public void testMethodsForGeneratedPropertyImpl() {
- final GeneratedPropertyImpl propertyImpl = new GeneratedPropertyImpl(null, "Test", null,
+ final GeneratedPropertyImpl propertyImpl = new GeneratedPropertyImpl("Test", null,
TypeMemberComment.contractOf("test property"), AccessModifier.PRIVATE, null, true, true, true,
"test value");
Constant constant2 = generatedTypeBuilder.addConstant(
Types.typeForClass(int.class, BindingGeneratorUtil.getRestrictions(null)), "myIntConstant", 1);
- Constant constant3 = new ConstantImpl(generatedTypeBuilder, Types.typeForClass(String.class), "myConstant",
- "myConstantValue");
- final Constant constant4 = new ConstantImpl(generatedTypeBuilder, Types.typeForClass(String.class),
- "myConstant2", "myConstantValue");
- final Constant constant5 = new ConstantImpl(generatedTypeBuilder, Types.typeForClass(String.class),
- "myConstant", "myConstantValue2");
+ Constant constant3 = new ConstantImpl(Types.typeForClass(String.class), "myConstant", "myConstantValue");
+ final Constant constant4 = new ConstantImpl(Types.typeForClass(String.class), "myConstant2", "myConstantValue");
+ final Constant constant5 = new ConstantImpl(Types.typeForClass(String.class), "myConstant", "myConstantValue2");
assertNotNull(constant);
assertNotNull(constant2);
assertFalse(constant.hashCode() == constant4.hashCode());
assertTrue(constant.hashCode() == constant5.hashCode());
- assertEquals("Constant [type=Type (java.lang.String), name=myConstant, value=myConstantValue, "
- + "definingType=my.package.MyName]", constant.toString());
+ assertEquals("Constant [type=Type (java.lang.String), name=myConstant, value=myConstantValue]",
+ constant.toString());
assertEquals("Type (java.lang.String) myConstant myConstantValue", constant.toFormattedString());
assertEquals("myConstant", constant.getName());
assertEquals("myConstantValue", constant.getValue());
assertEquals(Types.typeForClass(String.class), constant.getType());
- assertEquals(generatedTypeBuilder, constant.getDefiningType());
}
@Test(expected = IllegalArgumentException.class)
assertEquals(2, properties.size());
- assertTrue(properties.contains(propertyBuilder.toInstance(instance)));
- assertTrue(properties.contains(propertyBuilder2.toInstance(instance)));
+ assertTrue(properties.contains(propertyBuilder.toInstance()));
+ assertTrue(properties.contains(propertyBuilder2.toInstance()));
// assertTrue(properties.contains(propertyBuilderNull.toInstance(instance)));
- assertFalse(properties.contains(new GeneratedPropertyBuilderImpl("myProperty3").toInstance(instance)));
+ assertFalse(properties.contains(new GeneratedPropertyBuilderImpl("myProperty3").toInstance()));
}
assertEquals(2, enumerations.size());
- assertTrue(enumerations.contains(enumBuilder.toInstance(instance)));
- assertTrue(enumerations.contains(enumBuilder2.toInstance(instance)));
+ assertTrue(enumerations.contains(enumBuilder.toInstance()));
+ assertTrue(enumerations.contains(enumBuilder2.toInstance()));
assertFalse(enumerations.contains(new CodegenEnumerationBuilder(JavaTypeName.create("my.package",
- "myEnumName3"))
- .toInstance(instance)));
+ "myEnumName3")).toInstance()));
}
boolean isAbstract = false;
boolean isStatic = false;
- signature1 = new MethodSignatureImpl(type, name, annotations, comment,
+ signature1 = new MethodSignatureImpl(name, annotations, comment,
accessModifier, returnType, params, isFinal, isAbstract,
isStatic);
- signature2 = new MethodSignatureImpl(type, name, annotations, comment,
+ signature2 = new MethodSignatureImpl(name, annotations, comment,
accessModifier, returnType, params, isFinal, isAbstract,
isStatic);
returnType = null;
- signature3 = new MethodSignatureImpl(type, name, annotations, comment,
+ signature3 = new MethodSignatureImpl(name, annotations, comment,
accessModifier, returnType, params, isFinal, isAbstract,
isStatic);
name = null;
- signature4 = new MethodSignatureImpl(type, name, annotations, comment,
+ signature4 = new MethodSignatureImpl(name, annotations, comment,
accessModifier, returnType, params, isFinal, isAbstract,
isStatic);
throw uoe();
}
- @Override
- public Type getDefiningType() {
- throw uoe();
- }
-
@Override
public String getValue() {
throw uoe();
Code Review / mdsal.git / commitdiff