<p>
Creates an array with the specified elements and an <i>operation expression</i> on it.
</p>

@param elements the elements of the array being created
@return an operator, ready for chaining
14909
public static <T> Level0ArrayOperator<BigInteger[],BigInteger> onArrayFor(final BigInteger... elements) {
        return onArrayOf(Types.BIG_INTEGER, VarArgsUtil.asRequiredObjectArray(elements));
    }
529480
public static <A> Set<A> set(A... elements) {
        final Set<A> set = new HashSet<A>(elements.length);
        for (A element : elements) {
            set.add(element);
        }
        return set;
    }
1081939
public static <R> Stream<R> of(R... elements) {
        return new Stream<R>(new ArrayIterable.ArrayIterator<R>(elements));
    }
479412
@SafeVarargs
  public static <E> List<E> of(E... elements) {
    Preconditions.checkNotNull(elements, "elements");
    return Collections.unmodifiableList(Arrays.asList(elements));
  }
402622
public static IntBuffer createIntBuffer(int elements)
    {
        ByteBuffer byteBuffer = ByteBuffer.allocateDirect(elements * 4);
        byteBuffer.order(ByteOrder.nativeOrder());
        return byteBuffer.asIntBuffer();
    }
1277611
public static <T> ArrayList<T> newArrayList(Iterator<? extends T> elements) {
        return Lists.newArrayList(elements);
    }
1327625
public static <T> T[] append(final T[] array, final T element) {

    Class<?> compType = getClassType(array, element);
    if (compType == null) {
      return null;
    }
    int newArrLength = array != null ? array.length + 1 : 1;
    @SuppressWarnings("unchecked")
    T[] newArray = (T[]) Array.newInstance(compType, newArrLength);
    if (array != null) {
      System.arraycopy(array, 0, newArray, 0, array.length);
    }
    newArray[newArray.length - 1] = element;
    return newArray;
  }
589881
public HllUpdate addAll(Collection<String> elements)
    {
        if (elements == null)
        {
            throw new IllegalArgumentException("Elements cannot be null");
        }

        for (String element : elements)
        {
            this.adds.add(BinaryValue.create(element));
        }

        return this;
    }
713043
public static List<ExecutableElement>
            constructorsIn(Iterable<? extends Element> elements) {
        return listFilter(elements, CONSTRUCTOR_KIND, ExecutableElement.class);
    }
249973
static public BooleanExpression OR(Collection<? extends BooleanExpression> operands){
		BooleanExpression result = new BooleanExpression(OPERATOR_OR);
		result.addOperand(operands);
		return result;
	}
1173718
public static <F> FullList<F> newList(final F... elements) {
		final FullList<F> l = new FullList<F>(null, FullList.DEFAULT_CAPACITY);
		l.addAll(Arrays.asList(elements));
		return l;
	}
666129
protected final List<String> parseElementList(final List<Element> elements) {
        final List<String> values = new ArrayList<String>();
        for (final Element element : elements) {
            values.add(element.getText());
        }
        return values;
    }
1169167
public static <T> Level0ArrayOperator<Short[],Short> onArrayFor(final Short... elements) {
        return onArrayOf(Types.SHORT, VarArgsUtil.asRequiredObjectArray(elements));
    }
242579
@SuppressWarnings({"unchecked"})
    public static <T> T[] arrayOf(T[] firstElements, T lastElement) {
        checkArgNotNull(firstElements, "firstElements");
        Class elementType = firstElements.getClass().getComponentType();
        T[] array = (T[]) Array.newInstance(elementType, firstElements.length + 1);
        System.arraycopy(firstElements, 0, array, 0, firstElements.length);
        array[firstElements.length] = lastElement;
        return array;
    }
1256933
public void setElements(
                    final Collection<? extends T> elements
                    )
    {
        clear();
        if (elements == null  ||  elements.size() == 0) {
            return;
        }

        for (T  obj : elements) {
            addElement( obj );
        }
    }
996181
public Operator createOperator(int op, Selector operand)
  {
	Operator operator = new OperatorImpl(op, operand);

	return operator; 
  }
751246
public static <T> Level0ArrayOperator<Character[],Character> onArrayFor(final Character... elements) {
        return onArrayOf(Types.CHARACTER, VarArgsUtil.asRequiredObjectArray(elements));
    }