A bunch of operators.

Author: akarnokd

src/main/java/ix/EqualityHelper.java

@@ -0,0 +1,26 @@
+/*
+ * 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;
+
+enum EqualityHelper implements Pred2<Object, Object> {
+    INSTANCE;
+    
+    @Override
+    public boolean test(Object t, Object u) {
+        return (t == u) || (t != null && t.equals(u));
+    }
+}

src/main/java/ix/GroupedIx.java

@@ -1,3 +1,19 @@
+/*
+ * 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;
 
 /**

src/main/java/ix/Ix.java

@@ -201,108 +201,87 @@ public final Ix<Boolean> all(Pred<? super T> predicate) {
     }
 
     public final Ix<Boolean> hasElements() {
-        // TODO implement
-        throw new UnsupportedOperationException();
+        return new IxHasElements<T>(this);
     }
 
     public final Ix<T> ignoreElements() {
-        // TODO implement
-        throw new UnsupportedOperationException();
+        return new IxIgnoreElements<T>(this);
     }
 
     public final Ix<T> max(Comparator<? super T> comparator) {
-        // TODO implement
-        throw new UnsupportedOperationException();
+        return new IxMinMax<T>(this, comparator, -1);
     }
 
+    @SuppressWarnings({ "rawtypes", "unchecked" })
     public final Ix<T> max() {
-        // TODO implement
-        throw new UnsupportedOperationException();
+        return max((Comparator)SelfComparator.INSTANCE);
     }
 
     public final Ix<T> min(Comparator<? super T> comparator) {
-        // TODO implement
-        throw new UnsupportedOperationException();
+        return new IxMinMax<T>(this, comparator, 1);
     }
 
+    @SuppressWarnings({ "rawtypes", "unchecked" })
     public final Ix<T> min() {
-        // TODO implement
-        throw new UnsupportedOperationException();
+        return min((Comparator)SelfComparator.INSTANCE);
     }
 
     public final Ix<Boolean> contains(Object o) {
-        // TODO implement
-        throw new UnsupportedOperationException();
+        return new IxContains<T>(this, o);
     }
 
     public final Ix<Integer> count() {
-        // TODO implement
-        throw new UnsupportedOperationException();
+        return new IxCount<T>(this);
     }
 
     public final Ix<Long> countLong() {
-        // TODO implement
-        throw new UnsupportedOperationException();
+        return new IxCountLong<T>(this);
     }
 
     public final Ix<T> distinct() {
-        // TODO implement
-        throw new UnsupportedOperationException();
-    }
-
-    public final Ix<T> distinct(Pred2<? super T, ? super T> comparer) {
-        // TODO implement
-        throw new UnsupportedOperationException();
+        return distinct(IdentityHelper.instance());
     }
 
     public final <K> Ix<T> distinct(Func1<? super T, K> keySelector) {
-        // TODO implement
-        throw new UnsupportedOperationException();
+        return new IxDistinct<T, K>(this, keySelector);
     }
 
     public final Ix<T> distinctUntilChanged() {
-        // TODO implement
-        throw new UnsupportedOperationException();
+        return distinctUntilChanged(IdentityHelper.instance());
     }
 
     public final Ix<T> distinctUntilChanged(Pred2<? super T, ? super T> comparer) {
-        // TODO implement
-        throw new UnsupportedOperationException();
+        return new IxDistinctUntilChanged<T, T>(this, IdentityHelper.<T>instance(), comparer);
     }
 
     public final <K> Ix<T> distinctUntilChanged(Func1<? super T, K> keySelector) {
-        // TODO implement
-        throw new UnsupportedOperationException();
+        return new IxDistinctUntilChanged<T, K>(this, keySelector, EqualityHelper.INSTANCE);
     }
 
     public final Ix<T> doOnNext(Action1<? super T> action) {
-        // TODO implement
-        throw new UnsupportedOperationException();
+        return new IxDoOn<T>(this, action, IxEmptyAction.instance0());
     }
 
-    public final Ix<T> doOnCompleted(Action1<? super T> action) {
-        // TODO implement
-        throw new UnsupportedOperationException();
+    public final Ix<T> doOnCompleted(Action0 action) {
+        return new IxDoOn<T>(this, IxEmptyAction.instance1(), action);
     }
 
-    public final Ix<T> startWith(T... value) {
-        // TODO implement
-        throw new UnsupportedOperationException();
+    @SuppressWarnings("unchecked")
+    public final Ix<T> startWith(T... values) {
+        return concatArray(fromArray(values), this);
     }
 
-    public final Ix<T> endWith(T... value) {
-        // TODO implement
-        throw new UnsupportedOperationException();
+    @SuppressWarnings("unchecked")
+    public final Ix<T> endWith(T... values) {
+        return concatArray(this, fromArray(values));
     }
 
     public final Ix<String> join() {
-        // TODO implement
-        throw new UnsupportedOperationException();
+        return join(", ");
     }
 
     public final Ix<String> join(CharSequence separator) {
-        // TODO implement
-        throw new UnsupportedOperationException();
+        return new IxJoin<T>(this, separator);
     }
 
     public final <R> Ix<R> map(Func1<? super T, ? extends R> mapper) {
@@ -515,18 +494,17 @@ public final Ix<Ix<T>> window(int size, int skip) {
         throw new UnsupportedOperationException();
     }
 
-    public final Ix<T> concatWith(Iterator<? extends T> other) {
-        // TODO implement
-        throw new UnsupportedOperationException();
+    @SuppressWarnings("unchecked")
+    public final Ix<T> concatWith(Iterable<? extends T> other) {
+        return concatArray(this, other);
     }
 
-    public final Ix<T> mergeWith(Iterator<? extends T> other) {
+    public final Ix<T> mergeWith(Iterable<? extends T> other) {
         return concatWith(other);
     }
 
-    public final <U, R> Ix<R> zipWith(Iterator<U> other, Func2<? super T, ? super U, ? extends R> zipper) {
-        // TODO implement
-        throw new UnsupportedOperationException();
+    public final <U, R> Ix<R> zipWith(Iterable<U> other, Func2<? super T, ? super U, ? extends R> zipper) {
+        return zip(this, other, zipper);
     }
 
     public final Ix<T> orderBy() {

src/main/java/ix/IxCompose.java

@@ -1,3 +1,19 @@
+/*
+ * 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;

src/main/java/ix/IxContains.java

@@ -0,0 +1,66 @@
+/*
+ * 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 IxContains<T> extends IxSource<T, Boolean> {
+
+    final Object o;
+    
+    public IxContains(Iterable<T> source, Object o) {
+        super(source);
+        this.o = o;
+    }
+
+    @Override
+    public Iterator<Boolean> iterator() {
+        return new ContainsIterator<T>(source.iterator(), o);
+    }
+    
+    static final class ContainsIterator<T> extends IxSourceIterator<T, Boolean> {
+
+        final Object o;
+
+        public ContainsIterator(Iterator<T> it, Object o) {
+            super(it);
+            this.o = o;
+        }
+        
+        @Override
+        protected boolean moveNext() {
+            Iterator<T> it = this.it;
+            Object o = this.o;
+            
+            while (it.hasNext()) {
+                T v = it.next();
+                if (o == v || (o != null && o.equals(v))) {
+                    value = true;
+                    hasValue = true;
+                    done = true;
+                    return true;
+                }
+            }
+            
+            value = false;
+            hasValue = true;
+            done = true;
+            return true;
+        }
+    }
+
+}

src/main/java/ix/IxCount.java

@@ -0,0 +1,55 @@
+/*
+ * 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 IxCount<T> extends IxSource<T, Integer> {
+
+    public IxCount(Iterable<T> source) {
+        super(source);
+    }
+
+    @Override
+    public Iterator<Integer> iterator() {
+        return new CountIterator<T>(source.iterator());
+    }
+
+    static final class CountIterator<T> extends IxSourceIterator<T, Integer> {
+
+        public CountIterator(Iterator<T> it) {
+            super(it);
+        }
+
+        @Override
+        protected boolean moveNext() {
+            int c = 0;
+            
+            Iterator<T> it = this.it;
+            
+            while (it.hasNext()) {
+                it.next();
+                c++;
+            }
+            
+            value = c;
+            hasValue = true;
+            done = true;
+            return true;
+        }
+    }
+}