+ any, +all, +compose, +forloop, +repeat; fix take remove() passthrough

Author: akarnokd

src/main/java/ix/Ix.java

@@ -161,49 +161,43 @@ public static <T1, T2, T3, T4, R> Ix<R> zip(
         return new IxZip4<T1, T2, T3, T4, R>(it1, it2, it3, it4, zipper);
     }
 
-    public static <T> Ix<T> repeat(T value) {
-        // TODO implement
-        throw new UnsupportedOperationException();
+    public static <T> Ix<T> repeatValue(T value) {
+        return new IxRepeat<T>(value);
     }
 
-    public static <T> Ix<T> repeat(T value, long count) {
-        // TODO implement
-        throw new UnsupportedOperationException();
+    public static <T> Ix<T> repeatValue(T value, long count) {
+        return new IxRepeatCount<T>(value, count);
     }
 
-    public static <T> Ix<T> repeat(T value, Pred0 stopPredicate) {
-        // TODO implement
-        throw new UnsupportedOperationException();
+    public static <T> Ix<T> repeatValue(T value, Pred0 stopPredicate) {
+        return new IxRepeatPredicate<T>(value, stopPredicate);
     }
 
-    public static <T> Ix<T> forloop(T seed, Pred<? super T> condition, Func1<? super T, ? extends T> next) {
-        // TODO implement
-        throw new UnsupportedOperationException();
+    public static <T, R> Ix<R> forloop(T seed, Pred<? super T> condition, 
+            Func1<? super T, ? extends T> next,
+            Func1<? super T, ? extends R> selector) {
+        return new IxForloop<T, R>(seed, condition, selector, next);
     }
 
     //---------------------------------------------------------------------------------------
     // Instance operators
     //---------------------------------------------------------------------------------------
 
     public final <R> R as(Func1<? super Ix<T>, R> transformer) {
-        // TODO implement
-        throw new UnsupportedOperationException();
+        return transformer.call(this);
     }
 
     public final <R> Ix<R> compose(Func1<? super Ix<T>, ? extends Iterable<? extends R>> transformer) {
-        // TODO implement
-        throw new UnsupportedOperationException();
+        return new IxCompose<T, R>(this, transformer);
     }
 
     public final Ix<Boolean> any(Pred<? super T> predicate) {
-        // TODO implement
-        throw new UnsupportedOperationException();
+        return new IxAny<T>(this, predicate);
     }
 
 
     public final Ix<Boolean> all(Pred<? super T> predicate) {
-        // TODO implement
-        throw new UnsupportedOperationException();
+        return new IxAll<T>(this, predicate);
     }
 
     public final Ix<Boolean> hasElements() {

src/main/java/ix/IxAll.java

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2011-2016 David Karnok
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ix;
+
+import java.util.Iterator;
+
+final class IxAll<T> extends IxSource<T, Boolean> {
+
+    final Pred<? super T> predicate;
+    
+    public IxAll(Iterable<T> source, Pred<? super T> predicate) {
+        super(source);
+        this.predicate = predicate;
+    }
+    
+    @Override
+    public Iterator<Boolean> iterator() {
+        return new AllIterator<T>(source.iterator(), predicate);
+    }
+    
+    static final class AllIterator<T> extends IxSourceIterator<T, Boolean> {
+
+        final Pred<? super T> predicate;
+
+        public AllIterator(Iterator<T> it, Pred<? super T> predicate) {
+            super(it);
+            this.predicate = predicate;
+        }
+        
+        @Override
+        protected boolean moveNext() {
+            Iterator<T> it = this.it;
+            Pred<? super T> pred = predicate;
+            
+            while (it.hasNext()) {
+                if (!pred.test(it.next())) {
+                    hasValue = true;
+                    value = false;
+                    done = true;
+                    return true;
+                }
+            }
+            
+            hasValue = true;
+            value = true;
+            done = true;
+            return true;
+        }
+        
+    }
+}

src/main/java/ix/IxAny.java

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2011-2016 David Karnok
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ix;
+
+import java.util.Iterator;
+
+final class IxAny<T> extends IxSource<T, Boolean> {
+
+    final Pred<? super T> predicate;
+    
+    public IxAny(Iterable<T> source, Pred<? super T> predicate) {
+        super(source);
+        this.predicate = predicate;
+    }
+    
+    @Override
+    public Iterator<Boolean> iterator() {
+        return new AnyIterator<T>(source.iterator(), predicate);
+    }
+    
+    static final class AnyIterator<T> extends IxSourceIterator<T, Boolean> {
+
+        final Pred<? super T> predicate;
+
+        public AnyIterator(Iterator<T> it, Pred<? super T> predicate) {
+            super(it);
+            this.predicate = predicate;
+        }
+        
+        @Override
+        protected boolean moveNext() {
+            Iterator<T> it = this.it;
+            Pred<? super T> pred = predicate;
+            
+            while (it.hasNext()) {
+                if (pred.test(it.next())) {
+                    hasValue = true;
+                    value = true;
+                    done = true;
+                    return true;
+                }
+            }
+            
+            hasValue = true;
+            value = false;
+            done = true;
+            return true;
+        }
+        
+    }
+}

src/main/java/ix/IxCompose.java

@@ -0,0 +1,22 @@
+package ix;
+
+import java.util.Iterator;
+
+import rx.functions.Func1;
+
+final class IxCompose<T, R> extends IxSource<T, R> {
+
+    final Func1<? super Ix<T>, ? extends Iterable<? extends R>> transformer;
+    
+    public IxCompose(Iterable<T> source, Func1<? super Ix<T>, ? extends Iterable<? extends R>> transformer) {
+        super(source);
+        this.transformer = transformer;
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public Iterator<R> iterator() {
+        return (Iterator<R>)transformer.call(from(source)).iterator();
+    }
+
+}

src/main/java/ix/IxForloop.java

@@ -0,0 +1,88 @@
+/*
+ * Copyright 2011-2016 David Karnok
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ix;
+
+import java.util.Iterator;
+
+import rx.functions.Func1;
+
+final class IxForloop<T, R> extends Ix<R> {
+
+    final T seed;
+    
+    final Pred<? super T> condition;
+    
+    final Func1<? super T, ? extends R> selector;
+    
+    final Func1<? super T, ? extends T> next;
+
+    public IxForloop(T seed, Pred<? super T> condition, Func1<? super T, ? extends R> selector,
+            Func1<? super T, ? extends T> next) {
+        this.seed = seed;
+        this.condition = condition;
+        this.selector = selector;
+        this.next = next;
+    }
+    
+    @Override
+    public Iterator<R> iterator() {
+        return new ForloopIterator<T, R>(seed, condition, selector, next);
+    }
+    
+    static final class ForloopIterator<T, R> extends IxBaseIterator<R> {
+        
+        T index;
+
+        final Pred<? super T> condition;
+        
+        final Func1<? super T, ? extends R> selector;
+        
+        final Func1<? super T, ? extends T> next;
+
+        boolean exceptFirst;
+        
+        public ForloopIterator(T index, Pred<? super T> condition, Func1<? super T, ? extends R> selector,
+                Func1<? super T, ? extends T> next) {
+            this.index = index;
+            this.condition = condition;
+            this.selector = selector;
+            this.next = next;
+        }
+
+        @Override
+        protected boolean moveNext() {
+            T i = index;
+            
+            if (exceptFirst) {
+                i = next.call(i);
+                index = i;
+            } else {
+                exceptFirst = true;
+            }
+            
+            if (!condition.test(i)) {
+                done = true;
+                return false;
+            }
+            
+            value = selector.call(i);
+            hasValue = true;
+            
+            return true;
+        }
+    }
+}

src/main/java/ix/IxRepeat.java

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2011-2016 David Karnok
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ix;
+
+import java.util.Iterator;
+
+final class IxRepeat<T> extends Ix<T> {
+
+    final T value;
+    
+    public IxRepeat(T value) {
+        this.value = value;
+    }
+
+    @Override
+    public Iterator<T> iterator() {
+        return new RepeatIterator<T>(value);
+    }
+
+    static final class RepeatIterator<T> implements Iterator<T> {
+        
+        final T value;
+        
+        public RepeatIterator(T value) {
+            this.value = value;
+        }
+        
+        @Override
+        public boolean hasNext() {
+            return true;
+        }
+        
+        @Override
+        public T next() {
+            return value;
+        }
+        
+        @Override
+        public void remove() {
+            throw new UnsupportedOperationException();
+        }
+    }
+}