API Docs for: 3.8.0
Show:

File: event-custom/js/subscriber.js

  1. /**
  2.  * Stores the subscriber information to be used when the event fires.
  3.  * @param {Function} fn       The wrapped function to execute.
  4.  * @param {Object}   context  The value of the keyword 'this' in the listener.
  5.  * @param {Array} args*       0..n additional arguments to supply the listener.
  6.  *
  7.  * @class Subscriber
  8.  * @constructor
  9.  */
  10. Y.Subscriber = function(fn, context, args, when) {

  12.     /**
  13.      * The callback that will be execute when the event fires
  14.      * This is wrapped by Y.rbind if obj was supplied.
  15.      * @property fn
  16.      * @type Function
  17.      */
  18.     this.fn = fn;

  20.     /**
  21.      * Optional 'this' keyword for the listener
  22.      * @property context
  23.      * @type Object
  24.      */
  25.     this.context = context;

  27.     /**
  28.      * Unique subscriber id
  29.      * @property id
  30.      * @type String
  31.      */
  32.     this.id = Y.stamp(this);

  34.     /**
  35.      * Additional arguments to propagate to the subscriber
  36.      * @property args
  37.      * @type Array
  38.      */
  39.     this.args = args;

  41.     this._when = when;

  43.     /**
  44.      * Custom events for a given fire transaction.
  45.      * @property events
  46.      * @type {EventTarget}
  47.      */
  48.     // this.events = null;

  50.     /**
  51.      * This listener only reacts to the event once
  52.      * @property once
  53.      */
  54.     // this.once = false;

  56. };

  58. Y.Subscriber.prototype = {
  59.     constructor: Y.Subscriber,

  61.     _notify: function(c, args, ce) {
  62.         if (this.deleted && !this.postponed) {
  63.             if (this.postponed) {
  64.                 delete this.fn;
  65.                 delete this.context;
  66.             } else {
  67.                 delete this.postponed;
  68.                 return null;
  69.             }
  70.         }
  71.         var a = this.args, ret;
  72.         switch (ce.signature) {
  73.             case 0:
  74.                 ret = this.fn.call(c, ce.type, args, c);
  75.                 break;
  76.             case 1:
  77.                 ret = this.fn.call(c, args[0] || null, c);
  78.                 break;
  79.             default:
  80.                 if (a || args) {
  81.                     args = args || [];
  82.                     a = (a) ? args.concat(a) : args;
  83.                     ret = this.fn.apply(c, a);
  84.                 } else {
  85.                     ret = this.fn.call(c);
  86.                 }
  87.         }

  89.         if (this.once) {
  90.             ce._delete(this);
  91.         }

  93.         return ret;
  94.     },

  96.     /**
  97.      * Executes the subscriber.
  98.      * @method notify
  99.      * @param args {Array} Arguments array for the subscriber.
  100.      * @param ce {CustomEvent} The custom event that sent the notification.
  101.      */
  102.     notify: function(args, ce) {
  103.         var c = this.context,
  104.             ret = true;

  106.         if (!c) {
  107.             c = (ce.contextFn) ? ce.contextFn() : ce.context;
  108.         }

  110.         // only catch errors if we will not re-throw them.
  111.         if (Y.config && Y.config.throwFail) {
  112.             ret = this._notify(c, args, ce);
  113.         } else {
  114.             try {
  115.                 ret = this._notify(c, args, ce);
  116.             } catch (e) {
  117.                 Y.error(this + ' failed: ' + e.message, e);
  118.             }
  119.         }

  121.         return ret;
  122.     },

  124.     /**
  125.      * Returns true if the fn and obj match this objects properties.
  126.      * Used by the unsubscribe method to match the right subscriber.
  127.      *
  128.      * @method contains
  129.      * @param {Function} fn the function to execute.
  130.      * @param {Object} context optional 'this' keyword for the listener.
  131.      * @return {boolean} true if the supplied arguments match this
  132.      *                   subscriber's signature.
  133.      */
  134.     contains: function(fn, context) {
  135.         if (context) {
  136.             return ((this.fn == fn) && this.context == context);
  137.         } else {
  138.             return (this.fn == fn);
  139.         }
  140.     },
  141.     
  142.     valueOf : function() {
  143.         return this.id;
  144.     }

  146. };

  148.