File: event-custom/js/subscriber.js

            /**
             * 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;
                }
            
            };