ArrayProxySeq.java
001 /*
002  * Java Genetic Algorithm Library (jenetics-2.0.2).
003  * Copyright (c) 2007-2014 Franz Wilhelmstötter
004  *
005  * Licensed under the Apache License, Version 2.0 (the "License");
006  * you may not use this file except in compliance with the License.
007  * You may obtain a copy of the License at
008  *
009  *      http://www.apache.org/licenses/LICENSE-2.0
010  *
011  * Unless required by applicable law or agreed to in writing, software
012  * distributed under the License is distributed on an "AS IS" BASIS,
013  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014  * See the License for the specific language governing permissions and
015  * limitations under the License.
016  *
017  * Author:
018  *    Franz Wilhelmstötter (franz.wilhelmstoetter@gmx.at)
019  */
020 package org.jenetics.internal.util;
021 
022 import static java.util.Objects.requireNonNull;
023 
024 import java.util.Iterator;
025 import java.util.List;
026 import java.util.ListIterator;
027 
028 import org.jenetics.util.Function;
029 import org.jenetics.util.Seq;
030 
031 /**
032  @author <a href="mailto:franz.wilhelmstoetter@gmx.at">Franz Wilhelmstötter</a>
033  @since 1.4
034  @version 1.5 &mdash; <em>$Date: 2014-03-10 $</em>
035  */
036 public abstract class ArrayProxySeq<T> implements Seq<T> {
037 
038     protected final ArrayProxy<T> _proxy;
039 
040     public ArrayProxySeq(final ArrayProxy<T> proxy) {
041         _proxy = requireNonNull(proxy, "ArrayProxy must not be null.");
042     }
043 
044     @Override
045     public final T get(final int index) {
046         return _proxy.get(index);
047     }
048 
049     @Override
050     public Iterator<T> iterator() {
051         return new ArrayProxyIterator<>(_proxy);
052     }
053 
054     public ListIterator<T> listIterator() {
055         return new ArrayProxyIterator<>(_proxy);
056     }
057 
058     @Override
059     public <B> Iterator<B> iterator(
060         final Function<? super T, ? extends B> mapper
061     ) {
062         requireNonNull(mapper, "Mapper must not be null.");
063 
064         return new Iterator<B>() {
065             private final Iterator<T> _iterator = iterator();
066             @Override public boolean hasNext() {
067                 return _iterator.hasNext();
068             }
069             @Override public B next() {
070                 return mapper.apply(_iterator.next());
071             }
072             @Override public void remove() {
073                 _iterator.remove();
074             }
075         };
076     }
077 
078     @Override
079     public <R> void forEach(final Function<? super T, ? extends R> function) {
080         requireNonNull(function, "Function");
081 
082         for (int i = _proxy._start; i < _proxy._end; ++i) {
083             function.apply(_proxy.__get(i));
084         }
085     }
086 
087     @Override
088     public boolean forAll(final Function<? super T, Boolean> predicate) {
089         requireNonNull(predicate, "Predicate");
090 
091         boolean valid = true;
092         for (int i = _proxy._start; i < _proxy._end && valid; ++i) {
093             valid = predicate.apply(_proxy.__get(i));
094         }
095         return valid;
096     }
097 
098     @Override
099     public boolean contains(final Object element) {
100         return indexOf(element!= -1;
101     }
102 
103     @Override
104     public int indexOf(final Object element) {
105         return indexOf(element, 0, length());
106     }
107 
108     @Override
109     public int indexOf(final Object element, final int start) {
110         return indexOf(element, start, _proxy._length);
111     }
112 
113     @Override
114     public int indexOf(final Object element, final int start, final int end) {
115         _proxy.checkIndex(start, end);
116 
117         int index = -1;
118         if (element == null) {
119             for (int i = start + _proxy._start, n = end + _proxy._start;
120                 i < n && index == -1; ++i)
121             {
122                 if (_proxy.__get(i== null) {
123                     index = i - _proxy._start;
124                 }
125             }
126         else {
127             for (int i = start + _proxy._start, n = end + _proxy._start;
128             i < n && index == -1; ++i)
129             {
130                 if (element.equals(_proxy.__get(i))) {
131                     index = i - _proxy._start;
132                 }
133             }
134         }
135 
136         return index;
137     }
138 
139     @Override
140     public int indexWhere(final Function<? super T, Boolean> predicate) {
141         return indexWhere(predicate, 0, _proxy._length);
142     }
143 
144     @Override
145     public int indexWhere(
146         final Function<? super T, Boolean> predicate,
147         final int start
148     ) {
149         return indexWhere(predicate, start, _proxy._length);
150     }
151 
152     @Override
153     public int indexWhere(
154         final Function<? super T, Boolean> predicate,
155         final int start,
156         final int end
157     ) {
158         _proxy.checkIndex(start, end);
159         requireNonNull(predicate, "Predicate");
160 
161         int index = -1;
162 
163         for (int i = start + _proxy._start, n = end + _proxy._start;
164                 i < n && index == -1; ++i)
165         {
166             if (predicate.apply(_proxy.__get(i))) {
167                 index = i - _proxy._start;
168             }
169         }
170 
171         return index;
172     }
173 
174     @Override
175     public int lastIndexOf(final Object element) {
176         return lastIndexOf(element, 0, _proxy._length);
177     }
178 
179     @Override
180     public int lastIndexOf(final Object element, final int end) {
181         return lastIndexOf(element, 0, end);
182     }
183 
184     @Override
185     public int lastIndexOf(final Object element, final int start, final int end) {
186         _proxy.checkIndex(start, end);
187         int index = -1;
188 
189         if (element == null) {
190             for (int i = end + _proxy._start;
191                 --i >= start + _proxy._start && index == -1;)
192             {
193                 if (_proxy.__get(i== null) {
194                     index = i - _proxy._start;
195                 }
196             }
197         else {
198             for (int i = end + _proxy._start;
199                 --i >= start + _proxy._start && index == -1;)
200             {
201                 if (element.equals(_proxy.__get(i))) {
202                     index = i - _proxy._start;
203                 }
204             }
205         }
206 
207         return index;
208     }
209 
210     @Override
211     public int lastIndexWhere(final Function<? super T, Boolean> predicate) {
212         return lastIndexWhere(predicate, 0, _proxy._length);
213     }
214 
215     @Override
216     public int lastIndexWhere(
217         final Function<? super T, Boolean> predicate,
218         final int end
219     ) {
220         return lastIndexWhere(predicate, 0, end);
221     }
222 
223     @Override
224     public int lastIndexWhere(
225         final Function<? super T, Boolean> predicate,
226         final int start,
227         final int end
228     ) {
229         _proxy.checkIndex(start, end);
230         requireNonNull(predicate, "Predicate must not be null.");
231 
232         int index = -1;
233 
234         for (int i = end + _proxy._start;
235             --i >= start + _proxy._start && index == -1;)
236         {
237             if (predicate.apply(_proxy.__get(i))) {
238                 index = i - _proxy._start;
239             }
240         }
241 
242         return index;
243     }
244 
245     @Override
246     public int length() {
247         return _proxy._length;
248     }
249 
250     @Override
251     public List<T> asList() {
252         return new ArrayProxyList<>(_proxy);
253     }
254 
255     @Override
256     public Object[] toArray() {
257         return asList().toArray();
258     }
259 
260     @Override
261     public T[] toArray(final T[] array) {
262         return asList().toArray(array);
263     }
264 
265     @Override
266     public String toString(
267         final String prefix,
268         final String separator,
269         final String suffix
270     ) {
271         final StringBuilder out = new StringBuilder();
272 
273         out.append(prefix);
274         if (_proxy._length > 0) {
275             out.append(_proxy.get(0));
276         }
277         for (int i = 1; i < _proxy._length; ++i) {
278             out.append(separator);
279             out.append(_proxy.get(i));
280         }
281         out.append(suffix);
282 
283         return out.toString();
284     }
285 
286     @Override
287     public String toString(String separator) {
288         return toString("", separator, "");
289     }
290 
291     @Override
292     public String toString() {
293           return toString("["",""]");
294     }
295 
296 }