001package co.codewizards.cloudstore.core.collection;
002
003import static co.codewizards.cloudstore.core.util.AssertUtil.*;
004
005import java.util.ArrayList;
006import java.util.Collection;
007import java.util.Collections;
008import java.util.Iterator;
009import java.util.List;
010import java.util.ListIterator;
011
012public abstract class LazyUnmodifiableList<E> implements List<E> {
013
014        private List<E> elements;
015
016//      @Override
017//      public void forEach(Consumer<? super E> action) {
018//              getElements().forEach(action);
019//      }
020
021        @Override
022        public int size() {
023                return getElements().size();
024        }
025
026        @Override
027        public boolean isEmpty() {
028                return getElements().isEmpty();
029        }
030
031        @Override
032        public boolean contains(Object o) {
033                return getElements().contains(o);
034        }
035
036        @Override
037        public Iterator<E> iterator() {
038                return getElements().iterator();
039        }
040
041        @Override
042        public Object[] toArray() {
043                return getElements().toArray();
044        }
045
046        @Override
047        public <T> T[] toArray(T[] a) {
048                return getElements().toArray(a);
049        }
050
051        @Override
052        public boolean add(E e) {
053                return getElements().add(e);
054        }
055
056        @Override
057        public boolean remove(Object o) {
058                return getElements().remove(o);
059        }
060
061        @Override
062        public boolean containsAll(Collection<?> c) {
063                return getElements().containsAll(c);
064        }
065
066        @Override
067        public boolean addAll(Collection<? extends E> c) {
068                return getElements().addAll(c);
069        }
070
071        @Override
072        public boolean addAll(int index, Collection<? extends E> c) {
073                return getElements().addAll(index, c);
074        }
075
076        @Override
077        public boolean removeAll(Collection<?> c) {
078                return getElements().removeAll(c);
079        }
080
081        @Override
082        public boolean retainAll(Collection<?> c) {
083                return getElements().retainAll(c);
084        }
085
086//      @Override
087//      public void replaceAll(UnaryOperator<E> operator) {
088//              getElements().replaceAll(operator);
089//      }
090
091//      @Override
092//      public boolean removeIf(Predicate<? super E> filter) {
093//              return getElements().removeIf(filter);
094//      }
095
096//      @Override
097//      public void sort(Comparator<? super E> c) {
098//              getElements().sort(c);
099//      }
100
101        @Override
102        public void clear() {
103                getElements().clear();
104        }
105
106        @Override
107        public boolean equals(Object o) {
108                return getElements().equals(o);
109        }
110
111        @Override
112        public int hashCode() {
113                return getElements().hashCode();
114        }
115
116        @Override
117        public E get(int index) {
118                return getElements().get(index);
119        }
120
121        @Override
122        public E set(int index, E element) {
123                return getElements().set(index, element);
124        }
125
126        @Override
127        public void add(int index, E element) {
128                getElements().add(index, element);
129        }
130
131//      @Override
132//      public Stream<E> stream() {
133//              return getElements().stream();
134//      }
135
136        @Override
137        public E remove(int index) {
138                return getElements().remove(index);
139        }
140
141//      @Override
142//      public Stream<E> parallelStream() {
143//              return getElements().parallelStream();
144//      }
145
146        @Override
147        public int indexOf(Object o) {
148                return getElements().indexOf(o);
149        }
150
151        @Override
152        public int lastIndexOf(Object o) {
153                return getElements().lastIndexOf(o);
154        }
155
156        @Override
157        public ListIterator<E> listIterator() {
158                return getElements().listIterator();
159        }
160
161        @Override
162        public ListIterator<E> listIterator(int index) {
163                return getElements().listIterator(index);
164        }
165
166        @Override
167        public List<E> subList(int fromIndex, int toIndex) {
168                return getElements().subList(fromIndex, toIndex);
169        }
170
171//      @Override
172//      public Spliterator<E> spliterator() {
173//              return getElements().spliterator();
174//      }
175
176        protected List<E> getElements() {
177                if (elements == null)
178                        elements = Collections.unmodifiableList(new ArrayList<E>(assertNotNull(loadElements(), getClass().getName() + ".loadElements()")));
179
180                return elements;
181        }
182
183        protected abstract Collection<E> loadElements();
184}