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.io.Serializable;
018    
019    import java.util.Collection;
020    import java.util.Iterator;
021    import java.util.List;
022    import java.util.ListIterator;
023    
024    /**
025     * <p>
026     * This is a read-only wrapper around any <code>java.util.List</code>. Query
027     * operations will "read through" to the specified list. Attempts to modify the
028     * list directly or via its iterator will result in a
029     * <code>java.lang.UnsupportedOperationException</code>.
030     * </p>
031     *
032     * @author Alexander Chow
033     */
034    public class UnmodifiableList<E> implements List<E>, Serializable {
035    
036            public UnmodifiableList(List<? extends E> list) {
037                    if (list == null) {
038                            throw new NullPointerException();
039                    }
040    
041                    _list = list;
042            }
043    
044            @Override
045            public boolean add(E element) {
046                    throw new UnsupportedOperationException(_MESSAGE);
047            }
048    
049            @Override
050            public void add(int index, E element) {
051                    throw new UnsupportedOperationException(_MESSAGE);
052            }
053    
054            @Override
055            public boolean addAll(Collection<? extends E> collection) {
056                    throw new UnsupportedOperationException(_MESSAGE);
057            }
058    
059            @Override
060            public boolean addAll(int index, Collection<? extends E> collection) {
061                    throw new UnsupportedOperationException(_MESSAGE);
062            }
063    
064            @Override
065            public void clear() {
066                    throw new UnsupportedOperationException(_MESSAGE);
067            }
068    
069            @Override
070            public boolean contains(Object object) {
071                    return _list.contains(object);
072            }
073    
074            @Override
075            public boolean containsAll(Collection<?> collection) {
076                    return _list.containsAll(collection);
077            }
078    
079            @Override
080            public boolean equals(Object object) {
081                    return _list.equals(object);
082            }
083    
084            @Override
085            public E get(int index) {
086                    return _list.get(index);
087            }
088    
089            @Override
090            public int hashCode() {
091                    return _list.hashCode();
092            }
093    
094            @Override
095            public int indexOf(Object object) {
096                    return _list.indexOf(object);
097            }
098    
099            @Override
100            public boolean isEmpty() {
101                    return _list.isEmpty();
102            }
103    
104            @Override
105            public Iterator<E> iterator() {
106                    return new Iterator<E>() {
107    
108                            Iterator<? extends E> itr = _list.iterator();
109    
110                            @Override
111                            public boolean hasNext() {
112                                    return itr.hasNext();
113                            }
114    
115                            @Override
116                            public E next() {
117                                    return itr.next();
118                            }
119    
120                            @Override
121                            public void remove() {
122                                    throw new UnsupportedOperationException(_MESSAGE);
123                            }
124    
125                    };
126            }
127    
128            @Override
129            public int lastIndexOf(Object o) {
130                    return _list.lastIndexOf(o);
131            }
132    
133            @Override
134            public ListIterator<E> listIterator() {
135                    return listIterator(0);
136            }
137    
138            @Override
139            public ListIterator<E> listIterator(final int index) {
140                    return new ListIterator<E>() {
141    
142                            ListIterator<? extends E> itr = _list.listIterator(index);
143    
144                            @Override
145                            public void add(E element) {
146                                    throw new UnsupportedOperationException(_MESSAGE);
147                            }
148    
149                            @Override
150                            public boolean hasNext() {
151                                    return itr.hasNext();
152                            }
153    
154                            @Override
155                            public E next() {
156                                    return itr.next();
157                            }
158    
159                            @Override
160                            public boolean hasPrevious() {
161                                    return itr.hasPrevious();
162                            }
163    
164                            @Override
165                            public E previous() {
166                                    return itr.previous();
167                            }
168    
169                            @Override
170                            public int nextIndex() {
171                                    return itr.nextIndex();
172                            }
173    
174                            @Override
175                            public int previousIndex() {
176                                    return itr.previousIndex();
177                            }
178    
179                            @Override
180                            public void remove() {
181                                    throw new UnsupportedOperationException(_MESSAGE);
182                            }
183    
184                            @Override
185                            public void set(E element) {
186                                    throw new UnsupportedOperationException(_MESSAGE);
187                            }
188    
189                    };
190            }
191    
192            @Override
193            public E remove(int index) {
194                    throw new UnsupportedOperationException(_MESSAGE);
195            }
196    
197            @Override
198            public boolean remove(Object object) {
199                    throw new UnsupportedOperationException(_MESSAGE);
200            }
201    
202            @Override
203            public boolean removeAll(Collection<?> collection) {
204                    throw new UnsupportedOperationException(_MESSAGE);
205            }
206    
207            @Override
208            public boolean retainAll(Collection<?> collection) {
209                    throw new UnsupportedOperationException(_MESSAGE);
210            }
211    
212            @Override
213            public E set(int index, E element) {
214                    throw new UnsupportedOperationException(_MESSAGE);
215            }
216    
217            @Override
218            public int size() {
219                    return _list.size();
220            }
221    
222            @Override
223            public List<E> subList(int fromIndex, int toIndex) {
224                    return new UnmodifiableList<E>(_list.subList(fromIndex, toIndex));
225            }
226    
227            @Override
228            public Object[] toArray() {
229                    return _list.toArray();
230            }
231    
232            @Override
233            public <T> T[] toArray(T[] a) {
234                    return _list.toArray(a);
235            }
236    
237            @Override
238            public String toString() {
239                    return _list.toString();
240            }
241    
242            private static final String _MESSAGE =
243                    "Please make a copy of this read-only list before modifying it.";
244    
245            private List<? extends E> _list;
246    
247    }