#

API Docs for: 3.10.3
Show: Inherited Protected Private Deprecated

# 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;
        }

    };