Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.infinispan.commons.util;
  
  import java.util.Iterator;
  import java.util.List;
A list which forwards all its method calls to another list. Subclasses should override one or more methods to modify the behavior of the backing list as desired per the decorator pattern.

This class does not implement java.util.RandomAccess. If the delegate supports random access, the ForwardingList subclass should implement the RandomAccess interface.

Author(s):
Mike Bostock
Since:
2 (imported from Google Collections Library)
 
 public abstract class ForwardingList<E> implements List<E> {

   
Constructor for use by subclasses.
 
    protected ForwardingList() {
    }
 
    protected abstract List<E> delegate();
 
    @Override
    public void add(int index, E element) {
       delegate().add(indexelement);
    }
 
    @Override
    public boolean addAll(int indexCollection<? extends E> elements) {
       return delegate().addAll(indexelements);
    }
 
    @Override
    public E get(int index) {
       return delegate().get(index);
    }
 
    @Override
    public int indexOf(Object element) {
       return delegate().indexOf(element);
    }
 
    @Override
    public int lastIndexOf(Object element) {
       return delegate().lastIndexOf(element);
    }
 
    @Override
    public ListIterator<E> listIterator() {
       return delegate().listIterator();
    }
 
    @Override
    public ListIterator<E> listIterator(int index) {
       return delegate().listIterator(index);
    }
 
    @Override
    public E remove(int index) {
       return delegate().remove(index);
    }
 
    @Override
    public E set(int index, E element) {
       return delegate().set(indexelement);
    }
 
    @Override
    public List<E> subList(int fromIndexint toIndex) {
       return delegate().subList(fromIndextoIndex);
    }
 
    @Override
    public boolean equals(Object object) {
       return object == this || delegate().equals(object);
    }
 
    @Override
    public int hashCode() {
       return delegate().hashCode();
    }
 
    @Override
    public Iterator<E> iterator() {
       return delegate().iterator();
    }
 
    @Override
    public int size() {
       return delegate().size();
    }
 
    @Override
    public boolean removeAll(Collection<?> collection) {
      return delegate().removeAll(collection);
   }
   public boolean isEmpty() {
      return delegate().isEmpty();
   }
   public boolean contains(Object object) {
      return delegate().contains(object);
   }
   public Object[] toArray() {
      return delegate().toArray();
   }
   public <T> T[] toArray(T[] array) {
      return delegate().toArray(array);
   }
   public boolean add(E element) {
      return delegate().add(element);
   }
   public boolean remove(Object object) {
      return delegate().remove(object);
   }
   public boolean containsAll(Collection<?> collection) {
      return delegate().containsAll(collection);
   }
   public boolean addAll(Collection<? extends E> collection) {
      return delegate().addAll(collection);
   }
   public boolean retainAll(Collection<?> collection) {
      return delegate().retainAll(collection);
   }
   public void clear() {
      delegate().clear();
   }
New to GrepCode? Check out our FAQ X