Issue 505 - [Typed objects] Implement array helper methods

lib/typedObjects/arrayTypes.js

 /*
  * This file is part of Adblock Plus <http://adblockplus.org/>,
  * Copyright (C) 2006-2014 Eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 172 matching lines @@
           dealloc(reference, origBufferIndex, origByteOffset);
         else
           removeBuffer(origBufferIndex, buffers, views);
       }
     }
 
     return newSize;
   }
 }
 
+function push()
+{
+  let length = this.length | 0;
+  let newCount = arguments.length | 0;
+  this.length = length + newCount;
+  for (let i = 0; i < newCount; i++)
+    this.set(length + i, arguments[i]);
+  return length + newCount;
+}
+
+function pop()
+{
+  let length = this.length | 0;
+  if (length == 0)
+    throw new Error("No elements in the array");
+
+  let result = this.get(length - 1);
+  this.length = this.length - 1;
+  return result;
+}
+
+function splice(index, count)
+{
+  index = index | 0;
+  count = count | 0;
+  let length = this.length | 0;
+  if (index < 0)

[René Jeschke, 2014/05/19 08:35:53]

What about the negative indexing one can use on 'splice'? 

So:
if (index < 0)
{
  index += length;
  if (index < 0)
    index = 0;
}

[Wladimir Palant, 2014/05/19 15:22:02]

You are right, I wasn't aware that splice supported this - fixed.

+    index = 0;
+  if (index > length)
+    index = length;
+  if (index + count > length)
+    count = length - index;
+
+  let newCount = (arguments.length | 0) - 2;
+  let diff = newCount - count;
+  let newLength = length + diff;
+  if (diff > 0)
+  {
+    this.length = newLength;
+    for (let i = length - 1; i >= index + count; i--)
+      this.set(i + diff, this.get(i));
+  }
+  else if (diff < 0)
+  {
+    for (let i = index + count; i < length; i++)
+      this.set(i + diff, this.get(i));
+    this.length = newLength;
+  }
+
+  for (let i = 0; i < newCount; i++)
+    this.set(index + i, arguments[i + 2]);
+}
+
+function unshift(value)
+{
+  let args = [0, 0].concat(Array.prototype.slice.apply(arguments));
+  this.splice.apply(this, args);
+  return this.length | 0;
+}
+
+function shift()
+{
+  let length = this.length | 0;
+  if (length == 0)
+    throw new Error("No elements in the array");
+
+  let result = this.get(0);
+  this.splice(0, 1);
+  return result;
+}
+
 function createArrayType(elementType, typeDescriptor, meta)
 {
   if (typeof meta != "object" || meta == null)
     meta = {};
 
   // We need to make sure that all buffer chunks are big enough to hold a
   // reference in order to manage the free chunks as a linked list. Each array
   // buffer should be dedicated to arrays of particular size - the number of
   // possible sizes is limited as the sizes can only be powers of two.
   let {TypedReference} = require("typedObjects/references");
@@ skipping 32 matching lines @@
   let {int16, uint32} = require("typedObjects/primitiveTypes");
   typeDescriptor = Object.create(typeDescriptor || {});
   typeDescriptor.arrayBufferIndex = int16;
   typeDescriptor.arrayByteOffset = uint32;
   typeDescriptor.getArrayBuffer = function()
   {
     return this.arrayBufferIndex >= 0 ? buffers[this.arrayBufferIndex] : null;
   };
   typeDescriptor.length = uint32;
   typeDescriptor.size = uint32;
+  typeDescriptor.push = push;
+  typeDescriptor.pop = pop;
+  typeDescriptor.splice = splice;
+  typeDescriptor.unshift = unshift;
+  typeDescriptor.shift = shift;
 
   let elementShift = ilog2(elementType.referenceLength | 0);
   typeDescriptor.get = createGetter(elementGetter, elementShift);
   typeDescriptor.set = createSetter(elementSetter, elementShift);
 
   if (meta.hasOwnProperty("constructor") && typeof meta.constructor == "function")
     meta.constructor = createCombinedConstructor(meta.constructor);
   else
     meta.constructor = defaultArrayConstructor;
 
   if (meta.hasOwnProperty("destructor") && typeof meta.destructor == "function")
     meta.destructor = createCombinedDestructor(meta.destructor);
   else
     meta.destructor = defaultArrayDestructor;
 
   if (!meta.watch || typeof meta.watch != "object")
     meta.watch = {};
 
   meta.watch.length = createLengthWatcher(elementType, elementSetter);
   meta.watch.size = createSizeWatcher(elementType, minElements, bufferSize, buffers, viewTypes, views, firstFree);
 
   let {ObjectBase} = require("typedObjects/objectTypes");
   return ObjectBase.extend(typeDescriptor, meta);
 }
 
 exports.createArrayType = createArrayType;