Source: utils/EventEmitter.js

  1. (function() {
  2.   /**
  3.    * EventEmitter utility.
  4.    * @constructor
  5.    */
  6.   tracking.EventEmitter = function() {};
  8.   /**
  9.    * Holds event listeners scoped by event type.
  10.    * @type {object}
  11.    * @private
  12.    */
  13.   tracking.EventEmitter.prototype.events_ = null;
  15.   /**
  16.    * Adds a listener to the end of the listeners array for the specified event.
  17.    * @param {string} event
  18.    * @param {function} listener
  19.    * @return {object} Returns emitter, so calls can be chained.
  20.    */
  21.   tracking.EventEmitter.prototype.addListener = function(event, listener) {
  22.     if (typeof listener !== 'function') {
  23.       throw new TypeError('Listener must be a function');
  24.     }
  25.     if (!this.events_) {
  26.       this.events_ = {};
  27.     }
  29.     this.emit('newListener', event, listener);
  31.     if (!this.events_[event]) {
  32.       this.events_[event] = [];
  33.     }
  35.     this.events_[event].push(listener);
  37.     return this;
  38.   };
  40.   /**
  41.    * Returns an array of listeners for the specified event.
  42.    * @param {string} event
  43.    * @return {array} Array of listeners.
  44.    */
  45.   tracking.EventEmitter.prototype.listeners = function(event) {
  46.     return this.events_ && this.events_[event];
  47.   };
  49.   /**
  50.    * Execute each of the listeners in order with the supplied arguments.
  51.    * @param {string} event
  52.    * @param {*} opt_args [arg1], [arg2], [...]
  53.    * @return {boolean} Returns true if event had listeners, false otherwise.
  54.    */
  55.   tracking.EventEmitter.prototype.emit = function(event) {
  56.     var listeners = this.listeners(event);
  57.     if (listeners) {
  58.       var args = Array.prototype.slice.call(arguments, 1);
  59.       for (var i = 0; i < listeners.length; i++) {
  60.         if (listeners[i]) {
  61.           listeners[i].apply(this, args);
  62.         }
  63.       }
  64.       return true;
  65.     }
  66.     return false;
  67.   };
  69.   /**
  70.    * Adds a listener to the end of the listeners array for the specified event.
  71.    * @param {string} event
  72.    * @param {function} listener
  73.    * @return {object} Returns emitter, so calls can be chained.
  74.    */
  75.   tracking.EventEmitter.prototype.on = tracking.EventEmitter.prototype.addListener;
  77.   /**
  78.    * Adds a one time listener for the event. This listener is invoked only the
  79.    * next time the event is fired, after which it is removed.
  80.    * @param {string} event
  81.    * @param {function} listener
  82.    * @return {object} Returns emitter, so calls can be chained.
  83.    */
  84.   tracking.EventEmitter.prototype.once = function(event, listener) {
  85.     var self = this;
  86.     self.on(event, function handlerInternal() {
  87.       self.removeListener(event, handlerInternal);
  88.       listener.apply(this, arguments);
  89.     });
  90.   };
  92.   /**
  93.    * Removes all listeners, or those of the specified event. It's not a good
  94.    * idea to remove listeners that were added elsewhere in the code,
  95.    * especially when it's on an emitter that you didn't create.
  96.    * @param {string} event
  97.    * @return {object} Returns emitter, so calls can be chained.
  98.    */
  99.   tracking.EventEmitter.prototype.removeAllListeners = function(opt_event) {
  100.     if (!this.events_) {
  101.       return this;
  102.     }
  103.     if (opt_event) {
  104.       delete this.events_[opt_event];
  105.     } else {
  106.       delete this.events_;
  107.     }
  108.     return this;
  109.   };
  111.   /**
  112.    * Remove a listener from the listener array for the specified event.
  113.    * Caution: changes array indices in the listener array behind the listener.
  114.    * @param {string} event
  115.    * @param {function} listener
  116.    * @return {object} Returns emitter, so calls can be chained.
  117.    */
  118.   tracking.EventEmitter.prototype.removeListener = function(event, listener) {
  119.     if (typeof listener !== 'function') {
  120.       throw new TypeError('Listener must be a function');
  121.     }
  122.     if (!this.events_) {
  123.       return this;
  124.     }
  126.     var listeners = this.listeners(event);
  127.     if (Array.isArray(listeners)) {
  128.       var i = listeners.indexOf(listener);
  129.       if (i < 0) {
  130.         return this;
  131.       }
  132.       listeners.splice(i, 1);
  133.     }
  135.     return this;
  136.   };
  138.   /**
  139.    * By default EventEmitters will print a warning if more than 10 listeners
  140.    * are added for a particular event. This is a useful default which helps
  141.    * finding memory leaks. Obviously not all Emitters should be limited to 10.
  142.    * This function allows that to be increased. Set to zero for unlimited.
  143.    * @param {number} n The maximum number of listeners.
  144.    */
  145.   tracking.EventEmitter.prototype.setMaxListeners = function() {
  146.     throw new Error('Not implemented');
  147.   };
  149. }());