import org.opendaylight.mdsal.binding.dom.codec.api.MissingClassInLoadingStrategyException;
import org.opendaylight.mdsal.binding.dom.codec.api.MissingSchemaException;
import org.opendaylight.mdsal.binding.dom.codec.api.MissingSchemaForClassException;
-import org.opendaylight.mdsal.binding.model.api.DefaultType;
+import org.opendaylight.mdsal.binding.model.api.Type;
import org.opendaylight.mdsal.binding.runtime.api.BindingRuntimeContext;
import org.opendaylight.yangtools.yang.binding.Augmentation;
import org.opendaylight.yangtools.yang.binding.BindingObject;
}
try {
- runtimeContext.loadClass(DefaultType.of(childClass));
+ runtimeContext.loadClass(Type.of(childClass));
} catch (final ClassNotFoundException e) {
throw new MissingClassInLoadingStrategyException(
"User supplied class " + childClass.getName() + " is not available in " + runtimeContext, e);
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.mdsal.binding.dom.codec.api.IncorrectNestingException;
-import org.opendaylight.mdsal.binding.model.api.DefaultType;
import org.opendaylight.mdsal.binding.model.api.Type;
import org.opendaylight.mdsal.binding.runtime.api.BindingRuntimeContext;
import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
final BindingRuntimeContext ctx = factory().getRuntimeContext();
final Class<?> loaded;
try {
- loaded = ctx.loadClass(DefaultType.of(cls));
+ loaded = ctx.loadClass(Type.of(cls));
} catch (ClassNotFoundException e) {
LOG.debug("Proposed {} cannot be loaded in {}", cls, ctx, e);
return false;
exports org.opendaylight.mdsal.binding.model.api;
exports org.opendaylight.mdsal.binding.model.api.type.builder;
+ requires transitive org.opendaylight.yangtools.concepts;
requires transitive org.opendaylight.yangtools.yang.model.api;
// Annotations
*/
package org.opendaylight.mdsal.binding.model.api;
-import static java.util.Objects.requireNonNull;
-
import com.google.common.annotations.Beta;
-import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.yangtools.concepts.AbstractSimpleIdentifiable;
/**
* It is used only as ancestor for other <code>Type</code>s. Note this forms the equality domain over most types, please
* consider joining the party.
*/
@Beta
-public class AbstractBaseType implements Type {
- /**
- * Name of this <code>Type</code>.
- */
- private final @NonNull JavaTypeName identifier;
-
+public abstract class AbstractType extends AbstractSimpleIdentifiable<JavaTypeName> implements Type {
/**
* Constructs the instance of this class with a JavaTypeName.
*
* @param identifier for this <code>Type</code>
*/
- protected AbstractBaseType(final JavaTypeName identifier) {
- this.identifier = requireNonNull(identifier);
- }
-
- @Override
- public final JavaTypeName getIdentifier() {
- return this.identifier;
+ protected AbstractType(final JavaTypeName identifier) {
+ super(identifier);
}
@Override
public final int hashCode() {
- return identifier.hashCode();
+ return getIdentifier().hashCode();
}
@Override
public final boolean equals(final Object obj) {
- if (this == obj) {
- return true;
- }
- if (!(obj instanceof Type)) {
- return false;
- }
- return identifier.equals(((Type) obj).getIdentifier());
- }
-
- @Override
- public String toString() {
- return "Type (" + getFullyQualifiedName() + ")";
+ return this == obj || obj instanceof Type && getIdentifier().equals(((Type) obj).getIdentifier());
}
}
*/
package org.opendaylight.mdsal.binding.model.api;
-import com.google.common.annotations.Beta;
-import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.concepts.Identifiable;
-
/**
* Wraps combination of <code>packageName</code> and <code>name</code> to the object representation.
*/
-@Beta
-public final class DefaultType extends AbstractBaseType {
- private DefaultType(final JavaTypeName identifier) {
+final class DefaultType extends AbstractType {
+ DefaultType(final JavaTypeName identifier) {
super(identifier);
}
-
- public static @NonNull DefaultType of(final JavaTypeName identifier) {
- return new DefaultType(identifier);
- }
-
- public static @NonNull DefaultType of(final Identifiable<JavaTypeName> type) {
- return of(type.getIdentifier());
- }
-
- public static @NonNull Type of(final Class<?> type) {
- return of(JavaTypeName.create(type));
- }
}
*/
package org.opendaylight.mdsal.binding.model.api;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.Identifiable;
/**
default String getFullyQualifiedName() {
return getIdentifier().toString();
}
+
+ static @NonNull Type of(final JavaTypeName identifier) {
+ return new DefaultType(identifier);
+ }
+
+ static @NonNull Type of(final Identifiable<JavaTypeName> type) {
+ return of(type.getIdentifier());
+ }
+
+ static @NonNull Type of(final Class<?> type) {
+ return of(JavaTypeName.create(type));
+ }
}
import org.junit.Test;
-public class DefaultTypeTest {
+public class TypeTest {
@Test
public void testCreateNewReferencedType() {
- DefaultType refType = DefaultType.of(JavaTypeName.create("org.opendaylight.yangtools.test", "RefTypeTest"));
+ Type refType = Type.of(JavaTypeName.create("org.opendaylight.yangtools.test", "RefTypeTest"));
assertEquals("RefTypeTest", refType.getName());
}
@Test
public void testToStringMethod() {
- DefaultType refType = DefaultType.of(JavaTypeName.create("org.opendaylight.yangtools.test", "RefTypeTest"));
+ Type refType = Type.of(JavaTypeName.create("org.opendaylight.yangtools.test", "RefTypeTest"));
assertTrue(refType.toString().contains("RefTypeTest"));
}
}
package org.opendaylight.mdsal.binding.generator.impl.reactor;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.mdsal.binding.model.api.DefaultType;
import org.opendaylight.mdsal.binding.model.api.GeneratedType;
import org.opendaylight.mdsal.binding.model.api.Type;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
if (parent instanceof ListGenerator) {
final KeyGenerator keyGen = ((ListGenerator) parent).keyGenerator();
if (keyGen != null) {
- return BindingTypes.keyedListAction(DefaultType.of(parent.typeName()),
- keyGen.getGeneratedType(builderFactory), input, output);
+ return BindingTypes.keyedListAction(Type.of(parent.typeName()), keyGen.getGeneratedType(builderFactory),
+ input, output);
}
}
- return BindingTypes.action(DefaultType.of(parent.typeName()), input, output);
+ return BindingTypes.action(Type.of(parent.typeName()), input, output);
}
@Override
*/
package org.opendaylight.mdsal.binding.generator.impl.reactor;
-import org.opendaylight.mdsal.binding.model.api.DefaultType;
import org.opendaylight.mdsal.binding.model.api.GeneratedType;
+import org.opendaylight.mdsal.binding.model.api.Type;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
import org.opendaylight.mdsal.binding.model.util.BindingTypes;
import org.opendaylight.yangtools.yang.model.api.stmt.ChoiceEffectiveStatement;
@Override
GeneratedType createTypeImpl(final TypeBuilderFactory builderFactory) {
final GeneratedTypeBuilder builder = builderFactory.newGeneratedTypeBuilder(typeName());
- builder.addImplementsType(BindingTypes.choiceIn(DefaultType.of(getParent().typeName())));
+ builder.addImplementsType(BindingTypes.choiceIn(Type.of(getParent().typeName())));
final ModuleGenerator module = currentModule();
module.addQNameConstant(builder, localName());
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.mdsal.binding.generator.impl.reactor.CollisionDomain.Member;
import org.opendaylight.mdsal.binding.model.api.AccessModifier;
-import org.opendaylight.mdsal.binding.model.api.DefaultType;
import org.opendaylight.mdsal.binding.model.api.GeneratedType;
import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.Type;
break;
}
- builder.addImplementsType(BindingTypes.childOf(DefaultType.of(ancestor.typeName())));
+ builder.addImplementsType(BindingTypes.childOf(Type.of(ancestor.typeName())));
}
/**
* @param builder Target builder
*/
static final void defaultImplementedInterace(final GeneratedTypeBuilder builder) {
- defineImplementedInterfaceMethod(builder, DefaultType.of(builder)).setDefault(true);
+ defineImplementedInterfaceMethod(builder, Type.of(builder)).setDefault(true);
}
static final <T extends EffectiveStatement<?, ?>> AbstractExplicitGenerator<T> getChild(final Generator parent,
import java.util.Set;
import org.opendaylight.mdsal.binding.generator.impl.reactor.CollisionDomain.Member;
-import org.opendaylight.mdsal.binding.model.api.DefaultType;
import org.opendaylight.mdsal.binding.model.api.GeneratedType;
+import org.opendaylight.mdsal.binding.model.api.Type;
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.GeneratedTypeBuilderBase;
GeneratedType createTypeImpl(final TypeBuilderFactory builderFactory) {
final GeneratedTOBuilder builder = builderFactory.newGeneratedTOBuilder(typeName());
- builder.addImplementsType(BindingTypes.identifier(DefaultType.of(listGen.typeName())));
+ builder.addImplementsType(BindingTypes.identifier(Type.of(listGen.typeName())));
final Set<QName> leafNames = statement().argument();
for (Generator listChild : listGen) {
*/
package org.opendaylight.mdsal.binding.generator.impl.reactor;
-import org.opendaylight.mdsal.binding.model.api.DefaultType;
import org.opendaylight.mdsal.binding.model.api.GeneratedType;
import org.opendaylight.mdsal.binding.model.api.Type;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
return BindingTypes.NOTIFICATION;
}
- final Type parentType = DefaultType.of(parent.typeName());
+ final Type parentType = Type.of(parent.typeName());
if (parent instanceof ListGenerator) {
final KeyGenerator keyGen = ((ListGenerator) parent).keyGenerator();
if (keyGen != null) {
assertEquals("mplsLabelGeneralUse", general.getName());
assertEquals("org.opendaylight.yang.gen.v1.mdsal269.rev180130.MplsLabelGeneralUse",
- general.getReturnType().toString());
+ general.getReturnType().getFullyQualifiedName());
assertEquals("mplsLabelSpecialPurpose", special.getName());
- assertEquals("Type (java.lang.Class)", special.getReturnType().toString());
+ assertEquals("java.lang.Class", special.getReturnType().getFullyQualifiedName());
}
}
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.mdsal.binding.model.api.ConcreteType;
-import org.opendaylight.mdsal.binding.model.api.DefaultType;
import org.opendaylight.mdsal.binding.model.api.Enumeration;
import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
final Type leafrefResolvedType1 = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
assertNotNull(leafrefResolvedType1);
- assertTrue(leafrefResolvedType1 instanceof DefaultType);
final QName leafListNode = QName.create(module.getQNameModule(), "enums");
final DataSchemaNode enumListNode = module.findDataChildByName(leafListNode).get();
"resolve-direct-use-of-enum");
final TypeDefinition<?> enumLeafTypedef = enumLeafNode.getType();
provider.putReferencedType(enumLeafNode.getPath(),
- DefaultType.of(provider.javaTypeForSchemaDefinitionType(enumLeafTypedef, enumLeafNode)));
+ Type.of(provider.javaTypeForSchemaDefinitionType(enumLeafTypedef, enumLeafNode)));
final LeafListSchemaNode enumListNode = provideLeafListNodeFromTopLevelContainer(TEST_TYPE_PROVIDER,
"foo", "list-of-enums");
final TypeDefinition<?> enumLeafListTypedef = enumListNode.getType();
provider.putReferencedType(enumListNode.getPath(),
- DefaultType.of(provider.javaTypeForSchemaDefinitionType(enumLeafListTypedef, enumListNode)));
+ Type.of(provider.javaTypeForSchemaDefinitionType(enumLeafListTypedef, enumListNode)));
}
@Test
import java.util.Set;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.mdsal.binding.model.api.AbstractBaseType;
+import org.opendaylight.mdsal.binding.model.api.AbstractType;
import org.opendaylight.mdsal.binding.model.api.BaseTypeWithRestrictions;
import org.opendaylight.mdsal.binding.model.api.ConcreteType;
import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
/**
* Represents concrete JAVA type.
*/
- private static final class ConcreteTypeImpl extends AbstractBaseType implements ConcreteType {
+ private static final class ConcreteTypeImpl extends AbstractType implements ConcreteType {
private final Restrictions restrictions;
/**
/**
* Represents concrete JAVA type with changed restriction values.
*/
- private static final class BaseTypeWithRestrictionsImpl extends AbstractBaseType implements
+ private static final class BaseTypeWithRestrictionsImpl extends AbstractType implements
BaseTypeWithRestrictions {
private final Restrictions restrictions;
/**
* Represents parametrized JAVA type.
*/
- private static class ParametrizedTypeImpl extends AbstractBaseType implements ParameterizedType {
+ private static class ParametrizedTypeImpl extends AbstractType implements ParameterizedType {
/**
* Array of JAVA actual type parameters.
*/
/**
* Represents JAVA bounded wildcard type.
*/
- private static class WildcardTypeImpl extends AbstractBaseType implements WildcardType {
+ private static class WildcardTypeImpl extends AbstractType implements WildcardType {
/**
* Creates instance of this class with concrete package and type name.
*
import static java.util.Objects.requireNonNull;
import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.MoreObjects.ToStringHelper;
import com.google.common.collect.ImmutableList;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;
-import org.opendaylight.mdsal.binding.model.api.AbstractBaseType;
+import org.opendaylight.mdsal.binding.model.api.AbstractType;
import org.opendaylight.mdsal.binding.model.api.AnnotationType;
import org.opendaylight.mdsal.binding.model.api.Constant;
import org.opendaylight.mdsal.binding.model.api.Enumeration;
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition.EnumPair;
// FIXME: public because EnumBuilder does not have setters we are exposing
-public abstract class AbstractEnumerationBuilder extends AbstractBaseType implements EnumBuilder {
+public abstract class AbstractEnumerationBuilder extends AbstractType implements EnumBuilder {
private List<Enumeration.Pair> values = ImmutableList.of();
private List<AnnotationTypeBuilder> annotationBuilders = ImmutableList.of();
abstract AbstractPair createEnumPair(String name, String mappedName, int value, Status status, String description,
String reference);
- /*
- * (non-Javadoc)
- *
- * @see java.lang.Object#toString()
- */
@Override
- public final String toString() {
- final StringBuilder builder = new StringBuilder();
- builder.append("EnumerationBuilderImpl [packageName=");
- builder.append(getPackageName());
- builder.append(", name=");
- builder.append(getName());
- builder.append(", values=");
- builder.append(values);
- builder.append("]");
- return builder.toString();
+ protected ToStringHelper addToStringAttributes(final ToStringHelper toStringHelper) {
+ return super.addToStringAttributes(toStringHelper).add("values", values);
}
@Override
}
}
- abstract static class AbstractEnumeration extends AbstractBaseType implements Enumeration {
+ abstract static class AbstractEnumeration extends AbstractType implements Enumeration {
private final List<AnnotationType> annotations;
private final List<Pair> values;
}
@Override
- public final String toString() {
- final StringBuilder builder = new StringBuilder();
- builder.append("Enumeration [packageName=");
- builder.append(getPackageName());
- builder.append(", name=");
- builder.append(getName());
- builder.append(", values=");
- builder.append(this.values);
- builder.append("]");
- return builder.toString();
+ protected ToStringHelper addToStringAttributes(final ToStringHelper toStringHelper) {
+ return super.addToStringAttributes(toStringHelper).add("values", values);
}
@Override
*/
package org.opendaylight.mdsal.binding.model.util.generated.type.builder;
+import com.google.common.base.MoreObjects.ToStringHelper;
import com.google.common.base.Preconditions;
import java.util.Collections;
import java.util.List;
}
@Override
- public final String toString() {
- final StringBuilder builder = new StringBuilder();
- builder.append("GeneratedTransferObject [packageName=");
- builder.append(getPackageName());
- builder.append(", name=");
- builder.append(getName());
- builder.append(", comment=");
- builder.append(getComment());
- builder.append(", constants=");
- builder.append(getConstants());
- builder.append(", enumerations=");
- builder.append(getEnumerations());
- builder.append(", equalsProperties=");
- builder.append(this.equalsProperties);
- builder.append(", hashCodeProperties=");
- builder.append(this.hashProperties);
- builder.append(", stringProperties=");
- builder.append(this.toStringProperties);
- builder.append(", annotations=");
- builder.append(getAnnotations());
- builder.append(", methods=");
- builder.append(getMethodDefinitions());
- builder.append("]");
- return builder.toString();
+ protected ToStringHelper addToStringAttributes(final ToStringHelper toStringHelper) {
+ return super.addToStringAttributes(toStringHelper)
+ .add("equalsProperties", equalsProperties)
+ .add("hashCodeProperties", hashProperties)
+ .add("stringProperties", toStringProperties);
}
@Override
}
@Override
- public final String toString() {
- if (this.isTypedef) {
- return serializeTypedef(this);
- }
- final StringBuilder builder = new StringBuilder();
- builder.append("GeneratedTransferObject [packageName=");
- builder.append(getPackageName());
- builder.append(", name=");
- builder.append(getName());
- builder.append(", comment=");
- builder.append(", annotations=");
- builder.append(getAnnotations());
- builder.append(getComment());
- builder.append(", extends=");
- builder.append(getSuperType());
- builder.append(", implements=");
- builder.append(getImplements());
- builder.append(", enclosedTypes=");
- builder.append(getEnclosedTypes());
- builder.append(", constants=");
- builder.append(getConstantDefinitions());
- builder.append(", enumerations=");
- builder.append(getEnumerations());
- builder.append(", properties=");
- builder.append(getProperties());
- builder.append(", equalsProperties=");
- builder.append(this.equalsProperties);
- builder.append(", hashCodeProperties=");
- builder.append(this.hashCodeProperties);
- builder.append(", stringProperties=");
- builder.append(this.stringProperties);
- builder.append(", methods=");
- builder.append(getMethodDefinitions());
- builder.append("]");
- return builder.toString();
+ protected ToStringHelper addToStringAttributes(final ToStringHelper toStringHelper) {
+ return super.addToStringAttributes(toStringHelper)
+ .omitNullValues()
+ .add("annotations", getAnnotations())
+ .add("comment", getComment())
+ .add("extends", getSuperType())
+ .add("implements", getImplements())
+ .add("enclosedTypes", getEnclosedTypes())
+ .add("constants", getConstantDefinitions())
+ .add("enumerations", getEnumerations())
+ .add("properties", getProperties())
+ .add("equalsProperties", equalsProperties)
+ .add("hashCodeProperties", hashCodeProperties)
+ .add("stringProperties", stringProperties)
+ .add("methods", getMethodDefinitions());
}
- public final String serializeTypedef(final Type type) {
+ public static final String serializeTypedef(final Type type) {
if (!(type instanceof ParameterizedType)) {
return type.getFullyQualifiedName();
}
*/
package org.opendaylight.mdsal.binding.model.util.generated.type.builder;
+import com.google.common.base.MoreObjects.ToStringHelper;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Optional;
import java.util.Set;
-import org.opendaylight.mdsal.binding.model.api.AbstractBaseType;
+import org.opendaylight.mdsal.binding.model.api.AbstractType;
import org.opendaylight.mdsal.binding.model.api.AnnotationType;
import org.opendaylight.mdsal.binding.model.api.Constant;
import org.opendaylight.mdsal.binding.model.api.Enumeration;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
import org.opendaylight.mdsal.binding.model.api.type.builder.MethodSignatureBuilder;
-abstract class AbstractGeneratedType extends AbstractBaseType implements GeneratedType {
-
+abstract class AbstractGeneratedType extends AbstractType implements GeneratedType {
private final TypeComment comment;
private final List<AnnotationType> annotations;
private final List<Type> implementsTypes;
}
@Override
- public String toString() {
- final StringBuilder builder = new StringBuilder();
- builder.append("GeneratedType [packageName=");
- builder.append(getPackageName());
- builder.append(", name=");
- builder.append(getName());
- builder.append(", comment=");
- builder.append(this.comment);
- builder.append(", annotations=");
- builder.append(this.annotations);
- builder.append(", enclosedTypes=");
- builder.append(this.enclosedTypes);
- builder.append(", enumerations=");
- builder.append(this.enumerations);
- builder.append(", constants=");
- builder.append(this.constants);
- builder.append(", methodSignatures=");
- builder.append(this.methodSignatures);
- builder.append("]");
- return builder.toString();
+ protected ToStringHelper addToStringAttributes(final ToStringHelper toStringHelper) {
+ return super.addToStringAttributes(toStringHelper)
+ .omitNullValues()
+ .add("comment", comment)
+ .add("annotations", annotations)
+ .add("enclosedTypes", enclosedTypes)
+ .add("enumerations", enumerations)
+ .add("constants", constants)
+ .add("methodSignatures", methodSignatures);
}
}
import static com.google.common.base.Preconditions.checkArgument;
import static java.util.Objects.requireNonNull;
+import com.google.common.base.MoreObjects.ToStringHelper;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
-import org.opendaylight.mdsal.binding.model.api.AbstractBaseType;
+import org.opendaylight.mdsal.binding.model.api.AbstractType;
import org.opendaylight.mdsal.binding.model.api.AccessModifier;
import org.opendaylight.mdsal.binding.model.api.Constant;
import org.opendaylight.mdsal.binding.model.api.Enumeration;
import org.opendaylight.mdsal.binding.model.api.type.builder.MethodSignatureBuilder;
import org.opendaylight.yangtools.util.LazyCollections;
-abstract class AbstractGeneratedTypeBuilder<T extends GeneratedTypeBuilderBase<T>> extends AbstractBaseType
+abstract class AbstractGeneratedTypeBuilder<T extends GeneratedTypeBuilderBase<T>> extends AbstractType
implements GeneratedTypeBuilderBase<T> {
private List<AnnotationTypeBuilder> annotationBuilders = Collections.emptyList();
return Optional.ofNullable(yangSourceDefinition);
}
-
@Override
public void setYangSourceDefinition(final YangSourceDefinition definition) {
yangSourceDefinition = requireNonNull(definition);
}
+
+ @Override
+ protected ToStringHelper addToStringAttributes(final ToStringHelper toStringHelper) {
+ return super.addToStringAttributes(toStringHelper).omitNullValues()
+ .add("comment", comment == null ? null : comment.getJavadoc())
+ .add("constants", constants)
+ .add("enumerations", enumDefinitions)
+ .add("methods", methodDefinitions)
+ .add("annotations", annotationBuilders)
+ .add("implements", implementsTypes);
+ }
}
*/
package org.opendaylight.mdsal.binding.model.util.generated.type.builder;
+import com.google.common.base.MoreObjects.ToStringHelper;
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.AbstractBaseType;
+import org.opendaylight.mdsal.binding.model.api.AbstractType;
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.yangtools.util.LazyCollections;
-final class AnnotationTypeBuilderImpl extends AbstractBaseType implements AnnotationTypeBuilder {
+final class AnnotationTypeBuilderImpl extends AbstractType implements AnnotationTypeBuilder {
private List<AnnotationTypeBuilder> annotationBuilders = Collections.emptyList();
private List<AnnotationType.Parameter> parameters = Collections.emptyList();
}
@Override
- public String toString() {
- final StringBuilder builder = new StringBuilder();
- builder.append("AnnotationTypeBuilder [packageName=");
- builder.append(getPackageName());
- builder.append(", name=");
- builder.append(getName());
- builder.append(", annotationBuilders=");
- builder.append(this.annotationBuilders);
- builder.append(", parameters=");
- builder.append(this.parameters);
- builder.append("]");
- return builder.toString();
+ protected ToStringHelper addToStringAttributes(final ToStringHelper toStringHelper) {
+ return super.addToStringAttributes(toStringHelper)
+ .omitNullValues()
+ .add("annotationBuilders", annotationBuilders)
+ .add("parameters", parameters);
}
- private static final class AnnotationTypeImpl extends AbstractBaseType implements AnnotationType {
+ private static final class AnnotationTypeImpl extends AbstractType implements AnnotationType {
private final List<AnnotationType> annotations;
private final List<AnnotationType.Parameter> parameters;
private final List<String> paramNames;
}
@Override
- public String toString() {
- final StringBuilder builder = new StringBuilder();
- builder.append("AnnotationType [packageName=");
- builder.append(getPackageName());
- builder.append(", name=");
- builder.append(getName());
- builder.append(", annotations=");
- builder.append(this.annotations);
- builder.append(", parameters=");
- builder.append(this.parameters);
- builder.append("]");
- return builder.toString();
+ protected ToStringHelper addToStringAttributes(final ToStringHelper toStringHelper) {
+ return super.addToStringAttributes(toStringHelper)
+ .omitNullValues()
+ .add("annotations", annotations)
+ .add("parameters", parameters);
}
}
import org.opendaylight.mdsal.binding.model.api.GeneratedType;
import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
-import org.opendaylight.mdsal.binding.model.api.TypeComment;
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;
this.reference = reference;
}
- @Override
- public String toString() {
- final StringBuilder builder = new StringBuilder();
- builder.append("GeneratedTransferObject [packageName=");
- builder.append(getPackageName());
- builder.append(", name=");
- builder.append(getName());
-
- final TypeComment comment = getComment();
- if (comment != null) {
- builder.append(", comment=");
- builder.append(comment.getJavadoc());
- }
- builder.append(", annotations=");
- builder.append(getAnnotations());
- builder.append(", implements=");
- builder.append(getImplementsTypes());
- builder.append(", constants=");
- builder.append(getConstants());
- builder.append(", enumerations=");
- builder.append(getEnumerations());
- builder.append(", properties=");
- builder.append(", methods=");
- builder.append(getMethodDefinitions());
- builder.append("]");
- return builder.toString();
- }
-
@Override
public GeneratedType build() {
return new GeneratedTypeImpl(this);
import org.opendaylight.mdsal.binding.model.api.GeneratedType;
import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
-import org.opendaylight.mdsal.binding.model.api.TypeComment;
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;
// No-op
}
- @Override
- public String toString() {
- final StringBuilder builder = new StringBuilder();
- builder.append("GeneratedTransferObject [packageName=");
- builder.append(getPackageName());
- builder.append(", name=");
- builder.append(getName());
-
- final TypeComment comment = getComment();
- if (comment != null) {
- builder.append(", comment=");
- builder.append(comment.getJavadoc());
- }
- builder.append(", annotations=");
- builder.append(getAnnotations());
- builder.append(", implements=");
- builder.append(getImplementsTypes());
- builder.append(", constants=");
- builder.append(getConstants());
- builder.append(", enumerations=");
- builder.append(getEnumerations());
- builder.append(", properties=");
- builder.append(", methods=");
- builder.append(getMethodDefinitions());
- builder.append("]");
- return builder.toString();
- }
-
@Override
protected RuntimeGeneratedTypeBuilder thisInstance() {
return this;
annotationTypeBuilder.addAnnotation("my.package", "MySubAnnotationName");
annotationTypeBuilder.addParameter("MyParameter", "myValue");
- assertEquals("AnnotationTypeBuilder [packageName=my.package, name=MyAnnotationName, "
- + "annotationBuilders=[AnnotationTypeBuilder [packageName=my.package, name=MySubAnnotationName, "
- + "annotationBuilders=[], parameters=[]]], parameters=[ParameterImpl [name=MyParameter, value=myValue, "
- + "values=[]]]]", annotationTypeBuilder.toString());
+ assertEquals("AnnotationTypeBuilderImpl{identifier=my.package.MyAnnotationName, "
+ + "annotationBuilders=[AnnotationTypeBuilderImpl{identifier=my.package.MySubAnnotationName, "
+ + "annotationBuilders=[], parameters=[]}], parameters=[ParameterImpl [name=MyParameter, value=myValue, "
+ + "values=[]]]}", annotationTypeBuilder.toString());
AnnotationType annotationTypeInstance = annotationTypeBuilder.build();
assertEquals("my.package.MyAnnotationName", annotationTypeInstance.getFullyQualifiedName());
- assertEquals("AnnotationType [packageName=my.package, name=MyAnnotationName, annotations=[AnnotationType "
- + "[packageName=my.package, name=MySubAnnotationName, annotations=[], parameters=[]]], "
- + "parameters=[ParameterImpl [name=MyParameter, value=myValue, values=[]]]]",
+ assertEquals("AnnotationTypeImpl{identifier=my.package.MyAnnotationName, "
+ + "annotations=[AnnotationTypeImpl{identifier=my.package.MySubAnnotationName, annotations=[], "
+ + "parameters=[]}], parameters=[ParameterImpl [name=MyParameter, value=myValue, values=[]]]}",
annotationTypeInstance.toString());
}
*/
package org.opendaylight.mdsal.binding.model.util.generated.type.builder;
-import static org.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
assertEquals("BaseType", constImpl.getType().getName());
assertEquals("IpAddress", constImpl.getName());
assertEquals("127.0.0.1", constImpl.getValue());
- assertThat(constImpl.toString(), containsString("GeneratedTransferObject"));
+ assertEquals(
+ "Constant [type=CodegenGeneratedTypeBuilder{identifier=org.opendaylight.yangtools.test.v1.BaseType, "
+ + "constants=[], enumerations=[], methods=[], annotations=[], implements=[]}, name=IpAddress, "
+ + "value=127.0.0.1]", constImpl.toString());
assertEquals(constImpl.hashCode(), constImpl2.hashCode());
assertNotNull(constImpl.getType());
assertNotNull(constImpl.getName());
@Test
public void testEnumerationToString() {
- assertEquals("Enumeration [packageName=" + packageName + ", name=" + name
- + ", values=[EnumPair [name=TestValue, mappedName=TestValue, value=12]]]", enumeration.toString());
+ assertEquals("EnumerationImpl{identifier=org.opendaylight.test.TestName, "
+ + "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]]]",
- enumerationBuilder.toString());
+ assertEquals("CodegenEnumerationBuilder{identifier=org.opendaylight.test.TestName, "
+ + "values=[EnumPair [name=TestValue, mappedName=TestValue, value=12]]}", enumerationBuilder.toString());
}
@Test
generatedPropertyBuilderImpl.setAccessModifier(AccessModifier.PUBLIC);
generatedPropertyBuilderImpl.setReturnType(Types.BOOLEAN);
- assertEquals("GeneratedPropertyImpl [name=myPropertyName, annotations=[], comment=null, returnType=Type "
- + "(java.lang.Boolean), isFinal=true, isReadOnly=false, modifier=PUBLIC]",
- generatedPropertyBuilderImpl.toString());
+ assertEquals("GeneratedPropertyImpl [name=myPropertyName, annotations=[], comment=null, "
+ + "returnType=ConcreteTypeImpl{identifier=java.lang.Boolean}, isFinal=true, isReadOnly=false, "
+ + "modifier=PUBLIC]", generatedPropertyBuilderImpl.toString());
GeneratedProperty instance = generatedPropertyBuilderImpl.toInstance();
assertEquals("GeneratedPropertyImpl [name=myPropertyName, annotations=[], "
+ "comment=TypeMemberComment{contract=myComment}, "
- + "returnType=Type (java.lang.Boolean), isFinal=true, isReadOnly=false, "
+ + "returnType=ConcreteTypeImpl{identifier=java.lang.Boolean}, isFinal=true, isReadOnly=false, "
+ "modifier=PUBLIC]", instance.toString());
}
*/
package org.opendaylight.mdsal.binding.model.util.generated.type.builder;
-import static org.junit.Assert.assertFalse;
+import static org.hamcrest.CoreMatchers.startsWith;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
import org.junit.Test;
import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
public void testToString() {
final GeneratedTOBuilder genTypeBuilder = new CodegenGeneratedTOBuilder(
JavaTypeName.create("org.opendaylight.controller", "AnnotClassCache"));
- String toString = genTypeBuilder.toString();
- assertTrue(toString.contains("GeneratedTransferObject"));
+ assertThat(genTypeBuilder.toString(),
+ startsWith("CodegenGeneratedTOBuilder{identifier=org.opendaylight.controller.AnnotClassCache"));
}
@Test
final GeneratedTOBuilder genTypeBuilder1 = new CodegenGeneratedTOBuilder(
JavaTypeName.create("org.opendaylight.controller", "AnnotClassCache"));
- genTypeBuilder1.setTypedef(true);
GeneratedTransferObject genTO = genTypeBuilder1.build();
- String toString = genTO.toString();
- assertFalse(toString.contains("GeneratedTransferObject"));
-
- final GeneratedTOBuilder genTypeBuilder2 = new CodegenGeneratedTOBuilder(
- JavaTypeName.create("org.opendaylight.controller", "AnnotClassCache"));
-
- genTypeBuilder2.setTypedef(false);
- genTO = genTypeBuilder2.build();
- toString = genTO.toString();
-
- assertTrue(toString.contains("GeneratedTransferObject"));
+ assertThat(genTO.toString(), startsWith("GTO{identifier=org.opendaylight.controller.AnnotClassCache"));
}
}
assertFalse(constant.hashCode() == constant4.hashCode());
assertTrue(constant.hashCode() == constant5.hashCode());
- assertEquals("Constant [type=Type (java.lang.String), name=myConstant, value=myConstantValue]",
+ assertEquals(
+ "Constant [type=ConcreteTypeImpl{identifier=java.lang.String}, name=myConstant, value=myConstantValue]",
constant.toString());
GeneratedType instance = generatedTypeBuilder.build();
generatedTypeBuilder.setSchemaPath(SchemaPath.create(true, QName.create("test", "path")));
assertNotNull(generatedTypeBuilder.addComment(TypeComments.javadoc("My comment..").get()));
- assertEquals(
- "GeneratedTransferObject [packageName=my.package, name=MyName, comment=My comment.., annotations=[], "
- + "implements=[], constants=[], enumerations=[], properties=, methods=[]]",
- generatedTypeBuilder.toString());
+ assertEquals("CodegenGeneratedTypeBuilder{identifier=my.package.MyName, comment=My comment.., constants=[], "
+ + "enumerations=[], methods=[], annotations=[], implements=[]}", generatedTypeBuilder.toString());
GeneratedType instance = generatedTypeBuilder.build();
import org.eclipse.xtext.xbase.lib.StringExtensions;
import org.opendaylight.mdsal.binding.model.api.AnnotationType;
import org.opendaylight.mdsal.binding.model.api.ConcreteType;
-import org.opendaylight.mdsal.binding.model.api.DefaultType;
import org.opendaylight.mdsal.binding.model.api.GeneratedProperty;
import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
import org.opendaylight.mdsal.binding.model.api.GeneratedType;
throw new ExceptionInInitializerError(e);
}
- AUGMENTATION_RET_TYPE = DefaultType.of(JavaTypeName.create(m.getReturnType()));
+ AUGMENTATION_RET_TYPE = Type.of(JavaTypeName.create(m.getReturnType()));
}
private final AbstractJavaGeneratedType javaType;
augmentType = t;
}
} else if (Augmentable.class.getName().equals(implementedIfc.getFullyQualifiedName())) {
- augmentType = Types.parameterizedTypeFor(AUGMENTATION_RET_TYPE, DefaultType.of(type.getIdentifier()));
+ augmentType = Types.parameterizedTypeFor(AUGMENTATION_RET_TYPE, Type.of(type.getIdentifier()));
}
}
import java.util.Set;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.mdsal.binding.model.api.DefaultType;
import org.opendaylight.mdsal.binding.model.api.GeneratedType;
import org.opendaylight.mdsal.binding.model.api.MethodSignature;
import org.opendaylight.mdsal.binding.model.api.ParameterizedType;
@Override
public final <T extends Augmentation<?>> AugmentationSchemaNode getAugmentationDefinition(final Class<T> augClass) {
- return getTypes().findAugmentation(DefaultType.of(augClass)).orElse(null);
+ return getTypes().findAugmentation(Type.of(augClass)).orElse(null);
}
@Override
checkArgument(!Augmentation.class.isAssignableFrom(cls), "Supplied class must not be an augmentation (%s is)",
cls);
checkArgument(!Action.class.isAssignableFrom(cls), "Supplied class must not be an action (%s is)", cls);
- return (DataSchemaNode) getTypes().findSchema(DefaultType.of(cls)).orElse(null);
+ return (DataSchemaNode) getTypes().findSchema(Type.of(cls)).orElse(null);
}
@Override
public final ActionDefinition getActionDefinition(final Class<? extends Action<?, ?, ?>> cls) {
- return (ActionDefinition) getTypes().findSchema(DefaultType.of(cls)).orElse(null);
+ return (ActionDefinition) getTypes().findSchema(Type.of(cls)).orElse(null);
}
@Override
public final Absolute getActionIdentifier(final Class<? extends Action<?, ?, ?>> cls) {
- return getTypes().findSchemaNodeIdentifier(DefaultType.of(cls)).orElse(null);
+ return getTypes().findSchemaNodeIdentifier(Type.of(cls)).orElse(null);
}
@Override
@Override
public final Entry<GeneratedType, WithStatus> getTypeWithSchema(final Class<?> type) {
- return getTypeWithSchema(getTypes(), DefaultType.of(type));
+ return getTypeWithSchema(getTypes(), Type.of(type));
}
private static @NonNull Entry<GeneratedType, WithStatus> getTypeWithSchema(final BindingRuntimeTypes types,
@Override
public final Set<Class<?>> getCases(final Class<?> choice) {
- final Collection<Type> cazes = getTypes().findCases(DefaultType.of(choice));
+ final Collection<Type> cazes = getTypes().findCases(Type.of(choice));
final Set<Class<?>> ret = new HashSet<>(cazes.size());
for (final Type caze : cazes) {
try {