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 111 matching lines @@
 
   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)),

[René Jeschke, 2014/05/02 16:16:37]

Just wondering, every other member name you use is camel-case, but not this one.

Shouldn't this then be called 'isInstance'?

[Wladimir Palant, 2014/05/02 19:14:31]

It's really because the JavaScript operator is called "isinstance" - but you are
right, it should be camel-cased.

+    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;