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