Issue 260 - [Typed objects] Implement type inheritance

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 93 matching lines @@
 
 function createSetter(typeId, offset)
 {
   typeId = typeId | 0;
   offset = offset | 0;
 
   let views = Array.prototype.slice.call(arguments, 2);
   let reference = new Reference(types, views);
   return function(value)
   {
-    if (value && !isinstance(typeId, value))
+    if (value && !isInstance(typeId, value))
       throw new Error("Incompatible type");
 
     reference.bufferIndex = this.bufferIndex | 0;
     reference.byteOffset = (this.byteOffset | 0) + offset;
     if (value)
     {
       reference.typeId = value.typeId;
       reference.targetBufferIndex = value.bufferIndex;
       reference.targetByteOffset = value.byteOffset;
     }
@@ skipping 77 matching lines @@
   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 from meta parameter, allow calling superclass constructor.
-  let constructor = null;
+  let constructor = parentTypeInfo && parentTypeInfo.constructor;
   if (meta.hasOwnProperty("constructor") && typeof meta.constructor == "function")
   {
-    if (parentTypeInfo && parentTypeInfo.constructor)
-      constructor = createSubclassMethod(meta.constructor, parentTypeInfo.constructor);
+    if (constructor)
+      constructor = createSubclassMethod(meta.constructor, constructor);
     else
       constructor = meta.constructor;
   }

[Wladimir Palant, 2014/04/28 07:03:37]

The logic here was wrong: if no constructor is defined for the class then the
superclass constructor should still be called.

 
   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,
     properties: properties,
     methods: methods,
     buffers: buffers,
     viewTypes: viewTypes,
     views: views,
     typeId: typeId,
     parentTypeInfo: parentTypeInfo,
     constructor: constructor
   };
 
   let result = create.bind(typeInfo);
   Object.defineProperties(result, {
     byteLength: fixedPropertyDescriptor(byteLength),
 
     referenceLength: fixedPropertyDescriptor(Reference.byteLength),
     viewTypes: fixedPropertyDescriptor(Reference.viewTypes),
 
     typeId: fixedPropertyDescriptor(typeId),
     extend: fixedPropertyDescriptor(extend.bind(null, typeInfo)),
-    isinstance: fixedPropertyDescriptor(isinstance.bind(null, typeId)),
+    isInstance: fixedPropertyDescriptor(isInstance.bind(null, typeId)),
 
     createGetter: fixedPropertyDescriptor(createGetter),
     createSetter: fixedPropertyDescriptor(createSetter.bind(null, typeId))
   });
   types.push(typeInfo);
   return result;
 }
 
-function isinstance(typeId, obj)
+function isInstance(typeId, obj)
 {
   typeId = typeId | 0;
 
   // TODO: This could be optimized by compiling the list of all subclasses for
   // each type up front. Question is whether this is worth it.
   let typeInfo = types[obj.typeId | 0];
   while (typeInfo)
   {
     if ((typeInfo.typeId | 0) == typeId)
       return true;
     typeInfo = typeInfo.parentTypeInfo;
   }
   return false;
 }
 
 let ObjectBase = exports.ObjectBase = extend(null, {
   equals: function(obj)
   {
     if (!obj)
       return false;
     return this.typeId == obj.typeId && this.bufferIndex == obj.bufferIndex && this.byteOffset == obj.byteOffset;
   }
 }, null);
 
 exports.ObjectType = ObjectBase.extend;