X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=binding%2Fmdsal-binding-generator-util%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fmdsal%2Fbinding%2Fmodel%2Futil%2FTypes.java;h=a5166c3e646573150b7749f41fc7523e8cc2765d;hb=bfad05606e2defc1a376921f1b82781abb4a233b;hp=03a70f05be5255ed8796dbeea3f97ad54414cac5;hpb=fb42ec94e8db8d63634b15c31dddd8dcaeafa057;p=mdsal.git diff --git a/binding/mdsal-binding-generator-util/src/main/java/org/opendaylight/mdsal/binding/model/util/Types.java b/binding/mdsal-binding-generator-util/src/main/java/org/opendaylight/mdsal/binding/model/util/Types.java index 03a70f05be..a5166c3e64 100644 --- a/binding/mdsal-binding-generator-util/src/main/java/org/opendaylight/mdsal/binding/model/util/Types.java +++ b/binding/mdsal-binding-generator-util/src/main/java/org/opendaylight/mdsal/binding/model/util/Types.java @@ -7,7 +7,8 @@ */ package org.opendaylight.mdsal.binding.model.util; -import com.google.common.base.Preconditions; +import static java.util.Objects.requireNonNull; + import com.google.common.cache.CacheBuilder; import com.google.common.cache.CacheLoader; import com.google.common.cache.LoadingCache; @@ -15,11 +16,15 @@ import com.google.common.collect.ImmutableRangeSet; import com.google.common.collect.Range; import com.google.common.collect.RangeSet; import com.google.common.util.concurrent.ListenableFuture; +import java.io.Serializable; +import java.util.Arrays; import java.util.Collections; import java.util.List; import java.util.Map; +import java.util.Objects; import java.util.Optional; import java.util.Set; +import org.eclipse.jdt.annotation.NonNull; import org.eclipse.jdt.annotation.Nullable; import org.opendaylight.mdsal.binding.model.api.BaseTypeWithRestrictions; import org.opendaylight.mdsal.binding.model.api.ConcreteType; @@ -28,42 +33,56 @@ import org.opendaylight.mdsal.binding.model.api.ParameterizedType; import org.opendaylight.mdsal.binding.model.api.Restrictions; import org.opendaylight.mdsal.binding.model.api.Type; import org.opendaylight.mdsal.binding.model.api.WildcardType; -import org.opendaylight.yangtools.yang.binding.Augmentable; +import org.opendaylight.yangtools.concepts.Builder; import org.opendaylight.yangtools.yang.binding.Augmentation; import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint; import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint; import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint; public final class Types { - private static final CacheLoader, ConcreteType> TYPE_LOADER = - new CacheLoader, ConcreteType>() { - @Override - public ConcreteType load(final Class key) { - return new ConcreteTypeImpl(JavaTypeName.create(key), null); - } + private static final CacheLoader, ConcreteType> TYPE_LOADER = new CacheLoader, ConcreteType>() { + @Override + public ConcreteType load(final Class key) { + return new ConcreteTypeImpl(JavaTypeName.create(key), null); + } }; private static final LoadingCache, ConcreteType> TYPE_CACHE = CacheBuilder.newBuilder().weakKeys().build(TYPE_LOADER); - public static final Type SET_TYPE = typeForClass(Set.class); - public static final Type LIST_TYPE = typeForClass(List.class); - public static final Type MAP_TYPE = typeForClass(Map.class); public static final ConcreteType BOOLEAN = typeForClass(Boolean.class); - public static final ConcreteType FUTURE = typeForClass(ListenableFuture.class); public static final ConcreteType STRING = typeForClass(String.class); public static final ConcreteType VOID = typeForClass(Void.class); public static final ConcreteType BYTE_ARRAY = typeForClass(byte[].class); - public static final ConcreteType CHAR_ARRAY = typeForClass(char[].class); + private static final ConcreteType BUILDER = typeForClass(Builder.class); + private static final ConcreteType CLASS = typeForClass(Class.class); + private static final ConcreteType LIST_TYPE = typeForClass(List.class); + private static final ConcreteType LISTENABLE_FUTURE = typeForClass(ListenableFuture.class); + private static final ConcreteType MAP_TYPE = typeForClass(Map.class); + private static final ConcreteType OBJECT = typeForClass(Object.class); private static final ConcreteType PRIMITIVE_VOID = typeForClass(void.class); + private static final ConcreteType SERIALIZABLE = typeForClass(Serializable.class); + private static final ConcreteType SET_TYPE = typeForClass(Set.class); /** - * It is not desirable to create instance of this class + * It is not desirable to create instance of this class. */ private Types() { } + /** + * Returns an instance of {@link ParameterizedType} which represents JAVA java.lang.Class type + * specialized to specified type. + * + * @param type Type for which to specialize + * @return A parameterized type corresponding to {@code Class} + * @throws NullPointerException if {@code type} is null + */ + public static ParameterizedType classType(final Type type) { + return parameterizedTypeFor(CLASS, type); + } + /** * Returns an instance of {@link ConcreteType} which represents JAVA java.lang.Void type. * @@ -73,6 +92,15 @@ public final class Types { return VOID; } + /** + * Returns an instance of {@link ConcreteType} which represents {@link Object} type. + * + * @return ConcreteType instance which represents {@link Object} + */ + public static ConcreteType objectType() { + return OBJECT; + } + /** * Returns an instance of {@link ConcreteType} which represents JAVA void type. * @@ -83,10 +111,18 @@ public final class Types { } /** - * Returns an instance of {@link ConcreteType} describing the class + * Returns an instance of {@link ConcreteType} which represents {@link Serializable} type. + * + * @return ConcreteType instance which represents JAVA {@link Serializable} + */ + public static ConcreteType serializableType() { + return SERIALIZABLE; + } + + /** + * Returns an instance of {@link ConcreteType} describing the class. * - * @param cls - * Class to describe + * @param cls Class to describe * @return Description of class */ public static ConcreteType typeForClass(final Class cls) { @@ -106,13 +142,10 @@ public final class Types { } /** - * Returns an instance of {@link ParameterizedType} describing the typed - * {@link Map}<K,V> + * Returns an instance of {@link ParameterizedType} describing the typed {@link Map}<K,V>. * - * @param keyType - * Key Type - * @param valueType - * Value Type + * @param keyType Key Type + * @param valueType Value Type * @return Description of generic type instance */ public static ParameterizedType mapTypeFor(final Type keyType, final Type valueType) { @@ -120,11 +153,10 @@ public final class Types { } /** - * Returns an instance of {@link ParameterizedType} describing the typed - * {@link Set}<V> with concrete type of value. + * Returns an instance of {@link ParameterizedType} describing the typed {@link Set}<V> with concrete type + * of value. * - * @param valueType - * Value Type + * @param valueType Value Type * @return Description of generic type instance of Set */ public static ParameterizedType setTypeFor(final Type valueType) { @@ -132,28 +164,53 @@ public final class Types { } /** - * Returns an instance of {@link ParameterizedType} describing the typed - * {@link List}<V> with concrete type of value. + * Returns an instance of {@link ParameterizedType} describing the typed {@link List}<V> with concrete type + * of value. * - * @param valueType - * Value Type + * @param valueType Value Type * @return Description of type instance of List */ public static ParameterizedType listTypeFor(final Type valueType) { return parameterizedTypeFor(LIST_TYPE, valueType); } + public static boolean isListType(final ParameterizedType type) { + return LIST_TYPE.equals(type.getRawType()); + } + + public static boolean isListType(final Type type) { + return type instanceof ParameterizedType && isListType((ParameterizedType) type); + } + /** - * Creates instance of type - * {@link org.opendaylight.mdsal.binding.model.api.ParameterizedType - * ParameterizedType} + * Returns an instance of {@link ParameterizedType} describing the typed {@link ListenableFuture}<V> + * with concrete type of value. + * + * @param valueType Value Type + * @return Description of type instance of ListenableFuture + */ + public static ParameterizedType listenableFutureTypeFor(final Type valueType) { + return parameterizedTypeFor(LISTENABLE_FUTURE, valueType); + } + + /** + * Returns an instance of {@link ParameterizedType} describing the typed + * {@link Builder}<V> with concrete type of value. + * + * @param valueType Value Type + * @return Description of type instance of Builder + */ + public static ParameterizedType builderTypeFor(final Type valueType) { + return parameterizedTypeFor(BUILDER, valueType); + } + + /** + * Creates instance of type {@link org.opendaylight.mdsal.binding.model.api.ParameterizedType ParameterizedType}. * - * @param type - * JAVA Type for raw type - * @param parameters - * JAVA Types for actual parameter types - * @return ParametrizedType reprezentation of type - * and its parameters parameters + * @param type JAVA Type for raw type + * @param parameters JAVA Types for actual parameter types + * @return ParametrizedType representation of type and its parameters + * @throws NullPointerException if any argument or any member of {@code parameters} is null */ public static ParameterizedType parameterizedTypeFor(final Type type, final Type... parameters) { return new ParametrizedTypeImpl(type, parameters); @@ -176,26 +233,23 @@ public final class Types { * {@link org.opendaylight.yangtools.yang.binding.Augmentable} and actual * parameter is valueType. * - * @param valueType - * JAVA Type with actual parameter + * @param valueType JAVA Type with actual parameter * @return ParametrizedType representation of raw type * Augmentable with actual parameter * valueType + * @deprecated Use {@link BindingTypes#augmentable(Type)} instead. */ - public static ParameterizedType augmentableTypeFor(final Type valueType) { - final Type augmentable = typeForClass(Augmentable.class); - return parameterizedTypeFor(augmentable, valueType); + @Deprecated + public static @NonNull ParameterizedType augmentableTypeFor(final Type valueType) { + return BindingTypes.augmentable(valueType); } /** - * Creates instance of - * {@link org.opendaylight.mdsal.binding.model.api.ParameterizedType - * ParameterizedType} where raw type is - * {@link org.opendaylight.yangtools.yang.binding.Augmentation} and actual - * parameter is valueType. + * Creates instance of {@link org.opendaylight.mdsal.binding.model.api.ParameterizedType ParameterizedType} where + * raw type is {@link org.opendaylight.yangtools.yang.binding.Augmentation} and actual parameter + * is valueType. * - * @param valueType - * JAVA Type with actual parameter + * @param valueType JAVA Type with actual parameter * @return ParametrizedType reprezentation of raw type * Augmentation with actual parameter * valueType @@ -210,21 +264,16 @@ public final class Types { } /** - * * Represents concrete JAVA type. - * */ private static final class ConcreteTypeImpl extends AbstractBaseType implements ConcreteType { private final Restrictions restrictions; /** - * Creates instance of this class with package pkName and - * with the type name name. + * Creates instance of this class with package pkName and with the type name name. * - * @param pkName - * string with package name - * @param name - * string with the name of the type + * @param pkName string with package name + * @param name string with the name of the type */ ConcreteTypeImpl(final JavaTypeName identifier, final Restrictions restrictions) { super(identifier); @@ -240,21 +289,19 @@ public final class Types { /** * Represents concrete JAVA type with changed restriction values. */ - private static final class BaseTypeWithRestrictionsImpl extends AbstractBaseType implements BaseTypeWithRestrictions { + private static final class BaseTypeWithRestrictionsImpl extends AbstractBaseType implements + BaseTypeWithRestrictions { private final Restrictions restrictions; /** - * Creates instance of this class with package pkName and - * with the type name name. + * Creates instance of this class with package pkName and with the type name name. * - * @param pkName - * string with package name - * @param name - * string with the name of the type + * @param pkName string with package name + * @param name string with the name of the type */ BaseTypeWithRestrictionsImpl(final JavaTypeName identifier, final Restrictions restrictions) { super(identifier); - this.restrictions = Preconditions.checkNotNull(restrictions); + this.restrictions = requireNonNull(restrictions); } @Override @@ -273,10 +320,25 @@ public final class Types { private final Type[] actualTypes; /** - * JAVA raw type (like List, Set, Map...) + * JAVA raw type (like List, Set, Map...). */ private final Type rawType; + /** + * Creates instance of this class with concrete rawType and array of actual parameters. + * + * @param rawType JAVA Type for raw type + * @param actTypes array of actual parameters + */ + ParametrizedTypeImpl(final Type rawType, final Type[] actTypes) { + super(rawType.getIdentifier()); + this.rawType = requireNonNull(rawType); + actualTypes = actTypes.clone(); + if (Arrays.stream(actualTypes).anyMatch(Objects::isNull)) { + throw new NullPointerException("actTypes contains a null"); + } + } + @Override public Type[] getActualTypeArguments() { @@ -287,21 +349,6 @@ public final class Types { public Type getRawType() { return this.rawType; } - - /** - * Creates instance of this class with concrete rawType and array of - * actual parameters. - * - * @param rawType - * JAVA Type for raw type - * @param actTypes - * array of actual parameters - */ - public ParametrizedTypeImpl(final Type rawType, final Type[] actTypes) { - super(rawType.getIdentifier()); - this.rawType = rawType; - this.actualTypes = actTypes.clone(); - } } /** @@ -311,57 +358,24 @@ public final class Types { /** * Creates instance of this class with concrete package and type name. * - * @param packageName - * string with the package name - * @param typeName - * string with the name of type + * @param packageName string with the package name + * @param typeName string with the name of type */ WildcardTypeImpl(final JavaTypeName identifier) { super(identifier); } } - public static > DefaultRestrictions getDefaultRestrictions(final T min, + public static > DefaultRestrictions getDefaultRestrictions(final T min, final T max) { return new DefaultRestrictions<>(min, max); } private static final class DefaultRestrictions> implements Restrictions { - private final T min; - private final T max; private final RangeConstraint rangeConstraint; - private DefaultRestrictions(final T min, final T max) { - this.min = Preconditions.checkNotNull(min); - this.max = Preconditions.checkNotNull(max); - - this.rangeConstraint = new RangeConstraint() { - - @Override - public Optional getErrorAppTag() { - return Optional.empty(); - } - - @Override - public Optional getErrorMessage() { - return Optional.empty(); - } - - @Override - public Optional getDescription() { - return Optional.empty(); - } - - @Override - public Optional getReference() { - return Optional.empty(); - } - - @Override - public RangeSet getAllowedRanges() { - return ImmutableRangeSet.of(Range.closed(min, max)); - } - }; + DefaultRestrictions(final T min, final T max) { + this.rangeConstraint = new DefaultRangeConstraint<>(min, max); } @Override @@ -384,4 +398,39 @@ public final class Types { return Optional.empty(); } } + + private static final class DefaultRangeConstraint> implements RangeConstraint { + private final T min; + private final T max; + + DefaultRangeConstraint(final T min, final T max) { + this.min = requireNonNull(min); + this.max = requireNonNull(max); + } + + @Override + public Optional getErrorAppTag() { + return Optional.empty(); + } + + @Override + public Optional getErrorMessage() { + return Optional.empty(); + } + + @Override + public Optional getDescription() { + return Optional.empty(); + } + + @Override + public Optional getReference() { + return Optional.empty(); + } + + @Override + public RangeSet getAllowedRanges() { + return ImmutableRangeSet.of(Range.closed(min, max)); + } + } }