• Classes
• Modules
• Everything

 /**
 * Stores the subscriber information to be used when the event fires.
 * @param {Function} fn The wrapped function to execute.
 * @param {Object} context The value of the keyword 'this' in the listener.
 * @param {Array} args* 0..n additional arguments to supply the listener.
 *
 * @class Subscriber
 * @constructor
 */
 Y.Subscriber = function(fn, context, args, when) {
 
 /**
 * The callback that will be execute when the event fires
 * This is wrapped by Y.rbind if obj was supplied.
 * @property fn
 * @type Function
 */
 this.fn = fn;
 
 /**
 * Optional 'this' keyword for the listener
 * @property context
 * @type Object
 */
 this.context = context;
 
 /**
 * Unique subscriber id
 * @property id
 * @type String
 */
 this.id = Y.guid();
 
 /**
 * Additional arguments to propagate to the subscriber
 * @property args
 * @type Array
 */
 this.args = args;
 
 this._when = when;
 
 /**
 * Custom events for a given fire transaction.
 * @property events
 * @type {EventTarget}
 */
 // this.events = null;
 
 /**
 * This listener only reacts to the event once
 * @property once
 */
 // this.once = false;
 
 };
 
 Y.Subscriber.prototype = {
 constructor: Y.Subscriber,
 
 _notify: function(c, args, ce) {
 if (this.deleted && !this.postponed) {
 if (this.postponed) {
 delete this.fn;
 delete this.context;
 } else {
 delete this.postponed;
 return null;
 }
 }
 var a = this.args, ret;
 switch (ce.signature) {
 case 0:
 ret = this.fn.call(c, ce.type, args, c);
 break;
 case 1:
 ret = this.fn.call(c, args[0] || null, c);
 break;
 default:
 if (a || args) {
 args = args || [];
 a = (a) ? args.concat(a) : args;
 ret = this.fn.apply(c, a);
 } else {
 ret = this.fn.call(c);
 }
 }
 
 if (this.once) {
 ce._delete(this);
 }
 
 return ret;
 },
 
 /**
 * Executes the subscriber.
 * @method notify
 * @param args {Array} Arguments array for the subscriber.
 * @param ce {CustomEvent} The custom event that sent the notification.
 */
 notify: function(args, ce) {
 var c = this.context,
 ret = true;
 
 if (!c) {
 c = (ce.contextFn) ? ce.contextFn() : ce.context;
 }
 
 // only catch errors if we will not re-throw them.
 if (Y.config && Y.config.throwFail) {
 ret = this._notify(c, args, ce);
 } else {
 try {
 ret = this._notify(c, args, ce);
 } catch (e) {
 Y.error(this + ' failed: ' + e.message, e);
 }
 }
 
 return ret;
 },
 
 /**
 * Returns true if the fn and obj match this objects properties.
 * Used by the unsubscribe method to match the right subscriber.
 *
 * @method contains
 * @param {Function} fn the function to execute.
 * @param {Object} context optional 'this' keyword for the listener.
 * @return {boolean} true if the supplied arguments match this
 * subscriber's signature.
 */
 contains: function(fn, context) {
 if (context) {
 return ((this.fn === fn) && this.context === context);
 } else {
 return (this.fn === fn);
 }
 },
 
 valueOf : function() {
 return this.id;
 }
 
 };