001
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
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 }