* unspecified order.
   *
   * @param elements the elements that the set should contain
   * @return a new {@code CompactHashSet} containing those elements (minus duplicates)
   */
  @SafeVarargs
  public static <E extends @Nullable Object> CompactHashSet<E> create(E... elements) {
    CompactHashSet<E> set = createWithExpectedSize(elements.length);

      }

      @Override
      public T set(int index, T element) {
        return data.set(index, element);
      }

      @Override
      public boolean add(T element) {
        return data.add(element);
      }

      @Override
      public void add(int index, T element) {
        data.add(index, element);
      }

      @Override
      public T remove(int index) {

 * limitations under the License.
 */

package gradlebuild.docs.dsl.docbook.model;

import org.w3c.dom.Element;

import java.util.List;

public interface DslElementDoc {
    String getId();

    Element getDescription();

    List<Element> getComment();

    boolean isDeprecated();

    boolean isIncubating();

    boolean isReplaced();

    String getReplacement();

  private int position;

  /** Returns the element with the specified index. This method is called by {@link #next()}. */
  @ParametricNullness
  protected abstract E get(int index);

  /**
   * Constructs an iterator across a sequence of the given size whose initial position is 0. That
   * is, the first call to {@link #next()} will return the first element (or throw {@link
   * NoSuchElementException} if {@code size} is zero).

        }

        return type.cast(object);
    }


    /**
     * 
     * @param type
     * @param enumeration
     * @return next element from enumeration cast to type
     * @throws PACDecodingException
     */
    public static <T extends Object> T as ( Class<T> type, Enumeration<?> enumeration ) throws PACDecodingException {

  /** Constructor for use by subclasses. */
  protected ForwardingListIterator() {}

  @Override
  protected abstract ListIterator<E> delegate();

  @Override
  public void add(@ParametricNullness E element) {
    delegate().add(element);
  }

  @Override
  public boolean hasPrevious() {
    return delegate().hasPrevious();
  }

  @Override
  public int nextIndex() {
    return delegate().nextIndex();
  }

import org.gradle.api.tasks.TaskAction
import org.gradle.api.tasks.UntrackedTask
import org.gradle.internal.util.PropertiesUtils
import org.gradle.util.internal.VersionNumber
import org.jsoup.Jsoup
import org.w3c.dom.Element
import java.util.Properties
import javax.xml.parsers.DocumentBuilderFactory


/**
 * Fetch the latest AGP versions and write a properties file.
 * Never up-to-date, non-cacheable.
 */

  private static <E extends @Nullable Object> Entry<E> entry(final E element, final int count) {
    return Multisets.immutableEntry(element, count);
  }

  private static <E extends @Nullable Object> Entry<E> control(E element, int count) {
    return HashMultiset.create(nCopies(count, element)).entrySet().iterator().next();
  }

  public void testToString() {

              public Collection<String> create(String[] elements) {
                // TODO: MinimalCollection should perhaps throw
                for (Object element : elements) {
                  if (element == null) {
                    throw new NullPointerException();
                  }
                }
                return MinimalCollection.of(elements);
              }
            })

   * @since 3.0
   */
  // TODO(kevinb): rerun benchmarks including new options
  public <E extends @NonNull T> ImmutableList<E> immutableSortedCopy(Iterable<E> elements) {
    return ImmutableList.sortedCopyOf(this, elements);
  }

  /**
   * Returns {@code true} if each element in {@code iterable} after the first is greater than or