Append to the argument list the given argument values with the specified types.

@param types  the actual types to use, rather than getClass
@param values the value(s) to append
@return a new Binder
5757
public Binder append(Class<?>[] types, Object... values) {
        return new Binder(this, new Insert(type().parameterCount(), types, values));
    }
701161
@SafeVarargs
  static <T> String sqlArgumentList(T... values) {
    StringBuilder sb = new StringBuilder();
    if (values.length != 0) {
      sb.append(values[0]);
      for (int i=1; i < values.length; i++) {
        sb.append(',').append(' ').append(values[i]);
      }
    }
    return sb.toString();
  }
708221
public void createValueCells(Object... values) {
        for (Object value : values) {
            if (value == null) {
                this.createCell("");
                continue;
            }

            if (value instanceof String) {
                this.createCell((String) value);
            } else if (value instanceof Date) {
                this.createCell((Date) value);
            } else if (ValidationObjUtil.isIntType(value.getClass())) {
                long longValue = Long.valueOf(value + "");
                this.createCell(longValue);
            } else if (ValidationObjUtil.isDoubleType(value.getClass())) {
                double doubleValue = Double.valueOf(value + "");
                this.createCell(doubleValue);
            } else {
                this.createCell(value);
            }
        }
    }
985537
public static <K, V> GinMapBinder<K, V> newMapBinder(
      GinBinder binder, Class<K> keyType, Class<V> valueType) {
    return newMapBinder(binder, TypeLiteral.get(keyType), TypeLiteral.get(valueType));
  }
675315
@SuppressWarnings("unchecked")
    public T addAll(YamlNode... values) {
        for (YamlNode value : values) {
            add(value);
        }
        return (T) this;
    }
1131614
public BeanBuilder<T> addTypes(Type... types) {
        this.types.addAll(Arrays2.asSet(types));
        return this;
    }
776712
public static <E> List<E> newArrayList(E... values) {
    List<E> list = new ArrayList<E>(values.length);
    for (E e : values) {
      list.add(e);
    }
    return list;
  }
249028
public Binder prepend(Class<?> type, Object value) {
        return new Binder(this, new Insert(0, new Class[]{type}, value));
    }
136695
public SmartBinder append(String name, Object value) {
        return new SmartBinder(this, signature().appendArg(name, value.getClass()), binder.append(value));
    }
484820
public static Integer[] wrap(int... values) {
		if (null == values) {
			return null;
		}
		final int length = values.length;
		if (0 == length) {
			return new Integer[0];
		}

		final Integer[] array = new Integer[length];
		for (int i = 0; i < length; i++) {
			array[i] = Integer.valueOf(values[i]);
		}
		return array;
	}
654542
public static TypedArgument typed( Class<?> type, Object value )
    {
        type = Objects.requireNonNull( type, "type" );
        if ( value != null && !type.isInstance( value ) )
        {
            throw new IllegalArgumentException(
                    value + " (a " + value.getClass().getName() + ") is not an instance of " + type.getName() );
        }
        return new TypedArgument( type, value );
    }
1245889
@SafeVarargs
	public static <T> List<T> list(boolean isLinked, T... values) {
		if (ArrayUtil.isEmpty(values)) {
			return list(isLinked);
		}
		List<T> arrayList = isLinked ? new LinkedList<T>() : new ArrayList<T>(values.length);
		for (T t : values) {
			arrayList.add(t);
		}
		return arrayList;
	}
822621
@ReplacedBy("java.util.Collections#addAll()")
    public static <T, E extends T, C extends Collection<T>> C addAll (C col, E[] values)
    {
        if (values != null) {
            for (E value : values) {
                col.add(value);
            }
        }
        return col;
    }
936327
public void add(byte[] values) {
        ensureCapacity(size + values.length);
        for (byte element : values) {
            this.add(element);
        }
    }
24600
public Binder<T> attributes(Map<String, Object> attributes) {
        this.attributes.putAll(attributes);
        return this;
    }
559628
public T mapObject(final Map<String, String> values) throws Exception {

        T result = createInstance();

        // for each field
        for (Map.Entry<String, String> entry : values.entrySet()) {

            String field = entry.getKey();
            //get field raw value
            String value = values.get(field);

            Method setter = setters.get(field);
            if (setter == null) {
                LOGGER.warn("No public setter found for field {}, this field will be set to null (if object type) or default value (if primitive type)", field);
                continue;
            }

            Class<?> type = setter.getParameterTypes()[0];
            TypeConverter<String, ?> typeConverter = typeConverters.get(type);
            if (typeConverter == null) {
                LOGGER.warn(
                        "Type conversion not supported for type {}, field {} will be set to null (if object type) or default value (if primitive type)",
                        type, field);
                continue;
            }

            if (value == null) {
                LOGGER.warn("Attempting to convert null to type {} for field {}, this field will be set to null (if object type) or default value (if primitive type)", type, field);
                continue;
            }

            if (value.isEmpty()) {
                LOGGER.debug("Attempting to convert an empty string to type {} for field {}, this field will be ignored", type, field);
                continue;
            }

            convertValue(result, field, value, setter, type, typeConverter);

        }

        return result;
    }
480536
public final RiakIndex<T> add(Collection<T> values)
    {
        for (T value : values)
        {
            add(value);
        }

        return this;
    }