Implemented Map polyfill and toMap IEnumerable extension.

BSick7 · Jun 17, 2014 · e2b591a · e2b591a
1 parent b19bc61
commit e2b591a
Show file tree

Hide file tree

Showing 11 changed files with 372 additions and 4 deletions.
diff --git a/bower.json b/bower.json
@@ -1,6 +1,6 @@
 {
   "name": "exjs",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "homepage": "https://github.com/BSick7/exjs",
   "authors": [
     "BSick7 <brad.sickles@gmail.com>"

diff --git a/dist/ex.d.ts b/dist/ex.d.ts
@@ -38,6 +38,7 @@ declare module exjs {
         takeWhile(predicate: (t: T, index?: number) => boolean): IEnumerable<T>;
         toArray(): T[];
         toList(): IList<T>;
+        toMap<TKey, TValue>(keySelector: (t: T) => TKey, valueSelector: (t: T) => TValue): IMap<TKey, TValue>;
         union(second: IEnumerable<T>, comparer?: (f: T, s: T) => boolean): IEnumerable<T>;
         union(second: T[], comparer?: (f: T, s: T) => boolean): IEnumerable<T>;
         where(filter: (t: T) => boolean): IEnumerable<T>;
@@ -126,6 +127,7 @@ declare module exjs {
         public take(count: number): IEnumerable<T>;
         public takeWhile(predicate: (t: T, index?: number) => boolean): IEnumerable<T>;
         public toArray(): T[];
+        public toMap<TKey, TValue>(keySelector: (t: T) => TKey, valueSelector: (t: T) => TValue): Map<TKey, TValue>;
         public toList(): IList<T>;
         public union(second: IEnumerable<T>, comparer?: (f: T, s: T) => boolean): IEnumerable<T>;
         public union(second: T[], comparer?: (f: T, s: T) => boolean): IEnumerable<T>;
@@ -184,6 +186,37 @@ declare module exjs {
         public removeWhere(predicate: (t: T, index?: number) => boolean): IEnumerable<T>;
     }
 }
+declare module exjs {
+    interface IMap<TKey, TValue> {
+        size: number;
+        clear(): any;
+        delete(key: TKey): boolean;
+        entries(): IEnumerable<any[]>;
+        forEach(callbackFn: (value: TValue, key: TKey, map?: IMap<TKey, TValue>) => void, thisArg?: any): any;
+        get(key: TKey): TValue;
+        has(key: TKey): boolean;
+        keys(): IEnumerable<TKey>;
+        set(key: TKey, value: TValue): any;
+        values(): IEnumerable<TValue>;
+    }
+    class Map<TKey, TValue> implements IMap<TKey, TValue> {
+        private _keys;
+        private _values;
+        public size : number;
+        constructor();
+        constructor(enumerable: any[][]);
+        constructor(enumerable: IEnumerable<any[]>);
+        public clear(): void;
+        public delete(key: TKey): boolean;
+        public entries(): IEnumerable<any[]>;
+        public forEach(callbackFn: (value: TValue, key: TKey, map?: IMap<TKey, TValue>) => void, thisArg?: any): void;
+        public get(key: TKey): TValue;
+        public has(key: TKey): boolean;
+        public keys(): IEnumerable<TKey>;
+        public set(key: TKey, value: TValue): any;
+        public values(): IEnumerable<TValue>;
+    }
+}
 declare module exjs {
 }
 declare module exjs {

diff --git a/dist/ex.js b/dist/ex.js
diff --git a/dist/ex.min.js b/dist/ex.min.js
diff --git a/exjs.nuspec b/exjs.nuspec
@@ -2,7 +2,7 @@
 <package xmlns="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd">
     <metadata>
         <id>exjs</id>
-        <version>0.1.7</version>
+        <version>0.1.8</version>
         <title>exjs</title>
         <authors>Brad Sickles</authors>
         <licenseUrl>https://raw.githubusercontent.com/BSick7/exjs/master/LICENSE</licenseUrl>
@@ -28,3 +28,4 @@ This is a lightweight library to aid in data manipulation and transformation.</d
 
 
 
+
diff --git a/nuget/exjs.0.1.8.nupkg b/nuget/exjs.0.1.8.nupkg
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "exjs",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "Extension library",
   "main": "Gruntfile.js",
   "directories": {

diff --git a/src/enumerable.ts b/src/enumerable.ts
@@ -38,6 +38,7 @@ module exjs {
         takeWhile(predicate: (t: T, index?: number) => boolean): IEnumerable<T>;
         toArray(): T[];
         toList(): IList<T>;
+        toMap<TKey, TValue>(keySelector: (t: T) => TKey, valueSelector: (t: T) => TValue): IMap<TKey, TValue>;
         //toDictionary();
         union(second: IEnumerable<T>, comparer?: (f: T, s: T) => boolean): IEnumerable<T>;
         union(second: T[], comparer?: (f: T, s: T) => boolean): IEnumerable<T>;
@@ -315,6 +316,13 @@ module exjs {
             }
             return arr;
         }
+        toMap<TKey, TValue>(keySelector: (t: T) => TKey, valueSelector: (t: T) => TValue): Map<TKey, TValue> {
+            var m = new Map<TKey, TValue>();
+            for (var en = this.getEnumerator(); en.moveNext();) {
+                m.set(keySelector(en.current), valueSelector(en.current));
+            }
+            return m;
+        }
         toList(): IList<T> { throw new Error("Not implemented"); }
         //toDictionary() {
         //}

diff --git a/src/map.ts b/src/map.ts
@@ -0,0 +1,97 @@
+module exjs {
+    export interface IMap<TKey, TValue> {
+        size: number;
+        clear();
+        delete(key: TKey): boolean;
+        entries(): IEnumerable<any[]>;
+        forEach(callbackFn: (value: TValue, key: TKey, map?: IMap<TKey, TValue>) => void, thisArg?: any);
+        get(key: TKey): TValue;
+        has(key: TKey): boolean;
+        keys(): IEnumerable<TKey>;
+        set(key: TKey, value: TValue): any;
+        values(): IEnumerable<TValue>;
+    }
+
+    export class Map<TKey, TValue> implements IMap<TKey, TValue> {
+        private _keys: TKey[] = [];
+        private _values: TValue[] = [];
+
+        get size (): number {
+            return this._keys.length;
+        }
+
+        constructor ();
+        constructor (enumerable: any[][]);
+        constructor (enumerable: IEnumerable<any[]>);
+        constructor (enumerable?: any) {
+            var enu: IEnumerable<any[]>;
+            if (enumerable instanceof Array) {
+                enu = (<Array<any[]>>enumerable).en();
+            } else if (enumerable && enumerable.getEnumerator instanceof Function) {
+                enu = <IEnumerable<any[]>>enumerable;
+            }
+
+            if (!enu)
+                return;
+            for (var en = enu.getEnumerator(); en && en.moveNext();) {
+                this.set(en.current[0], en.current[1]);
+            }
+        }
+
+        clear () {
+            this._keys.length = 0;
+            this._values.length = 0;
+        }
+
+        delete (key: TKey): boolean {
+            var index = this._keys.indexOf(key);
+            if (!(index > -1))
+                return false;
+            this._keys.splice(index, 1);
+            this._values.splice(index, 1);
+            return true;
+        }
+
+        entries (): IEnumerable<any[]> {
+            return exjs.range(0, this.size).select(i => [this._keys[i], this._values[i]]);
+        }
+
+        forEach (callbackFn: (value: TValue, key: TKey, map?: IMap<TKey, TValue>) => void, thisArg?: any) {
+            if (thisArg == null)
+                thisArg = this;
+            for (var i = 0, keys = this._keys, vals = this._values, len = keys.length; i < len; i++) {
+                callbackFn.call(thisArg, vals[i], keys[i], this);
+            }
+        }
+
+        get (key: TKey): TValue {
+            var index = this._keys.indexOf(key);
+            return this._values[index];
+        }
+
+        has (key: TKey): boolean {
+            return this._keys.indexOf(key) > -1;
+        }
+
+        keys (): IEnumerable<TKey> {
+            return this._keys.en();
+        }
+
+        set (key: TKey, value: TValue): any {
+            var index = this._keys.indexOf(key);
+            if (index > -1) {
+                this._values[index] = value;
+            } else {
+                this._keys.push(key);
+                this._values.push(value);
+            }
+            return undefined;
+        }
+
+        values (): IEnumerable<TValue> {
+            return this._values.en();
+        }
+    }
+    if (!(<any>window).Map)
+        (<any>window).Map = Map;
+}