File Explorer

1/**2 * Mnemonist Stack3 * ================4 *5 * Stack implementation relying on JavaScript arrays, which are fast enough &6 * correctly optimized for this kind of work.7 */8var Iterator = require('obliterator/iterator'),9    forEach = require('obliterator/foreach');10 11/**12 * Stack13 *14 * @constructor15 */16function Stack() {17  this.clear();18}19 20/**21 * Method used to clear the stack.22 *23 * @return {undefined}24 */25Stack.prototype.clear = function() {26 27  // Properties28  this.items = [];29  this.size = 0;30};31 32/**33 * Method used to add an item to the stack.34 *35 * @param  {any}    item - Item to add.36 * @return {number}37 */38Stack.prototype.push = function(item) {39  this.items.push(item);40  return ++this.size;41};42 43/**44 * Method used to retrieve & remove the last item of the stack.45 *46 * @return {any}47 */48Stack.prototype.pop = function() {49  if (this.size === 0)50    return;51 52  this.size--;53  return this.items.pop();54};55 56/**57 * Method used to get the last item of the stack.58 *59 * @return {any}60 */61Stack.prototype.peek = function() {62  return this.items[this.size - 1];63};64 65/**66 * Method used to iterate over the stack.67 *68 * @param  {function}  callback - Function to call for each item.69 * @param  {object}    scope    - Optional scope.70 * @return {undefined}71 */72Stack.prototype.forEach = function(callback, scope) {73  scope = arguments.length > 1 ? scope : this;74 75  for (var i = 0, l = this.items.length; i < l; i++)76    callback.call(scope, this.items[l - i - 1], i, this);77};78 79/**80 * Method used to convert the stack to a JavaScript array.81 *82 * @return {array}83 */84Stack.prototype.toArray = function() {85  var array = new Array(this.size),86      l = this.size - 1,87      i = this.size;88 89  while (i--)90    array[i] = this.items[l - i];91 92  return array;93};94 95/**96 * Method used to create an iterator over a stack's values.97 *98 * @return {Iterator}99 */100Stack.prototype.values = function() {101  var items = this.items,102      l = items.length,103      i = 0;104 105  return new Iterator(function() {106    if (i >= l)107      return {108        done: true109      };110 111    var value = items[l - i - 1];112    i++;113 114    return {115      value: value,116      done: false117    };118  });119};120 121/**122 * Method used to create an iterator over a stack's entries.123 *124 * @return {Iterator}125 */126Stack.prototype.entries = function() {127  var items = this.items,128      l = items.length,129      i = 0;130 131  return new Iterator(function() {132    if (i >= l)133      return {134        done: true135      };136 137    var value = items[l - i - 1];138 139    return {140      value: [i++, value],141      done: false142    };143  });144};145 146/**147 * Attaching the #.values method to Symbol.iterator if possible.148 */149if (typeof Symbol !== 'undefined')150  Stack.prototype[Symbol.iterator] = Stack.prototype.values;151 152 153/**154 * Convenience known methods.155 */156Stack.prototype.toString = function() {157  return this.toArray().join(',');158};159 160Stack.prototype.toJSON = function() {161  return this.toArray();162};163 164Stack.prototype.inspect = function() {165  var array = this.toArray();166 167  // Trick so that node displays the name of the constructor168  Object.defineProperty(array, 'constructor', {169    value: Stack,170    enumerable: false171  });172 173  return array;174};175 176if (typeof Symbol !== 'undefined')177  Stack.prototype[Symbol.for('nodejs.util.inspect.custom')] = Stack.prototype.inspect;178 179/**180 * Static @.from function taking an arbitrary iterable & converting it into181 * a stack.182 *183 * @param  {Iterable} iterable   - Target iterable.184 * @return {Stack}185 */186Stack.from = function(iterable) {187  var stack = new Stack();188 189  forEach(iterable, function(value) {190    stack.push(value);191  });192 193  return stack;194};195 196/**197 * Static @.of function taking an arbitrary number of arguments & converting it198 * into a stack.199 *200 * @param  {...any} args201 * @return {Stack}202 */203Stack.of = function() {204  return Stack.from(arguments);205};206 207/**208 * Exporting.209 */210module.exports = Stack;211