text: /**
   * Copyright 2013-2014, Facebook, Inc.
   * All rights reserved.
   *
   * This source code is licensed under the BSD-style license found in the
   * LICENSE file in the root directory of this source tree. An additional grant
   * of patent rights can be found in the PATENTS file in the same directory.
   *
   * @providesModule CallbackQueue
   */
  
  "use strict";
  
  var PooledClass = require('PooledClass');
  
  var assign = require('Object.assign');
  var invariant = require('invariant');
  
  /**
   * A specialized pseudo-event module to help keep track of components waiting to
   * be notified when their DOM representations are available for use.
   *
   * This implements `PooledClass`, so you should never need to instantiate this.
   * Instead, use `CallbackQueue.getPooled()`.
   *
   * @class ReactMountReady
   * @implements PooledClass
   * @internal
   */
  function CallbackQueue() {
    this._callbacks = null;
    this._contexts = null;
  }
  
  assign(CallbackQueue.prototype, {
  
    /**
     * Enqueues a callback to be invoked when `notifyAll` is invoked.
     *
     * @param {function} callback Invoked when `notifyAll` is invoked.
     * @param {?object} context Context to call `callback` with.
     * @internal
     */
    enqueue: function(callback, context) {
      this._callbacks = this._callbacks || [];
      this._contexts = this._contexts || [];
      this._callbacks.push(callback);
      this._contexts.push(context);
    },
  
    /**
     * Invokes all enqueued callbacks and clears the queue. This is invoked after
     * the DOM representation of a component has been created or updated.
     *
     * @internal
     */
    notifyAll: function() {
      var callbacks = this._callbacks;
      var contexts = this._contexts;
      if (callbacks) {
        invariant(
          callbacks.length === contexts.length,
          "Mismatched list of contexts in callback queue"
        );
        this._callbacks = null;
        this._contexts = null;
        for (var i = 0, l = callbacks.length; i < l; i++) {
          callbacks[i].call(contexts[i]);
        }
        callbacks.length = 0;
        contexts.length = 0;
      }
    },
  
    /**
     * Resets the internal queue.
     *
     * @internal
     */
    reset: function() {
      this._callbacks = null;
      this._contexts = null;
    },
  
    /**
     * `PooledClass` looks for this.
     */
    destructor: function() {
      this.reset();
    }
  
  });
  
  PooledClass.addPoolingTo(CallbackQueue);
  
  module.exports = CallbackQueue;
  