Issue 507 - Implement lightweight array.slice() method

lib/typedObjects/arrayTypes.js

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-2015 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
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 "use strict";
 
-let {ilog2, nextPow2, alloc, dealloc, addBuffer, removeBuffer} = require("typedObjects/utils");
+let {ilog2, nextPow2, alloc, fixedPropertyDescriptor, dealloc, addBuffer, removeBuffer} = require("typedObjects/utils");
 
 function defaultArrayConstructor()
 {
   this.arrayBufferIndex = -1;
 };
 
 function defaultArrayDestructor()
 {
-  this.length = 0;
-  this.size = 0;
+  if (this._copy)
+  {
+    // Carefully zero length + size if this is a slice of an array
+    Object.defineProperties(this, {
+      length: fixedPropertyDescriptor(0),
+      size: fixedPropertyDescriptor(0)
+    });
+  }
+  else
+  {
+    // Remove read-only length property for previously sliced arrays
+    delete this.length;
+
+    this.length = 0;
+    this.size = 0;
+  }
 };
 
 function createGetter(elementGetter, elementShift)
 {
   return function(index)
   {
     if (index < 0 || index >= this.length)
       throw new Error("Array index out of bounds");
     return elementGetter.call(this, this.arrayBufferIndex, this.arrayByteOffset + (index << elementShift));
   };
@@ skipping 164 matching lines @@
 {
   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 createSlicer(elementShift)
+{
+  let {STATE_UNINITIALIZED} = require("typedObjects/objectTypes");
+
+  return function slice(start, end)
+  {
+    start = start | 0;
+    end = end | 0;
+
+    if (start < 0)
+      start = Math.max(0, this.length + start);
+    else
+      start = Math.min(start, this.length);
+
+    if (end > 0)
+      end = Math.min(0, end - this.length);
+    else
+      end = Math.max(end, -1 * this.length);
+
+    Object.defineProperties(this, {
+      length: {value: this.length, configurable: true}
+    });
+    this.retain();
+
+    let result = Object.create(this, {
+      arrayByteOffset: fixedPropertyDescriptor(
+        this.arrayByteOffset + start << elementShift
+      ),
+      length: {value: this.length - start + end, configurable: true},
+      _refCount: {value: 1, writable: true},
+      _copy: fixedPropertyDescriptor(true),
+      _state: {value: STATE_UNINITIALIZED, writable: true}
+    });
+
+    // TODO
+    //  - A sliced array will have a read-only length even if all slices are
+    //    released. We could fix this by keeping a count of slices, but is it
+    //    worth it?
+    //  - A slice of an array still keeps a reference to the array in it's
+    //    __proto__ property after it's released. (We can't just replace it
+    //    with null as modifying an object's prototype is apparently very slow.)
+
+    return result;
+  };
+}
+
 function splice(index, count)
 {
   index = index | 0;
   count = count | 0;
   let length = this.length | 0;
   if (index < 0)
   {
     index += length;
     if (index < 0)
       index = 0;
@@ skipping 93 matching lines @@
   };
   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.slice = createSlicer(elementShift);
   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;