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

lib/typedObjects/objectTypes.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 40 matching lines @@
   let [bufferIndex, byteOffset] = alloc(this.firstFree, this.byteLength,
       this.bufferSize, this.buffers, this.viewTypes, this.views);
 
   let result = Object.create(this.proto, {
     typeId: fixedPropertyDescriptor(this.typeId),
     bufferIndex: fixedPropertyDescriptor(bufferIndex),
     byteOffset: fixedPropertyDescriptor(byteOffset)
   });
 
   result._state = STATE_UNINITIALIZED;
-  for (let [prop, value] of this.cleanupValues)
+  for (let [prop, value] of this.initialValues)
     result[prop] = value;
   result._state = STATE_CREATED;
   result._refCount = 1;
 
   if (this.constructor)
     this.constructor.apply(result, arguments);
   return result;
 }
 
 function free(obj)
 {
   try
   {
     if (this.destructor)
     {
       this.destructor.call(obj);
       if (obj._refCount | 0)
         throw new Error("Reference count is no longer zero after calling the destructor");
     }
   }
   finally
   {
-    for (let [prop, value] of this.cleanupValues)
+    for (let [prop, value] of this.initialValues)
       obj[prop] = value;
 
     dealloc(this.firstFree, obj.bufferIndex, obj.byteOffset);
   }
 }
 
 function createGetter(offset)
 {
   offset = offset | 0;
 
@@ skipping 114 matching lines @@
   {
     watchers = Object.create(watchers);
     for (let key in meta.watch)
       watchers[key] = meta.watch[key];
   }
 
   let proto = {};
   let buffers = [];
   let viewTypes = [];
   let views = [];
-  let cleanupValues = [];
-  let byteLength = defineProperties(proto, properties, viewTypes, views, 0, watchers, cleanupValues);
+  let initialValues = [];
+  let byteLength = defineProperties(proto, properties, viewTypes, views, 0, watchers, initialValues);
   Object.defineProperties(proto, methods);
 
   // Round up to be a multiple of the maximal property size
   byteLength = ((byteLength - 1) | (maxReferenceLength - 1)) + 1;
 
   // We need to be able to store a typed reference in the object's buffer
   byteLength = Math.max(byteLength, TypedReference.byteLength) | 0;
   let typedReferenceViews = getViewsForType(TypedReference, viewTypes, views);
 
   // Take constructor and destructor from meta parameters, allow calling
@@ skipping 21 matching lines @@
     byteLength: byteLength,
     bufferSize: "bufferSize" in meta ? Math.max(meta.bufferSize | 0, 2) : 128,
     firstFree: new TypedReference(typeId, typedReferenceViews),
     proto: proto,
     properties: properties,
     methods: methods,
     watchers: watchers,
     buffers: buffers,
     viewTypes: viewTypes,
     views: views,
-    cleanupValues: cleanupValues,
+    initialValues: initialValues,
     typeId: typeId,
     parentTypeInfo: parentTypeInfo,
     constructor: constructor,
     destructor: destructor
   };
 
   let result = create.bind(typeInfo);
   Object.defineProperties(result, {
     byteLength: fixedPropertyDescriptor(byteLength),
 
     referenceLength: fixedPropertyDescriptor(Reference.byteLength),
     viewTypes: fixedPropertyDescriptor(Reference.viewTypes),
-    cleanupValue: fixedPropertyDescriptor(null),
+    initialValue: fixedPropertyDescriptor(null),
 
     typeId: fixedPropertyDescriptor(typeId),
     extend: fixedPropertyDescriptor(extend.bind(null, typeInfo)),
     isInstance: fixedPropertyDescriptor(isInstance.bind(null, typeId)),
     Array: fixedPropertyDescriptor(createArrayType.bind(null, result)),
 
     createGetter: fixedPropertyDescriptor(createGetter),
     createSetter: fixedPropertyDescriptor(createSetter.bind(null, typeId))
   });
   types.push(typeInfo);
@@ skipping 37 matching lines @@
     this._refCount--;
     if (this._refCount == 0 && this._state < STATE_RELEASING)
     {
       this._state = STATE_RELEASING;
       free.call(types[this.typeId | 0], this);
     }
   }
 }, null);
 
 exports.ObjectType = ObjectBase.extend;