001    /**
002     * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.kernel.util;
016    
017    import java.util.Collection;
018    import java.util.Iterator;
019    import java.util.List;
020    import java.util.ListIterator;
021    
022    /**
023     * @author Brian Wing Shun Chan
024     */
025    public class ListWrapper<E> implements List<E> {
026    
027            public ListWrapper(List<E> list) {
028                    _list = list;
029            }
030    
031            @Override
032            public boolean add(E o) {
033                    return _list.add(o);
034            }
035    
036            @Override
037            public void add(int index, E element) {
038                    _list.add(index, element);
039            }
040    
041            @Override
042            public boolean addAll(Collection<? extends E> c) {
043                    return _list.addAll(c);
044            }
045    
046            @Override
047            public boolean addAll(int index, Collection<? extends E> c) {
048                    return _list.addAll(index, c);
049            }
050    
051            @Override
052            public void clear() {
053                    _list.clear();
054            }
055    
056            @Override
057            public boolean contains(Object o) {
058                    return _list.contains(o);
059            }
060    
061            @Override
062            public boolean containsAll(Collection<?> c) {
063                    return _list.containsAll(c);
064            }
065    
066            @Override
067            public E get(int index) {
068                    return _list.get(index);
069            }
070    
071            @Override
072            public int indexOf(Object o) {
073                    return _list.indexOf(o);
074            }
075    
076            @Override
077            public boolean isEmpty() {
078                    return _list.isEmpty();
079            }
080    
081            @Override
082            public Iterator<E> iterator() {
083                    return _list.iterator();
084            }
085    
086            @Override
087            public int lastIndexOf(Object o) {
088                    return _list.lastIndexOf(o);
089            }
090    
091            @Override
092            public ListIterator<E> listIterator() {
093                    return _list.listIterator();
094            }
095    
096            @Override
097            public ListIterator<E> listIterator(int index) {
098                    return _list.listIterator(index);
099            }
100    
101            @Override
102            public E remove(int index) {
103                    return _list.remove(index);
104            }
105    
106            @Override
107            public boolean remove(Object o) {
108                    return _list.remove(o);
109            }
110    
111            @Override
112            public boolean removeAll(Collection<?> c) {
113                    return _list.removeAll(c);
114            }
115    
116            @Override
117            public boolean retainAll(Collection<?> c) {
118                    return _list.retainAll(c);
119            }
120    
121            @Override
122            public E set(int index, E element) {
123                    return _list.set(index, element);
124            }
125    
126            @Override
127            public int size() {
128                    return _list.size();
129            }
130    
131            @Override
132            public List<E> subList(int fromIndex, int toIndex) {
133                    return _list.subList(fromIndex, toIndex);
134            }
135    
136            @Override
137            public Object[] toArray() {
138                    return _list.toArray();
139            }
140    
141            @Override
142            public <T> T[] toArray(T[] a) {
143                    return _list.toArray(a);
144            }
145    
146            private List<E> _list;
147    
148    }