#

API Docs for: 3.10.3
Show: Inherited Protected Private Deprecated

# File: parallel/js/parallel.js

    /**
    * A concurrent parallel processor to help in running several async functions.
    * @module parallel
    * @main parallel
    */

    /**
    A concurrent parallel processor to help in running several async functions.

        var stack = new Y.Parallel();

        for (var i = 0; i < 15; i++) {
            Y.io('./api/json/' + i, {
                on: {
                    success: stack.add(function() {
                        Y.log('Done!');
                    })
                }
            });
        }

        stack.done(function() {
            Y.log('All IO requests complete!');
        });

    @class Parallel
    @param {Object} o A config object
    @param {Object} [o.context=Y] The execution context of the callback to done

    */

    Y.Parallel = function(o) {
        this.config = o || {};
        this.results = [];
        this.context = this.config.context || Y;
        this.total = 0;
        this.finished = 0;
    };

    Y.Parallel.prototype = {
        /**
        * An Array of results from all the callbacks in the stack
        * @property results
        * @type Array
        */

        results: null,
        /**
        * The total items in the stack
        * @property total
        * @type Number
        */
        total: null,
        /**
        * The number of stacked callbacks executed
        * @property finished
        * @type Number
        */
        finished: null,
        /**
        * Add a callback to the stack
        * @method add
        * @param {Function} fn The function callback we are waiting for
        */
        add: function (fn) {
            var self = this,
                index = self.total;

            self.total += 1;

            return function () {
                self.finished++;
                self.results[index] = (fn && fn.apply(self.context, arguments)) ||
                    (arguments.length === 1 ? arguments[0] : Y.Array(arguments));

                self.test();
            };
        },
        /**
        * Test to see if all registered items in the stack have completed, if so call the callback to `done`
        * @method test
        */
        test: function () {
            var self = this;
            if (self.finished >= self.total && self.callback) {
                self.callback.call(self.context, self.results, self.data);
            }
        },
        /**
        * The method to call when all the items in the stack are complete.
        * @method done
        * @param {Function} callback The callback to execute on complete
        * @param {Mixed} callback.results The results of all the callbacks in the stack
        * @param {Mixed} [callback.data] The data given to the `done` method
        * @param {Mixed} data Mixed data to pass to the success callback
        */
        done: function (callback, data) {
            this.callback = callback;
            this.data = data;
            this.test();
        }
    };