add Dojo 1.1.1

[eow] / static / dojo-release-1.1.1 / dojo / _base / Deferred.js

if(!dojo._hasResource["dojo._base.Deferred"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
dojo._hasResource["dojo._base.Deferred"] = true;
dojo.provide("dojo._base.Deferred");
dojo.require("dojo._base.lang");

dojo.Deferred = function(/*Function?*/ canceller){
        // summary:
        //              Encapsulates a sequence of callbacks in response to a value that
        //              may not yet be available.  This is modeled after the Deferred class
        //              from Twisted <http://twistedmatrix.com>.
        // description:
        //              JavaScript has no threads, and even if it did, threads are hard.
        //              Deferreds are a way of abstracting non-blocking events, such as the
        //              final response to an XMLHttpRequest. Deferreds create a promise to
        //              return a response a some point in the future and an easy way to
        //              register your interest in receiving that response.
        //
        //              The most important methods for Deffered users are:
        //
        //                      * addCallback(handler)
        //                      * addErrback(handler)
        //                      * callback(result)
        //                      * errback(result)
        //
        //              In general, when a function returns a Deferred, users then "fill
        //              in" the second half of the contract by registering callbacks and
        //              error handlers. You may register as many callback and errback
        //              handlers as you like and they will be executed in the order
        //              registered when a result is provided. Usually this result is
        //              provided as the result of an asynchronous operation. The code
        //              "managing" the Deferred (the code that made the promise to provide
        //              an answer later) will use the callback() and errback() methods to
        //              communicate with registered listeners about the result of the
        //              operation. At this time, all registered result handlers are called
        //              *with the most recent result value*.
        //
        //              Deferred callback handlers are treated as a chain, and each item in
        //              the chain is required to return a value that will be fed into
        //              successive handlers. The most minimal callback may be registered
        //              like this:
        //
        //              |       var d = new dojo.Deferred();
        //              |       d.addCallback(function(result){ return result; });
        //
        //              Perhaps the most common mistake when first using Deferreds is to
        //              forget to return a value (in most cases, the value you were
        //              passed).
        //
        //              The sequence of callbacks is internally represented as a list of
        //              2-tuples containing the callback/errback pair.  For example, the
        //              following call sequence:
        //              
        //              |       var d = new dojo.Deferred();
        //              |       d.addCallback(myCallback);
        //              |       d.addErrback(myErrback);
        //              |       d.addBoth(myBoth);
        //              |       d.addCallbacks(myCallback, myErrback);
        //
        //              is translated into a Deferred with the following internal
        //              representation:
        //
        //              |       [
        //              |               [myCallback, null],
        //              |               [null, myErrback],
        //              |               [myBoth, myBoth],
        //              |               [myCallback, myErrback]
        //              |       ]
        //
        //              The Deferred also keeps track of its current status (fired).  Its
        //              status may be one of three things:
        //
        //                      * -1: no value yet (initial condition)
        //                      * 0: success
        //                      * 1: error
        //      
        //              A Deferred will be in the error state if one of the following three
        //              conditions are met:
        //
        //                      1. The result given to callback or errback is "instanceof" Error
        //                      2. The previous callback or errback raised an exception while
        //                         executing
        //                      3. The previous callback or errback returned a value
        //                         "instanceof" Error
        //
        //              Otherwise, the Deferred will be in the success state. The state of
        //              the Deferred determines the next element in the callback sequence
        //              to run.
        //
        //              When a callback or errback occurs with the example deferred chain,
        //              something equivalent to the following will happen (imagine
        //              that exceptions are caught and returned):
        //
        //              |       // d.callback(result) or d.errback(result)
        //              |       if(!(result instanceof Error)){
        //              |               result = myCallback(result);
        //              |       }
        //              |       if(result instanceof Error){
        //              |               result = myErrback(result);
        //              |       }
        //              |       result = myBoth(result);
        //              |       if(result instanceof Error){
        //              |               result = myErrback(result);
        //              |       }else{
        //              |               result = myCallback(result);
        //              |       }
        //
        //              The result is then stored away in case another step is added to the
        //              callback sequence.      Since the Deferred already has a value
        //              available, any new callbacks added will be called immediately.
        //
        //              There are two other "advanced" details about this implementation
        //              that are useful:
        //
        //              Callbacks are allowed to return Deferred instances themselves, so
        //              you can build complicated sequences of events with ease.
        //
        //              The creator of the Deferred may specify a canceller.  The canceller
        //              is a function that will be called if Deferred.cancel is called
        //              before the Deferred fires. You can use this to implement clean
        //              aborting of an XMLHttpRequest, etc. Note that cancel will fire the
        //              deferred with a CancelledError (unless your canceller returns
        //              another kind of error), so the errbacks should be prepared to
        //              handle that error for cancellable Deferreds.
        // example:
        //      |       var deferred = new dojo.Deferred();
        //      |       setTimeout(function(){ deferred.callback({success: true}); }, 1000);
        //      |       return deferred;
        // example:
        //              Deferred objects are often used when making code asynchronous. It
        //              may be easiest to write functions in a synchronous manner and then
        //              split code using a deferred to trigger a response to a long-lived
        //              operation. For example, instead of register a callback function to
        //              denote when a rendering operation completes, the function can
        //              simply return a deferred:
        //
        //              |       // callback style:
        //              |       function renderLotsOfData(data, callback){
        //              |               var success = false
        //              |               try{
        //              |                       for(var x in data){
        //              |                               renderDataitem(data[x]);
        //              |                       }
        //              |                       success = true;
        //              |               }catch(e){ }
        //              |               if(callback){
        //              |                       callback(success);
        //              |               }
        //              |       }
        //
        //              |       // using callback style
        //              |       renderLotsOfData(someDataObj, function(success){
        //              |               // handles success or failure
        //              |               if(!success){
        //              |                       promptUserToRecover();
        //              |               }
        //              |       });
        //              |       // NOTE: no way to add another callback here!!
        // example:
        //              Using a Deferred doesn't simplify the sending code any, but it
        //              provides a standard interface for callers and senders alike,
        //              providing both with a simple way to service multiple callbacks for
        //              an operation and freeing both sides from worrying about details
        //              such as "did this get called already?". With Deferreds, new
        //              callbacks can be added at any time.
        //
        //              |       // Deferred style:
        //              |       function renderLotsOfData(data){
        //              |               var d = new dojo.Deferred();
        //              |               try{
        //              |                       for(var x in data){
        //              |                               renderDataitem(data[x]);
        //              |                       }
        //              |                       d.callback(true);
        //              |               }catch(e){ 
        //              |                       d.errback(new Error("rendering failed"));
        //              |               }
        //              |               return d;
        //              |       }
        //
        //              |       // using Deferred style
        //              |       renderLotsOfData(someDataObj).addErrback(function(){
        //              |               promptUserToRecover();
        //              |       });
        //              |       // NOTE: addErrback and addCallback both return the Deferred
        //              |       // again, so we could chain adding callbacks or save the
        //              |       // deferred for later should we need to be notified again.
        // example:
        //              In this example, renderLotsOfData is syncrhonous and so both
        //              versions are pretty artificial. Putting the data display on a
        //              timeout helps show why Deferreds rock:
        //
        //              |       // Deferred style and async func
        //              |       function renderLotsOfData(data){
        //              |               var d = new dojo.Deferred();
        //              |               setTimeout(function(){
        //              |                       try{
        //              |                               for(var x in data){
        //              |                                       renderDataitem(data[x]);
        //              |                               }
        //              |                               d.callback(true);
        //              |                       }catch(e){ 
        //              |                               d.errback(new Error("rendering failed"));
        //              |                       }
        //              |               }, 100);
        //              |               return d;
        //              |       }
        //
        //              |       // using Deferred style
        //              |       renderLotsOfData(someDataObj).addErrback(function(){
        //              |               promptUserToRecover();
        //              |       });
        //
        //              Note that the caller doesn't have to change his code at all to
        //              handle the asynchronous case.

        this.chain = [];
        this.id = this._nextId();
        this.fired = -1;
        this.paused = 0;
        this.results = [null, null];
        this.canceller = canceller;
        this.silentlyCancelled = false;
};

dojo.extend(dojo.Deferred, {
        /*
        makeCalled: function(){
                // summary:
                //              returns a new, empty deferred, which is already in the called
                //              state. Calling callback() or errback() on this deferred will
                //              yeild an error and adding new handlers to it will result in
                //              them being called immediately.
                var deferred = new dojo.Deferred();
                deferred.callback();
                return deferred;
        },

        toString: function(){
                var state;
                if(this.fired == -1){
                        state = 'unfired';
                }else{
                        state = this.fired ? 'success' : 'error';
                }
                return 'Deferred(' + this.id + ', ' + state + ')';
        },
        */

        _nextId: (function(){
                var n = 1;
                return function(){ return n++; };
        })(),

        cancel: function(){
                // summary:     
                //              Cancels a Deferred that has not yet received a value, or is
                //              waiting on another Deferred as its value.
                // description:
                //              If a canceller is defined, the canceller is called. If the
                //              canceller did not return an error, or there was no canceller,
                //              then the errback chain is started.
                var err;
                if(this.fired == -1){
                        if(this.canceller){
                                err = this.canceller(this);
                        }else{
                                this.silentlyCancelled = true;
                        }
                        if(this.fired == -1){
                                if(!(err instanceof Error)){
                                        var res = err;
                                        err = new Error("Deferred Cancelled");
                                        err.dojoType = "cancel";
                                        err.cancelResult = res;
                                }
                                this.errback(err);
                        }
                }else if(       (this.fired == 0) &&
                                        (this.results[0] instanceof dojo.Deferred)
                ){
                        this.results[0].cancel();
                }
        },
                        

        _resback: function(res){
                // summary:
                //              The private primitive that means either callback or errback
                this.fired = ((res instanceof Error) ? 1 : 0);
                this.results[this.fired] = res;
                this._fire();
        },

        _check: function(){
                if(this.fired != -1){
                        if(!this.silentlyCancelled){
                                throw new Error("already called!");
                        }
                        this.silentlyCancelled = false;
                        return;
                }
        },

        callback: function(res){
                //      summary:        
                //              Begin the callback sequence with a non-error value.
                
                /*
                callback or errback should only be called once on a given
                Deferred.
                */
                this._check();
                this._resback(res);
        },

        errback: function(/*Error*/res){
                //      summary: 
                //              Begin the callback sequence with an error result.
                this._check();
                if(!(res instanceof Error)){
                        res = new Error(res);
                }
                this._resback(res);
        },

        addBoth: function(/*Function|Object*/cb, /*String?*/cbfn){
                //      summary:
                //              Add the same function as both a callback and an errback as the
                //              next element on the callback sequence.This is useful for code
                //              that you want to guarantee to run, e.g. a finalizer.
                var enclosed = dojo.hitch.apply(dojo, arguments);
                return this.addCallbacks(enclosed, enclosed);
        },

        addCallback: function(/*Function|Object*/cb, /*String?*/cbfn /*...*/){
                //      summary: 
                //              Add a single callback to the end of the callback sequence.
                return this.addCallbacks(dojo.hitch.apply(dojo, arguments));
        },

        addErrback: function(cb, cbfn){
                //      summary: 
                //              Add a single callback to the end of the callback sequence.
                return this.addCallbacks(null, dojo.hitch.apply(dojo, arguments));
        },

        addCallbacks: function(cb, eb){
                // summary: 
                //              Add separate callback and errback to the end of the callback
                //              sequence.
                this.chain.push([cb, eb])
                if(this.fired >= 0){
                        this._fire();
                }
                return this;
        },

        _fire: function(){
                // summary: 
                //              Used internally to exhaust the callback sequence when a result
                //              is available.
                var chain = this.chain;
                var fired = this.fired;
                var res = this.results[fired];
                var self = this;
                var cb = null;
                while(
                        (chain.length > 0) &&
                        (this.paused == 0)
                ){
                        // Array
                        var f = chain.shift()[fired];
                        if(!f){ continue; }
                        try{
                                res = f(res);
                                fired = ((res instanceof Error) ? 1 : 0);
                                if(res instanceof dojo.Deferred){
                                        cb = function(res){
                                                self._resback(res);
                                                // inlined from _pause()
                                                self.paused--;
                                                if(
                                                        (self.paused == 0) && 
                                                        (self.fired >= 0)
                                                ){
                                                        self._fire();
                                                }
                                        }
                                        // inlined from _unpause
                                        this.paused++;
                                }
                        }catch(err){
                                console.debug(err);
                                fired = 1;
                                res = err;
                        }
                }
                this.fired = fired;
                this.results[fired] = res;
                if((cb)&&(this.paused)){
                        // this is for "tail recursion" in case the dependent
                        // deferred is already fired
                        res.addBoth(cb);
                }
        }
});

}