Builds a new, <em>detached</em> tuple type.

@param componentTypes neither the individual types, nor the vararg array itself, can be {@code
null}.
@see Detachable
514351
@NonNull
  public static TupleType tupleOf(@NonNull DataType... componentTypes) {
    return new DefaultTupleType(ImmutableList.copyOf(Arrays.asList(componentTypes)));
  }
448341
@SuppressWarnings("unchecked")
    public <T extends GVRComponent> ArrayList<T> getAllComponents(long type) {
        ArrayList<T> list = new ArrayList<T>();
        GVRComponent component = getComponent(type);
        if (component != null)
            list.add((T) component);
        for (GVRSceneObject child : mChildren) {
            ArrayList<T> temp = child.getAllComponents(type);
            list.addAll(temp);
        }
        return list;
    }
1147558
@SuppressWarnings("AmbiguousMethodReference")
  public static FunctionType toMaybeFunctionType(JSType type) {
    return type == null ? null : type.toMaybeFunctionType();
  }
217512
public static Type getArrayComponentType(Type type) {
        if (type instanceof GenericArrayType) {
            return GenericArrayType.class.cast(type).getGenericComponentType();
        }
        if (type instanceof Class<?>) {
            Class<?> clazz = (Class<?>) type;
            if (clazz.isArray()) {
                return clazz.getComponentType();
            }
        }
        throw new IllegalArgumentException("Not an array type " + type);
    }
1222130
public ParameterAmp[] marshalParamTypes(ParameterAmp [] sourceTypes)
  {
    if (sourceTypes == null) {
      return null;
    }
    
    ParameterAmp[] paramTypes = new ParameterAmp[sourceTypes.length];
    
    for (int i = 0; i < paramTypes.length; i++) {
      paramTypes[i] = ParameterAmp.of(marshalType(sourceTypes[i].rawClass()));
    }
    
    return paramTypes;
  }
533860
@SuppressWarnings("unchecked")
	protected final void updateComponentType(Collection<? extends P> newElements) {
		final Class<? extends P> lclazz = extractClassFrom(newElements);
		this.clazz = (Class<? extends P>) ReflectionUtil.getCommonType(this.clazz, lclazz);
	}
288542
@Nullable
  @SuppressWarnings("unchecked")
  public final GenericType<?> getComponentType() {
    TypeToken<?> componentTypeToken = token.getComponentType();
    return (componentTypeToken == null) ? null : new GenericType(componentTypeToken);
  }
841208
public void setExportableLogTypes(java.util.Collection<String> exportableLogTypes) {
        if (exportableLogTypes == null) {
            this.exportableLogTypes = null;
            return;
        }

        this.exportableLogTypes = new com.amazonaws.internal.SdkInternalList<String>(exportableLogTypes);
    }
1131614
public BeanBuilder<T> addTypes(Type... types) {
        this.types.addAll(Arrays2.asSet(types));
        return this;
    }
86160
public Datatype.Builder setNullableRebuildableType(TypeClass rebuildableType) {
    if (rebuildableType != null) {
      return setRebuildableType(rebuildableType);
    } else {
      return clearRebuildableType();
    }
  }
749246
public static Class<?> forType(Type type)
  {
    if(type instanceof Class) {
      return (Class<?>)type;
    }

    if(type instanceof ParameterizedType) {
      return forType(((ParameterizedType)type).getRawType());
    }

    if(!(type instanceof GenericArrayType)) {
      return null;
    }

    Type componentType = ((GenericArrayType)type).getGenericComponentType();
    Class<?> componentClass = forType(componentType);
    return componentClass != null ? Array.newInstance(componentClass, 0).getClass() : null;
  }
479680
public <T> T getComponent(String componentName, Class<T> componentType)
    {
        BeanFactory factory = getBeanFactory();
        T component = factory.getBean(componentName, componentType);
        return component;
    }
877024
public static Object[] cast(Class<?> type, Object arrayObj) throws NullPointerException, IllegalArgumentException {
		if (null == arrayObj) {
			throw new NullPointerException("Argument [arrayObj] is null !");
		}
		if (false == arrayObj.getClass().isArray()) {
			throw new IllegalArgumentException("Argument [arrayObj] is not array !");
		}
		if (null == type) {
			return (Object[]) arrayObj;
		}

		final Class<?> componentType = type.isArray() ? type.getComponentType() : type;
		final Object[] array = (Object[]) arrayObj;
		final Object[] result = ArrayUtil.newArray(componentType, array.length);
		System.arraycopy(array, 0, result, 0, array.length);
		return result;
	}
1280798
protected <T extends IComponent> void addComponent(Class<T> componentType, T component) {
        components.put(componentType, component);
    }
1053653
<T extends Component> List<T> getFormRowChildren(AbstractComponentContainer container, final Class<T> cls) {

        final List<T> result = Lists.newArrayList();
        CmsVaadinUtils.visitDescendants(container, new Predicate<Component>() {

            public boolean apply(Component comp) {

                if (cls.isAssignableFrom(comp.getClass())) {
                    result.add(cls.cast(comp));
                }
                return true;
            }
        });
        return result;
    }
805471
private <T> MapperWrapper<T> createMappingChain(JavaType type) {
		return new MapperWrapper<T>(type, this.mapper, this.createUnmappedChain());
	}
786309
@SuppressWarnings({"unchecked"})
    public static <T> T[] concat(Object[] array1, Object array2[], Class<T> componentType){
        Object newArray[] = (Object[])Array.newInstance(componentType, array1.length+array2.length);
        System.arraycopy(array1, 0, newArray, 0, array1.length);
        System.arraycopy(array2, 0, newArray, array1.length, array2.length);
        return (T[])newArray;
    }