content: package com.nhaarman.listviewanimations.itemmanipulation;
  
  import android.util.Pair;
  
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Set;
  import java.util.concurrent.atomic.AtomicInteger;
  
  /**
   * A class to insert items only when there are no active items.
   * A pending index-item pair can have two states: active and pending. When inserting new items, the {@link com.nhaarman.listviewanimations.itemmanipulation.AnimateAdditionAdapter.Insertable#add
   * (int, Object)} method will be called directly if there are no active index-item pairs.
   * Otherwise, pairs will be queued until the active list is empty.
   */
  public class InsertQueue<T> {
  
      private final AnimateAdditionAdapter.Insertable<T> mInsertable;
  
      private final Set<AtomicInteger> mActiveIndexes = new HashSet<AtomicInteger>();
      private final List<Pair<Integer, T>> mPendingItemsToInsert = new ArrayList<Pair<Integer, T>>();
  
      public InsertQueue(final AnimateAdditionAdapter.Insertable<T> insertable) {
          mInsertable = insertable;
      }
  
      /**
       * Insert an item into the queue at given index. Will directly call {@link com.nhaarman.listviewanimations.itemmanipulation.AnimateAdditionAdapter.Insertable#add(int,
       * Object)} if there are no active index-item pairs. Otherwise, the pair will be queued.
       * @param index the index at which the item should be inserted.
       * @param item the item to insert.
       */
      public void insert(final int index, final T item) {
          if (mActiveIndexes.isEmpty() && mPendingItemsToInsert.isEmpty()) {
              mActiveIndexes.add(new AtomicInteger(index));
              //noinspection unchecked
              mInsertable.add(index, item);
          } else {
              mPendingItemsToInsert.add(new Pair<Integer, T>(index, item));
          }
      }
  
      @SuppressWarnings("UnusedDeclaration")
      public void insert(final Pair<Integer, T>... indexItemPair) {
          insert(Arrays.asList(indexItemPair));
      }
  
      public void insert(final List<Pair<Integer, T>> indexItemPairs) {
          if (mActiveIndexes.isEmpty() && mPendingItemsToInsert.isEmpty()) {
              for (Pair<Integer, T> pair : indexItemPairs) {
                  for (AtomicInteger existing : mActiveIndexes) {
                      if (existing.intValue() >= pair.first) {
                          existing.incrementAndGet();
                      }
                  }
                  mActiveIndexes.add(new AtomicInteger(pair.first));
  
                  mInsertable.add(pair.first, pair.second);
              }
          } else {
              mPendingItemsToInsert.addAll(indexItemPairs);
          }
      }
  
      /**
       * Clears the active states and inserts any pending pairs if applicable.
       */
      public void clearActive() {
          mActiveIndexes.clear();
          insertPending();
      }
  
      /**
       * Clear the active state for given index. Will insert any pending pairs if this call leads to a state where there are no active pairs.
       * @param index the index to remove.
       */
      public void removeActiveIndex(final int index) {
          boolean found = false;
          for (Iterator<AtomicInteger> iterator = mActiveIndexes.iterator(); iterator.hasNext() && !found; ) {
              if (iterator.next().get() == index) {
                  iterator.remove();
                  found = true;
              }
          }
          if (mActiveIndexes.isEmpty()) {
              insertPending();
          }
      }
  
      /**
       * Inserts pending items into the Insertable, and adds them to the active positions (correctly managing position shifting). Clears the pending items.
       */
      private void insertPending() {
          for (Pair<Integer, T> pi : mPendingItemsToInsert) {
              for (AtomicInteger existing : mActiveIndexes) {
                  if (existing.intValue() >= pi.first) {
                      existing.incrementAndGet();
                  }
              }
              mActiveIndexes.add(new AtomicInteger(pi.first));
              mInsertable.add(pi.first, pi.second);
          }
          mPendingItemsToInsert.clear();
      }
  
      /**
       * Returns a collection of currently active indexes.
       */
      public Collection<Integer> getActiveIndexes() {
          HashSet<Integer> result = new HashSet<Integer>();
          for (AtomicInteger i : mActiveIndexes) {
              result.add(i.get());
          }
          return result;
      }
  
      /**
       * Returns a {@code List} of {@code Pair}s with the index and items that are pending to be inserted, in the order they were requested.
       */
      public List<Pair<Integer, T>> getPendingItemsToInsert() {
          return mPendingItemsToInsert;
      }
  }
  