ArrayProxySeq.java
001 /*
002  * Java Genetic Algorithm Library (jenetics-1.6.0).
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: 2013-12-04 $</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     @Deprecated
080     public <R> void foreach(final Function<? super T, ? extends R> function) {
081         forEach(function);
082     }
083 
084     @Override
085     public <R> void forEach(final Function<? super T, ? extends R> function) {
086         requireNonNull(function, "Function");
087 
088         for (int i = _proxy._start; i < _proxy._end; ++i) {
089             function.apply(_proxy.__get(i));
090         }
091     }
092 
093     @Override
094     @Deprecated
095     public boolean forall(final Function<? super T, Boolean> predicate) {
096         return forAll(predicate);
097     }
098 
099     @Override
100     public boolean forAll(final Function<? super T, Boolean> predicate) {
101         requireNonNull(predicate, "Predicate");
102 
103         boolean valid = true;
104         for (int i = _proxy._start; i < _proxy._end && valid; ++i) {
105             valid = predicate.apply(_proxy.__get(i));
106         }
107         return valid;
108     }
109 
110     @Override
111     public boolean contains(final Object element) {
112         return indexOf(element!= -1;
113     }
114 
115     @Override
116     public int indexOf(final Object element) {
117         return indexOf(element, 0, length());
118     }
119 
120     @Override
121     public int indexOf(final Object element, final int start) {
122         return indexOf(element, start, _proxy._length);
123     }
124 
125     @Override
126     public int indexOf(final Object element, final int start, final int end) {
127         _proxy.checkIndex(start, end);
128 
129         int index = -1;
130         if (element == null) {
131             for (int i = start + _proxy._start, n = end + _proxy._start;
132                 i < n && index == -1; ++i)
133             {
134                 if (_proxy.__get(i== null) {
135                     index = i - _proxy._start;
136                 }
137             }
138         else {
139             for (int i = start + _proxy._start, n = end + _proxy._start;
140             i < n && index == -1; ++i)
141             {
142                 if (element.equals(_proxy.__get(i))) {
143                     index = i - _proxy._start;
144                 }
145             }
146         }
147 
148         return index;
149     }
150 
151     @Override
152     public int indexWhere(final Function<? super T, Boolean> predicate) {
153         return indexWhere(predicate, 0, _proxy._length);
154     }
155 
156     @Override
157     public int indexWhere(
158         final Function<? super T, Boolean> predicate,
159         final int start
160     ) {
161         return indexWhere(predicate, start, _proxy._length);
162     }
163 
164     @Override
165     public int indexWhere(
166         final Function<? super T, Boolean> predicate,
167         final int start,
168         final int end
169     ) {
170         _proxy.checkIndex(start, end);
171         requireNonNull(predicate, "Predicate");
172 
173         int index = -1;
174 
175         for (int i = start + _proxy._start, n = end + _proxy._start;
176                 i < n && index == -1; ++i)
177         {
178             if (predicate.apply(_proxy.__get(i))) {
179                 index = i - _proxy._start;
180             }
181         }
182 
183         return index;
184     }
185 
186     @Override
187     public int lastIndexOf(final Object element) {
188         return lastIndexOf(element, 0, _proxy._length);
189     }
190 
191     @Override
192     public int lastIndexOf(final Object element, final int end) {
193         return lastIndexOf(element, 0, end);
194     }
195 
196     @Override
197     public int lastIndexOf(final Object element, final int start, final int end) {
198         _proxy.checkIndex(start, end);
199         int index = -1;
200 
201         if (element == null) {
202             for (int i = end + _proxy._start;
203                 --i >= start + _proxy._start && index == -1;)
204             {
205                 if (_proxy.__get(i== null) {
206                     index = i - _proxy._start;
207                 }
208             }
209         else {
210             for (int i = end + _proxy._start;
211                 --i >= start + _proxy._start && index == -1;)
212             {
213                 if (element.equals(_proxy.__get(i))) {
214                     index = i - _proxy._start;
215                 }
216             }
217         }
218 
219         return index;
220     }
221 
222     @Override
223     public int lastIndexWhere(final Function<? super T, Boolean> predicate) {
224         return lastIndexWhere(predicate, 0, _proxy._length);
225     }
226 
227     @Override
228     public int lastIndexWhere(
229         final Function<? super T, Boolean> predicate,
230         final int end
231     ) {
232         return lastIndexWhere(predicate, 0, end);
233     }
234 
235     @Override
236     public int lastIndexWhere(
237         final Function<? super T, Boolean> predicate,
238         final int start,
239         final int end
240     ) {
241         _proxy.checkIndex(start, end);
242         requireNonNull(predicate, "Predicate must not be null.");
243 
244         int index = -1;
245 
246         for (int i = end + _proxy._start;
247             --i >= start + _proxy._start && index == -1;)
248         {
249             if (predicate.apply(_proxy.__get(i))) {
250                 index = i - _proxy._start;
251             }
252         }
253 
254         return index;
255     }
256 
257     @Override
258     public int length() {
259         return _proxy._length;
260     }
261 
262     @Override
263     public List<T> asList() {
264         return new ArrayProxyList<>(_proxy);
265     }
266 
267     @Override
268     public Object[] toArray() {
269         return asList().toArray();
270     }
271 
272     @Override
273     public T[] toArray(final T[] array) {
274         return asList().toArray(array);
275     }
276 
277     @Override
278     public String toString(
279         final String prefix,
280         final String separator,
281         final String suffix
282     ) {
283         final StringBuilder out = new StringBuilder();
284 
285         out.append(prefix);
286         if (_proxy._length > 0) {
287             out.append(_proxy.get(0));
288         }
289         for (int i = 1; i < _proxy._length; ++i) {
290             out.append(separator);
291             out.append(_proxy.get(i));
292         }
293         out.append(suffix);
294 
295         return out.toString();
296     }
297 
298     @Override
299     public String toString(String separator) {
300         return toString("", separator, "");
301     }
302 
303     @Override
304     public String toString() {
305           return toString("["",""]");
306     }
307 
308 }