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