Ticket #4060: base.js.4.diff

src/base.js

@@ -1 @@
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    }
-
-
+
+
+
-
+  var __enableMimicry = function(__ctor) {
+    var __old = __ctor.prototype;
+    __ctor['mimic'] = function(obj) {
+      var __new = Object.extend(obj, __old);
+      __ensureDefaults(__new, __old);
+      return Object.extend(function() {
+        return __ctor.apply(this, arguments);
+      }, { 'prototype': __new });
+    };
+  };
+
+  var __inherit = function(subclass, superclass) {
+    
+    switch (typeof(superclass)) {
+      case 'object': default:
+        superclass[vocab['init']] = superclass.constructor;
+        subclass.prototype = superclass; break;
+      case 'function':
+        superclass.getInstance = superclass.getInstance ||
+          Class.encap(new superclass($doNotInit));
+        subclass.prototype = superclass.getInstance();
+    }
+    
+    return subclass.prototype;
+    
+  };
+
+  var __setupAttachDelete = function(declarations) {
+    return Object.extend(declarations, {
+      
+      'attachMethod': function(fnName, func) {
+        if (!this.ownPrototypeHas(fnName)) {
+          this._runTimeDeclarations[fnName] = true;
+          func.ancestor = this[fnName];
+          __attachClassProperty(fnName, func, this);
+        } else throw "Can't replace existing methods."
+      },
+      
+      'deleteMethod': function(fnName) {
+        if (this._runTimeDeclarations[fnName]) {
+          __attachClassProperty(fnName, null, this, true);
+          this._runTimeDeclarations[fnName] = false;
+        } else throw "Only attachMethod additions can be deleted."
+      }
+      
+    });
+  };
+
+  var __validOverride = function(propName, hasAncestor) {
+    switch (propName) {
+    case vocab['super']: case 'valueOf':
+    case 'attachMethod': case 'deleteMethod':
+    case 'getBaseInstance': return false;
+    default: return !!hasAncestor;
+    }
+  };
+  
+  var __attachClassProperty = function(propName, prop, obj,
+                                       /*optional*/ removeInstead) {
+    if (removeInstead) {
+      
+      if (obj.ownPrototypeHas(propName))
+        delete obj[propName];
+      
+    } else if (typeof(prop) == 'function' &&
+               __validOverride(propName, !!prop.ancestor)) {
+                 
+      obj[propName] = function() {
+        var __superSaver = this[vocab['super']];
+        this[vocab['super']] = prop.ancestor;
+        try { var result = prop.apply(this, arguments); }
+        catch (ex) { throw ex; }
+        finally { this[vocab['super']] = __superSaver; }
+        return result;
+      };
+      
+      obj[propName].valueOf = Class.encap(prop);
+
+      var __origStr = prop.toString();
+      prop.toString = obj[propName].toString = function() {
+        return __origStr.replace(/^\s*function/, propName);
+      };
+      
+    } else obj[propName] = prop;
+    
+  };
+
+  var __ensureDefaults = function(ownPrototype, declarations) {
+    ['toString', 'toLocaleString', 'valueOf'].each(function(propName) {
+      var prop = declarations[propName];
+      if (!!prop) {
+        prop.ancestor = ownPrototype[propName];
+        __attachClassProperty(propName, prop, ownPrototype);
+      }
+    });
+  };
+
+  var __ensureOwnPrototypeMemory = function(ownPrototype, declarations) {
+    ownPrototype.ownPrototypeHas = function(property) {
+      return (typeof(declarations[property]) != 'undefined' ||
+              (this._runTimeDeclarations && // present if instantiated
+               this._runTimeDeclarations[property]));
+    };
+  };
+
+  // convenient mechanism for creating accessor functions
+  this.encap = function(__val, mutable) {
+    if (!mutable) return function() { return __val; }
+    else return function(/* optional new value */) {
+      if (arguments.length > 0) __val = arguments[0];
+      return __val;
+    }
+  };
+  
+})( // the vocabulary is arbitrary:
+{'super': 'sup', 'init': 'initialize'});
+
-var Abstract = new Object();
-
-Object.extend = function(destination, source) {