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();
                }
            };