<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
432458
public static <T> Level0IndefiniteArrayOperator<T[],T> onArrayFor(final T... elements) {
        return new Level0IndefiniteArrayOperator<T[],T>(ExecutionTarget.forOp(VarArgsUtil.asRequiredObjectArray(elements), Normalisation.NONE));
    }
1034783
public static <T> Object[] store(T[] array, Object... elements) {
        Object[] result = new Object[array.length + elements.length];
        System.arraycopy(array, 0, result, 0, array.length);
        System.arraycopy(elements, 0, result, array.length, elements.length);
        return result;
    }
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;
    }
303122
public static <T> Iterator<T> singleElementIterator(final T element) {
    return new Iterator<T>() {
      private boolean mHasNext = true;

      @Override
      public boolean hasNext() {
        return mHasNext;
      }

      @Override
      public T next() {
        if (!hasNext()) {
          throw new NoSuchElementException();
        }
        mHasNext = false;
        return element;
      }

      @Override
      public void remove() {
        throw new UnsupportedOperationException("remove is not supported.");
      }
    };
  }
1298906
public static <T> Gather<T> from(T... elements) {
		return null == elements 
				? Gather.<T>empty() : from(Arrays.asList(elements));
	}
956792
public static <T> Level0ArrayOperator<Long[],Long> onArrayFor(final Long... elements) {
        return onArrayOf(Types.LONG, VarArgsUtil.asRequiredObjectArray(elements));
    }
53081
public static <E> ArraySet<E> newArraySet(E... elements) {
        int capacity = elements.length * 4 / 3 + 1;
        ArraySet<E> set = new ArraySet<E>(capacity);
        Collections.addAll(set, elements);
        return set;
    }
376557
static <T> List<T> list(T... elements) {
    return new ArrayList<>(Arrays.asList(elements));
  }
1001805
public static <E> List<E> copyOf(E[] elements) {
    Preconditions.checkNotNull(elements, "elements");
    List<E> result = new ArrayList<>(elements.length);
    Collections.addAll(result, elements);
    return Collections.unmodifiableList(result);
  }
713043
public static List<ExecutableElement>
            constructorsIn(Iterable<? extends Element> elements) {
        return listFilter(elements, CONSTRUCTOR_KIND, ExecutableElement.class);
    }
1255919
public static <T> Level0ArrayOperator<Float[],Float> onArrayFor(final Float... elements) {
        return onArrayOf(Types.FLOAT, VarArgsUtil.asRequiredObjectArray(elements));
    }
1371077
public static <T> Expiring<T> of(T... elements) {
		return of(Arrays.asList(checkNotNull(elements)));
	}
249973
static public BooleanExpression OR(Collection<? extends BooleanExpression> operands){
		BooleanExpression result = new BooleanExpression(OPERATOR_OR);
		result.addOperand(operands);
		return result;
	}
298390
public static <T> Level0ArrayOperator<Calendar[],Calendar> onArrayFor(final Calendar... elements) {
        return onArrayOf(Types.CALENDAR, VarArgsUtil.asRequiredObjectArray(elements));
    }
1342407
public static <E> HashSet<E> newHashSet(Iterator<? extends E> elements) {
		HashSet<E> set = newHashSet();
		while (elements.hasNext()) {
			set.add(elements.next());
		}
		return set;
	}
115403
public <T> List<T> randomElements(List<T> elements, int count) {
		if (elements.size() >= count) {
			return extractRandomList(elements, count);
		} else {
			List<T> randomElements = new ArrayList<T>();
			randomElements.addAll(extractRandomList(elements, count % elements.size()));
			do {
				randomElements.addAll(extractRandomList(elements, elements.size()));
			} while (randomElements.size() < count);
			return randomElements;
		}
	}
996181
public Operator createOperator(int op, Selector operand)
  {
	Operator operator = new OperatorImpl(op, operand);

	return operator; 
  }