Return loop iterating over entites on overloaded server

src/main/java/kcauldron/wrapper/CollectionWrapper.java

@@ -4,7 +4,7 @@ import java.util.Collection;
 import java.util.Iterator;
 
 public class CollectionWrapper<T, C extends Collection<T>> implements Collection<T> {
-    private C mCollection;
+    protected C mCollection;
 
     public CollectionWrapper(C collection) {
         mCollection = collection;
@@ -22,7 +22,7 @@ public class CollectionWrapper<T, C extends Collection<T>> implements Collection
 
     @Override
     public void clear() {
-        mCollection.clear();        
+        mCollection.clear();
     }
 
     @Override
@@ -74,4 +74,8 @@ public class CollectionWrapper<T, C extends Collection<T>> implements Collection
     public <T> T[] toArray(T[] a) {
         return mCollection.toArray(a);
     }
+
+    public C unwrap() {
+        return mCollection;
+    }
 }

src/main/java/kcauldron/wrapper/ProcessingQueue.java

@@ -0,0 +1,132 @@
+package kcauldron.wrapper;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Queue;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class ProcessingQueue<T> extends QueueWrapper<T> {
+    public class ProcessingIterator implements Iterator<T> {
+        private Iterator<T> mRealIterator = mCollection.iterator();
+        private AtomicInteger mPosition = new AtomicInteger(0);
+
+        @Override
+        public boolean hasNext() {
+            final int size = mSize.get();
+            final int position = mPosition.get();
+            if (size == 0 || position >= size) {
+                mPosition.compareAndSet(position, 0);
+                mRealIterator = mCollection.iterator();
+                return false;
+            }
+            boolean value = mRealIterator.hasNext();
+            if (!value) {
+                mRealIterator = mCollection.iterator();
+                value = mRealIterator.hasNext();
+            }
+            return value;
+        }
+
+        @Override
+        public T next() {
+            T value = mRealIterator.next();
+            mPosition.incrementAndGet();
+            return value;
+        }
+
+        @Override
+        public void remove() {
+            mRealIterator.remove();
+            mSize.decrementAndGet();
+            mPosition.decrementAndGet();
+        }
+
+        public void reset() {
+            mPosition.set(0);
+        }
+    }
+
+    private final AtomicInteger mSize;
+    private final ProcessingIterator mIterator = new ProcessingIterator();
+
+    @Override
+    public boolean add(T e) {
+        boolean result = super.add(e);
+        if (result) {
+            mSize.incrementAndGet();
+        }
+        return result;
+    };
+
+    @Override
+    public boolean offer(T e) {
+        boolean result = super.offer(e);
+        if (result) {
+            mSize.incrementAndGet();
+        }
+        return result;
+    }
+
+    @Override
+    public boolean addAll(Collection<? extends T> c) {
+        boolean result = false;
+        for (T t : c) {
+            result |= add(t);
+        }
+        return result;
+    }
+
+    @Override
+    public T remove() {
+        T result = super.remove();
+        mSize.decrementAndGet();
+        return result;
+    }
+
+    @Override
+    public boolean remove(Object o) {
+        boolean result = super.remove(o);
+        if (result) {
+            mSize.decrementAndGet();
+        }
+        return result;
+    }
+
+    @Override
+    public boolean removeAll(Collection<?> c) {
+        boolean result = false;
+        for (Object t : c) {
+            result |= remove(t);
+        }
+        return result;
+    }
+
+    @Override
+    public boolean retainAll(Collection<?> c) {
+        boolean result = super.retainAll(c);
+        if (result) {
+            mSize.set(mCollection.size());
+        }
+        return result;
+    }
+
+    @Override
+    public T poll() {
+        T result = super.remove();
+        if (result != null) {
+            mSize.decrementAndGet();
+        }
+        return result;
+    }
+
+    public ProcessingQueue(Queue<T> collection) {
+        super(collection);
+        mSize = new AtomicInteger(collection.size());
+    }
+
+    @Override
+    public ProcessingIterator iterator() {
+        mIterator.reset();
+        return mIterator;
+    }
+}

src/main/java/kcauldron/wrapper/QueueToList.java

@@ -5,7 +5,7 @@ import java.util.List;
 import java.util.ListIterator;
 import java.util.Queue;
 
-public class QueueToList<T> extends CollectionWrapper<T, Queue<T>>implements List<T> {
+public class QueueToList<T> extends CollectionWrapper<T, Queue<T>> implements List<T> {
     private final Queue<T> mQueue;
     private final LinkedHelper<T> mHelper;
 

src/main/java/kcauldron/wrapper/QueueWrapper.java

@@ -0,0 +1,34 @@
+package kcauldron.wrapper;
+
+import java.util.Queue;
+
+public class QueueWrapper<T> extends CollectionWrapper<T, Queue<T>> implements Queue<T>{
+    public QueueWrapper(Queue<T> collection) {
+        super(collection);
+    }
+
+    @Override
+    public T element() {
+        return mCollection.element();
+    }
+
+    @Override
+    public boolean offer(T e) {
+        return mCollection.offer(e);
+    }
+
+    @Override
+    public T peek() {
+        return mCollection.peek();
+    }
+
+    @Override
+    public T poll() {
+        return mCollection.poll();
+    }
+
+    @Override
+    public T remove() {
+        return mCollection.remove();
+    }
+}