@everyonesoftware/common 1.0.0

package/sources/whereIterable.ts

@@ -0,0 +1,108 @@
+import { EqualFunctions } from "./equalFunctions";
+import { Iterable } from "./iterable";
+import { Iterator } from "./iterator";
+import { JavascriptIterable, JavascriptIterator } from "./javascript";
+import { PreCondition } from "./preCondition";
+import { SyncResult } from "./syncResult";
+import { ToStringFunctions } from "./toStringFunctions";
+import { Type } from "./types";
+
+/**
+ * An {@link Iterable} that only returns values that match a condition.
+ */
+export class WhereIterable<T> implements Iterable<T>
+{
+    // WhereIterable cannot extend Iterable because their create() functions are different.
+
+    private readonly innerIterable: Iterable<T>;
+    private readonly condition: (value: T) => (boolean | SyncResult<boolean>);
+
+    private constructor(innerIterable: Iterable<T>, condition: (value: T) => (boolean | SyncResult<boolean>))
+    {
+        PreCondition.assertNotUndefinedAndNotNull(innerIterable, "innerIterable");
+        PreCondition.assertNotUndefinedAndNotNull(condition, "condition");
+
+        this.innerIterable = innerIterable;
+        this.condition = condition;
+    }
+
+    public static create<T>(innerIterable: Iterable<T>, condition: (value: T) => (boolean | SyncResult<boolean>)): WhereIterable<T>
+    {
+        return new WhereIterable(innerIterable, condition);
+    }
+
+    public iterate(): Iterator<T>
+    {
+        return this.innerIterable.iterate().where(this.condition);
+    }
+
+    public toArray(): SyncResult<T[]>
+    {
+        return Iterable.toArray(this);
+    }
+
+    public any(): SyncResult<boolean>
+    {
+        return Iterable.any(this);
+    }
+
+    public getCount(): SyncResult<number>
+    {
+        return Iterable.getCount(this);
+    }
+
+    public equals(right: JavascriptIterable<T>, equalFunctions?: EqualFunctions): SyncResult<boolean>
+    {
+        return Iterable.equals(this, right, equalFunctions);
+    }
+
+    public toString(toStringFunctions?: ToStringFunctions): string
+    {
+        return Iterable.toString(this, toStringFunctions);
+    }
+
+    public concatenate(...toConcatenate: JavascriptIterable<T>[]): Iterable<T>
+    {
+        return Iterable.concatenate(this, ...toConcatenate);
+    }
+
+    public map<TOutput>(mapping: (value: T) => (TOutput | SyncResult<TOutput>)): Iterable<TOutput>
+    {
+        return Iterable.map(this, mapping);
+    }
+
+    public flatMap<TOutput>(mapping: (value: T) => JavascriptIterable<TOutput>): Iterable<TOutput>
+    {
+        return Iterable.flatMap(this, mapping);
+    }
+
+    public where(condition: (value: T) => (boolean | SyncResult<boolean>)): Iterable<T>
+    {
+        return Iterable.where(this, condition);
+    }
+
+    public instanceOf<TOutput extends T>(typeOrTypeCheck: Type<TOutput> | ((value: T) => value is TOutput)): Iterable<TOutput>
+    {
+        return Iterable.instanceOf(this, typeOrTypeCheck);
+    }
+
+    public first(condition?: ((value: T) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<T>
+    {
+        return Iterable.first(this, condition);
+    }
+
+    public last(condition?: ((value: T) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<T>
+    {
+        return Iterable.last(this, condition);
+    }
+
+    public [Symbol.iterator](): JavascriptIterator<T>
+    {
+        return Iterable[Symbol.iterator](this);
+    }
+
+    public contains(value: T, equalFunctions?: EqualFunctions): SyncResult<boolean>
+    {
+        return Iterable.contains(this, value, equalFunctions);
+    }
+}

package/sources/whereIterator.ts

@@ -0,0 +1,157 @@
+import { Iterator } from "./iterator";
+import { JavascriptIterable, JavascriptIterator } from "./javascript";
+import { PreCondition } from "./preCondition";
+import { SyncResult } from "./syncResult";
+import { isBoolean, Type } from "./types";
+
+/**
+ * An {@link Iterator} that only returns values that match a condition.
+ */
+export class WhereIterator<T> implements Iterator<T>
+{
+    // WhereIterator cannot extend Iterator because their create() functions are different.
+    private readonly innerIterator: Iterator<T>;
+    private started: boolean;
+    private readonly condition: (value: T) => (boolean | SyncResult<boolean>);
+
+    private constructor(innerIterator: Iterator<T>, condition: (value: T) => (boolean | SyncResult<boolean>))
+    {
+        PreCondition.assertNotUndefinedAndNotNull(innerIterator, "innerIterator");
+        PreCondition.assertNotUndefinedAndNotNull(condition, "condition");
+
+        this.innerIterator = innerIterator;
+        this.started = false;
+        this.condition = condition;
+    }
+
+    public static create<T>(innerIterator: Iterator<T>, condition: (value: T) => (boolean | SyncResult<boolean>)): WhereIterator<T>
+    {
+        return new WhereIterator(innerIterator, condition);
+    }
+
+    public hasStarted(): boolean
+    {
+        return this.started;
+    }
+
+    public hasCurrent(): boolean
+    {
+        return this.hasStarted() && this.innerIterator.hasCurrent();
+    }
+
+    public getCurrent(): T
+    {
+        PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
+
+        return this.innerIterator.getCurrent();
+    }
+
+    public next(): SyncResult<boolean>
+    {
+        return SyncResult.create(() =>
+        {
+            if (!this.hasStarted())
+            {
+                this.innerIterator.start().await();
+                this.started = true;
+            }
+            else
+            {
+                this.innerIterator.next().await();
+            }
+
+            while (this.hasCurrent())
+            {
+                const conditionResult: boolean | SyncResult<boolean> = this.condition(this.getCurrent());
+                const conditionBoolean: boolean = isBoolean(conditionResult) ? conditionResult : conditionResult.await();
+                if (conditionBoolean)
+                {
+                    break;
+                }
+                
+                this.innerIterator.next().await();
+            }
+            return this.hasCurrent();
+        });
+    }
+
+    public start(): SyncResult<this>
+    {
+        return Iterator.start<T, this>(this);
+    }
+
+    public takeCurrent(): SyncResult<T>
+    {
+        return Iterator.takeCurrent(this);
+    }
+
+    public any(): SyncResult<boolean>
+    {
+        return Iterator.any(this);
+    }
+
+    public getCount(): SyncResult<number>
+    {
+        return Iterator.getCount(this);
+    }
+
+    public toArray(): SyncResult<T[]>
+    {
+        return Iterator.toArray(this);
+    }
+    
+    public concatenate(...toConcatenate: JavascriptIterable<T>[]): Iterator<T>
+    {
+        return Iterator.concatenate(this, ...toConcatenate);
+    }
+
+    public where(condition: (value: T) => boolean): Iterator<T>
+    {
+        return Iterator.where(this, condition);
+    }
+
+    public map<TOutput>(mapping: (value: T) => (TOutput | SyncResult<TOutput>)): Iterator<TOutput>
+    {
+        return Iterator.map(this, mapping);
+    }
+
+    public flatMap<TOutput>(mapping: (value: T) => JavascriptIterable<TOutput>): Iterator<TOutput>
+    {
+        return Iterator.flatMap(this, mapping);
+    }
+
+    public whereInstanceOf<U extends T>(typeCheck: (value: T) => value is U): Iterator<U>
+    {
+        return Iterator.whereInstanceOf(this, typeCheck);
+    }
+
+    public whereInstanceOfType<U extends T>(type: Type<U>): Iterator<U>
+    {
+        return Iterator.whereInstanceOfType(this, type);
+    }
+
+    public first(condition?: (value: T) => boolean): SyncResult<T>
+    {
+        return Iterator.first(this, condition);
+    }
+
+    public last(condition?: (value: T) => boolean): SyncResult<T>
+    {
+        return Iterator.last(this, condition);
+    }
+
+    public take(maximumToTake: number): Iterator<T>
+    {
+        return Iterator.take(this, maximumToTake);
+    }
+
+    public skip(maximumToSkip: number): Iterator<T>
+    {
+        return Iterator.skip(this, maximumToSkip);
+    }
+
+    public [Symbol.iterator](): JavascriptIterator<T>
+    {
+        return Iterator[Symbol.iterator](this);
+    }
+}