package com.carrotsearch.hppc;

import java.util.Iterator;

import com.carrotsearch.hppc.cursors.IntCursor;
import com.carrotsearch.hppc.predicates.IntPredicate;
import com.carrotsearch.hppc.procedures.IntProcedure;

A generic container holding ints.
/**
 * A generic container holding <code>int</code>s.
 */
 @com.carrotsearch.hppc.Generated(
    date = "2018-05-21T12:24:05+0200",
    value = "KTypeContainer.java") 
public interface IntContainer extends Iterable<IntCursor> {
  
Returns an iterator to a cursor traversing the collection. The order of
traversal is not defined. More than one cursor may be active at a time. The
behavior of iterators is undefined if structural changes are made to the
underlying collection.

The iterator is implemented as a cursor and it returns the same cursor
instance on every call to Iterator.next() (to avoid boxing of primitive types). To read the current list's value (or index in the list) use the cursor's public fields. An example is shown below. 
for (IntCursor<int> c : container) {
  System.out.println("index=" + c.index + " value=" + c.value);
}

/**
   * Returns an iterator to a cursor traversing the collection. The order of
   * traversal is not defined. More than one cursor may be active at a time. The
   * behavior of iterators is undefined if structural changes are made to the
   * underlying collection.
   * 
   * <p>
   * The iterator is implemented as a cursor and it returns <b>the same cursor
   * instance</b> on every call to {@link Iterator#next()} (to avoid boxing of
   * primitive types). To read the current list's value (or index in the list)
   * use the cursor's public fields. An example is shown below.
   * </p>
   * 
   * <pre>
   * for (IntCursor&lt;int&gt; c : container) {
   *   System.out.println(&quot;index=&quot; + c.index + &quot; value=&quot; + c.value);
   * }
   * </pre>
   */
  public Iterator<IntCursor> iterator();

  
Lookup a given element in the container. This operation has no speed
guarantees (may be linear with respect to the size of this container).
Returns:
Returns true if this container has an element equal to
        e./**
   * Lookup a given element in the container. This operation has no speed
   * guarantees (may be linear with respect to the size of this container).
   * 
   * @return Returns <code>true</code> if this container has an element equal to
   *         <code>e</code>.
   */
  public boolean contains(int e);

  
Return the current number of elements in this container. The time for
calculating the container's size may take O(n) time, although
implementing classes should try to maintain the current size and return in
constant time.
/**
   * Return the current number of elements in this container. The time for
   * calculating the container's size may take <code>O(n)</code> time, although
   * implementing classes should try to maintain the current size and return in
   * constant time.
   */
  public int size();

  
Shortcut for size() == 0.
/**
   * Shortcut for <code>size() == 0</code>.
   */
  public boolean isEmpty();

  
Copies all elements of this container to an array.
The returned array is always a copy, regardless of the storage used by the
container.
/**
   * Copies all elements of this container to an array.
   * 
   * The returned array is always a copy, regardless of the storage used by the
   * container.
   */
     public int [] toArray();
 

  /*  */

  
Applies a procedure to all container elements. Returns the argument (any subclass of IntProcedure. This lets the caller to call methods of the argument by chaining the call (even if the argument is an anonymous type) to retrieve computed values, for example (IntContainer): 
int count = container.forEach(new IntProcedure() {
  int count; // this is a field declaration in an anonymous class.
  public void apply(int value) {
    count++;
  }
}).count;

/**
   * Applies a <code>procedure</code> to all container elements. Returns the
   * argument (any subclass of {@link IntProcedure}. This lets the caller to
   * call methods of the argument by chaining the call (even if the argument is
   * an anonymous type) to retrieve computed values, for example (IntContainer):
   * 
   * <pre>
   * int count = container.forEach(new IntProcedure() {
   *   int count; // this is a field declaration in an anonymous class.
   * 
   *   public void apply(int value) {
   *     count++;
   *   }
   * }).count;
   * </pre>
   */
  public <T extends IntProcedure> T forEach(T procedure);

  
Applies a predicate to container elements as long, as the
predicate returns true. The iteration is interrupted
otherwise.
/**
   * Applies a <code>predicate</code> to container elements as long, as the
   * predicate returns <code>true</code>. The iteration is interrupted
   * otherwise.
   */
  public <T extends IntPredicate> T forEach(T predicate);
}