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