Issue 147 - [Typed objects] Implement object 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 24 matching lines @@
       bufferIndex: fixedPropertyDescriptor(reference.targetBufferIndex),
       byteOffset: fixedPropertyDescriptor(reference.targetByteOffset)
     });
   }
   else
     return null;
 }
 
 function create()
 {
-  let views = this.views;
   let {bufferIndex, byteOffset} = this.firstFree;
   if (bufferIndex >= 0)
   {
     // There is still a free spot, simply move on firstFree reference
     [this.firstFree.bufferIndex, this.firstFree.byteOffset] =
         [this.firstFree.targetBufferIndex, this.firstFree.targetByteOffset];

[René Jeschke, 2014/04/21 17:24:12]

Do we gain anything from [a, b] = [c, d] instead of using a = c; b = d; ? 
Otherwise this will lead to the creation of a temporary array (as far as I am
aware of) and therefore pollute the heap.

[Wladimir Palant, 2014/04/22 15:25:05]

reference.bufferIndex = reference.targetBufferIndex will change what memory area
the reference points to. Consequently, reading reference.targetByteOffset will
return bogus data.

AFAIK, using the destructuring assignment like that won't actually create a
temporary array.

[René Jeschke, 2014/04/22 15:40:34]

Right, using temporaries also will look ugly. So: ok.

   }
   else
   {
     let viewTypes = this.viewTypes;
+    let views = this.views;
     let byteLength = this.byteLength | 0;
     let bufferSize = this.bufferSize | 0;
 
     // Create new buffer and use the first element of it
     let buffer = new ArrayBuffer(byteLength * bufferSize);
     bufferIndex = (this.buffers.push(buffer) | 0) - 1;
     byteOffset = 0;
     for (let i = 0, l = viewTypes.length | 0; i < l; i++)
       views[i].push(new viewTypes[i](buffer));
 
@@ skipping 89 matching lines @@
     else
       throw new Error("Unrecognized type " + type + " given for property " + name);
   }
 
   let buffers = [];
   let viewTypes = [];
   let views = [];
   let byteLength = defineProperties(proto, propList, viewTypes, views, 0);
 
   // Round up to be a multiple of the maximal property size
   byteLength = ((byteLength - 1) | (maxReferenceLength - 1)) + 1;

[René Jeschke, 2014/04/21 17:24:12]

This only works correctly if either 'byteLength' or 'maxReferenceLength' is a
power-of-two. Have you considered this or better: can this become a problem?

Considering that we only use native primitive buffer views, this should not
become a problem. (Or am I missing something?)

[Wladimir Palant, 2014/04/22 15:25:05]

No, maxReferenceLength has to be a power of two - that's a requirement for each
primitive type. Note that we round up the size of the Reference class in
calculateSize() for that very reason (not that it changes much, size of an
object reference is 8 bytes anyway).

[René Jeschke, 2014/04/22 15:40:34]

Okay then.

 
   // 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);
 
   let typeId = types.length | 0;
   let typeInfo = {
     byteLength: byteLength,
     bufferSize: "bufferSize" in meta ? Math.max(meta.bufferSize | 0, 2) : 128,
     firstFree: new TypedReference(typeId, typedReferenceViews),
     proto: proto,
     buffers: buffers,
     viewTypes: viewTypes,
     views: views,
     typeId: typeId,
-    constructor: (typeof meta.constructor == "function" ? meta.constructor : null)

[Wladimir Palant, 2014/04/22 15:25:05]

This was a bug - each JavaScript object has a constructor property that is a
function.

[René Jeschke, 2014/04/22 15:40:34]

Didn't know that, now I do. Finally a good use case for 'hasOwnProperty'.

+    constructor: (meta.hasOwnProperty("constructor") && typeof meta.constructor == "function" ? meta.constructor : null)
   };
 
   let result = create.bind(typeInfo);
   Object.defineProperties(result, {
     byteLength: fixedPropertyDescriptor(byteLength),
 
     referenceLength: fixedPropertyDescriptor(Reference.byteLength),
     viewTypes: fixedPropertyDescriptor(Reference.viewTypes),
 
     typeId: fixedPropertyDescriptor(typeId),
 
     createGetter: fixedPropertyDescriptor(createGetter),
     createSetter: fixedPropertyDescriptor(createSetter.bind(null, typeId))
   });
   types.push(typeInfo);
   return result;
 }
 exports.ObjectType = ObjectType;