Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2011 The Guava Authors
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package com.google.common.reflect;
 
 import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkNotNull;
 import static com.google.common.collect.Iterables.transform;
 
 
 
 import  javax.annotation.Nullable;

Utilities for working with Type.

Author(s):
Ben Yu
 
 final class Types {

  
Class#toString without the "class " and "interface " prefixes
 
   private static final Function<TypeStringTYPE_TO_STRING =
       new Function<TypeString>() {
         @Override public String apply(Type from) {
           return Types.toString(from);
         }
       };
 
   private static final Joiner COMMA_JOINER = Joiner.on(", ").useForNull("null");

  
Returns the array type of componentType.
 
   static Type newArrayType(Type componentType) {
     if (componentType instanceof WildcardType) {
       WildcardType wildcard = (WildcardTypecomponentType;
       Type[] lowerBounds = wildcard.getLowerBounds();
       checkArgument(lowerBounds.length <= 1, "Wildcard cannot have more than one lower bounds.");
       if (lowerBounds.length == 1) {
         return supertypeOf(newArrayType(lowerBounds[0]));
       } else {
         Type[] upperBounds = wildcard.getUpperBounds();
         checkArgument(upperBounds.length == 1, "Wildcard should have only one upper bound.");
         return subtypeOf(newArrayType(upperBounds[0]));
       }
     }
     return ..newArrayType(componentType);
   }

  
Returns a type where rawType is parameterized by arguments and is owned by ownerType.
 
       @Nullable Type ownerTypeClass<?> rawTypeType... arguments) {
     if (ownerType == null) {
       return newParameterizedType(rawTypearguments);
     }
     // ParameterizedTypeImpl constructor already checks, but we want to throw NPE before IAE
     checkNotNull(arguments);
     checkArgument(rawType.getEnclosingClass() != null"Owner type for unenclosed %s"rawType);
     return new ParameterizedTypeImpl(ownerTyperawTypearguments);
   }

  
Returns a type where rawType is parameterized by arguments.
 
   static ParameterizedType newParameterizedType(Class<?> rawTypeType... arguments) {
       return new ParameterizedTypeImpl(
          ..getOwnerType(rawType), rawTypearguments);
  }

  
Decides what owner type to use for constructing ParameterizedType from a raw class.
  private enum ClassOwnership {
    OWNED_BY_ENCLOSING_CLASS {
      @Nullable
      @Override
      Class<?> getOwnerType(Class<?> rawType) {
        return rawType.getEnclosingClass();
      }
    },
    LOCAL_CLASS_HAS_NO_OWNER {
      @Nullable
      @Override
      Class<?> getOwnerType(Class<?> rawType) {
        if (rawType.isLocalClass()) {
          return null;
        } else {
          return rawType.getEnclosingClass();
        }
      }
    };
    @Nullable abstract Class<?> getOwnerType(Class<?> rawType);
    static final ClassOwnership JVM_BEHAVIOR = detectJvmBehavior();
    private static ClassOwnership detectJvmBehavior() {
      class LocalClass<T> {}
      Class<?> subclass = new LocalClass<String>() {}.getClass();
      ParameterizedType parameterizedType = (ParameterizedType)
          subclass.getGenericSuperclass();
      for (ClassOwnership behavior : ClassOwnership.values()) {
        if (behavior.getOwnerType(LocalClass.class) == parameterizedType.getOwnerType()) {
          return behavior;
        }
      }
      throw new AssertionError();
    }
  }

  
Returns a new TypeVariable that belongs to declaration with name and bounds.
  static <D extends GenericDeclarationTypeVariable<D> newTypeVariable(
      D declarationString nameType... bounds) {
    return new TypeVariableImpl<D>(
        declaration,
        name,
        (bounds.length == 0)
            ? new Type[] { Object.class }
            : bounds);
  }

  
Returns a new WildcardType with upperBound.
  @VisibleForTesting static WildcardType subtypeOf(Type upperBound) {
    return new WildcardTypeImpl(new Type[0], new Type[] { upperBound });
  }

  
Returns a new WildcardType with lowerBound.
  @VisibleForTesting static WildcardType supertypeOf(Type lowerBound) {
    return new WildcardTypeImpl(new Type[] { lowerBound }, new Type[] { Object.class });
  }

  
Returns human readable string representation of type.
  • For array type Foo[], "com.mypackage.Foo[]" are returned.
  • For any class, theClass.getName() are returned.
  • For all other types, type.toString() are returned.
  static String toString(Type type) {
    return (type instanceof Class)
        ? ((Class<?>) type).getName()
        : type.toString();
  }
  @Nullable static Type getComponentType(Type type) {
    checkNotNull(type);
    final AtomicReference<Typeresult = new AtomicReference<Type>();
    new TypeVisitor() {
      @Override void visitTypeVariable(TypeVariable<?> t) {
        result.set(subtypeOfComponentType(t.getBounds()));
      }
      @Override void visitWildcardType(WildcardType t) {
        result.set(subtypeOfComponentType(t.getUpperBounds()));
      }
        result.set(t.getGenericComponentType());
      }
      @Override void visitClass(Class<?> t) {
        result.set(t.getComponentType());
      }
    }.visit(type);
    return result.get();
  }

  
Returns ? extends X if any of bounds is a subtype of X[]; or null otherwise.
  @Nullable private static Type subtypeOfComponentType(Type[] bounds) {
    for (Type bound : bounds) {
      Type componentType = getComponentType(bound);
      if (componentType != null) {
        // Only the first bound can be a class or array.
        // Bounds after the first can only be interfaces.
        if (componentType instanceof Class) {
          Class<?> componentClass = (Class<?>) componentType;
          if (componentClass.isPrimitive()) {
            return componentClass;
          }
        }
        return subtypeOf(componentType);
      }
    }
    return null;
  }
  private static final class GenericArrayTypeImpl
      implements GenericArrayTypeSerializable {
    private final Type componentType;
    GenericArrayTypeImpl(Type componentType) {
      this. = ..usedInGenericType(componentType);
    }
    @Override public Type getGenericComponentType() {
      return ;
    }
    @Override public String toString() {
      return Types.toString() + "[]";
    }
    @Override public int hashCode() {
      return .hashCode();
    }
    @Override public boolean equals(Object obj) {
      if (obj instanceof GenericArrayType) {
        GenericArrayType that = (GenericArrayTypeobj;
        return Objects.equal(
            getGenericComponentType(), that.getGenericComponentType());
      }
      return false;
    }
    private static final long serialVersionUID = 0;
  }
  private static final class ParameterizedTypeImpl
      implements ParameterizedTypeSerializable {
    private final Type ownerType;
    private final ImmutableList<TypeargumentsList;
    private final Class<?> rawType;
        @Nullable Type ownerTypeClass<?> rawTypeType[] typeArguments) {
      checkNotNull(rawType);
      checkArgument(typeArguments.length == rawType.getTypeParameters().length);
      disallowPrimitiveType(typeArguments"type parameter");
      this. = ownerType;
      this. = rawType;
      this. = ..usedInGenericType(typeArguments);
    }
    @Override public Type[] getActualTypeArguments() {
      return toArray();
    }
    @Override public Type getRawType() {
      return ;
    }
    @Override public Type getOwnerType() {
      return ;
    }
    @Override public String toString() {
      StringBuilder builder = new StringBuilder();
      if ( != null) {
        builder.append(Types.toString()).append('.');
      }
      builder.append(.getName())
          .append('<')
          .append('>');
      return builder.toString();
    }
    @Override public int hashCode() {
      return ( == null ? 0 : .hashCode())
          ^ .hashCode() ^ .hashCode();
    }
    @Override public boolean equals(Object other) {
      if (!(other instanceof ParameterizedType)) {
        return false;
      }
      ParameterizedType that = (ParameterizedTypeother;
      return getRawType().equals(that.getRawType())
          && Objects.equal(getOwnerType(), that.getOwnerType())
          && Arrays.equals(
              getActualTypeArguments(), that.getActualTypeArguments());
    }
    private static final long serialVersionUID = 0;
  }
  private static final class TypeVariableImpl<D extends GenericDeclaration>
      implements TypeVariable<D> {
    private final D genericDeclaration;
    private final String name;
    private final ImmutableList<Typebounds;
    TypeVariableImpl(D genericDeclarationString nameType[] bounds) {
      disallowPrimitiveType(bounds"bound for type variable");
      this. = checkNotNull(genericDeclaration);
      this. = checkNotNull(name);
      this. = ImmutableList.copyOf(bounds);
    }
    @Override public Type[] getBounds() {
      return toArray();
    }
    @Override public D getGenericDeclaration() {
      return ;
    }
    @Override public String getName() {
      return ;
    }
    @Override public String toString() {
      return ;
    }
    @Override public int hashCode() {
      return .hashCode() ^ .hashCode();
    }
    @Override public boolean equals(Object obj) {
      if (obj instanceof TypeVariable) {
        TypeVariable<?> that = (TypeVariable<?>) obj;
        return .equals(that.getName())
            && .equals(that.getGenericDeclaration());
      }
      return false;
    }
  }
  static final class WildcardTypeImpl implements WildcardTypeSerializable {
    private final ImmutableList<TypelowerBounds;
    private final ImmutableList<TypeupperBounds;
    WildcardTypeImpl(Type[] lowerBoundsType[] upperBounds) {
      disallowPrimitiveType(lowerBounds"lower bound for wildcard");
      disallowPrimitiveType(upperBounds"upper bound for wildcard");
      this. = ..usedInGenericType(lowerBounds);
      this. = ..usedInGenericType(upperBounds);
    }
    @Override public Type[] getLowerBounds() {
      return toArray();
    }
    @Override public Type[] getUpperBounds() {
      return toArray();
    }
    @Override public boolean equals(Object obj) {
      if (obj instanceof WildcardType) {
        WildcardType that = (WildcardTypeobj;
        return .equals(Arrays.asList(that.getLowerBounds()))
            && .equals(Arrays.asList(that.getUpperBounds()));
      }
      return false;
    }
    @Override public int hashCode() {
      return .hashCode() ^ .hashCode();
    }
    @Override public String toString() {
      StringBuilder builder = new StringBuilder("?");
      for (Type lowerBound : ) {
        builder.append(" super ").append(Types.toString(lowerBound));
      }
      for (Type upperBound : filterUpperBounds()) {
        builder.append(" extends ").append(Types.toString(upperBound));
      }
      return builder.toString();
    }
    private static final long serialVersionUID = 0;
  }
  private static Type[] toArray(Collection<Typetypes) {
    return types.toArray(new Type[types.size()]);
  }
  private static Iterable<TypefilterUpperBounds(Iterable<Typebounds) {
    return Iterables.filter(
        bounds, Predicates.not(Predicates.<Type>equalTo(Object.class)));
  }
  private static void disallowPrimitiveType(Type[] typesString usedAs) {
    for (Type type : types) {
      if (type instanceof Class) {
        Class<?> cls = (Class<?>) type;
        checkArgument(!cls.isPrimitive(),
            "Primitive type '%s' used as %s"clsusedAs);
      }
    }
  }

  
Returns the Class object of arrays with componentType.
  static Class<?> getArrayClass(Class<?> componentType) {
    // TODO(user): This is not the most efficient way to handle generic
    // arrays, but is there another way to extract the array class in a
    // non-hacky way (i.e. using String value class names- "[L...")?
    return Array.newInstance(componentType, 0).getClass();
  }
  // TODO(benyu): Once we are on Java 7, delete this abstraction
  enum JavaVersion {
    JAVA6 {
      @Override GenericArrayType newArrayType(Type componentType) {
        return new GenericArrayTypeImpl(componentType);
      }
      @Override Type usedInGenericType(Type type) {
        checkNotNull(type);
        if (type instanceof Class) {
          Class<?> cls = (Class<?>) type;
          if (cls.isArray()) {
            return new GenericArrayTypeImpl(cls.getComponentType());
          }
        }
        return type;
      }
    },
    JAVA7 {
      @Override Type newArrayType(Type componentType) {
        if (componentType instanceof Class) {
          return getArrayClass((Class<?>) componentType);
        } else {
          return new GenericArrayTypeImpl(componentType);
        }
      }
      @Override Type usedInGenericType(Type type) {
        return checkNotNull(type);
      }
    }
    ;
    static final JavaVersion CURRENT =
        (new TypeCapture<int[]>() {}.capture() instanceof Class)
        ?  : ;
    abstract Type newArrayType(Type componentType);
    abstract Type usedInGenericType(Type type);
    final ImmutableList<TypeusedInGenericType(Type[] types) {
      ImmutableList.Builder<Typebuilder = ImmutableList.builder();
      for (Type type : types) {
        builder.add(usedInGenericType(type));
      }
      return builder.build();
    }
  }
  private Types() {}
New to GrepCode? Check out our FAQ X