summaryrefslogtreecommitdiff
path: root/lib/dojo/_base/declare.js.uncompressed.js
diff options
context:
space:
mode:
Diffstat (limited to 'lib/dojo/_base/declare.js.uncompressed.js')
-rw-r--r--lib/dojo/_base/declare.js.uncompressed.js1045
1 files changed, 0 insertions, 1045 deletions
diff --git a/lib/dojo/_base/declare.js.uncompressed.js b/lib/dojo/_base/declare.js.uncompressed.js
deleted file mode 100644
index cb25e2873..000000000
--- a/lib/dojo/_base/declare.js.uncompressed.js
+++ /dev/null
@@ -1,1045 +0,0 @@
-define("dojo/_base/declare", ["./kernel", "../has", "./lang"], function(dojo, has, lang){
- // module:
- // dojo/_base/declare
-
- var mix = lang.mixin, op = Object.prototype, opts = op.toString,
- xtor = new Function, counter = 0, cname = "constructor";
-
- function err(msg, cls){ throw new Error("declare" + (cls ? " " + cls : "") + ": " + msg); }
-
- // C3 Method Resolution Order (see http://www.python.org/download/releases/2.3/mro/)
- function c3mro(bases, className){
- var result = [], roots = [{cls: 0, refs: []}], nameMap = {}, clsCount = 1,
- l = bases.length, i = 0, j, lin, base, top, proto, rec, name, refs;
-
- // build a list of bases naming them if needed
- for(; i < l; ++i){
- base = bases[i];
- if(!base){
- err("mixin #" + i + " is unknown. Did you use dojo.require to pull it in?", className);
- }else if(opts.call(base) != "[object Function]"){
- err("mixin #" + i + " is not a callable constructor.", className);
- }
- lin = base._meta ? base._meta.bases : [base];
- top = 0;
- // add bases to the name map
- for(j = lin.length - 1; j >= 0; --j){
- proto = lin[j].prototype;
- if(!proto.hasOwnProperty("declaredClass")){
- proto.declaredClass = "uniqName_" + (counter++);
- }
- name = proto.declaredClass;
- if(!nameMap.hasOwnProperty(name)){
- nameMap[name] = {count: 0, refs: [], cls: lin[j]};
- ++clsCount;
- }
- rec = nameMap[name];
- if(top && top !== rec){
- rec.refs.push(top);
- ++top.count;
- }
- top = rec;
- }
- ++top.count;
- roots[0].refs.push(top);
- }
-
- // remove classes without external references recursively
- while(roots.length){
- top = roots.pop();
- result.push(top.cls);
- --clsCount;
- // optimization: follow a single-linked chain
- while(refs = top.refs, refs.length == 1){
- top = refs[0];
- if(!top || --top.count){
- // branch or end of chain => do not end to roots
- top = 0;
- break;
- }
- result.push(top.cls);
- --clsCount;
- }
- if(top){
- // branch
- for(i = 0, l = refs.length; i < l; ++i){
- top = refs[i];
- if(!--top.count){
- roots.push(top);
- }
- }
- }
- }
- if(clsCount){
- err("can't build consistent linearization", className);
- }
-
- // calculate the superclass offset
- base = bases[0];
- result[0] = base ?
- base._meta && base === result[result.length - base._meta.bases.length] ?
- base._meta.bases.length : 1 : 0;
-
- return result;
- }
-
- function inherited(args, a, f){
- var name, chains, bases, caller, meta, base, proto, opf, pos,
- cache = this._inherited = this._inherited || {};
-
- // crack arguments
- if(typeof args == "string"){
- name = args;
- args = a;
- a = f;
- }
- f = 0;
-
- caller = args.callee;
- name = name || caller.nom;
- if(!name){
- err("can't deduce a name to call inherited()", this.declaredClass);
- }
-
- meta = this.constructor._meta;
- bases = meta.bases;
-
- pos = cache.p;
- if(name != cname){
- // method
- if(cache.c !== caller){
- // cache bust
- pos = 0;
- base = bases[0];
- meta = base._meta;
- if(meta.hidden[name] !== caller){
- // error detection
- chains = meta.chains;
- if(chains && typeof chains[name] == "string"){
- err("calling chained method with inherited: " + name, this.declaredClass);
- }
- // find caller
- do{
- meta = base._meta;
- proto = base.prototype;
- if(meta && (proto[name] === caller && proto.hasOwnProperty(name) || meta.hidden[name] === caller)){
- break;
- }
- }while(base = bases[++pos]); // intentional assignment
- pos = base ? pos : -1;
- }
- }
- // find next
- base = bases[++pos];
- if(base){
- proto = base.prototype;
- if(base._meta && proto.hasOwnProperty(name)){
- f = proto[name];
- }else{
- opf = op[name];
- do{
- proto = base.prototype;
- f = proto[name];
- if(f && (base._meta ? proto.hasOwnProperty(name) : f !== opf)){
- break;
- }
- }while(base = bases[++pos]); // intentional assignment
- }
- }
- f = base && f || op[name];
- }else{
- // constructor
- if(cache.c !== caller){
- // cache bust
- pos = 0;
- meta = bases[0]._meta;
- if(meta && meta.ctor !== caller){
- // error detection
- chains = meta.chains;
- if(!chains || chains.constructor !== "manual"){
- err("calling chained constructor with inherited", this.declaredClass);
- }
- // find caller
- while(base = bases[++pos]){ // intentional assignment
- meta = base._meta;
- if(meta && meta.ctor === caller){
- break;
- }
- }
- pos = base ? pos : -1;
- }
- }
- // find next
- while(base = bases[++pos]){ // intentional assignment
- meta = base._meta;
- f = meta ? meta.ctor : base;
- if(f){
- break;
- }
- }
- f = base && f;
- }
-
- // cache the found super method
- cache.c = f;
- cache.p = pos;
-
- // now we have the result
- if(f){
- return a === true ? f : f.apply(this, a || args);
- }
- // intentionally no return if a super method was not found
- }
-
- function getInherited(name, args){
- if(typeof name == "string"){
- return this.__inherited(name, args, true);
- }
- return this.__inherited(name, true);
- }
-
- function inherited__debug(args, a1, a2){
- var f = this.getInherited(args, a1);
- if(f){ return f.apply(this, a2 || a1 || args); }
- // intentionally no return if a super method was not found
- }
-
- var inheritedImpl = dojo.config.isDebug ? inherited__debug : inherited;
-
- // emulation of "instanceof"
- function isInstanceOf(cls){
- var bases = this.constructor._meta.bases;
- for(var i = 0, l = bases.length; i < l; ++i){
- if(bases[i] === cls){
- return true;
- }
- }
- return this instanceof cls;
- }
-
- function mixOwn(target, source){
- // add props adding metadata for incoming functions skipping a constructor
- for(var name in source){
- if(name != cname && source.hasOwnProperty(name)){
- target[name] = source[name];
- }
- }
- if(has("bug-for-in-skips-shadowed")){
- for(var extraNames= lang._extraNames, i= extraNames.length; i;){
- name = extraNames[--i];
- if(name != cname && source.hasOwnProperty(name)){
- target[name] = source[name];
- }
- }
- }
- }
-
- // implementation of safe mixin function
- function safeMixin(target, source){
- // summary:
- // Mix in properties skipping a constructor and decorating functions
- // like it is done by declare().
- // target: Object
- // Target object to accept new properties.
- // source: Object
- // Source object for new properties.
- // description:
- // This function is used to mix in properties like lang.mixin does,
- // but it skips a constructor property and decorates functions like
- // declare() does.
- //
- // It is meant to be used with classes and objects produced with
- // declare. Functions mixed in with dojo.safeMixin can use
- // this.inherited() like normal methods.
- //
- // This function is used to implement extend() method of a constructor
- // produced with declare().
- //
- // example:
- // | var A = declare(null, {
- // | m1: function(){
- // | console.log("A.m1");
- // | },
- // | m2: function(){
- // | console.log("A.m2");
- // | }
- // | });
- // | var B = declare(A, {
- // | m1: function(){
- // | this.inherited(arguments);
- // | console.log("B.m1");
- // | }
- // | });
- // | B.extend({
- // | m2: function(){
- // | this.inherited(arguments);
- // | console.log("B.m2");
- // | }
- // | });
- // | var x = new B();
- // | dojo.safeMixin(x, {
- // | m1: function(){
- // | this.inherited(arguments);
- // | console.log("X.m1");
- // | },
- // | m2: function(){
- // | this.inherited(arguments);
- // | console.log("X.m2");
- // | }
- // | });
- // | x.m2();
- // | // prints:
- // | // A.m1
- // | // B.m1
- // | // X.m1
-
- var name, t;
- // add props adding metadata for incoming functions skipping a constructor
- for(name in source){
- t = source[name];
- if((t !== op[name] || !(name in op)) && name != cname){
- if(opts.call(t) == "[object Function]"){
- // non-trivial function method => attach its name
- t.nom = name;
- }
- target[name] = t;
- }
- }
- if(has("bug-for-in-skips-shadowed")){
- for(var extraNames= lang._extraNames, i= extraNames.length; i;){
- name = extraNames[--i];
- t = source[name];
- if((t !== op[name] || !(name in op)) && name != cname){
- if(opts.call(t) == "[object Function]"){
- // non-trivial function method => attach its name
- t.nom = name;
- }
- target[name] = t;
- }
- }
- }
- return target;
- }
-
- function extend(source){
- declare.safeMixin(this.prototype, source);
- return this;
- }
-
- function createSubclass(mixins){
- return declare([this].concat(mixins));
- }
-
- // chained constructor compatible with the legacy declare()
- function chainedConstructor(bases, ctorSpecial){
- return function(){
- var a = arguments, args = a, a0 = a[0], f, i, m,
- l = bases.length, preArgs;
-
- if(!(this instanceof a.callee)){
- // not called via new, so force it
- return applyNew(a);
- }
-
- //this._inherited = {};
- // perform the shaman's rituals of the original declare()
- // 1) call two types of the preamble
- if(ctorSpecial && (a0 && a0.preamble || this.preamble)){
- // full blown ritual
- preArgs = new Array(bases.length);
- // prepare parameters
- preArgs[0] = a;
- for(i = 0;;){
- // process the preamble of the 1st argument
- a0 = a[0];
- if(a0){
- f = a0.preamble;
- if(f){
- a = f.apply(this, a) || a;
- }
- }
- // process the preamble of this class
- f = bases[i].prototype;
- f = f.hasOwnProperty("preamble") && f.preamble;
- if(f){
- a = f.apply(this, a) || a;
- }
- // one peculiarity of the preamble:
- // it is called if it is not needed,
- // e.g., there is no constructor to call
- // let's watch for the last constructor
- // (see ticket #9795)
- if(++i == l){
- break;
- }
- preArgs[i] = a;
- }
- }
- // 2) call all non-trivial constructors using prepared arguments
- for(i = l - 1; i >= 0; --i){
- f = bases[i];
- m = f._meta;
- f = m ? m.ctor : f;
- if(f){
- f.apply(this, preArgs ? preArgs[i] : a);
- }
- }
- // 3) continue the original ritual: call the postscript
- f = this.postscript;
- if(f){
- f.apply(this, args);
- }
- };
- }
-
-
- // chained constructor compatible with the legacy declare()
- function singleConstructor(ctor, ctorSpecial){
- return function(){
- var a = arguments, t = a, a0 = a[0], f;
-
- if(!(this instanceof a.callee)){
- // not called via new, so force it
- return applyNew(a);
- }
-
- //this._inherited = {};
- // perform the shaman's rituals of the original declare()
- // 1) call two types of the preamble
- if(ctorSpecial){
- // full blown ritual
- if(a0){
- // process the preamble of the 1st argument
- f = a0.preamble;
- if(f){
- t = f.apply(this, t) || t;
- }
- }
- f = this.preamble;
- if(f){
- // process the preamble of this class
- f.apply(this, t);
- // one peculiarity of the preamble:
- // it is called even if it is not needed,
- // e.g., there is no constructor to call
- // let's watch for the last constructor
- // (see ticket #9795)
- }
- }
- // 2) call a constructor
- if(ctor){
- ctor.apply(this, a);
- }
- // 3) continue the original ritual: call the postscript
- f = this.postscript;
- if(f){
- f.apply(this, a);
- }
- };
- }
-
- // plain vanilla constructor (can use inherited() to call its base constructor)
- function simpleConstructor(bases){
- return function(){
- var a = arguments, i = 0, f, m;
-
- if(!(this instanceof a.callee)){
- // not called via new, so force it
- return applyNew(a);
- }
-
- //this._inherited = {};
- // perform the shaman's rituals of the original declare()
- // 1) do not call the preamble
- // 2) call the top constructor (it can use this.inherited())
- for(; f = bases[i]; ++i){ // intentional assignment
- m = f._meta;
- f = m ? m.ctor : f;
- if(f){
- f.apply(this, a);
- break;
- }
- }
- // 3) call the postscript
- f = this.postscript;
- if(f){
- f.apply(this, a);
- }
- };
- }
-
- function chain(name, bases, reversed){
- return function(){
- var b, m, f, i = 0, step = 1;
- if(reversed){
- i = bases.length - 1;
- step = -1;
- }
- for(; b = bases[i]; i += step){ // intentional assignment
- m = b._meta;
- f = (m ? m.hidden : b.prototype)[name];
- if(f){
- f.apply(this, arguments);
- }
- }
- };
- }
-
- // forceNew(ctor)
- // return a new object that inherits from ctor.prototype but
- // without actually running ctor on the object.
- function forceNew(ctor){
- // create object with correct prototype using a do-nothing
- // constructor
- xtor.prototype = ctor.prototype;
- var t = new xtor;
- xtor.prototype = null; // clean up
- return t;
- }
-
- // applyNew(args)
- // just like 'new ctor()' except that the constructor and its arguments come
- // from args, which must be an array or an arguments object
- function applyNew(args){
- // create an object with ctor's prototype but without
- // calling ctor on it.
- var ctor = args.callee, t = forceNew(ctor);
- // execute the real constructor on the new object
- ctor.apply(t, args);
- return t;
- }
-
- function declare(className, superclass, props){
- // summary:
- // Create a feature-rich constructor from compact notation.
- // className: String?
- // The optional name of the constructor (loosely, a "class")
- // stored in the "declaredClass" property in the created prototype.
- // It will be used as a global name for a created constructor.
- // superclass: Function|Function[]
- // May be null, a Function, or an Array of Functions. This argument
- // specifies a list of bases (the left-most one is the most deepest
- // base).
- // props: Object
- // An object whose properties are copied to the created prototype.
- // Add an instance-initialization function by making it a property
- // named "constructor".
- // returns: dojo/_base/declare.__DeclareCreatedObject
- // New constructor function.
- // description:
- // Create a constructor using a compact notation for inheritance and
- // prototype extension.
- //
- // Mixin ancestors provide a type of multiple inheritance.
- // Prototypes of mixin ancestors are copied to the new class:
- // changes to mixin prototypes will not affect classes to which
- // they have been mixed in.
- //
- // Ancestors can be compound classes created by this version of
- // declare(). In complex cases all base classes are going to be
- // linearized according to C3 MRO algorithm
- // (see http://www.python.org/download/releases/2.3/mro/ for more
- // details).
- //
- // "className" is cached in "declaredClass" property of the new class,
- // if it was supplied. The immediate super class will be cached in
- // "superclass" property of the new class.
- //
- // Methods in "props" will be copied and modified: "nom" property
- // (the declared name of the method) will be added to all copied
- // functions to help identify them for the internal machinery. Be
- // very careful, while reusing methods: if you use the same
- // function under different names, it can produce errors in some
- // cases.
- //
- // It is possible to use constructors created "manually" (without
- // declare()) as bases. They will be called as usual during the
- // creation of an instance, their methods will be chained, and even
- // called by "this.inherited()".
- //
- // Special property "-chains-" governs how to chain methods. It is
- // a dictionary, which uses method names as keys, and hint strings
- // as values. If a hint string is "after", this method will be
- // called after methods of its base classes. If a hint string is
- // "before", this method will be called before methods of its base
- // classes.
- //
- // If "constructor" is not mentioned in "-chains-" property, it will
- // be chained using the legacy mode: using "after" chaining,
- // calling preamble() method before each constructor, if available,
- // and calling postscript() after all constructors were executed.
- // If the hint is "after", it is chained as a regular method, but
- // postscript() will be called after the chain of constructors.
- // "constructor" cannot be chained "before", but it allows
- // a special hint string: "manual", which means that constructors
- // are not going to be chained in any way, and programmer will call
- // them manually using this.inherited(). In the latter case
- // postscript() will be called after the construction.
- //
- // All chaining hints are "inherited" from base classes and
- // potentially can be overridden. Be very careful when overriding
- // hints! Make sure that all chained methods can work in a proposed
- // manner of chaining.
- //
- // Once a method was chained, it is impossible to unchain it. The
- // only exception is "constructor". You don't need to define a
- // method in order to supply a chaining hint.
- //
- // If a method is chained, it cannot use this.inherited() because
- // all other methods in the hierarchy will be called automatically.
- //
- // Usually constructors and initializers of any kind are chained
- // using "after" and destructors of any kind are chained as
- // "before". Note that chaining assumes that chained methods do not
- // return any value: any returned value will be discarded.
- //
- // example:
- // | declare("my.classes.bar", my.classes.foo, {
- // | // properties to be added to the class prototype
- // | someValue: 2,
- // | // initialization function
- // | constructor: function(){
- // | this.myComplicatedObject = new ReallyComplicatedObject();
- // | },
- // | // other functions
- // | someMethod: function(){
- // | doStuff();
- // | }
- // | });
- //
- // example:
- // | var MyBase = declare(null, {
- // | // constructor, properties, and methods go here
- // | // ...
- // | });
- // | var MyClass1 = declare(MyBase, {
- // | // constructor, properties, and methods go here
- // | // ...
- // | });
- // | var MyClass2 = declare(MyBase, {
- // | // constructor, properties, and methods go here
- // | // ...
- // | });
- // | var MyDiamond = declare([MyClass1, MyClass2], {
- // | // constructor, properties, and methods go here
- // | // ...
- // | });
- //
- // example:
- // | var F = function(){ console.log("raw constructor"); };
- // | F.prototype.method = function(){
- // | console.log("raw method");
- // | };
- // | var A = declare(F, {
- // | constructor: function(){
- // | console.log("A.constructor");
- // | },
- // | method: function(){
- // | console.log("before calling F.method...");
- // | this.inherited(arguments);
- // | console.log("...back in A");
- // | }
- // | });
- // | new A().method();
- // | // will print:
- // | // raw constructor
- // | // A.constructor
- // | // before calling F.method...
- // | // raw method
- // | // ...back in A
- //
- // example:
- // | var A = declare(null, {
- // | "-chains-": {
- // | destroy: "before"
- // | }
- // | });
- // | var B = declare(A, {
- // | constructor: function(){
- // | console.log("B.constructor");
- // | },
- // | destroy: function(){
- // | console.log("B.destroy");
- // | }
- // | });
- // | var C = declare(B, {
- // | constructor: function(){
- // | console.log("C.constructor");
- // | },
- // | destroy: function(){
- // | console.log("C.destroy");
- // | }
- // | });
- // | new C().destroy();
- // | // prints:
- // | // B.constructor
- // | // C.constructor
- // | // C.destroy
- // | // B.destroy
- //
- // example:
- // | var A = declare(null, {
- // | "-chains-": {
- // | constructor: "manual"
- // | }
- // | });
- // | var B = declare(A, {
- // | constructor: function(){
- // | // ...
- // | // call the base constructor with new parameters
- // | this.inherited(arguments, [1, 2, 3]);
- // | // ...
- // | }
- // | });
- //
- // example:
- // | var A = declare(null, {
- // | "-chains-": {
- // | m1: "before"
- // | },
- // | m1: function(){
- // | console.log("A.m1");
- // | },
- // | m2: function(){
- // | console.log("A.m2");
- // | }
- // | });
- // | var B = declare(A, {
- // | "-chains-": {
- // | m2: "after"
- // | },
- // | m1: function(){
- // | console.log("B.m1");
- // | },
- // | m2: function(){
- // | console.log("B.m2");
- // | }
- // | });
- // | var x = new B();
- // | x.m1();
- // | // prints:
- // | // B.m1
- // | // A.m1
- // | x.m2();
- // | // prints:
- // | // A.m2
- // | // B.m2
-
- // crack parameters
- if(typeof className != "string"){
- props = superclass;
- superclass = className;
- className = "";
- }
- props = props || {};
-
- var proto, i, t, ctor, name, bases, chains, mixins = 1, parents = superclass;
-
- // build a prototype
- if(opts.call(superclass) == "[object Array]"){
- // C3 MRO
- bases = c3mro(superclass, className);
- t = bases[0];
- mixins = bases.length - t;
- superclass = bases[mixins];
- }else{
- bases = [0];
- if(superclass){
- if(opts.call(superclass) == "[object Function]"){
- t = superclass._meta;
- bases = bases.concat(t ? t.bases : superclass);
- }else{
- err("base class is not a callable constructor.", className);
- }
- }else if(superclass !== null){
- err("unknown base class. Did you use dojo.require to pull it in?", className);
- }
- }
- if(superclass){
- for(i = mixins - 1;; --i){
- proto = forceNew(superclass);
- if(!i){
- // stop if nothing to add (the last base)
- break;
- }
- // mix in properties
- t = bases[i];
- (t._meta ? mixOwn : mix)(proto, t.prototype);
- // chain in new constructor
- ctor = new Function;
- ctor.superclass = superclass;
- ctor.prototype = proto;
- superclass = proto.constructor = ctor;
- }
- }else{
- proto = {};
- }
- // add all properties
- declare.safeMixin(proto, props);
- // add constructor
- t = props.constructor;
- if(t !== op.constructor){
- t.nom = cname;
- proto.constructor = t;
- }
-
- // collect chains and flags
- for(i = mixins - 1; i; --i){ // intentional assignment
- t = bases[i]._meta;
- if(t && t.chains){
- chains = mix(chains || {}, t.chains);
- }
- }
- if(proto["-chains-"]){
- chains = mix(chains || {}, proto["-chains-"]);
- }
-
- // build ctor
- t = !chains || !chains.hasOwnProperty(cname);
- bases[0] = ctor = (chains && chains.constructor === "manual") ? simpleConstructor(bases) :
- (bases.length == 1 ? singleConstructor(props.constructor, t) : chainedConstructor(bases, t));
-
- // add meta information to the constructor
- ctor._meta = {bases: bases, hidden: props, chains: chains,
- parents: parents, ctor: props.constructor};
- ctor.superclass = superclass && superclass.prototype;
- ctor.extend = extend;
- ctor.createSubclass = createSubclass;
- ctor.prototype = proto;
- proto.constructor = ctor;
-
- // add "standard" methods to the prototype
- proto.getInherited = getInherited;
- proto.isInstanceOf = isInstanceOf;
- proto.inherited = inheritedImpl;
- proto.__inherited = inherited;
-
- // add name if specified
- if(className){
- proto.declaredClass = className;
- lang.setObject(className, ctor);
- }
-
- // build chains and add them to the prototype
- if(chains){
- for(name in chains){
- if(proto[name] && typeof chains[name] == "string" && name != cname){
- t = proto[name] = chain(name, bases, chains[name] === "after");
- t.nom = name;
- }
- }
- }
- // chained methods do not return values
- // no need to chain "invisible" functions
-
- return ctor; // Function
- }
-
- /*=====
- declare.__DeclareCreatedObject = {
- // summary:
- // dojo/_base/declare() returns a constructor `C`. `new C()` returns an Object with the following
- // methods, in addition to the methods and properties specified via the arguments passed to declare().
-
- inherited: function(name, args, newArgs){
- // summary:
- // Calls a super method.
- // name: String?
- // The optional method name. Should be the same as the caller's
- // name. Usually "name" is specified in complex dynamic cases, when
- // the calling method was dynamically added, undecorated by
- // declare(), and it cannot be determined.
- // args: Arguments
- // The caller supply this argument, which should be the original
- // "arguments".
- // newArgs: Object?
- // If "true", the found function will be returned without
- // executing it.
- // If Array, it will be used to call a super method. Otherwise
- // "args" will be used.
- // returns:
- // Whatever is returned by a super method, or a super method itself,
- // if "true" was specified as newArgs.
- // description:
- // This method is used inside method of classes produced with
- // declare() to call a super method (next in the chain). It is
- // used for manually controlled chaining. Consider using the regular
- // chaining, because it is faster. Use "this.inherited()" only in
- // complex cases.
- //
- // This method cannot me called from automatically chained
- // constructors including the case of a special (legacy)
- // constructor chaining. It cannot be called from chained methods.
- //
- // If "this.inherited()" cannot find the next-in-chain method, it
- // does nothing and returns "undefined". The last method in chain
- // can be a default method implemented in Object, which will be
- // called last.
- //
- // If "name" is specified, it is assumed that the method that
- // received "args" is the parent method for this call. It is looked
- // up in the chain list and if it is found the next-in-chain method
- // is called. If it is not found, the first-in-chain method is
- // called.
- //
- // If "name" is not specified, it will be derived from the calling
- // method (using a methoid property "nom").
- //
- // example:
- // | var B = declare(A, {
- // | method1: function(a, b, c){
- // | this.inherited(arguments);
- // | },
- // | method2: function(a, b){
- // | return this.inherited(arguments, [a + b]);
- // | }
- // | });
- // | // next method is not in the chain list because it is added
- // | // manually after the class was created.
- // | B.prototype.method3 = function(){
- // | console.log("This is a dynamically-added method.");
- // | this.inherited("method3", arguments);
- // | };
- // example:
- // | var B = declare(A, {
- // | method: function(a, b){
- // | var super = this.inherited(arguments, true);
- // | // ...
- // | if(!super){
- // | console.log("there is no super method");
- // | return 0;
- // | }
- // | return super.apply(this, arguments);
- // | }
- // | });
- return {}; // Object
- },
-
- getInherited: function(name, args){
- // summary:
- // Returns a super method.
- // name: String?
- // The optional method name. Should be the same as the caller's
- // name. Usually "name" is specified in complex dynamic cases, when
- // the calling method was dynamically added, undecorated by
- // declare(), and it cannot be determined.
- // args: Arguments
- // The caller supply this argument, which should be the original
- // "arguments".
- // returns:
- // Returns a super method (Function) or "undefined".
- // description:
- // This method is a convenience method for "this.inherited()".
- // It uses the same algorithm but instead of executing a super
- // method, it returns it, or "undefined" if not found.
- //
- // example:
- // | var B = declare(A, {
- // | method: function(a, b){
- // | var super = this.getInherited(arguments);
- // | // ...
- // | if(!super){
- // | console.log("there is no super method");
- // | return 0;
- // | }
- // | return super.apply(this, arguments);
- // | }
- // | });
- return {}; // Object
- },
-
- isInstanceOf: function(cls){
- // summary:
- // Checks the inheritance chain to see if it is inherited from this
- // class.
- // cls: Function
- // Class constructor.
- // returns:
- // "true", if this object is inherited from this class, "false"
- // otherwise.
- // description:
- // This method is used with instances of classes produced with
- // declare() to determine of they support a certain interface or
- // not. It models "instanceof" operator.
- //
- // example:
- // | var A = declare(null, {
- // | // constructor, properties, and methods go here
- // | // ...
- // | });
- // | var B = declare(null, {
- // | // constructor, properties, and methods go here
- // | // ...
- // | });
- // | var C = declare([A, B], {
- // | // constructor, properties, and methods go here
- // | // ...
- // | });
- // | var D = declare(A, {
- // | // constructor, properties, and methods go here
- // | // ...
- // | });
- // |
- // | var a = new A(), b = new B(), c = new C(), d = new D();
- // |
- // | console.log(a.isInstanceOf(A)); // true
- // | console.log(b.isInstanceOf(A)); // false
- // | console.log(c.isInstanceOf(A)); // true
- // | console.log(d.isInstanceOf(A)); // true
- // |
- // | console.log(a.isInstanceOf(B)); // false
- // | console.log(b.isInstanceOf(B)); // true
- // | console.log(c.isInstanceOf(B)); // true
- // | console.log(d.isInstanceOf(B)); // false
- // |
- // | console.log(a.isInstanceOf(C)); // false
- // | console.log(b.isInstanceOf(C)); // false
- // | console.log(c.isInstanceOf(C)); // true
- // | console.log(d.isInstanceOf(C)); // false
- // |
- // | console.log(a.isInstanceOf(D)); // false
- // | console.log(b.isInstanceOf(D)); // false
- // | console.log(c.isInstanceOf(D)); // false
- // | console.log(d.isInstanceOf(D)); // true
- return {}; // Object
- },
-
- extend: function(source){
- // summary:
- // Adds all properties and methods of source to constructor's
- // prototype, making them available to all instances created with
- // constructor. This method is specific to constructors created with
- // declare().
- // source: Object
- // Source object which properties are going to be copied to the
- // constructor's prototype.
- // description:
- // Adds source properties to the constructor's prototype. It can
- // override existing properties.
- //
- // This method is similar to dojo.extend function, but it is specific
- // to constructors produced by declare(). It is implemented
- // using dojo.safeMixin, and it skips a constructor property,
- // and properly decorates copied functions.
- //
- // example:
- // | var A = declare(null, {
- // | m1: function(){},
- // | s1: "Popokatepetl"
- // | });
- // | A.extend({
- // | m1: function(){},
- // | m2: function(){},
- // | f1: true,
- // | d1: 42
- // | });
- }
- };
- =====*/
-
- // For back-compat, remove for 2.0
- dojo.safeMixin = declare.safeMixin = safeMixin;
- dojo.declare = declare;
-
- return declare;
-});
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-30 12:15:54 +0000