addMInsertAt() method added

Author: yusufshakeel

dist/js/dyCache.min.js

@@ -562,6 +562,37 @@ <h4><code>arrInsertAt(key, index, value)</code></h4>
 
             <hr>
 
+            <!-- arrMInsertAt() -->
+            <a name="arrMInsertAt"></a>
+            <h4><code>arrMInsertAt(key, index, value)</code></h4>
+
+            <p>This will insert multiple <code>value</code> at a given <code>index</code>
+                in an array referred by <code>key</code> in the cache.</p>
+
+            <p><code>index</code> is the index at which the new elements are inserted.</p>
+
+            <p><code>value</code> is an array of elements.
+                Each element can be a number, string, array or object.</p>
+
+            <p>On success return true. Otherwise false.</p>
+
+            <pre><code>obj.arrMInsertAt('users', 1, [ {id: 9999, name: 'yusufshakeel'}, 10, 'happy', [100] ]);</code></pre>
+
+            <div>
+                <a class="btn btn-primary"
+                   role="button"
+                   data-toggle="collapse"
+                   href="#collapse-arrMInsertAt"
+                   aria-expanded="false"
+                   aria-controls="collapse-arrMInsertAt">Output</a>
+            </div>
+            <div class="collapse" id="collapse-arrMInsertAt">
+            </div>
+
+            <!-- arrMInsertAt() ends here -->
+
+            <hr>
+
             <!-- arrUpdateElem() -->
             <a name="arrUpdateElem"></a>
             <h4><code>arrUpdateElem(key, index, value)</code></h4>

index.html

@@ -236,6 +236,35 @@ var dyCache = /** @class */ (function () {
         this._cache[key].splice(index, 0, value);
         return true;
     };
+    /**
+     * This will insert multiple values at a given index in the array
+     * referred by key in the cache.
+     *
+     * On success return true, otherwise false.
+     *
+     * @param {string} key
+     * @param {number} index
+     * @param value
+     * @returns {boolean}
+     */
+    dyCache.prototype.arrMInsertAt = function (key, index, value) {
+        // if key does not exists in the cache
+        if (!this.exists(key)) {
+            return false;
+        }
+        // if index is invalid
+        if (this.arrLength(key) < index || index < 0) {
+            return false;
+        }
+        // if value does not exists
+        if (typeof value === "undefined") {
+            return false;
+        }
+        for (var i = 0; i < value.length; i++) {
+            this._cache[key].splice(index + i, 0, value[i]);
+        }
+        return true;
+    };
     /**
      * This will update the value at given index in an array
      * referred by key in the cache.

src/js/dyCache.forTest.js

@@ -236,6 +236,35 @@ var dyCache = /** @class */ (function () {
         this._cache[key].splice(index, 0, value);
         return true;
     };
+    /**
+     * This will insert multiple values at a given index in the array
+     * referred by key in the cache.
+     *
+     * On success return true, otherwise false.
+     *
+     * @param {string} key
+     * @param {number} index
+     * @param value
+     * @returns {boolean}
+     */
+    dyCache.prototype.arrMInsertAt = function (key, index, value) {
+        // if key does not exists in the cache
+        if (!this.exists(key)) {
+            return false;
+        }
+        // if index is invalid
+        if (this.arrLength(key) < index || index < 0) {
+            return false;
+        }
+        // if value does not exists
+        if (typeof value === "undefined") {
+            return false;
+        }
+        for (var i = 0; i < value.length; i++) {
+            this._cache[key].splice(index + i, 0, value[i]);
+        }
+        return true;
+    };
     /**
      * This will update the value at given index in an array
      * referred by key in the cache.

src/js/dyCache.forTest.min.js

@@ -156,11 +156,17 @@ output("Fetch all the elements of the array referred by <code>users</code> key i
 outputJSON(obj.arrGet('users'), 'collapse-arrLPop');
 
 // arrInsertAt();
-output("insert a value at given <code>index</code> in a array referred by key <code>users</code> in the cache.", 'collapse-arrInsertAt');
+output("Insert a value at given <code>index</code> in a array referred by key <code>users</code> in the cache.", 'collapse-arrInsertAt');
 outputJSON(obj.arrInsertAt('users', 3, {username: 'foo', points: 99}), 'collapse-arrInsertAt');
 output("Fetch all the elements of the array referred by <code>users</code> key in the cache.", 'collapse-arrInsertAt');
 outputJSON(obj.arrGet('users'), 'collapse-arrInsertAt');
 
+// arrMInsertAt();
+output("Insert multiple values at given <code>index</code> in a array referred by key <code>users</code> in the cache.", 'collapse-arrMInsertAt');
+outputJSON(obj.arrMInsertAt('users', 1, [ {id: 9999, name: 'yusufshakeel'}, 10, 'happy', [100] ]), 'collapse-arrMInsertAt');
+output("Fetch all the elements of the array referred by <code>users</code> key in the cache.", 'collapse-arrMInsertAt');
+outputJSON(obj.arrGet('users'), 'collapse-arrMInsertAt');
+
 // arrUpdateElem();
 output("Update value of an element at index 0 in the array referred by key <code>users</code> in the cache.", 'collapse-arrUpdateElem');
 outputJSON(obj.arrUpdateElem('users', 0, { username: 'tintin', points: 50 }), 'collapse-arrUpdateElem');

src/js/dyCache.js

@@ -263,6 +263,40 @@ class dyCache {
         return true;
     }
 
+    /**
+     * This will insert multiple values at a given index in the array
+     * referred by key in the cache.
+     *
+     * On success return true, otherwise false.
+     *
+     * @param {string} key
+     * @param {number} index
+     * @param value
+     * @returns {boolean}
+     */
+    public arrMInsertAt(key: string, index: number, value: any): boolean {
+
+        // if key does not exists in the cache
+        if (!this.exists(key)) {
+            return false;
+        }
+
+        // if index is invalid
+        if (this.arrLength(key) < index || index < 0) {
+            return false;
+        }
+
+        // if value does not exists
+        if (typeof value === "undefined") {
+            return false;
+        }
+
+        for (let i = 0; i < value.length; i++) {
+            this._cache[key].splice(index + i, 0, value[i]);
+        }
+        return true;
+    }
+
     /**
      * This will update the value at given index in an array
      * referred by key in the cache.

src/js/index-page-example.js

@@ -377,6 +377,60 @@ describe('Testing dyCacheJS', function () {
 
         });
 
+        describe('Testing arrMInsertAt()', () => {
+
+            it('should insert multiple number values at a given index', function () {
+                for (let i = 1; i <= 3; i++) {
+                    obj.arrPush('arr', i);
+                }
+                assert.equal(obj.arrMInsertAt('arr', 1, [10, 20]), true);
+                assert.deepEqual(obj.arrGet('arr'), [1, 10, 20, 2, 3]);
+            });
+
+            it('should insert multiple string values at a given index', function () {
+                for (let i = 1; i <= 3; i++) {
+                    obj.arrPush('arr', i);
+                }
+                assert.equal(obj.arrMInsertAt('arr', 1, ['a', 'b']), true);
+                assert.deepEqual(obj.arrGet('arr'), [1, 'a', 'b', 2, 3]);
+            });
+
+            it('should insert multiple array values at a given index', function () {
+                for (let i = 1; i <= 3; i++) {
+                    obj.arrPush('arr', i);
+                }
+                assert.equal(obj.arrMInsertAt('arr', 1, [['a', 10], ['b', 20]]), true);
+                assert.deepEqual(obj.arrGet('arr'), [1, ['a', 10], ['b', 20], 2, 3]);
+            });
+
+            it('should insert multiple object values at a given index', function () {
+                for (let i = 1; i <= 3; i++) {
+                    obj.arrPush('arr', i);
+                }
+                assert.equal(obj.arrMInsertAt('arr', 1, [{a: 1}, {b: 2}]), true);
+                assert.deepEqual(obj.arrGet('arr'), [1, {a: 1}, {b: 2}, 2, 3]);
+            });
+
+            it('should return false for non-existing key', function () {
+                assert.equal(obj.arrMInsertAt('arr', 1, [1, 2]), false);
+            });
+
+            it('should return false for inserting at invalid index', function () {
+                for (let i = 1; i <= 10; i++) {
+                    obj.arrPush('arr', i);
+                }
+                assert.equal(obj.arrMInsertAt('arr', 99, [1, 2]), false);
+            });
+
+            it('should return false when value is missing', function () {
+                for (let i = 1; i <= 10; i++) {
+                    obj.arrPush('arr', i);
+                }
+                assert.equal(obj.arrMInsertAt('arr', 99), false);
+            });
+
+        });
+
         describe('Testing arrUpdateElem()', () => {
 
             it('should update an element at a given index in the array', function () {