text: //
  //  Generated by the J2ObjC translator.  DO NOT EDIT!
  //  source: android/platform/libcore/ojluni/src/main/java/java/util/Collection.java
  //
  
  #include "J2ObjC_header.h"
  
  #pragma push_macro("INCLUDE_ALL_JavaUtilCollection")
  #ifdef RESTRICT_JavaUtilCollection
  #define INCLUDE_ALL_JavaUtilCollection 0
  #else
  #define INCLUDE_ALL_JavaUtilCollection 1
  #endif
  #undef RESTRICT_JavaUtilCollection
  
  #pragma clang diagnostic push
  #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
  
  #if __has_feature(nullability)
  #pragma clang diagnostic push
  #pragma GCC diagnostic ignored "-Wnullability"
  #pragma GCC diagnostic ignored "-Wnullability-completeness"
  #endif
  
  #if !defined (JavaUtilCollection_) && (INCLUDE_ALL_JavaUtilCollection || defined(INCLUDE_JavaUtilCollection))
  #define JavaUtilCollection_
  
  #define RESTRICT_JavaLangIterable 1
  #define INCLUDE_JavaLangIterable 1
  #include "java/lang/Iterable.h"
  
  @class IOSObjectArray;
  @protocol JavaUtilFunctionPredicate;
  @protocol JavaUtilIterator;
  @protocol JavaUtilSpliterator;
  @protocol JavaUtilStreamStream;
  
  /*!
   @brief The root interface in the <i>collection hierarchy</i>.A collection
    represents a group of objects, known as its <i>elements</i>.
   Some
    collections allow duplicate elements and others do not.  Some are ordered
    and others unordered.  The JDK does not provide any <i>direct</i>
    implementations of this interface: it provides implementations of more
    specific subinterfaces like <tt>Set</tt> and <tt>List</tt>.  This interface
    is typically used to pass collections around and manipulate them where
    maximum generality is desired. 
   <p><i>Bags</i> or <i>multisets</i> (unordered collections that may contain
    duplicate elements) should implement this interface directly. 
   <p>All general-purpose <tt>Collection</tt> implementation classes (which
    typically implement <tt>Collection</tt> indirectly through one of its
    subinterfaces) should provide two "standard" constructors: a void (no
    arguments) constructor, which creates an empty collection, and a
    constructor with a single argument of type <tt>Collection</tt>, which
    creates a new collection with the same elements as its argument.  In
    effect, the latter constructor allows the user to copy any collection,
    producing an equivalent collection of the desired implementation type.
    There is no way to enforce this convention (as interfaces cannot contain
    constructors) but all of the general-purpose <tt>Collection</tt>
    implementations in the Java platform libraries comply. 
   <p>The "destructive" methods contained in this interface, that is, the
    methods that modify the collection on which they operate, are specified to
    throw <tt>UnsupportedOperationException</tt> if this collection does not
    support the operation.  If this is the case, these methods may, but are not
    required to, throw an <tt>UnsupportedOperationException</tt> if the
    invocation would have no effect on the collection.  For example, invoking the 
   <code>addAll(Collection)</code> method on an unmodifiable collection may,
    but is not required to, throw the exception if the collection to be added
    is empty. 
   <p><a name="optional-restrictions">
    Some collection implementations have restrictions on the elements that
    they may contain.</a>  For example, some implementations prohibit null elements,
    and some have restrictions on the types of their elements.  Attempting to
    add an ineligible element throws an unchecked exception, typically 
   <tt>NullPointerException</tt> or <tt>ClassCastException</tt>.  Attempting
    to query the presence of an ineligible element may throw an exception,
    or it may simply return false; some implementations will exhibit the former
    behavior and some will exhibit the latter.  More generally, attempting an
    operation on an ineligible element whose completion would not result in
    the insertion of an ineligible element into the collection may throw an
    exception or it may succeed, at the option of the implementation.
    Such exceptions are marked as "optional" in the specification for this
    interface. 
   <p>It is up to each collection to determine its own synchronization
    policy.  In the absence of a stronger guarantee by the
    implementation, undefined behavior may result from the invocation
    of any method on a collection that is being mutated by another
    thread; this includes direct invocations, passing the collection to
    a method that might perform invocations, and using an existing
    iterator to examine the collection. 
   <p>Many methods in Collections Framework interfaces are defined in
    terms of the <code>equals</code> method.  For example,
    the specification for the <code>contains(Object o)</code>
    method says: "returns <tt>true</tt> if and only if this collection
    contains at least one element <tt>e</tt> such that 
   <tt>(o==null ? e==null : o.equals(e))</tt>."  This specification should 
   <i>not</i> be construed to imply that invoking <tt>Collection.contains</tt>
    with a non-null argument <tt>o</tt> will cause <tt>o.equals(e)</tt> to be
    invoked for any element <tt>e</tt>.  Implementations are free to implement
    optimizations whereby the <tt>equals</tt> invocation is avoided, for
    example, by first comparing the hash codes of the two elements.  (The 
   <code>Object.hashCode()</code> specification guarantees that two objects with
    unequal hash codes cannot be equal.)  More generally, implementations of
    the various Collections Framework interfaces are free to take advantage of
    the specified behavior of underlying <code>Object</code> methods wherever the
    implementor deems it appropriate. 
   <p>Some collection operations which perform recursive traversal of the
    collection may fail with an exception for self-referential instances where
    the collection directly or indirectly contains itself. This includes the 
   <code>clone()</code>, <code>equals()</code>, <code>hashCode()</code> and <code>toString()</code>
    methods. Implementations may optionally handle the self-referential scenario,
    however most current implementations do not do so. 
   <p>This interface is a member of the 
   <a href="{@@docRoot}openjdk-redirect.html?v=8&path=/technotes/guides/collections/index.html">
    Java Collections Framework</a>.
   @author Josh Bloch
   @author Neal Gafter
   - seealso: Set
   - seealso: List
   - seealso: Map
   - seealso: SortedSet
   - seealso: SortedMap
   - seealso: HashSet
   - seealso: TreeSet
   - seealso: ArrayList
   - seealso: LinkedList
   - seealso: Vector
   - seealso: Collections
   - seealso: Arrays
   - seealso: AbstractCollection
   @since 1.2
   */
  @protocol JavaUtilCollection < JavaLangIterable, JavaObject >
  
  /*!
   @brief Returns the number of elements in this collection.If this collection
    contains more than <tt>Integer.MAX_VALUE</tt> elements, returns 
   <tt>Integer.MAX_VALUE</tt>.
   @return the number of elements in this collection
   */
  - (jint)size;
  
  /*!
   @brief Returns <tt>true</tt> if this collection contains no elements.
   @return <tt>true</tt> if this collection contains no elements
   */
  - (jboolean)isEmpty;
  
  /*!
   @brief Returns <tt>true</tt> if this collection contains the specified element.
   More formally, returns <tt>true</tt> if and only if this collection
    contains at least one element <tt>e</tt> such that 
   <tt>(o==null&nbsp;?&nbsp;e==null&nbsp;:&nbsp;o.equals(e))</tt>.
   @param o element whose presence in this collection is to be tested
   @return <tt>true</tt> if this collection contains the specified
            element
   @throw ClassCastExceptionif the type of the specified element
            is incompatible with this collection
            (<a href="#optional-restrictions">optional</a>)
   @throw NullPointerExceptionif the specified element is null and this
            collection does not permit null elements
            (<a href="#optional-restrictions">optional</a>)
   */
  - (jboolean)containsWithId:(id)o;
  
  /*!
   @brief Returns an iterator over the elements in this collection.There are no
    guarantees concerning the order in which the elements are returned
    (unless this collection is an instance of some class that provides a
    guarantee).
   @return an <tt>Iterator</tt> over the elements in this collection
   */
  - (id<JavaUtilIterator>)iterator;
  
  /*!
   @brief Returns an array containing all of the elements in this collection.
   If this collection makes any guarantees as to what order its elements
    are returned by its iterator, this method must return the elements in
    the same order. 
   <p>The returned array will be "safe" in that no references to it are
    maintained by this collection.  (In other words, this method must
    allocate a new array even if this collection is backed by an array).
    The caller is thus free to modify the returned array. 
   <p>This method acts as bridge between array-based and collection-based
    APIs.
   @return an array containing all of the elements in this collection
   */
  - (IOSObjectArray *)toArray;
  
  /*!
   @brief Returns an array containing all of the elements in this collection;
    the runtime type of the returned array is that of the specified array.
   If the collection fits in the specified array, it is returned therein.
    Otherwise, a new array is allocated with the runtime type of the
    specified array and the size of this collection. 
   <p>If this collection fits in the specified array with room to spare
    (i.e., the array has more elements than this collection), the element
    in the array immediately following the end of the collection is set to 
   <tt>null</tt>.  (This is useful in determining the length of this
    collection <i>only</i> if the caller knows that this collection does
    not contain any <tt>null</tt> elements.) 
   <p>If this collection makes any guarantees as to what order its elements
    are returned by its iterator, this method must return the elements in
    the same order. 
   <p>Like the <code>toArray()</code> method, this method acts as bridge between
    array-based and collection-based APIs.  Further, this method allows
    precise control over the runtime type of the output array, and may,
    under certain circumstances, be used to save allocation costs. 
   <p>Suppose <tt>x</tt> is a collection known to contain only strings.
    The following code can be used to dump the collection into a newly
    allocated array of <tt>String</tt>:
    
   @code
  
        String[] y = x.toArray(new String[0]);
  @endcode
    Note that <tt>toArray(new Object[0])</tt> is identical in function to 
   <tt>toArray()</tt>.
   @param a the array into which the elements of this collection are to be         stored, if it is big enough; otherwise, a new array of the same
            runtime type is allocated for this purpose.
   @return an array containing all of the elements in this collection
   @throw ArrayStoreExceptionif the runtime type of the specified array
            is not a supertype of the runtime type of every element in
            this collection
   @throw NullPointerExceptionif the specified array is null
   */
  - (IOSObjectArray *)toArrayWithNSObjectArray:(IOSObjectArray *)a;
  
  /*!
   @brief Ensures that this collection contains the specified element (optional
    operation).Returns <tt>true</tt> if this collection changed as a
    result of the call.
   (Returns <tt>false</tt> if this collection does
    not permit duplicates and already contains the specified element.)<p>
    Collections that support this operation may place limitations on what
    elements may be added to this collection.  In particular, some
    collections will refuse to add <tt>null</tt> elements, and others will
    impose restrictions on the type of elements that may be added.
    Collection classes should clearly specify in their documentation any
    restrictions on what elements may be added.<p>
    If a collection refuses to add a particular element for any reason
    other than that it already contains the element, it <i>must</i> throw
    an exception (rather than returning <tt>false</tt>).  This preserves
    the invariant that a collection always contains the specified element
    after this call returns.
   @param e element whose presence in this collection is to be ensured
   @return <tt>true</tt> if this collection changed as a result of the
            call
   @throw UnsupportedOperationExceptionif the <tt>add</tt> operation
            is not supported by this collection
   @throw ClassCastExceptionif the class of the specified element
            prevents it from being added to this collection
   @throw NullPointerExceptionif the specified element is null and this
            collection does not permit null elements
   @throw IllegalArgumentExceptionif some property of the element
            prevents it from being added to this collection
   @throw IllegalStateExceptionif the element cannot be added at this
            time due to insertion restrictions
   */
  - (jboolean)addWithId:(id)e;
  
  /*!
   @brief Removes a single instance of the specified element from this
    collection, if it is present (optional operation).More formally,
    removes an element <tt>e</tt> such that 
   <tt>(o==null&nbsp;?
   &nbsp;e==null&nbsp;:&nbsp;o.equals(e))</tt>, if
    this collection contains one or more such elements.  Returns 
   <tt>true</tt> if this collection contained the specified element (or
    equivalently, if this collection changed as a result of the call).
   @param o element to be removed from this collection, if present
   @return <tt>true</tt> if an element was removed as a result of this call
   @throw ClassCastExceptionif the type of the specified element
            is incompatible with this collection
            (<a href="#optional-restrictions">optional</a>)
   @throw NullPointerExceptionif the specified element is null and this
            collection does not permit null elements
            (<a href="#optional-restrictions">optional</a>)
   @throw UnsupportedOperationExceptionif the <tt>remove</tt> operation
            is not supported by this collection
   */
  - (jboolean)removeWithId:(id)o;
  
  /*!
   @brief Returns <tt>true</tt> if this collection contains all of the elements
    in the specified collection.
   @param c collection to be checked for containment in this collection
   @return <tt>true</tt> if this collection contains all of the elements
            in the specified collection
   @throw ClassCastExceptionif the types of one or more elements
            in the specified collection are incompatible with this
            collection
            (<a href="#optional-restrictions">optional</a>)
   @throw NullPointerExceptionif the specified collection contains one
            or more null elements and this collection does not permit null
            elements
            (<a href="#optional-restrictions">optional</a>),
            or if the specified collection is null.
   - seealso: #contains(Object)
   */
  - (jboolean)containsAllWithJavaUtilCollection:(id<JavaUtilCollection>)c;
  
  /*!
   @brief Adds all of the elements in the specified collection to this collection
    (optional operation).The behavior of this operation is undefined if
    the specified collection is modified while the operation is in progress.
   (This implies that the behavior of this call is undefined if the
    specified collection is this collection, and this collection is
    nonempty.)
   @param c collection containing elements to be added to this collection
   @return <tt>true</tt> if this collection changed as a result of the call
   @throw UnsupportedOperationExceptionif the <tt>addAll</tt> operation
            is not supported by this collection
   @throw ClassCastExceptionif the class of an element of the specified
            collection prevents it from being added to this collection
   @throw NullPointerExceptionif the specified collection contains a
            null element and this collection does not permit null elements,
            or if the specified collection is null
   @throw IllegalArgumentExceptionif some property of an element of the
            specified collection prevents it from being added to this
            collection
   @throw IllegalStateExceptionif not all the elements can be added at
            this time due to insertion restrictions
   - seealso: #add(Object)
   */
  - (jboolean)addAllWithJavaUtilCollection:(id<JavaUtilCollection>)c;
  
  /*!
   @brief Removes all of this collection's elements that are also contained in the
    specified collection (optional operation).After this call returns,
    this collection will contain no elements in common with the specified
    collection.
   @param c collection containing elements to be removed from this collection
   @return <tt>true</tt> if this collection changed as a result of the
            call
   @throw UnsupportedOperationExceptionif the <tt>removeAll</tt> method
            is not supported by this collection
   @throw ClassCastExceptionif the types of one or more elements
            in this collection are incompatible with the specified
            collection
            (<a href="#optional-restrictions">optional</a>)
   @throw NullPointerExceptionif this collection contains one or more
            null elements and the specified collection does not support         null elements
            (<a href="#optional-restrictions">optional</a>),
            or if the specified collection is null
   - seealso: #remove(Object)
   - seealso: #contains(Object)
   */
  - (jboolean)removeAllWithJavaUtilCollection:(id<JavaUtilCollection>)c;
  
  /*!
   @brief Removes all of the elements of this collection that satisfy the given
    predicate.Errors or runtime exceptions thrown during iteration or by
    the predicate are relayed to the caller.
   @param filter a predicate which returns <code>true</code>  for elements to be
            removed
   @return <code>true</code> if any elements were removed
   @throw NullPointerExceptionif the specified filter is null
   @throw UnsupportedOperationExceptionif elements cannot be removed
            from this collection.  Implementations may throw this exception if a
            matching element cannot be removed or if, in general, removal is not
            supported.
   @since 1.8
   */
  - (jboolean)removeIfWithJavaUtilFunctionPredicate:(id<JavaUtilFunctionPredicate>)filter;
  
  /*!
   @brief Retains only the elements in this collection that are contained in the
    specified collection (optional operation).In other words, removes from
    this collection all of its elements that are not contained in the
    specified collection.
   @param c collection containing elements to be retained in this collection
   @return <tt>true</tt> if this collection changed as a result of the call
   @throw UnsupportedOperationExceptionif the <tt>retainAll</tt> operation
            is not supported by this collection
   @throw ClassCastExceptionif the types of one or more elements
            in this collection are incompatible with the specified
            collection
            (<a href="#optional-restrictions">optional</a>)
   @throw NullPointerExceptionif this collection contains one or more
            null elements and the specified collection does not permit null
            elements
            (<a href="#optional-restrictions">optional</a>),
            or if the specified collection is null
   - seealso: #remove(Object)
   - seealso: #contains(Object)
   */
  - (jboolean)retainAllWithJavaUtilCollection:(id<JavaUtilCollection>)c;
  
  /*!
   @brief Removes all of the elements from this collection (optional operation).
   The collection will be empty after this method returns.
   @throw UnsupportedOperationExceptionif the <tt>clear</tt> operation
            is not supported by this collection
   */
  - (void)clear;
  
  /*!
   @brief Compares the specified object with this collection for equality.
   <p>
    While the <tt>Collection</tt> interface adds no stipulations to the
    general contract for the <tt>Object.equals</tt>, programmers who
    implement the <tt>Collection</tt> interface "directly" (in other words,
    create a class that is a <tt>Collection</tt> but is not a <tt>Set</tt>
    or a <tt>List</tt>) must exercise care if they choose to override the 
   <tt>Object.equals</tt>.  It is not necessary to do so, and the simplest
    course of action is to rely on <tt>Object</tt>'s implementation, but
    the implementor may wish to implement a "value comparison" in place of
    the default "reference comparison."  (The <tt>List</tt> and 
   <tt>Set</tt> interfaces mandate such value comparisons.)<p>
    The general contract for the <tt>Object.equals</tt> method states that
    equals must be symmetric (in other words, <tt>a.equals(b)</tt> if and
    only if <tt>b.equals(a)</tt>).  The contracts for <tt>List.equals</tt>
    and <tt>Set.equals</tt> state that lists are only equal to other lists,
    and sets to other sets.  Thus, a custom <tt>equals</tt> method for a
    collection class that implements neither the <tt>List</tt> nor 
   <tt>Set</tt> interface must return <tt>false</tt> when this collection
    is compared to any list or set.  (By the same logic, it is not possible
    to write a class that correctly implements both the <tt>Set</tt> and 
   <tt>List</tt> interfaces.)
   @param o object to be compared for equality with this collection
   @return <tt>true</tt> if the specified object is equal to this
    collection
   - seealso: Object#equals(Object)
   - seealso: Set#equals(Object)
   - seealso: List#equals(Object)
   */
  - (jboolean)isEqual:(id)o;
  
  /*!
   @brief Returns the hash code value for this collection.While the 
   <tt>Collection</tt> interface adds no stipulations to the general
    contract for the <tt>Object.hashCode</tt> method, programmers should
    take note that any class that overrides the <tt>Object.equals</tt>
    method must also override the <tt>Object.hashCode</tt> method in order
    to satisfy the general contract for the <tt>Object.hashCode</tt> method.
   In particular, <tt>c1.equals(c2)</tt> implies that 
   <tt>c1.hashCode()==c2.hashCode()</tt>.
   @return the hash code value for this collection
   - seealso: Object#hashCode()
   - seealso: Object#equals(Object)
   */
  - (NSUInteger)hash;
  
  /*!
   @brief Creates a <code>Spliterator</code> over the elements in this collection.
   Implementations should document characteristic values reported by the
    spliterator.  Such characteristic values are not required to be reported
    if the spliterator reports <code>Spliterator.SIZED</code> and this collection
    contains no elements. 
   <p>The default implementation should be overridden by subclasses that
    can return a more efficient spliterator.  In order to
    preserve expected laziness behavior for the <code>stream()</code> and 
   <code>parallelStream()</code>} methods, spliterators should either have the
    characteristic of <code>IMMUTABLE</code> or <code>CONCURRENT</code>, or be 
   <em><a href="Spliterator.html#binding">late-binding</a></em>.
    If none of these is practical, the overriding class should describe the
    spliterator's documented policy of binding and structural interference,
    and should override the <code>stream()</code> and <code>parallelStream()</code>
    methods to create streams using a <code>Supplier</code> of the spliterator,
    as in: 
   @code
      Stream<E> s = StreamSupport.stream(() -> spliterator(), spliteratorCharacteristics) 
   
  @endcode
    <p>These requirements ensure that streams produced by the 
   <code>stream()</code> and <code>parallelStream()</code> methods will reflect the
    contents of the collection as of initiation of the terminal stream
    operation.
   @return a <code>Spliterator</code> over the elements in this collection
   @since 1.8
   */
  - (id<JavaUtilSpliterator>)spliterator;
  
  /*!
   @brief Returns a sequential <code>Stream</code> with this collection as its source.
   <p>This method should be overridden when the <code>spliterator()</code>
    method cannot return a spliterator that is <code>IMMUTABLE</code>,
    <code>CONCURRENT</code>, or <em>late-binding</em>. (See <code>spliterator()</code>
    for details.)
   @return a sequential <code>Stream</code> over the elements in this collection
   @since 1.8
   */
  - (id<JavaUtilStreamStream>)stream;
  
  /*!
   @brief Returns a possibly parallel <code>Stream</code> with this collection as its
    source.It is allowable for this method to return a sequential stream.
   <p>This method should be overridden when the <code>spliterator()</code>
    method cannot return a spliterator that is <code>IMMUTABLE</code>,
    <code>CONCURRENT</code>, or <em>late-binding</em>. (See <code>spliterator()</code>
    for details.)
   @return a possibly parallel <code>Stream</code> over the elements in this
    collection
   @since 1.8
   */
  - (id<JavaUtilStreamStream>)parallelStream;
  
  @end
  
  J2OBJC_EMPTY_STATIC_INIT(JavaUtilCollection)
  
  FOUNDATION_EXPORT jboolean JavaUtilCollection_removeIfWithJavaUtilFunctionPredicate_(id<JavaUtilCollection> self, id<JavaUtilFunctionPredicate> filter);
  
  FOUNDATION_EXPORT id<JavaUtilSpliterator> JavaUtilCollection_spliterator(id<JavaUtilCollection> self);
  
  FOUNDATION_EXPORT id<JavaUtilStreamStream> JavaUtilCollection_stream(id<JavaUtilCollection> self);
  
  FOUNDATION_EXPORT id<JavaUtilStreamStream> JavaUtilCollection_parallelStream(id<JavaUtilCollection> self);
  
  J2OBJC_TYPE_LITERAL_HEADER(JavaUtilCollection)
  
  #endif
  
  
  #if __has_feature(nullability)
  #pragma clang diagnostic pop
  #endif
  
  #pragma clang diagnostic pop
  #pragma pop_macro("INCLUDE_ALL_JavaUtilCollection")
  