Iterable<? extends E> elements) {
    checkNotNull(elements); // for GWT
    // Let ArrayList's sizing logic work, if possible
    return (elements instanceof Collection)
        ? new ArrayList<>((Collection<? extends E>) elements)
        : newArrayList(elements.iterator());
  }

  /**
   * Creates a <i>mutable</i> {@code ArrayList} instance containing the given elements; a very thin

    private final Set<T> elements = new LinkedHashSet<T>();

    public ImmutableDomainObjectSet(Iterable<? extends T> elements) {
        for (T element : elements) {
            this.elements.add(element);
        }
    }

    @Override
    public Iterator<T> iterator() {
        return elements.iterator();
    }

    @Override
    public int size() {

            List<ResolvedArtifactSet> artifactSets = new ArrayList<>();
            for (Object element : elements) {
                if (element instanceof ResolvedArtifactSet) {
                    artifactSets.add((ResolvedArtifactSet) element);
                } else {
                    File file = (File) element;
                    artifactSets.add(new FileBackedArtifactSet(file));
                }
            }

    /**
     * Returns a source element that contains the union of the given elements.
     */
    public static SourceElement ofElements(final SourceElement... elements) {
        return new SourceElement() {
            @Override
            public List<SourceFile> getFiles() {
                List<SourceFile> files = new ArrayList<SourceFile>();
                for (SourceElement element : elements) {

 * elements FIFO (first-in-first-out). The head of the queue is that element that has been
 * on the queue the longest time. The tail of the queue is that element that has been on
 * the queue the shortest time. New elements are inserted at the tail of the queue, and the queue
 * retrieval operations obtain elements at the head of the queue.
 *

    /**
     * Maintains a fixed size window of elements by sliding the window one element and inserting a new element at the end.
     *
     * @param element The element to add
     */
    void slideAndInsert(T element);

    /**
     * Returns a snapshot of the elements in the window.
     *
     * @return collection view of the elements
     */
    Collection<T> snapshot();

    /**

    int estimatedSize();

    boolean contains(Object element);

    boolean containsAll(Collection<?> elements);

    @Override
    boolean isEmpty();

    boolean add(T element);

    /**
     * Sets a verifier that specifies whether there is a subscription for
     * elements of a given type. This is used to determine whether a 
     * pending element should be realized upon addition to this source.
     */

  /**
   * A collector that converts a stream of zero or one elements to an {@code Optional}.
   *
   * @throws IllegalArgumentException if the stream consists of two or more elements.
   * @throws NullPointerException if any element in the stream is {@code null}.
   * @return {@code Optional.of(onlyElement)} if the stream has exactly one element (must not be
   *     {@code null}) and returns {@code Optional.empty()} if it has none.

    if (element instanceof Entry) {
      Entry<?, ?> entry = (Entry<?, ?>) element;
      element = mapEntry(entry.getKey(), entry.getValue());
    }
    assertTrue(collection.contains(element)); // sanity check
    iterator.remove();
    assertFalse(collection.contains(element));
    assertEquals(originalSize - 1, collection.size());
  }

      Comparator<? super E> comparator, E... elements) {
    checkNotNull(elements);
    switch (elements.length) {
      case 0:
        return emptySet(comparator);
      default:
        SortedSet<E> delegate = new TreeSet<E>(comparator);
        for (E element : elements) {
          checkNotNull(element);
          delegate.add(element);
        }