Example usage for com.google.common.collect ForwardingIterator ForwardingIterator

Introduction

In this page you can find the example usage for com.google.common.collect ForwardingIterator ForwardingIterator.

Prototype

protected ForwardingIterator() 

Source Link

Document

Constructor for use by subclasses.

Usage

From source file:org.gabrielebaldassarre.tcomponent.bridge.TalendList.java

/**
 * {@inheritDoc}// www.  j  a  v  a  2 s  .  co m
 */
@Override
public Iterator<T> iterator() {
    final Iterator<T> iter = super.iterator();
    return new ForwardingIterator<T>() {
        @Override
        protected Iterator<T> delegate() {
            return iter;
        }

        @Override
        public T next() {
            T v = super.next();
            return (v);
        }
    };
}

---

From source file:com.palantir.common.collect.IteratorUtils.java

public static <T> Iterator<T> wrap(final Iterator<? extends T> iterator) {
    if (iterator == null) {
        return null;
    }/*from ww w  .  j  av  a2 s. co  m*/
    return new ForwardingIterator<T>() {
        @SuppressWarnings("unchecked")
        @Override
        protected Iterator<T> delegate() {
            return (Iterator<T>) iterator;
        }
    };
}

---

From source file:se.toxbee.sleepfighter.utils.collect.ObservableList.java

@Override
public Iterator<E> iterator() {
    return new ForwardingIterator<E>() {
        private E curr;

        private final Iterator<E> delegate = ObservableList.this.delegate().iterator();

        @Override/*w w  w .  jav a  2s. co  m*/
        protected Iterator<E> delegate() {
            return this.delegate;
        }

        @Override
        public E next() {
            this.curr = super.next();
            return this.curr;
        }

        @Override
        public void remove() {
            super.remove();
            fireEvent(new Event(Operation.REMOVE, -1, Collections.singleton(this.curr)));
        }
    };
}

---

From source file:com.github.benmanes.caffeine.guava.CaffeinatedGuavaCache.java

@Override
public ConcurrentMap<K, V> asMap() {
    return new ForwardingConcurrentMap<K, V>() {
        @Override/*w  w w.j a  v a2  s  . c o m*/
        public boolean containsKey(Object key) {
            return (key != null) && delegate().containsKey(key);
        }

        @Override
        public boolean containsValue(Object value) {
            return (value != null) && delegate().containsValue(value);
        }

        @Override
        public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
            delegate().replaceAll(function);
        }

        @Override
        public V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction) {
            return delegate().computeIfAbsent(key, mappingFunction);
        }

        @Override
        public V computeIfPresent(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
            return delegate().computeIfPresent(key, remappingFunction);
        }

        @Override
        public V compute(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
            return delegate().compute(key, remappingFunction);
        }

        @Override
        public V merge(K key, V value, BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
            return delegate().merge(key, value, remappingFunction);
        }

        @Override
        public Set<K> keySet() {
            return new ForwardingSet<K>() {
                @Override
                public boolean removeIf(Predicate<? super K> filter) {
                    return delegate().removeIf(filter);
                }

                @Override
                public boolean remove(Object o) {
                    return (o != null) && delegate().remove(o);
                }

                @Override
                protected Set<K> delegate() {
                    return cache.asMap().keySet();
                }
            };
        }

        @Override
        public Collection<V> values() {
            return new ForwardingCollection<V>() {
                @Override
                public boolean removeIf(Predicate<? super V> filter) {
                    return delegate().removeIf(filter);
                }

                @Override
                public boolean remove(Object o) {
                    return (o != null) && delegate().remove(o);
                }

                @Override
                protected Collection<V> delegate() {
                    return cache.asMap().values();
                }
            };
        }

        @Override
        public Set<Entry<K, V>> entrySet() {
            return new ForwardingSet<Entry<K, V>>() {
                @Override
                public boolean add(Entry<K, V> entry) {
                    throw new UnsupportedOperationException();
                }

                @Override
                public boolean addAll(Collection<? extends Entry<K, V>> entry) {
                    throw new UnsupportedOperationException();
                }

                @Override
                public boolean removeIf(Predicate<? super Entry<K, V>> filter) {
                    return delegate().removeIf(filter);
                }

                @Override
                public Iterator<Entry<K, V>> iterator() {
                    Iterator<Entry<K, V>> iterator = delegate().iterator();
                    return new ForwardingIterator<Entry<K, V>>() {
                        @Override
                        public Entry<K, V> next() {
                            Entry<K, V> entry = delegate().next();
                            return new ForwardingMapEntry<K, V>() {
                                @Override
                                public V setValue(V value) {
                                    throw new UnsupportedOperationException();
                                }

                                @Override
                                protected Entry<K, V> delegate() {
                                    return entry;
                                }
                            };
                        }

                        @Override
                        protected Iterator<Entry<K, V>> delegate() {
                            return iterator;
                        }
                    };
                }

                @Override
                protected Set<Entry<K, V>> delegate() {
                    return cache.asMap().entrySet();
                }
            };
        }

        @Override
        protected ConcurrentMap<K, V> delegate() {
            return cache.asMap();
        }
    };
}

---

From source file:com.github.benmanes.multiway.EliminationStack.java

@Override
public Iterator<E> iterator() {
    final class ReadOnlyIterator extends AbstractIterator<E> {
        Node<E> current = top.get();

        @Override/*w w w.j a v  a  2  s . c  o m*/
        protected E computeNext() {
            for (;;) {
                if (current == null) {
                    return endOfData();
                }
                E e = current.get();
                current = current.next;
                if (e != null) {
                    return e;
                }
            }
        }
    }
    ;
    return new ForwardingIterator<E>() {
        final ReadOnlyIterator delegate = new ReadOnlyIterator();

        @Override
        public void remove() {
            checkState(delegate.current != null);
            delegate.current.lazySet(null);
        }

        @Override
        protected Iterator<E> delegate() {
            return delegate;
        }
    };
}

---