package/LICENSE000644 0000001123 3560116604 010262 0ustar00000000 000000 Copyright (c) 2018 Mike Diarmid (Salakar) Licensed under the Apache License, Version 2.0 (the "License"); you may not use this library 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/index.js000644 0000026415 3560116604 010735 0ustar00000000 000000 'use strict'; /** * Custom implementation of a double ended queue. */ function Denque(array, options) { var options = options || {}; this._head = 0; this._tail = 0; this._capacity = options.capacity; this._capacityMask = 0x3; this._list = new Array(4); if (Array.isArray(array)) { this._fromArray(array); } } /** * ------------- * PUBLIC API * ------------- */ /** * Returns the item at the specified index from the list. * 0 is the first element, 1 is the second, and so on... * Elements at negative values are that many from the end: -1 is one before the end * (the last element), -2 is two before the end (one before last), etc. * @param index * @returns {*} */ Denque.prototype.peekAt = function peekAt(index) { var i = index; // expect a number or return undefined if ((i !== (i | 0))) { return void 0; } var len = this.size(); if (i >= len || i < -len) return undefined; if (i < 0) i += len; i = (this._head + i) & this._capacityMask; return this._list[i]; }; /** * Alias for peekAt() * @param i * @returns {*} */ Denque.prototype.get = function get(i) { return this.peekAt(i); }; /** * Returns the first item in the list without removing it. * @returns {*} */ Denque.prototype.peek = function peek() { if (this._head === this._tail) return undefined; return this._list[this._head]; }; /** * Alias for peek() * @returns {*} */ Denque.prototype.peekFront = function peekFront() { return this.peek(); }; /** * Returns the item that is at the back of the queue without removing it. * Uses peekAt(-1) */ Denque.prototype.peekBack = function peekBack() { return this.peekAt(-1); }; /** * Returns the current length of the queue * @return {Number} */ Object.defineProperty(Denque.prototype, 'length', { get: function length() { return this.size(); } }); /** * Return the number of items on the list, or 0 if empty. * @returns {number} */ Denque.prototype.size = function size() { if (this._head === this._tail) return 0; if (this._head < this._tail) return this._tail - this._head; else return this._capacityMask + 1 - (this._head - this._tail); }; /** * Add an item at the beginning of the list. * @param item */ Denque.prototype.unshift = function unshift(item) { if (item === undefined) return this.size(); var len = this._list.length; this._head = (this._head - 1 + len) & this._capacityMask; this._list[this._head] = item; if (this._tail === this._head) this._growArray(); if (this._capacity && this.size() > this._capacity) this.pop(); if (this._head < this._tail) return this._tail - this._head; else return this._capacityMask + 1 - (this._head - this._tail); }; /** * Remove and return the first item on the list, * Returns undefined if the list is empty. * @returns {*} */ Denque.prototype.shift = function shift() { var head = this._head; if (head === this._tail) return undefined; var item = this._list[head]; this._list[head] = undefined; this._head = (head + 1) & this._capacityMask; if (head < 2 && this._tail > 10000 && this._tail <= this._list.length >>> 2) this._shrinkArray(); return item; }; /** * Add an item to the bottom of the list. * @param item */ Denque.prototype.push = function push(item) { if (item === undefined) return this.size(); var tail = this._tail; this._list[tail] = item; this._tail = (tail + 1) & this._capacityMask; if (this._tail === this._head) { this._growArray(); } if (this._capacity && this.size() > this._capacity) { this.shift(); } if (this._head < this._tail) return this._tail - this._head; else return this._capacityMask + 1 - (this._head - this._tail); }; /** * Remove and return the last item on the list. * Returns undefined if the list is empty. * @returns {*} */ Denque.prototype.pop = function pop() { var tail = this._tail; if (tail === this._head) return undefined; var len = this._list.length; this._tail = (tail - 1 + len) & this._capacityMask; var item = this._list[this._tail]; this._list[this._tail] = undefined; if (this._head < 2 && tail > 10000 && tail <= len >>> 2) this._shrinkArray(); return item; }; /** * Remove and return the item at the specified index from the list. * Returns undefined if the list is empty. * @param index * @returns {*} */ Denque.prototype.removeOne = function removeOne(index) { var i = index; // expect a number or return undefined if ((i !== (i | 0))) { return void 0; } if (this._head === this._tail) return void 0; var size = this.size(); var len = this._list.length; if (i >= size || i < -size) return void 0; if (i < 0) i += size; i = (this._head + i) & this._capacityMask; var item = this._list[i]; var k; if (index < size / 2) { for (k = index; k > 0; k--) { this._list[i] = this._list[i = (i - 1 + len) & this._capacityMask]; } this._list[i] = void 0; this._head = (this._head + 1 + len) & this._capacityMask; } else { for (k = size - 1 - index; k > 0; k--) { this._list[i] = this._list[i = ( i + 1 + len) & this._capacityMask]; } this._list[i] = void 0; this._tail = (this._tail - 1 + len) & this._capacityMask; } return item; }; /** * Remove number of items from the specified index from the list. * Returns array of removed items. * Returns undefined if the list is empty. * @param index * @param count * @returns {array} */ Denque.prototype.remove = function remove(index, count) { var i = index; var removed; var del_count = count; // expect a number or return undefined if ((i !== (i | 0))) { return void 0; } if (this._head === this._tail) return void 0; var size = this.size(); var len = this._list.length; if (i >= size || i < -size || count < 1) return void 0; if (i < 0) i += size; if (count === 1 || !count) { removed = new Array(1); removed[0] = this.removeOne(i); return removed; } if (i === 0 && i + count >= size) { removed = this.toArray(); this.clear(); return removed; } if (i + count > size) count = size - i; var k; removed = new Array(count); for (k = 0; k < count; k++) { removed[k] = this._list[(this._head + i + k) & this._capacityMask]; } i = (this._head + i) & this._capacityMask; if (index + count === size) { this._tail = (this._tail - count + len) & this._capacityMask; for (k = count; k > 0; k--) { this._list[i = (i + 1 + len) & this._capacityMask] = void 0; } return removed; } if (index === 0) { this._head = (this._head + count + len) & this._capacityMask; for (k = count - 1; k > 0; k--) { this._list[i = (i + 1 + len) & this._capacityMask] = void 0; } return removed; } if (i < size / 2) { this._head = (this._head + index + count + len) & this._capacityMask; for (k = index; k > 0; k--) { this.unshift(this._list[i = (i - 1 + len) & this._capacityMask]); } i = (this._head - 1 + len) & this._capacityMask; while (del_count > 0) { this._list[i = (i - 1 + len) & this._capacityMask] = void 0; del_count--; } if (index < 0) this._tail = i; } else { this._tail = i; i = (i + count + len) & this._capacityMask; for (k = size - (count + index); k > 0; k--) { this.push(this._list[i++]); } i = this._tail; while (del_count > 0) { this._list[i = (i + 1 + len) & this._capacityMask] = void 0; del_count--; } } if (this._head < 2 && this._tail > 10000 && this._tail <= len >>> 2) this._shrinkArray(); return removed; }; /** * Native splice implementation. * Remove number of items from the specified index from the list and/or add new elements. * Returns array of removed items or empty array if count == 0. * Returns undefined if the list is empty. * * @param index * @param count * @param {...*} [elements] * @returns {array} */ Denque.prototype.splice = function splice(index, count) { var i = index; // expect a number or return undefined if ((i !== (i | 0))) { return void 0; } var size = this.size(); if (i < 0) i += size; if (i > size) return void 0; if (arguments.length > 2) { var k; var temp; var removed; var arg_len = arguments.length; var len = this._list.length; var arguments_index = 2; if (!size || i < size / 2) { temp = new Array(i); for (k = 0; k < i; k++) { temp[k] = this._list[(this._head + k) & this._capacityMask]; } if (count === 0) { removed = []; if (i > 0) { this._head = (this._head + i + len) & this._capacityMask; } } else { removed = this.remove(i, count); this._head = (this._head + i + len) & this._capacityMask; } while (arg_len > arguments_index) { this.unshift(arguments[--arg_len]); } for (k = i; k > 0; k--) { this.unshift(temp[k - 1]); } } else { temp = new Array(size - (i + count)); var leng = temp.length; for (k = 0; k < leng; k++) { temp[k] = this._list[(this._head + i + count + k) & this._capacityMask]; } if (count === 0) { removed = []; if (i != size) { this._tail = (this._head + i + len) & this._capacityMask; } } else { removed = this.remove(i, count); this._tail = (this._tail - leng + len) & this._capacityMask; } while (arguments_index < arg_len) { this.push(arguments[arguments_index++]); } for (k = 0; k < leng; k++) { this.push(temp[k]); } } return removed; } else { return this.remove(i, count); } }; /** * Soft clear - does not reset capacity. */ Denque.prototype.clear = function clear() { this._head = 0; this._tail = 0; }; /** * Returns true or false whether the list is empty. * @returns {boolean} */ Denque.prototype.isEmpty = function isEmpty() { return this._head === this._tail; }; /** * Returns an array of all queue items. * @returns {Array} */ Denque.prototype.toArray = function toArray() { return this._copyArray(false); }; /** * ------------- * INTERNALS * ------------- */ /** * Fills the queue with items from an array * For use in the constructor * @param array * @private */ Denque.prototype._fromArray = function _fromArray(array) { for (var i = 0; i < array.length; i++) this.push(array[i]); }; /** * * @param fullCopy * @returns {Array} * @private */ Denque.prototype._copyArray = function _copyArray(fullCopy) { var newArray = []; var list = this._list; var len = list.length; var i; if (fullCopy || this._head > this._tail) { for (i = this._head; i < len; i++) newArray.push(list[i]); for (i = 0; i < this._tail; i++) newArray.push(list[i]); } else { for (i = this._head; i < this._tail; i++) newArray.push(list[i]); } return newArray; }; /** * Grows the internal list array. * @private */ Denque.prototype._growArray = function _growArray() { if (this._head) { // copy existing data, head to end, then beginning to tail. this._list = this._copyArray(true); this._head = 0; } // head is at 0 and array is now full, safe to extend this._tail = this._list.length; this._list.length *= 2; this._capacityMask = (this._capacityMask << 1) | 1; }; /** * Shrinks the internal list array. * @private */ Denque.prototype._shrinkArray = function _shrinkArray() { this._list.length >>>= 1; this._capacityMask >>>= 1; }; module.exports = Denque; package/package.json000644 0000002751 3560116604 011553 0ustar00000000 000000 { "name": "denque", "version": "1.5.0", "description": "The fastest javascript implementation of a double-ended queue. Maintains compatability with deque.", "main": "index.js", "engines": { "node": ">=0.10" }, "keywords": [ "data-structure", "data-structures", "queue", "double", "end", "ended", "deque", "denque", "double-ended-queue" ], "scripts": { "test": "istanbul cover --report lcov _mocha && npm run typescript", "coveralls": "cat ./coverage/lcov.info | coveralls", "typescript": "tsc --project ./test/type/tsconfig.json", "benchmark_thousand": "node benchmark/thousand", "benchmark_2mil": "node benchmark/two_million", "benchmark_splice": "node benchmark/splice", "benchmark_remove": "node benchmark/remove", "benchmark_removeOne": "node benchmark/removeOne" }, "repository": { "type": "git", "url": "git+https://github.com/invertase/denque.git" }, "license": "Apache-2.0", "author": { "name": "Invertase", "email": "oss@invertase.io", "url": "http://github.com/invertase/" }, "contributors": [ "Mike Diarmid (Salakar) " ], "bugs": { "url": "https://github.com/invertase/denque/issues" }, "homepage": "https://github.com/invertase/denque#readme", "devDependencies": { "benchmark": "^2.1.4", "coveralls": "^2.13.3", "double-ended-queue": "^2.1.0-0", "istanbul": "^0.4.5", "mocha": "^3.5.3", "typescript": "^3.4.1" } } package/CHANGELOG.md000644 0000000104 3560116604 011064 0ustar00000000 000000 ## 1.5.0 - feat: adds capacity option for circular buffers (#27) package/README.md000644 0000022577 3560116604 010554 0ustar00000000 000000


Denque

NPM downloads NPM version Build version Build version License Chat Follow on Twitter

Extremely fast and lightweight [double-ended queue](http://en.wikipedia.org/wiki/Double-ended_queue) implementation with zero dependencies. Double-ended queues can also be used as a: - [Stack](http://en.wikipedia.org/wiki/Stack_\(abstract_data_type\)) - [Queue](http://en.wikipedia.org/wiki/Queue_\(data_structure\)) This implementation is currently the fastest available, even faster than `double-ended-queue`, see the [benchmarks](#benchmarks) Every queue operation is done at a constant `O(1)` - including random access from `.peekAt(index)`. **Works on all node versions >= v0.10** # Quick Start npm install denque ```js const Denque = require("denque"); const denque = new Denque([1,2,3,4]); denque.shift(); // 1 denque.pop(); // 4 ``` # API - [`new Denque()`](#new-denque---denque) - [`new Denque(Array items)`](#new-denquearray-items---denque) - [`push(item)`](#pushitem---int) - [`unshift(item)`](#unshiftitem---int) - [`pop()`](#pop---dynamic) - [`shift()`](#shift---dynamic) - [`toArray()`](#toarray---array) - [`peekBack()`](#peekback---dynamic) - [`peekFront()`](#peekfront---dynamic) - [`peekAt(int index)`](#peekAtint-index---dynamic) - [`remove(int index, int count)`](#remove) - [`removeOne(int index)`](#removeOne) - [`splice(int index, int count, item1, item2, ...)`](#splice) - [`isEmpty()`](#isempty---boolean) - [`clear()`](#clear---void) #### `new Denque()` -> `Denque` Creates an empty double-ended queue with initial capacity of 4. ```js var denque = new Denque(); denque.push(1); denque.push(2); denque.push(3); denque.shift(); //1 denque.pop(); //3 ```
#### `new Denque(Array items)` -> `Denque` Creates a double-ended queue from `items`. ```js var denque = new Denque([1,2,3,4]); denque.shift(); // 1 denque.pop(); // 4 ```
#### `push(item)` -> `int` Push an item to the back of this queue. Returns the amount of items currently in the queue after the operation. ```js var denque = new Denque(); denque.push(1); denque.pop(); // 1 denque.push(2); denque.push(3); denque.shift(); // 2 denque.shift(); // 3 ```
#### `unshift(item)` -> `int` Unshift an item to the front of this queue. Returns the amount of items currently in the queue after the operation. ```js var denque = new Denque([2,3]); denque.unshift(1); denque.toString(); // "1,2,3" denque.unshift(-2); denque.toString(); // "-2,-1,0,1,2,3" ```
#### `pop()` -> `dynamic` Pop off the item at the back of this queue. Note: The item will be removed from the queue. If you simply want to see what's at the back of the queue use [`peekBack()`](#peekback---dynamic) or [`.peekAt(-1)`](#peekAtint-index---dynamic). If the queue is empty, `undefined` is returned. If you need to differentiate between `undefined` values in the queue and `pop()` return value - check the queue `.length` before popping. ```js var denque = new Denque([1,2,3]); denque.pop(); // 3 denque.pop(); // 2 denque.pop(); // 1 denque.pop(); // undefined ``` **Aliases:** `removeBack`
#### `shift()` -> `dynamic` Shifts off the item at the front of this queue. Note: The item will be removed from the queue. If you simply want to see what's at the front of the queue use [`peekFront()`](#peekfront---dynamic) or [`.peekAt(0)`](#peekAtint-index---dynamic). If the queue is empty, `undefined` is returned. If you need to differentiate between `undefined` values in the queue and `shift()` return value - check the queue `.length` before shifting. ```js var denque = new Denque([1,2,3]); denque.shift(); // 1 denque.shift(); // 2 denque.shift(); // 3 denque.shift(); // undefined ```
#### `toArray()` -> `Array` Returns the items in the queue as an array. Starting from the item in the front of the queue and ending to the item at the back of the queue. ```js var denque = new Denque([1,2,3]); denque.push(4); denque.unshift(0); denque.toArray(); // [0,1,2,3,4] ```
#### `peekBack()` -> `dynamic` Returns the item that is at the back of this queue without removing it. If the queue is empty, `undefined` is returned. ```js var denque = new Denque([1,2,3]); denque.push(4); denque.peekBack(); // 4 ```
#### `peekFront()` -> `dynamic` Returns the item that is at the front of this queue without removing it. If the queue is empty, `undefined` is returned. ```js var denque = new Denque([1,2,3]); denque.push(4); denque.peekFront(); // 1 ```
#### `peekAt(int index)` -> `dynamic` Returns the item that is at the given `index` of this queue without removing it. The index is zero-based, so `.peekAt(0)` will return the item that is at the front, `.peekAt(1)` will return the item that comes after and so on. The index can be negative to read items at the back of the queue. `.peekAt(-1)` returns the item that is at the back of the queue, `.peekAt(-2)` will return the item that comes before and so on. Returns `undefined` if `index` is not a valid index into the queue. ```js var denque = new Denque([1,2,3]); denque.peekAt(0); //1 denque.peekAt(1); //2 denque.peekAt(2); //3 denque.peekAt(-1); // 3 denque.peekAt(-2); // 2 denque.peekAt(-3); // 1 ``` **Note**: The implementation has O(1) random access using `.peekAt()`. **Aliases:** `get`
#### `remove(int index, int count)` -> `array` Remove number of items from the specified index from the list. Returns array of removed items. Returns undefined if the list is empty. ```js var denque = new Denque([1,2,3,4,5,6,7]); denque.remove(0,3); //[1,2,3] denque.remove(1,2); //[5,6] var denque1 = new Denque([1,2,3,4,5,6,7]); denque1.remove(4, 100); //[5,6,7] ```
#### `removeOne(int index)` -> `dynamic` Remove and return the item at the specified index from the list. Returns undefined if the list is empty. ```js var denque = new Denque([1,2,3,4,5,6,7]); denque.removeOne(4); // 5 denque.removeOne(3); // 4 denque1.removeOne(1); // 2 ```
#### `splice(int index, int count, item1, item2, ...)` -> `array` Native splice implementation. Remove number of items from the specified index from the list and/or add new elements. Returns array of removed items or empty array if count == 0. Returns undefined if the list is empty. ```js var denque = new Denque([1,2,3,4,5,6,7]); denque.splice(denque.length, 0, 8, 9, 10); // [] denque.toArray() // [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] denque.splice(3, 3, 44, 55, 66); // [4,5,6] denque.splice(5,4, 666,667,668,669); // [ 66, 7, 8, 9 ] denque.toArray() // [ 1, 2, 3, 44, 55, 666, 667, 668, 669, 10 ] ```
#### `isEmpty()` -> `boolean` Return `true` if this queue is empty, `false` otherwise. ```js var denque = new Denque(); denque.isEmpty(); // true denque.push(1); denque.isEmpty(); // false ```
#### `clear()` -> `void` Remove all items from this queue. Does not change the queue's capacity. ```js var denque = new Denque([1,2,3]); denque.toString(); // "1,2,3" denque.clear(); denque.toString(); // "" ```
## Benchmarks #### Platform info: ``` Darwin 17.0.0 x64 Node.JS 9.4.0 V8 6.2.414.46-node.17 Intel(R) Core(TM) i7-7700K CPU @ 4.20GHz × 8 ``` #### 1000 items in queue (3 x shift + 3 x push ops per 'op') denque x 64,365,425 ops/sec ±0.69% (92 runs sampled) double-ended-queue x 26,646,882 ops/sec ±0.47% (94 runs sampled) #### 2 million items in queue (3 x shift + 3 x push ops per 'op') denque x 61,994,249 ops/sec ±0.26% (95 runs sampled) double-ended-queue x 26,363,500 ops/sec ±0.42% (91 runs sampled) #### Splice (1 x splice per 'op') - initial size of 100,000 items denque.splice x 925,749 ops/sec ±22.29% (77 runs sampled) native array splice x 7,777 ops/sec ±8.35% (50 runs sampled) #### Remove (1 x remove + 10 x push per 'op') - initial size of 100,000 items denque.remove x 2,635,275 ops/sec ±0.37% (95 runs sampled) native array splice - Fails to complete: "JavaScript heap out of memory" #### Remove One (1 x removeOne + 10 x push per 'op') - initial size of 100,000 items denque.removeOne x 1,088,240 ops/sec ±0.21% (93 runs sampled) native array splice x 5,300 ops/sec ±0.41% (96 runs sampled) --- Built and maintained with 💛 by [Invertase](https://invertase.io). - [💼 Hire Us](https://invertase.io/hire-us) - [☕️ Sponsor Us](https://opencollective.com/react-native-firebase) - [👩‍💻 Work With Us](https://invertase.io/jobs) package/index.d.ts000644 0000001327 3560116604 011164 0ustar00000000 000000 declare class Denque { constructor(); constructor(array: T[]); constructor(array: T[], options: IDenqueOptions); push(item: T): number; unshift(item: T): number; pop(): T | undefined; removeBack(): T | undefined; shift(): T | undefined; peekBack(): T | undefined; peekFront(): T | undefined; peekAt(index: number): T | undefined; get(index: number): T | undefined; remove(index: number, count: number): T[]; removeOne(index: number): T | undefined; splice(index: number, count: number, ...item: T[]): T[] | undefined; isEmpty(): boolean; clear(): void; toString(): string; toArray(): T[]; length: number; } interface IDenqueOptions { capacity?: number } export = Denque;