Class Table Of Contents

- All Classes
- All Files
- API
  - comb
    - logging
      - PropertyConfigurator
      - Level
      - BasicConfigurator
      - Logger
      - appenders
        - RollingFileAppender
        - ConsoleAppender
        - Appender
        - FileAppender
        - JSONAppender
    - PromiseList
    - Promise
    - regexp
    - array
    - string
    - collections
      - Pool
      - Iterable
      - HashTable
      - MaxHeap
      - Heap
      - Stack
      - AVLTree
      - AnderssonTree
      - Collection
      - RedBlackTree
      - Tree
      - Queue
      - BinaryTree
      - PriorityQueue
      - MinHeap
    - plugins
      - Middleware
      - Broadcaster
    - number
    - characters
    - date
- comb.Promise
- Methods
  - addCallback
  - addErrback
  - callback
  - chain
  - chainBoth
  - errback
  - then

# Class comb.Promise

Defined in: promise.js.

Class Detail
comb.Promise()
Promise object used for handling a thread

#### Example 1 :

             var myFunc = function(){
                 var promise = new Promise();
                 //callback the promise after 10 Secs
                 setTimeout(hitch(promise, "callback"), 10000);
                 return promise;
             }
             var myFunc2 = function(){
                 var promises =[];
                 for(var i = 0; i < 10; i++){
                     promises.push(myFunc);
                 }
                 //create a new promise list with all 10 promises
                 return new PromiseList(promises);
             }

             myFunc.then(do something...)
             myFunc.addCallback(do something...)
             myFunc.cain(myfunc).then(do something...)
             myFunc.cain(myfunc).addCallback(do something...)

             myFunc2.then(do something...)
             myFunc2.addCallback(do something...)
             myFunc2.cain(myfunc).then(do something...)
             myFunc2.cain(myfunc).addCallback(do something...)

    this.__errorCbs = [];
    this.__cbs = [];

Method Detail
addCallback(cb)
Add a callback to the callback chain of the promise

Parameters:
{Function} cb
  the function to callback when the promise is resolved

    if (cb) {
        if (this.__fired && this.__results) {
            cb.apply(this, this.__results);
        } else {
            this.__cbs.push(cb);
        }
    }
    return this;

addErrback(cb)
Add a callback to the errback chain of the promise

Parameters:
{Function} cb
  the function to callback when the promise errors

    if (cb) {
        if (this.__fired && this.__error) {
            cb.apply(this, this.__error);
        } else {
            this.__errorCbs.push(cb);
        }
    }

callback(anything)
When called all functions registered as callbacks are called with the passed in results.

Parameters:
anything
  variable number of results to pass back to listeners of the promise

    if (this.__fired) {
        throw new Error("Already fired!");
    }
    this.__results = Array.prototype.slice.call(arguments);
    this.__resolve();
    return this;

chain(callback, errback)
Call to chaining of promises

Parameters:
callback
  method to call that returns a promise to call after this one completes.
errback
  method to call if this promise errors.

    var promise = new Promise();
    this.addCallback(function(results){
        callback.call(this, results).then(hitch(promise, "callback"), hitch(promise, "errback"));
    });
    this.addErrback(errback);
    return promise;

{comb.Promise} chainBoth(callback)
Applies the same function that returns a promise to both the callback and errback.

Parameters:
{Function} callback
  function to call. This function must return a Promise

Returns:
  {comb.Promise} a promise to continue chaining or to resolve with.

    var p = this.chain(callback);
    this.addErrback(function(results){
        callback.call(this, results).then(hitch(p, "callback"), hitch(p, "errback"));
    });
    return p;

errback(anything)
When called all functions registered as errbacks are called with the passed in error(s)

Parameters:
anything
  variable number of errors to pass back to listeners of the promise

    if (this.__fired) {
        throw new Error(i);
    }
    this.__error = Array.prototype.slice.call(arguments);
    this.__resolve();
    return this;

then(callback, errback)
Call to specify action to take after promise completes or errors

Parameters:
{Function} callback Optional, Default: null
  function to call after the promise completes successfully
{Function} errback Optional, Default: null
  function to call if the promise errors

    this.addCallback(callback);
    this.addErrback(errback);
    return this;

Documentation generated by JsDoc Toolkit 2.4.0 on Tue Jan 31 2012 16:14:12 GMT-0600 (CST)