Issue 151 - [Typed objects] Implement dynamically-sized array types

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 67 matching lines @@
 {
   let {STATE_UNINITIALIZED} = require("typedObjects/objectTypes");
   return function lengthWatcher(newLength)
   {
     newLength = newLength | 0;
     if (newLength < 0)
       newLength = 0;
     if (newLength > this.size)
       this.size = newLength;
 
-    let cleanupValue = elementType.cleanupValue;
-    if (typeof cleanupValue != "undefined")
+    let initialValue = elementType.initialValue;
+    if (typeof initialValue != "undefined")
     {
       let length = this.length;
       if (newLength > length)
       {
         // We have to call element setter directly here, this.set() will
         // complain because of writing out of bounds (new length isn't set yet).
         // We also need to change state temporarily in order to avoid an attemt
         // to release "existing" values.
         let origState = this._state;
         this._state = STATE_UNINITIALIZED;
         try
         {
           let referenceLength = elementType.referenceLength | 0;
           let bufferIndex = this.arrayBufferIndex | 0;
           for (let i = length, offset = this.arrayByteOffset + length * referenceLength;
               i < newLength;
               i++, offset += referenceLength)
           {
-            elementSetter.call(this, bufferIndex, offset, cleanupValue);
+            elementSetter.call(this, bufferIndex, offset, initialValue);
           }
         }
         finally
         {
           this._state = origState;
         }
       }
       else
       {
         for (let i = newLength; i < length; i++)
-          this.set(i, cleanupValue);
+          this.set(i, initialValue);
       }
     }
 
     return newLength;
   }
 }
 
 function createSizeWatcher(elementType, minElements, bufferSize, buffers, viewTypes, views, firstFree)
 {
   let referenceLength = elementType.referenceLength | 0;
@@ skipping 22 matching lines @@
         if (typeof reference != "undefined")
         {
           [bufferIndex, byteOffset] = alloc(reference,
               referenceLength * newSize, (bufferSize / newSize) | 0,
               buffers, viewTypes, views);
         }
         else
         {
           // This array is too large, it needs an individual buffer
           bufferIndex = addBuffer(referenceLength * newSize, buffers, viewTypes, views);
+          bufferOffset = 0;
         }
 
         if (size > 0)
         {
           let copyBytes = length * referenceLength;
-          let src = Uint8Array(buffers[this.arrayBufferIndex], this.arrayByteOffset, copyBytes);
-          let dst = Uint8Array(buffers[bufferIndex], byteOffset, copyBytes);

[Wladimir Palant, 2014/05/19 07:58:34]

Chrome and Safari complained about Uint8Array being used as a function, Firefox
is apparently more forgiving here.

+          let src = new Uint8Array(buffers[this.arrayBufferIndex], this.arrayByteOffset, copyBytes);
+          let dst = new Uint8Array(buffers[bufferIndex], byteOffset, copyBytes);
           dst.set(src);
         }
 
         this.arrayBufferIndex = bufferIndex;
         this.arrayByteOffset = byteOffset;
       }
       else
         this.arrayBufferIndex = -1;
 
       if (size > 0)
@@ skipping 19 matching lines @@
   // 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");
   let minElements = nextPow2(Math.max(Math.ceil(TypedReference.byteLength / elementType.referenceLength) | 0, 1));
   let bufferSize = ("arrayBufferSize" in meta ? meta.arrayBufferSize | 0 : 1024);
   bufferSize = nextPow2(Math.max(bufferSize, minElements * 2)) | 0;
 
   let buffers = [];
-  let viewTypes = elementType.viewTypes;
+  let viewTypes = elementType.viewTypes.slice();
   let views = [];
   for (let i = 0, l = viewTypes.length | 0; i < l; i++)
     views.push([]);
 
   let elementGetter = elementType.createGetter.apply(elementType, [0].concat(views));
   let elementSetter = elementType.createSetter.apply(elementType, [0].concat(views));
 
   let typedReferenceTypes = TypedReference.viewTypes;
   let typedReferenceViews = [];
   for (let i = 0, l = typedReferenceTypes.length | 0; i < l; i++)
@@ skipping 38 matching lines @@
     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;