#

API Docs for: 3.10.3
Show: Inherited Protected Private Deprecated

# File: io/js/io-queue.js

    /**
    Extends IO to implement Queue for synchronous
    transaction processing.
    @module io
    @submodule io-queue
    @for IO
    **/
    var io = Y.io._map['io:0'] || new Y.IO();

    Y.mix(Y.IO.prototype, {
       /**
        * Array of transactions queued for processing
        *
        * @property _q
        * @private
        * @static
        * @type {Object}
        */
        _q: new Y.Queue(),
        _qActiveId: null,
        _qInit: false,

       /**
        * Property to determine whether the queue is set to
        * 1 (active) or 0 (inactive).  When inactive, transactions
        * will be stored in the queue until the queue is set to active.
        *
        * @property _qState
        * @private
        * @static
        * @type {Number}
        */
        _qState: 1,

       /**
        * Method Process the first transaction from the
        * queue in FIFO order.
        *
        * @method _qShift
        * @private
        * @static
        */
        _qShift: function() {
            var io = this,
                o = io._q.next();

            io._qActiveId = o.id;
            io._qState = 0;
            io.send(o.uri, o.cfg, o.id);
        },

       /**
        * Method for queueing a transaction before the request is sent to the
        * resource, to ensure sequential processing.
        *
        * @method queue
        * @static
        * @return {Object}
        */
        queue: function(uri, c) {
            var io = this,
                o = { uri: uri, cfg:c, id: this._id++ };

            if(!io._qInit) {
                Y.on('io:complete', function(id, o) { io._qNext(id); }, io);
                io._qInit = true;
            }

            io._q.add(o);
            if (io._qState === 1) {
                io._qShift();
            }

            Y.log('Object queued.  Transaction id is' + o.id, 'info', 'io');
            return o;
        },

        _qNext: function(id) {
            var io = this;
            io._qState = 1;
            if (io._qActiveId === id && io._q.size() > 0) {
                io._qShift();
            }
        },

       /**
        * Method for promoting a transaction to the top of the queue.
        *
        * @method promote
        * @static
        */
        qPromote: function(o) {
            this._q.promote(o);
        },

       /**
        * Method for removing a specific, pending transaction from
        * the queue.
        *
        * @method remove
        * @private
        * @static
        */
        qRemove: function(o) {
            this._q.remove(o);
        },

       /**
        * Method for cancel all pending transaction from
        * the queue.
        *
        * @method empty
        * @static
        * @since 3.7.3
        */
        qEmpty: function() {
            this._q = new Y.Queue();
        },

        qStart: function() {
            var io = this;
            io._qState = 1;

            if (io._q.size() > 0) {
                io._qShift();
            }
            Y.log('Queue started.', 'info', 'io');
        },

       /**
        * Method for setting queue processing to inactive.
        * Transaction requests to YUI.io.queue() will be stored in the queue, but
        * not processed until the queue is reset to "active".
        *
        * @method _stop
        * @private
        * @static
        */
        qStop: function() {
            this._qState = 0;
            Y.log('Queue stopped.', 'info', 'io');
        },

       /**
        * Method to query the current size of the queue.
        *
        * @method _size
        * @private
        * @static
        * @return {Number}
        */
        qSize: function() {
            return this._q.size();
        }

    }, true);

    function _queue(u, c) {
        return io.queue.apply(io, [u, c]);
    }

    _queue.start = function () { io.qStart(); };
    _queue.stop = function () { io.qStop(); };
    _queue.promote = function (o) { io.qPromote(o); };
    _queue.remove = function (o) { io.qRemove(o); };
    _queue.size = function () { io.qSize(); };
    _queue.empty = function () { io.qEmpty(); };
    Y.io.queue = _queue;