}

  @Override
  Collection<V> wrapCollection(@ParametricNullness K key, Collection<V> collection) {
    return wrapList(key, (List<V>) collection, null);
  }

  // Following Javadoc copied from ListMultimap.

  /**
   * {@inheritDoc}
   *
   * <p>Because the values for a given key may have duplicates and follow the insertion ordering,
   * this method returns a {@link List}, instead of the {@link Collection} specified in the {@link

  /**
   * For documenting collections that support no optional features, such as {@link
   * java.util.Collections#emptySet}
   */
  NONE;

  private final Set<Feature<? super Collection>> implied;

  CollectionFeature(Feature<? super Collection>... implied) {
    this.implied = Helpers.copyToSet(implied);
  }

  @Override
  public Set<Feature<? super Collection>> getImpliedFeatures() {
    return implied;

   */
  Collection<V> values();

  /**
   * Returns a view collection of all key-value pairs contained in this multimap, as {@link Entry}
   * instances.
   *
   * <p>Changes to the returned collection or the entries it contains will update the underlying
   * multimap, and vice versa. However, <i>adding</i> to the returned collection is not possible.
   */

            if (thing instanceof Collection) {
                Collection<?> collection = (Collection<?>) thing;
                List<T> list = new ArrayList<T>();
                for (Object element : collection) {
                    list.addAll(flattenCollections(type, element));
                }
                return list;
            }

            return Collections.singletonList(cast(type, thing));

        Visit,
        // Visitor is not interested in the contents of the collection, but would like to receive the source and other metadata
        NoContents
    }

    /**
     * Called when starting to visit a file collection. Can return true to continue with visiting or false to skip this collection and its contents.
     *

            private final Collection<Artifact> artifacts;

            DefaultArtifactInstallerRequest(@Nonnull Session session, @Nonnull Collection<Artifact> artifacts) {
                super(session);
                this.artifacts = unmodifiable(nonNull(artifacts, "artifacts cannot be null"));
            }

            @Nonnull
            @Override
            public Collection<Artifact> getArtifacts() {

    StringBuilder sb = newStringBuilderForCollection(collection.size()).append('[');
    boolean first = true;
    for (Object o : collection) {
      if (!first) {
        sb.append(", ");
      }
      first = false;
      if (o == collection) {
        sb.append("(this Collection)");
      } else {
        sb.append(o);
      }
    }
    return sb.append(']').toString();

    synchronized (collection) { // to allow Collections.synchronized* tests to pass
      Helpers.assertEqualIgnoringOrder(
          getSampleElements(), Arrays.asList(collection.stream().toArray()));
    }
  }

  @CollectionFeature.Require(KNOWN_ORDER)
  public void testStreamToArrayKnownOrder() {
    synchronized (collection) { // to allow Collections.synchronized* tests to pass

 *   }
 * }
 * </pre>
 *
 * <p>See semantic details at {@link #create(Collection)}.
 *
 * @author Luiz-Otavio Zorzella
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
final class ClusterException extends RuntimeException {

  final Collection<? extends Throwable> exceptions;

  private ClusterException(Collection<? extends Throwable> exceptions) {
    super(

 * collection instance can only be one size at once.
 *
 * @author George van den Driessche
 */
@SuppressWarnings("rawtypes") // maybe avoidable if we rework the whole package?
@GwtCompatible
public enum CollectionSize implements Feature<Collection>, Comparable<CollectionSize> {
  /** Test an empty collection. */
  ZERO(0),
  /** Test a one-element collection. */
  ONE(1),
  /** Test a three-element collection. */
  SEVERAL(3),