// @tag class 
/**
 * @class Ext.Base
 *
 * The root of all classes created with {@link Ext#define}.
 *
 * Ext.Base is the building block of all Ext classes. All classes in Ext inherit from Ext.Base.
 * All prototype and static members of this class are inherited by all other classes.
 */
Ext.Base = (function(flexSetter) {
// @define Ext.Base 
// @require Ext.Util 
// @require Ext.Version 
// @require Ext.Configurator 
// @uses Ext.ClassManager 
var noArgs = [],
    baseStaticMember,
    baseStaticMembers = [],
    //<debug> 
    makeDeprecatedMethod = function (oldName, newName, msg) {
        var message = '"'+ oldName +'" is deprecated.';
 
        if (msg) {
            message += ' ' + msg;
        } else if (newName) {
            message += ' Please use "'+ newName +'" instead.';
        }
 
        return function () {
            Ext.raise(message);
        };
    },
    addDeprecatedProperty = function (object, oldName, newName, message) {
        if (!message) {
            message = '"' + oldName + '" is deprecated.';
        }
        if (newName) {
            message += ' Please use "' + newName + '" instead.';
        }
 
        if (message) {
            Ext.Object.defineProperty(object, oldName, {
                get: function() {
                    Ext.raise(message);
                },
                set: function(value) {
                    Ext.raise(message);
                },
                configurable: true
            });
        }
    },
    //</debug> 
    makeAliasFn = function (name) {
        return function () {
            return this[name].apply(this, arguments);
        };
    },
    Version = Ext.Version,
    leadingDigitRe = /^\d/,
    oneMember = {},
    aliasOneMember = {},
    Base = function(){},
    BasePrototype = Base.prototype,
    Reaper;
 
    Ext.Reaper = Reaper = {
        delay: 100,
        queue: [],
        timer: null,
 
        add: function (obj) {
            if (!Reaper.timer) {
                Reaper.timer = Ext.defer(Reaper.tick, Reaper.delay);
            }
 
            Reaper.queue.push(obj);
        },
 
        flush: function () {
            if (Reaper.timer) {
                Ext.undefer(Reaper.timer);
                Reaper.timer = null;
            }
 
            var queue = Reaper.queue,
                n = queue.length,
                i, obj;
 
            Reaper.queue = [];
 
            for (= 0; i < n; ++i) {
                obj = queue[i];
 
                if (obj && obj.$reap) {
                    obj.$reap();
                }
            }
        },
 
        tick: function () {
            Reaper.timer = null;
            Reaper.flush();
        }
    };
 
    // These static properties will be copied to every newly created class with {@link Ext#define} 
    Ext.apply(Base, {
        $className: 'Ext.Base',
 
        $isClass: true,
 
        /**
         * Create a new instance of this Class.
         *
         *     Ext.define('My.cool.Class', {
         *         ...
         *     });
         *
         *     My.cool.Class.create({
         *         someConfig: true
         *     });
         *
         * All parameters are passed to the constructor of the class.
         *
         * @return {Object} the created instance.
         * @static
         * @inheritable
         */
        create: function() {
            return Ext.create.apply(Ext, [this].concat(Array.prototype.slice.call(arguments, 0)));
        },
 
        /**
         * This method applies a versioned, deprecation declaration to this class. This
         * is typically called by the `deprecated` config.
         * @private
         */
        addDeprecations: function (deprecations) {
            var me = this,
                all = [],
                compatVersion = Ext.getCompatVersion(deprecations.name),
                //<debug> 
                configurator = me.getConfigurator(),
                displayName = (me.$className || '') + '#',
                //</debug> 
                deprecate, versionSpec, index, message, target,
                enabled, existing, fn, names, oldName, newName, member, statics, version;
 
            for (versionSpec in deprecations) {
                if (leadingDigitRe.test(versionSpec)) {
                    version = new Ext.Version(versionSpec);
                    version.deprecations = deprecations[versionSpec];
                    all.push(version);
                }
            }
 
            all.sort(Version.compare);
 
            for (index = all.length; index--; ) {
                deprecate = (version = all[index]).deprecations;
                target = me.prototype;
                statics = deprecate.statics;
 
                // If user specifies, say 4.2 compatibility and we have a 5.0 deprecation 
                // then that block needs to be "enabled" to "revert" to behaviors prior 
                // to 5.0. By default, compatVersion === currentVersion, so there are no 
                // enabled blocks. In dev mode we still want to visit all the blocks and 
                // possibly add shims to detect use of deprecated methods, but in a build 
                // (if the deprecated block remains somehow) we just break the loop. 
                enabled = compatVersion && compatVersion.lt(version);
 
                //<debug> 
                if (!enabled) {} else
                //</debug> 
                if (!enabled) {
                    // we won't get here in dev mode when !enabled 
                    break;
                }
 
                while (deprecate) {
                    names = deprecate.methods;
                    if (names) {
                        for (oldName in names) {
                            member = names[oldName];
                            fn = null;
 
                            if (!member) {
                                /*
                                 * Something like:
                                 *
                                 *      '5.1': {
                                 *          methods: {
                                 *              removedMethod: null
                                 *          }
                                 *      }
                                 *
                                 * Since there is no recovering the method, we always put
                                 * on a shim to catch abuse.
                                 */
 
                                //<debug> 
                                // The class should not already have a method by the oldName 
                                Ext.Assert.isNotDefinedProp(target, oldName);
 
                                fn = makeDeprecatedMethod(displayName + oldName);
                                //</debug> 
                            } else if (Ext.isString(member)) {
                                /*
                                 * Something like:
                                 *
                                 *      '5.1': {
                                 *          methods: {
                                 *              oldName: 'newName'
                                 *          }
                                 *      }
                                 *
                                 * If this block is enabled, we just put an alias in place.
                                 * Otherwise we need to inject a
                                 */
 
                                //<debug> 
                                // The class should not already have a method by the oldName 
                                Ext.Assert.isNotDefinedProp(target, oldName);
                                Ext.Assert.isDefinedProp(target, member);
                                //</debug> 
 
                                if (enabled) {
                                    // This call to the real method name must be late 
                                    // bound if it is to pick up overrides and such. 
                                    fn = makeAliasFn(member);
                                }
                                //<debug> 
                                else {
                                    fn = makeDeprecatedMethod(displayName + oldName, member);
                                }
                                //</debug> 
                            } else {
                                /*
                                 * Something like:
                                 *
                                 *      '5.1': {
                                 *          methods: {
                                 *              foo: function () { ... }
                                 *          }
                                 *      }
                                 *
                                 * Or this:
                                 *
                                 *      '5.1': {
                                 *          methods: {
                                 *              foo: {
                                 *                  fn: function () { ... },
                                 *                  message: 'Please use "bar" instead.'
                                 *              }
                                 *          }
                                 *      }
                                 *
                                 * Or just this:
                                 *
                                 *      '5.1': {
                                 *          methods: {
                                 *              foo: {
                                 *                  message: 'Use something else instead.'
                                 *              }
                                 *          }
                                 *      }
                                 *
                                 * If this block is enabled, and "foo" is an existing
                                 * method, than we apply the given method as an override.
                                 * If "foo" is not existing, we simply add the method.
                                 *
                                 * If the block is not enabled and there is no existing
                                 * method by that name, than we add a shim to prevent
                                 * abuse.
                                 */
                                message = '';
                                if (member.message || member.fn) {
                                    //<debug> 
                                    message = member.message;
                                    //</debug> 
                                    member = member.fn;
                                }
 
                                existing = target.hasOwnProperty(oldName) && target[oldName];
 
                                if (enabled && member) {
                                    member.$owner = me;
                                    member.$name = oldName;
                                    //<debug> 
                                    member.name = displayName + oldName;
                                    //</debug> 
                                    if (existing) {
                                        member.$previous = existing;
                                    }
 
                                    fn = member;
                                }
                                //<debug> 
                                else if (!existing) {
                                    fn = makeDeprecatedMethod(displayName + oldName, null,
                                                              message);
                                }
                                //</debug> 
                            }
 
                            if (fn) {
                                target[oldName] = fn;
                            }
                        } // for oldName 
                    }
 
                    //------------------------------------- 
                    // Debug only 
                    //<debug> 
 
                    names = deprecate.configs;
                    if (names) {
                        // 
                        //  '6.0': { 
                        //      configs: { 
                        //          dead: null, 
                        // 
                        //          renamed: 'newName', 
                        // 
                        //          removed: { 
                        //              message: 'This config was replaced by pixie dust' 
                        //          } 
                        //      } 
                        //  } 
                        // 
                        configurator.addDeprecations(names);
                    }
 
                    names = deprecate.properties;
                    if (names && !enabled) {
                        // For properties about the only thing we can do is (on Good 
                        // Browsers), add warning shims for accessing them. So if the 
                        // block is enabled, we don't want those. 
                        for (oldName in names) {
                            newName = names[oldName];
 
                            if (Ext.isString(newName)) {
                                addDeprecatedProperty(target, displayName + oldName, newName);
                            } else if (newName && newName.message) {
                                addDeprecatedProperty(target, displayName + oldName, null,
                                                      newName.message);
                            } else {
                                addDeprecatedProperty(target, displayName + oldName);
                            }
                        }
                    }
 
                    //</debug> 
                    //------------------------------------- 
 
                    // reset to handle statics and apply them to the class 
                    deprecate = statics;
                    statics = null;
                    target = me;
                }
            }
        },
 
        /**
         * @private
         * @static
         * @inheritable
         * @param parentClass
         */
        extend: function (parentClass) {
            var me = this,
                parentPrototype = parentClass.prototype,
                prototype, name, statics;
 
            prototype = me.prototype = Ext.Object.chain(parentPrototype);
            prototype.self = me;
 
            me.superclass = prototype.superclass = parentPrototype;
 
            if (!parentClass.$isClass) {
                for (name in BasePrototype) {
                    if (name in prototype) {
                        prototype[name] = BasePrototype[name];
                    }
                }
            }
 
            //<feature classSystem.inheritableStatics> 
            // Statics inheritance 
            statics = parentPrototype.$inheritableStatics;
 
            if (statics) {
                for (name in statics) {
                    if (!me.hasOwnProperty(name)) {
                        me[name] = parentClass[name];
                    }
                }
            }
            //</feature> 
 
            if (parentClass.$onExtended) {
                me.$onExtended = parentClass.$onExtended.slice();
            }
 
            //<feature classSystem.config> 
            me.getConfigurator();
            //</feature> 
        },
 
        /**
         * @private
         * @static
         * @inheritable
         */
        $onExtended: [],
 
        /**
         * @private
         * @static
         * @inheritable
         */
        triggerExtended: function() {
            //<debug> 
            Ext.classSystemMonitor && Ext.classSystemMonitor(this, 'Ext.Base#triggerExtended', arguments);
            //</debug> 
 
            var callbacks = this.$onExtended,
                ln = callbacks.length,
                i, callback;
 
            if (ln > 0) {
                for (= 0; i < ln; i++) {
                    callback = callbacks[i];
                    callback.fn.apply(callback.scope || this, arguments);
                }
            }
        },
 
        /**
         * @private
         * @static
         * @inheritable
         */
        onExtended: function(fn, scope) {
            this.$onExtended.push({
                fn: fn,
                scope: scope
            });
 
            return this;
        },
 
        /**
         * Add / override static properties of this class.
         *
         *     Ext.define('My.cool.Class', {
         *         ...
         *     });
         *
         *     My.cool.Class.addStatics({
         *         someProperty: 'someValue',      // My.cool.Class.someProperty = 'someValue'
         *         method1: function() { ... },    // My.cool.Class.method1 = function() { ... };
         *         method2: function() { ... }     // My.cool.Class.method2 = function() { ... };
         *     });
         *
         * @param {Object} members 
         * @return {Ext.Base} this
         * @static
         * @inheritable
         */
        addStatics: function (members) {
            this.addMembers(members, true);
            return this;
        },
 
        /**
         * @private
         * @static
         * @inheritable
         * @param {Object} members 
         */
        addInheritableStatics: function(members) {
            var me = this,
                proto = me.prototype,
                inheritableStatics = me.$inheritableStatics,
                name, member, current;
 
            if (!inheritableStatics) {
                inheritableStatics = Ext.apply({}, proto.$inheritableStatics);
                me.$inheritableStatics = proto.$inheritableStatics = inheritableStatics;
            }
 
            //<debug> 
            var className = Ext.getClassName(me) + '.';
            //</debug> 
 
            for (name in members) {
                if (members.hasOwnProperty(name)) {
                    member = members[name];
                    current = me[name];
                    //<debug> 
                    if (typeof member == 'function') {
                        member.name = className + name;
                    }
                    //</debug> 
                    if (typeof current === 'function' && !current.$isClass && !current.$nullFn) {
                        member.$previous = current;
                    }
                    me[name] = member;
                    inheritableStatics[name] = true;
                }
            }
 
            return me;
        },
 
        /**
         * Add methods / properties to the prototype of this class.
         *
         *     Ext.define('My.awesome.Cat', {
         *         constructor: function() {
         *             ...
         *         }
         *     });
         *
         *      My.awesome.Cat.addMembers({
         *          meow: function() {
         *             alert('Meowww...');
         *          }
         *      });
         *
         *      var kitty = new My.awesome.Cat();
         *      kitty.meow();
         *
         * @param {Object} members The members to add to this class.
         * @param {Boolean} [isStatic=false] Pass `true` if the members are static.
         * @param {Boolean} [privacy=false] Pass `true` if the members are private. This
         * only has meaning in debug mode and only for methods.
         * @static
         * @inheritable
         */
        addMembers: function (members, isStatic, privacy) {
            var me = this, // this class 
                cloneFunction = Ext.Function.clone,
                target = isStatic ? me : me.prototype,
                defaultConfig = !isStatic && target.defaultConfig,
                enumerables = Ext.enumerables,
                privates = members.privates,
                configs, i, ln, member, name, subPrivacy, privateStatics;
 
            //<debug> 
            var displayName = (me.$className || '') + '#';
            //</debug> 
 
            if (privates) {
                // This won't run for normal class private members but will pick up all 
                // others (statics, overrides, etc). 
                delete members.privates;
                if (!isStatic) {
                    privateStatics = privates.statics;
                    delete privates.statics;
                }
 
                //<debug> 
                subPrivacy = privates.privacy || privacy || 'framework';
                //</debug> 
 
                me.addMembers(privates, isStatic, subPrivacy);
                if (privateStatics) {
                    me.addMembers(privateStatics, true, subPrivacy);
                }
            }
 
            for (name in members) {
                if (members.hasOwnProperty(name)) {
                    member = members[name];
 
                    //<debug> 
                    if (privacy === true) {
                        privacy = 'framework';
                    }
                    if (member && member.$nullFn && privacy !== member.$privacy) {
                        Ext.raise('Cannot use stock function for private method ' +
                            (me.$className ? me.$className + '#' : '') + name);
                    }
                    //</debug> 
 
                    if (typeof member === 'function' && !member.$isClass && !member.$nullFn) {
                        if (member.$owner) {
                            member = cloneFunction(member);
                        }
 
                        if (target.hasOwnProperty(name)) {
                            member.$previous = target[name];
                        }
 
                        // This information is needed by callParent() and callSuper() as 
                        // well as statics() and even Ext.fly(). 
                        member.$owner = me;
                        member.$name = name;
 
                        //<debug> 
                        member.name = displayName + name;
 
                        var existing = target[name];
 
                        if (privacy) {
                            member.$privacy = privacy;
 
                            // The general idea here is that an existing, non-private 
                            // method can be marked private. This is because the other 
                            // way is strictly forbidden (private method going public) 
                            // so if a method is in that gray area it can only be made 
                            // private in doc form which allows a derived class to make 
                            // it public. 
                            if (existing && existing.$privacy && existing.$privacy !== privacy) {
                                Ext.privacyViolation(me, existing, member, isStatic);
                            }
                        } else if (existing && existing.$privacy) {
                            Ext.privacyViolation(me, existing, member, isStatic);
                        }
                        //</debug> 
                    // The last part of the check here resolves a conflict if we have the same property 
                    // declared as both a config and a member on the class so that the config wins. 
                    } else if (defaultConfig && (name in defaultConfig) && !target.config.hasOwnProperty(name)) {
                        // This is a config property so it must be added to the configs 
                        // collection not just smashed on the prototype... 
                        (configs || (configs = {}))[name] = member;
                        continue;
                    }
 
                    target[name] = member;
                }
            }
 
            if (configs) {
                // Add any configs found in the normal members arena: 
                me.addConfig(configs);
            }
 
            if (enumerables) {
                for (= 0, ln = enumerables.length; i < ln; ++i) {
                    if (members.hasOwnProperty(name = enumerables[i])) {
                        member = members[name];
 
                        // The enumerables are all functions... 
                        if (member && !member.$nullFn) {
                            if (member.$owner) {
                                member = cloneFunction(member);
                            }
 
                            member.$owner = me;
                            member.$name = name;
                            //<debug> 
                            member.name = displayName + name;
                            //</debug> 
 
                            if (target.hasOwnProperty(name)) {
                                member.$previous = target[name];
                            }
                        }
 
                        target[name] = member;
                    }
                }
            }
 
            return this;
        },
 
        /**
         * @private
         * @static
         * @inheritable
         * @param name
         * @param member
         */
        addMember: function (name, member) {
            oneMember[name] = member;
            this.addMembers(oneMember);
            delete oneMember[name];
            return this;
        },
 
        /**
         * Borrow another class' members to the prototype of this class.
         *
         *     Ext.define('Bank', {
         *         money: '$$$',
         *         printMoney: function() {
         *             alert('$$$$$$$');
         *         }
         *     });
         *
         *     Ext.define('Thief', {
         *         ...
         *     });
         *
         *     Thief.borrow(Bank, ['money', 'printMoney']);
         *
         *     var steve = new Thief();
         *
         *     alert(steve.money); // alerts '$$$'
         *     steve.printMoney(); // alerts '$$$$$$$'
         *
         * @param {Ext.Base} fromClass The class to borrow members from
         * @param {Array/String} members The names of the members to borrow
         * @return {Ext.Base} this
         * @static
         * @inheritable
         * @private
         */
        borrow: function(fromClass, members) {
            //<debug> 
            Ext.classSystemMonitor && Ext.classSystemMonitor(this, 'Ext.Base#borrow', arguments);
            //</debug> 
 
            var prototype = fromClass.prototype,
                membersObj = {},
                i, ln, name;
 
            members = Ext.Array.from(members);
 
            for (= 0,ln = members.length; i < ln; i++) {
                name = members[i];
                membersObj[name] = prototype[name];
            }
 
            return this.addMembers(membersObj);
        },
 
        /**
         * Override members of this class. Overridden methods can be invoked via
         * {@link Ext.Base#method!callParent}.
         *
         *     Ext.define('My.Cat', {
         *         constructor: function() {
         *             alert("I'm a cat!");
         *         }
         *     });
         *
         *     My.Cat.override({
         *         constructor: function() {
         *             alert("I'm going to be a cat!");
         *
         *             this.callParent(arguments);
         *
         *             alert("Meeeeoooowwww");
         *         }
         *     });
         *
         *     var kitty = new My.Cat(); // alerts "I'm going to be a cat!"
         *                               // alerts "I'm a cat!"
         *                               // alerts "Meeeeoooowwww"
         *
         * Direct use of this method should be rare. Use {@link Ext#define Ext.define}
         * instead:
         *
         *     Ext.define('My.CatOverride', {
         *         override: 'My.Cat',
         *         constructor: function() {
         *             alert("I'm going to be a cat!");
         *
         *             this.callParent(arguments);
         *
         *             alert("Meeeeoooowwww");
         *         }
         *     });
         *
         * The above accomplishes the same result but can be managed by the {@link Ext.Loader}
         * which can properly order the override and its target class and the build process
         * can determine whether the override is needed based on the required state of the
         * target class (My.Cat).
         *
         * @param {Object} members The properties to add to this class. This should be
         * specified as an object literal containing one or more properties.
         * @return {Ext.Base} this class
         * @static
         * @inheritable
         */
        override: function(members) {
            var me = this,
                statics = members.statics,
                inheritableStatics = members.inheritableStatics,
                config = members.config,
                mixins = members.mixins,
                cachedConfig = members.cachedConfig;
 
            if (statics || inheritableStatics || config) {
                members = Ext.apply({}, members);
            }
 
            if (statics) {
                me.addMembers(statics, true);
                delete members.statics;
            }
 
            if (inheritableStatics){
                me.addInheritableStatics(inheritableStatics);
                delete members.inheritableStatics;
            }
 
            if (members.platformConfig) {
                me.addPlatformConfig(members);
            }
 
            if (config) {
                me.addConfig(config);
                delete members.config;
            }
 
            if (cachedConfig) {
                me.addCachedConfig(cachedConfig);
                delete members.cachedConfig;
            }
 
            delete members.mixins;
 
            me.addMembers(members);
            if (mixins) {
                me.mixin(mixins);
            }
            return me;
        },
 
        addPlatformConfig: function (data) {
            var me = this,
                prototype = me.prototype,
                platformConfigs = data.platformConfig,
                added, classConfigs, configs, configurator, keys, name, value, i, ln;
 
            delete prototype.platformConfig;
 
            //<debug> 
            if (platformConfigs instanceof Array) {
                throw new Error('platformConfigs must be specified as an object.');
            }
            //</debug> 
 
            configurator = me.getConfigurator();
            classConfigs = configurator.configs;
 
            // Get the keys shortest to longest (ish). 
            keys = Ext.getPlatformConfigKeys(platformConfigs);
 
            // To leverage the Configurator#add method, we want to generate potentially 
            // two objects to pass in: "added" and "hoisted". For any properties in an 
            // active platformConfig rule that set proper Configs in the base class, we 
            // need to put them in "added". If instead of the proper Config coming from 
            // a base class, it comes from this class's config block, we still need to 
            // put that config in "added" but we also need move the class-level config 
            // out of "config" and into "hoisted". 
            // 
            // This will ensure that the config defined at the class level is added to 
            // the Configurator first. 
            for (= 0, ln = keys.length; i < ln; ++i) {
                configs = platformConfigs[keys[i]];
                added = null;
 
                for (name in configs) {
                    value = configs[name];
 
                    // We have a few possibilities for each config name: 
                    if (name in classConfigs) {
                        //  It is a proper Config defined by a base class. 
                        (added || (added = {}))[name] = value;
                    } else {
                        //  It is just a property to put on the prototype. 
                        prototype[name] = value;
                    }
                }
 
                if (added) {
                    configurator.add(added);
                }
            }
        },
 
        /**
         * @protected
         * @static
         * @inheritable
         */
        callParent: function(args) {
            var method;
 
            // This code is intentionally inlined for the least amount of debugger stepping 
            return (method = this.callParent.caller) && (method.$previous ||
                  ((method = method.$owner ? method : method.caller) &&
                        method.$owner.superclass.self[method.$name])).apply(this, args || noArgs);
        },
 
        /**
         * @protected
         * @static
         * @inheritable
         */
        callSuper: function(args) {
            var method;
 
            // This code is intentionally inlined for the least amount of debugger stepping 
            return (method = this.callSuper.caller) &&
                    ((method = method.$owner ? method : method.caller) &&
                      method.$owner.superclass.self[method.$name]).apply(this, args || noArgs);
        },
 
        //<feature classSystem.mixins> 
        /**
         * Used internally by the mixins pre-processor
         * @private
         * @static
         * @inheritable
         */
        mixin: function(name, mixinClass) {
            var me = this,
                mixin, prototype, key, statics, i, ln,
                mixinName,  mixinValue, mixins,
                mixinStatics, staticName;
 
            if (typeof name !== 'string') {
                mixins = name;
                if (mixins instanceof Array) {
                    for (= 0,ln = mixins.length; i < ln; i++) {
                        mixin = mixins[i];
                        me.mixin(mixin.prototype.mixinId || mixin.$className, mixin);
                    }
                } else {
                    // Not a string or array - process the object form: 
                    // mixins: { 
                    //     foo: ... 
                    // } 
                    for (mixinName in mixins) {
                        me.mixin(mixinName, mixins[mixinName]);
                    }
                }
                return;
            }
 
            mixin = mixinClass.prototype;
            prototype = me.prototype;
 
            if (mixin.onClassMixedIn) {
                mixin.onClassMixedIn.call(mixinClass, me);
            }
 
            if (!prototype.hasOwnProperty('mixins')) {
                if ('mixins' in prototype) {
                    prototype.mixins = Ext.Object.chain(prototype.mixins);
                }
                else {
                    prototype.mixins = {};
                }
            }
 
            for (key in mixin) {
                mixinValue = mixin[key];
                if (key === 'mixins') {
                    // if 2 superclasses (e.g. a base class and a mixin) of this class both 
                    // have a mixin with the same id, the first one wins, that is to say, 
                    // the first mixin's methods to be applied to the prototype will not 
                    // be overwritten by the second one.  Since this is the case we also 
                    // want to make sure we use the first mixin's prototype as the mixin 
                    // reference, hence the "applyIf" below.  A real world example of this 
                    // is Ext.Widget which mixes in Ext.mixin.Observable.  Ext.Widget can 
                    // be mixed into subclasses of Ext.Component, which mixes in 
                    // Ext.util.Observable.  In this example, since the first "observable" 
                    // mixin's methods win, we also want its reference to be preserved. 
                    Ext.applyIf(prototype.mixins, mixinValue);
                }
                else if (!(key === 'mixinId' || key === 'config' || key === '$inheritableStatics') && (prototype[key] === undefined)) {
                    prototype[key] = mixinValue;
                }
            }
 
            //<feature classSystem.inheritableStatics> 
            // Mixin statics inheritance 
            statics = mixin.$inheritableStatics;
 
            if (statics) {
                mixinStatics = {};
                for (staticName in statics) {
                    if (!me.hasOwnProperty(staticName)) {
                        mixinStatics[staticName] = mixinClass[staticName];
                    }
                }
                me.addInheritableStatics(mixinStatics);
            }
            //</feature> 
 
            //<feature classSystem.config> 
            if ('config' in mixin) {
                me.addConfig(mixin.config, mixinClass);
            }
            //</feature> 
 
            prototype.mixins[name] = mixin;
 
            if (mixin.afterClassMixedIn) {
                mixin.afterClassMixedIn.call(mixinClass, me);
            }
 
            return me;
        },
        //</feature> 
 
        //<feature classSystem.config> 
        /**
         * Adds new config properties to this class. This is called for classes when they
         * are declared, then for any mixins that class may define and finally for any
         * overrides defined that target the class.
         *
         * @param {Object} config 
         * @param {Ext.Class} [mixinClass] The mixin class if the configs are from a mixin.
         * @private
         * @static
         * @inheritable
         */
        addConfig: function (config, mixinClass) {
            var cfg = this.$config || this.getConfigurator();
            cfg.add(config, mixinClass);
        },
 
        addCachedConfig: function(config, isMixin) {
            var cached = {},
                key;
 
            for (key in config) {
                cached[key] = {
                    cached: true,
                    $value: config[key]
                };
            }
            this.addConfig(cached, isMixin);
        },
 
        /**
         * Returns the `Ext.Configurator` for this class.
         *
         * @return {Ext.Configurator}
         * @private
         * @static
         * @inheritable
         */
        getConfigurator: function () {
            // the Ext.Configurator ctor will set $config so micro-opt out fn call: 
            return this.$config || new Ext.Configurator(this);
        },
        //</feature> 
 
        /**
         * Get the current class' name in string format.
         *
         *     Ext.define('My.cool.Class', {
         *         constructor: function() {
         *             alert(this.self.getName()); // alerts 'My.cool.Class'
         *         }
         *     });
         *
         *     My.cool.Class.getName(); // 'My.cool.Class'
         *
         * @return {String} className 
         * @static
         * @inheritable
         */
        getName: function() {
            return Ext.getClassName(this);
        },
 
        /**
         * Create aliases for existing prototype methods. Example:
         *
         *     Ext.define('My.cool.Class', {
         *         method1: function() { ... },
         *         method2: function() { ... }
         *     });
         *
         *     var test = new My.cool.Class();
         *
         *     My.cool.Class.createAlias({
         *         method3: 'method1',
         *         method4: 'method2'
         *     });
         *
         *     test.method3(); // test.method1()
         *
         *     My.cool.Class.createAlias('method5', 'method3');
         *
         *     test.method5(); // test.method3() -> test.method1()
         *
         * @param {String/Object} alias The new method name, or an object to set multiple aliases. See
         * {@link Ext.Function#flexSetter flexSetter}
         * @param {String/Object} origin The original method name
         * @static
         * @inheritable
         * @method
         */
        createAlias: flexSetter(function(alias, origin) {
            aliasOneMember[alias] = function() {
                return this[origin].apply(this, arguments);
            };
            this.override(aliasOneMember);
            delete aliasOneMember[alias];
        })
    });
 
    // Capture the set of static members on Ext.Base that we want to copy to all 
    // derived classes. This array is used by Ext.Class as well as the optimizer. 
    for (baseStaticMember in Base) {
        if (Base.hasOwnProperty(baseStaticMember)) {
            baseStaticMembers.push(baseStaticMember);
        }
    }
 
    Base.$staticMembers = baseStaticMembers;
 
    //<feature classSystem.config> 
    Base.getConfigurator(); // lazily create now so as not capture in $staticMembers 
    //</feature> 
 
    Base.addMembers({
        /** @private */
        $className: 'Ext.Base',
 
        /**
         * @property {Boolean} isInstance 
         * This value is `true` and is used to identify plain objects from instances of
         * a defined class.
         * @protected
         * @readonly
         */
        isInstance: true,
 
        /**
         * @property {Boolean} [$configPrefixed]
         * The value `true` causes `config` values to be stored on instances using a
         * property name prefixed with an underscore ("_") character. A value of `false`
         * stores `config` values as properties using their exact name (no prefix).
         * @private
         * @since 5.0.0
         */
        $configPrefixed: true,
 
        /**
         * @property {Boolean} [$configStrict]
         * The value `true` instructs the `initConfig` method to only honor values for
         * properties declared in the `config` block of a class. When `false`, properties
         * that are not declared in a `config` block will be placed on the instance.
         * @private
         * @since 5.0.0
         */
        $configStrict: true,
 
        /**
         * @property {Boolean} isConfiguring 
         * This property is set to `true` during the call to `initConfig`.
         * @protected
         * @readonly
         * @since 5.0.0
         */
        isConfiguring: false,
 
        /**
         * @property {Boolean} isFirstInstance 
         * This property is set to `true` if this instance is the first of its class.
         * @protected
         * @readonly
         * @since 5.0.0
         */
        isFirstInstance: false,
 
        /**
         * @property {Boolean} destroyed 
         * This property is set to `true` after the `destroy` method is called.
         * @protected
         */
        destroyed: false,
        
        /**
         * @property {Boolean/"async"} [clearPropertiesOnDestroy=true]
         * Setting this property to `false` will prevent nulling object references
         * on a Class instance after destruction. Setting this to `"async"` will delay
         * the clearing for approx 50ms.
         * @protected
         * @since 6.2.0
         */
        clearPropertiesOnDestroy: true,
        
        /**
         * @property {Boolean} [clearPrototypeOnDestroy=false]
         * Setting this property to `true` will result in setting the object's
         * prototype to `null` after the destruction sequence is fully completed.
         * After that, most attempts at calling methods on the object instance
         * will result in "method not defined" exception. This can be very helpful
         * with tracking down otherwise hard to find bugs like runaway Ajax requests,
         * timed functions not cleared on destruction, etc.
         *
         * Note that this option can only work in browsers that support `Object.setPrototypeOf`
         * method, and is only available in debugging mode.
         * @private
         * @since 6.2.0
         */
        clearPrototypeOnDestroy: false,
 
        /**
         * Get the reference to the class from which this object was instantiated. Note that unlike {@link Ext.Base#self},
         * `this.statics()` is scope-independent and it always returns the class from which it was called, regardless of what
         * `this` points to during run-time
         *
         *     Ext.define('My.Cat', {
         *         statics: {
         *             totalCreated: 0,
         *             speciesName: 'Cat' // My.Cat.speciesName = 'Cat'
         *         },
         *
         *         constructor: function() {
         *             var statics = this.statics();
         *
         *             alert(statics.speciesName);     // always equals to 'Cat' no matter what 'this' refers to
         *                                             // equivalent to: My.Cat.speciesName
         *
         *             alert(this.self.speciesName);   // dependent on 'this'
         *
         *             statics.totalCreated++;
         *         },
         *
         *         clone: function() {
         *             var cloned = new this.self();   // dependent on 'this'
         *
         *             cloned.groupName = this.statics().speciesName;   // equivalent to: My.Cat.speciesName
         *
         *             return cloned;
         *         }
         *     });
         *
         *
         *     Ext.define('My.SnowLeopard', {
         *         extend: 'My.Cat',
         *
         *         statics: {
         *             speciesName: 'Snow Leopard'     // My.SnowLeopard.speciesName = 'Snow Leopard'
         *         },
         *
         *         constructor: function() {
         *             this.callParent();
         *         }
         *     });
         *
         *     var cat = new My.Cat();                 // alerts 'Cat', then alerts 'Cat'
         *
         *     var snowLeopard = new My.SnowLeopard(); // alerts 'Cat', then alerts 'Snow Leopard'
         *
         *     var clone = snowLeopard.clone();
         *     alert(Ext.getClassName(clone));         // alerts 'My.SnowLeopard'
         *     alert(clone.groupName);                 // alerts 'Cat'
         *
         *     alert(My.Cat.totalCreated);             // alerts 3
         *
         * @protected
         * @return {Ext.Class}
         */
        statics: function() {
            var method = this.statics.caller,
                self = this.self;
 
            if (!method) {
                return self;
            }
 
            return method.$owner;
        },
 
        /**
         * Call the "parent" method of the current method. That is the method previously
         * overridden by derivation or by an override (see {@link Ext#define}).
         *
         *      Ext.define('My.Base', {
         *          constructor: function (x) {
         *              this.x = x;
         *          },
         *
         *          statics: {
         *              method: function (x) {
         *                  return x;
         *              }
         *          }
         *      });
         *
         *      Ext.define('My.Derived', {
         *          extend: 'My.Base',
         *
         *          constructor: function () {
         *              this.callParent([21]);
         *          }
         *      });
         *
         *      var obj = new My.Derived();
         *
         *      alert(obj.x);  // alerts 21
         *
         * This can be used with an override as follows:
         *
         *      Ext.define('My.DerivedOverride', {
         *          override: 'My.Derived',
         *
         *          constructor: function (x) {
         *              this.callParent([x*2]); // calls original My.Derived constructor
         *          }
         *      });
         *
         *      var obj = new My.Derived();
         *
         *      alert(obj.x);  // now alerts 42
         *
         * This also works with static and private methods.
         *
         *      Ext.define('My.Derived2', {
         *          extend: 'My.Base',
         *
         *          // privates: {
         *          statics: {
         *              method: function (x) {
         *                  return this.callParent([x*2]); // calls My.Base.method
         *              }
         *          }
         *      });
         *
         *      alert(My.Base.method(10));     // alerts 10
         *      alert(My.Derived2.method(10)); // alerts 20
         *
         * Lastly, it also works with overridden static methods.
         *
         *      Ext.define('My.Derived2Override', {
         *          override: 'My.Derived2',
         *
         *          // privates: {
         *          statics: {
         *              method: function (x) {
         *                  return this.callParent([x*2]); // calls My.Derived2.method
         *              }
         *          }
         *      });
         *
         *      alert(My.Derived2.method(10); // now alerts 40
         *
         * To override a method and replace it and also call the superclass method, use
         * {@link #method-callSuper}. This is often done to patch a method to fix a bug.
         *
         * @protected
         * @param {Array/Arguments} args The arguments, either an array or the `arguments` object
         * from the current method, for example: `this.callParent(arguments)`
         * @return {Object} Returns the result of calling the parent method
         */
        callParent: function(args) {
            // NOTE: this code is deliberately as few expressions (and no function calls) 
            // as possible so that a debugger can skip over this noise with the minimum number 
            // of steps. Basically, just hit Step Into until you are where you really wanted 
            // to be. 
            var method,
                superMethod = (method = this.callParent.caller) && (method.$previous ||
                        ((method = method.$owner ? method : method.caller) &&
                                method.$owner.superclass[method.$name]));
 
            //<debug> 
            if (!superMethod) {
                method = this.callParent.caller;
                var parentClass, methodName;
 
                if (!method.$owner) {
                    if (!method.caller) {
                        throw new Error("Attempting to call a protected method from the public scope, which is not allowed");
                    }
 
                    method = method.caller;
                }
 
                parentClass = method.$owner.superclass;
                methodName = method.$name;
 
                if (!(methodName in parentClass)) {
                    throw new Error("this.callParent() was called but there's no such method (" + methodName +
                                ") found in the parent class (" + (Ext.getClassName(parentClass) || 'Object') + ")");
                }
            }
            //</debug> 
 
            return superMethod.apply(this, args || noArgs);
        },
 
        /**
         * This method is used by an **override** to call the superclass method but
         * bypass any overridden method. This is often done to "patch" a method that
         * contains a bug but for whatever reason cannot be fixed directly.
         *
         * Consider:
         *
         *      Ext.define('Ext.some.Class', {
         *          method: function () {
         *              console.log('Good');
         *          }
         *      });
         *
         *      Ext.define('Ext.some.DerivedClass', {
         *          extend: 'Ext.some.Class',
         *          
         *          method: function () {
         *              console.log('Bad');
         * 
         *              // ... logic but with a bug ...
         *              
         *              this.callParent();
         *          }
         *      });
         *
         * To patch the bug in `Ext.some.DerivedClass.method`, the typical solution is to create an
         * override:
         *
         *      Ext.define('App.patches.DerivedClass', {
         *          override: 'Ext.some.DerivedClass',
         *          
         *          method: function () {
         *              console.log('Fixed');
         * 
         *              // ... logic but with bug fixed ...
         *
         *              this.callSuper();
         *          }
         *      });
         *
         * The patch method cannot use {@link #method-callParent} to call the superclass
         * `method` since that would call the overridden method containing the bug. In
         * other words, the above patch would only produce "Fixed" then "Good" in the
         * console log, whereas, using `callParent` would produce "Fixed" then "Bad"
         * then "Good".
         *
         * @protected
         * @param {Array/Arguments} args The arguments, either an array or the `arguments` object
         * from the current method, for example: `this.callSuper(arguments)`
         * @return {Object} Returns the result of calling the superclass method
         */
        callSuper: function(args) {
            // NOTE: this code is deliberately as few expressions (and no function calls) 
            // as possible so that a debugger can skip over this noise with the minimum number 
            // of steps. Basically, just hit Step Into until you are where you really wanted 
            // to be. 
            var method,
                superMethod = (method = this.callSuper.caller) &&
                        ((method = method.$owner ? method : method.caller) &&
                          method.$owner.superclass[method.$name]);
 
            //<debug> 
            if (!superMethod) {
                method = this.callSuper.caller;
                var parentClass, methodName;
 
                if (!method.$owner) {
                    if (!method.caller) {
                        throw new Error("Attempting to call a protected method from the public scope, which is not allowed");
                    }
 
                    method = method.caller;
                }
 
                parentClass = method.$owner.superclass;
                methodName = method.$name;
 
                if (!(methodName in parentClass)) {
                    throw new Error("this.callSuper() was called but there's no such method (" + methodName +
                                ") found in the parent class (" + (Ext.getClassName(parentClass) || 'Object') + ")");
                }
            }
            //</debug> 
 
            return superMethod.apply(this, args || noArgs);
        },
 
        /**
         * @property {Ext.Class} self
         *
         * Get the reference to the current class from which this object was instantiated. Unlike {@link Ext.Base#statics},
         * `this.self` is scope-dependent and it's meant to be used for dynamic inheritance. See {@link Ext.Base#statics}
         * for a detailed comparison
         *
         *     Ext.define('My.Cat', {
         *         statics: {
         *             speciesName: 'Cat' // My.Cat.speciesName = 'Cat'
         *         },
         *
         *         constructor: function() {
         *             alert(this.self.speciesName); // dependent on 'this'
         *         },
         *
         *         clone: function() {
         *             return new this.self();
         *         }
         *     });
         *
         *
         *     Ext.define('My.SnowLeopard', {
         *         extend: 'My.Cat',
         *         statics: {
         *             speciesName: 'Snow Leopard'         // My.SnowLeopard.speciesName = 'Snow Leopard'
         *         }
         *     });
         *
         *     var cat = new My.Cat();                     // alerts 'Cat'
         *     var snowLeopard = new My.SnowLeopard();     // alerts 'Snow Leopard'
         *
         *     var clone = snowLeopard.clone();
         *     alert(Ext.getClassName(clone));             // alerts 'My.SnowLeopard'
         *
         * @protected
         */
        self: Base,
 
        // Default constructor, simply returns `this` 
        constructor: function() {
            return this;
        },
 
        //<feature classSystem.config> 
        /**
         * Initialize configuration for this class. a typical example:
         *
         *     Ext.define('My.awesome.Class', {
         *         // The default config
         *         config: {
         *             name: 'Awesome',
         *             isAwesome: true
         *         },
         *
         *         constructor: function(config) {
         *             this.initConfig(config);
         *         }
         *     });
         *
         *     var awesome = new My.awesome.Class({
         *         name: 'Super Awesome'
         *     });
         *
         *     alert(awesome.getName()); // 'Super Awesome'
         *
         * @protected
         * @param {Object} instanceConfig 
         * @return {Ext.Base} this
         * @chainable
         */
        initConfig: function(instanceConfig) {
            var me = this,
                cfg = me.self.getConfigurator();
 
            me.initConfig = Ext.emptyFn; // ignore subsequent calls to initConfig 
            me.initialConfig = instanceConfig || {};
            cfg.configure(me, instanceConfig);
 
            return me;
        },
 
        beforeInitConfig: Ext.emptyFn,
 
        /**
         * Returns a specified config property value. If the name parameter is not passed,
         * all current configuration options will be returned as key value pairs.
         * @param {String} [name] The name of the config property to get.
         * @param {Boolean} [peek=false] `true` to peek at the raw value without calling the getter.
         * @param {Boolean} [ifInitialized=false] `true` to only return the initialized property value,
         * not the raw config value, and *not* to trigger initialization. Returns `undefined` if the
         * property has not yet been initialized.
         * @return {Object} The config property value.
         */
        getConfig: function (name, peek, ifInitialized) {
            var me = this,
                ret, cfg, propName;
 
            if (name) {
                cfg = me.self.$config.configs[name];
                if (cfg) {
                    propName = me.$configPrefixed ? cfg.names.internal : name;
 
                    // They only want the fully initialized value, not the initial config, 
                    //  but only if it's already present on this instance. 
                    // They don't want to trigger the initGetter. 
                    // This form is used by Bindable#updatePublishes to initially publish 
                    // the properties it's being asked make publishable. 
                    if (ifInitialized) {
                        ret = me.hasOwnProperty(propName) ? me[propName] : null;
                    }
                    else if (peek) {
                        // Attempt to return the instantiated property on this instance first. 
                        // Only return the config object if it has not yet been pulled through 
                        // the applier into the instance. 
                        ret = me.hasOwnProperty(propName) ? me[propName] : me.config[name];
                    } else {
                        ret = me[cfg.names.get]();
                    }
                } else {
                    ret = me[name];
                }
            } else {
                ret = me.getCurrentConfig();
            }
            return ret;
        },
 
        /**
         * Destroys member properties by name.
         *
         * If a property name is the name of a *config*, the getter is *not* invoked, so
         * if the config has not been initialized, nothing will be done.
         *
         * The property will be destroyed, and the corrected name (if the property is a *config*
         * and config names are prefixed) will set to `null` in this object's dictionary.
         *
         * @param {String...} args One or more names of the properties to destroy and remove from the object.
         */
        destroyMembers: function() {
            var me = this,
                configs = me.self.$config.configs,
                len = arguments.length,
                cfg, name, value, i;
 
            for (= 0; i < len; i++) {
                name = arguments[i];
                cfg = configs[name];
                name = cfg && me.$configPrefixed ? cfg.names.internal : name;
                value = me.hasOwnProperty(name) && me[name];
                if (value) {
                    Ext.destroy(value);
                    me[name] = null;
                }
            }
        },
 
        freezeConfig: function (name) {
            var me = this,
                config = Ext.Config.get(name),
                names = config.names,
                value = me[names.get]();
 
            me[names.set] = function (v) {
                //<debug> 
                if (!== value) {
                    Ext.raise('Cannot change frozen config "' + name + '"');
                }
                //</debug> 
                return me;
            };
 
            //<debug> 
            if (!Ext.isIE8) {
                Object.defineProperty(me, me.$configPrefixed ? names.internal : name, {
                    get: function () {
                        return value;
                    },
                    set: function (v) {
                        if (!== value) {
                            Ext.raise('Cannot change frozen config "' + name + '"');
                        }
                    }
                });
            }
            //</debug> 
        },
 
        /**
         * Sets a single/multiple configuration options.
         * @param {String/Object} name The name of the property to set, or a set of key value pairs to set.
         * @param {Object} [value] The value to set for the name parameter.
         * @param {Object} [options] (private)
         * @return {Ext.Base} this
         */
        setConfig: function (name, value, options) {
            // options can have the following properties: 
            // - defaults `true` to only set the config(s) that have not been already set on 
            // this instance. 
            // - strict `false` to apply properties to the instance that are not configs, 
            // and do not have setters. 
            var me = this,
                configurator,
                config,
                prop;
 
            if (name) {
                configurator = me.self.getConfigurator();
 
                if (typeof name === 'string') {
                    config = configurator.configs[name];
                    if (!config) {
                        if (me.$configStrict) {
                            prop = me.self.prototype[name];
                            if ((typeof prop === 'function') && !prop.$nullFn) {
                                //<debug> 
                                Ext.Error.raise("Cannot override method " + name + " on " + me.$className + " instance.");
                                //</debug> 
                                return me;
                            }
                            //<debug> 
                            else {
                                if (name !== 'type') {
                                    Ext.log.warn('No such config "' + name + '" for class ' +
                                        me.$className);
                                }
                            }
                            //</debug> 
                        }
                        config = Ext.Config.map[name] || Ext.Config.get(name);
                    }
                    if (me[config.names.set]) {
                        me[config.names.set](value);
                    } else {
                        // apply non-config props directly to the instance 
                        me[name] = value;
                    }
                } else {
                    // This should not have "options ||" except that it shipped in that 
                    // broken state, so we use it if present for compat. 
                    configurator.reconfigure(me, name, options || value);
                }
            }
 
            return me;
        },
 
        /**
         * @private
         */
        getCurrentConfig: function() {
            var cfg = this.self.getConfigurator();
 
            return cfg.getCurrentConfig(this);
        },
 
        /**
         * @param {String} name 
         * @private
         */
        hasConfig: function(name) {
            return name in this.defaultConfig;
        },
 
        /**
         * Returns the initial configuration passed to the constructor when
         * instantiating this class.
         *
         * Given this example Ext.button.Button definition and instance:
         *
         *     Ext.define('MyApp.view.Button', {
         *         extend: 'Ext.button.Button',
         *         xtype: 'mybutton',
         *     
         *         scale: 'large',
         *         enableToggle: true
         *     });
         *
         *     var btn = Ext.create({
         *         xtype: 'mybutton',
         *         renderTo: Ext.getBody(),
         *         text: 'Test Button'
         *     });
         *
         * Calling `btn.getInitialConfig()` would return an object including the config
         * options passed to the `create` method:
         *
         *     xtype: 'mybutton',
         *     renderTo: // The document body itself
         *     text: 'Test Button'
         *
         * Calling `btn.getInitialConfig('text')`returns **'Test Button'**.
         *
         * @param {String} [name] Name of the config option to return.
         * @return {Object/Mixed} The full config object or a single config value
         * when `name` parameter specified.
         */
        getInitialConfig: function(name) {
            var config = this.config;
 
            if (!name) {
                return config;
            }
 
            return config[name];
        },
        //</feature> 
 
        $links: null,
 
        /**
         * Adds a "destroyable" object to an internal list of objects that will be destroyed
         * when this instance is destroyed (via `{@link #method!destroy}`).
         * @param {String} name 
         * @param {Object} value 
         * @return {Object} The `value` passed.
         * @private
         */
        link: function (name, value) {
            var me = this,
                links = me.$links || (me.$links = {});
 
            links[name] = true;
            me[name] = value;
 
            return value;
        },
 
        /**
         * Destroys a given set of `{@link #link linked}` objects. This is only needed if
         * the linked object is being destroyed before this instance.
         * @param {String[]} names The names of the linked objects to destroy.
         * @return {Ext.Base} this
         * @private
         */
        unlink: function (names) {
            var me = this,
                i, ln, link, value;
 
            //<debug> 
            if (!Ext.isArray(names)) {
                Ext.raise('Invalid argument - expected array of strings');
            }
            //</debug> 
 
            for (= 0, ln = names.length; i < ln; i++) {
                link = names[i];
                value = me[link];
 
                if (value) {
                    if (value.isInstance && !value.destroyed) {
                        value.destroy();
                    }
                    else if (value.parentNode && 'nodeType' in value) {
                        value.parentNode.removeChild(value);
                    }
                }
 
                me[link] = null;
            }
 
            return me;
        },
 
        $reap: function () {
            var me = this,
                protectedProps = me.$noClearOnDestroy,
                props, prop, value, type, i, len;
            
            // This only returns own keys which is *much* faster than iterating 
            // over the whole prototype chain and calling hasOwnProperty() 
            props = Ext.Object.getKeys(me);
            
            for (= 0, len = props.length; i < len; i++) {
                prop = props[i];
                
                if (!protectedProps || !protectedProps[prop]) {
                    value = me[prop];
                    type = typeof value;
 
                    // Object may retain references to other objects. Functions can do too 
                    // if they are closures, and most of the *own* function properties 
                    // are closures indeed. We skip Ext.emptyFn and the like though, 
                    // they're mostly harmless. 
                    if (type === 'object' || (type === 'function' && !value.$noClearOnDestroy)) {
                        me[prop] = null;
                    }
                }
            }
            
            me.$nulled = true;
 
            //<debug> 
            // We also want to make sure no methods are called on the destroyed object, 
            // because that may lead to accessing nulled properties and resulting exceptions. 
            if (Object.setPrototypeOf) {
                if (me.clearPrototypeOnDestroy && !me.$vetoClearingPrototypeOnDestroy) {
                    props = me.$preservePrototypeProperties;
                    
                    if (props) {
                        for (= 0, len = props.length; i < len; i++) {
                            prop = props[i];
                            
                            if (!me.hasOwnProperty(prop)) {
                                me[prop] = me[prop];
                            }
                        }
                    }
                    
                    Object.setPrototypeOf(me, null);
                }
            }
            //</debug> 
        },
 
        /**
         * This method is called to cleanup an object and its resources. After calling
         * this method, the object should not be used any further in any way, including
         * access to its methods and properties.
         *
         * To prevent potential memory leaks, all object references will be nulled
         * at the end of destruction sequence, unless {@link #clearPropertiesOnDestroy}
         * is set to `false`.
         */
        destroy: function() {
            var me = this,
                links = me.$links,
                clearPropertiesOnDestroy = me.clearPropertiesOnDestroy;
 
            if (links) {
                me.$links = null;
                me.unlink(Ext.Object.getKeys(links));
            }
            
            me.destroy = Ext.emptyFn;
            
            // isDestroyed added for compat reasons 
            me.isDestroyed = me.destroyed = true;
 
            // By this time the destruction is complete. Now we can make sure 
            // no objects are retained by the husk of this ex-Instance. 
            if (clearPropertiesOnDestroy === true) {
                // Observable mixin will call destroyObservable that will reap the properties. 
                if (!me.isObservable) {
                    me.$reap();
                }
            }
            else if (clearPropertiesOnDestroy) {
                //<debug> 
                if (clearPropertiesOnDestroy !== 'async') {
                    Ext.raise('Invalid value for clearPropertiesOnDestroy');
                }
                //</debug> 
 
                Reaper.add(me);
            }
        }
    });
 
    /**
     * @method callOverridden
     * Call the original method that was previously overridden with {@link Ext.Base#override}
     *
     *     Ext.define('My.Cat', {
     *         constructor: function() {
     *             alert("I'm a cat!");
     *         }
     *     });
     *
     *     My.Cat.override({
     *         constructor: function() {
     *             alert("I'm going to be a cat!");
     *
     *             this.callOverridden();
     *
     *             alert("Meeeeoooowwww");
     *         }
     *     });
     *
     *     var kitty = new My.Cat(); // alerts "I'm going to be a cat!"
     *                               // alerts "I'm a cat!"
     *                               // alerts "Meeeeoooowwww"
     *
     * @param {Array/Arguments} args The arguments, either an array or the `arguments` object
     * from the current method, for example: `this.callOverridden(arguments)`
     * @return {Object} Returns the result of calling the overridden method
     * @deprecated 4.1.0 Use {@link #method-callParent} instead.
     * @protected
     */
    BasePrototype.callOverridden = BasePrototype.callParent;
 
    //<debug> 
    Ext.privacyViolation = function (cls, existing, member, isStatic) {
        var name = member.$name,
            conflictCls = existing.$owner && existing.$owner.$className,
            s = isStatic ? 'static ' : '',
            msg = member.$privacy
                ? 'Private ' + s + member.$privacy + ' method "' + name + '"'
                : 'Public ' + s + 'method "' + name + '"';
 
        if (cls.$className) {
            msg = cls.$className + '' + msg;
        }
 
        if (!existing.$privacy) {
            msg += conflictCls
                ? ' hides public method inherited from ' + conflictCls
                : ' hides inherited public method.';
        } else {
            msg += conflictCls
                ? ' conflicts with private ' + existing.$privacy +
                  ' method declared by ' + conflictCls
                : ' conflicts with inherited private ' + existing.$privacy + ' method.';
        }
 
        var compat = Ext.getCompatVersion();
        var ver = Ext.getVersion();
 
        // When compatibility is enabled, log problems instead of throwing errors. 
        if (ver && compat && compat.lt(ver)) {
            Ext.log.error(msg);
        } else {
            Ext.raise(msg);
        }
    };
    
    Ext.Reaper.tick.$skipTimerCheck = true;
    //</debug> 
 
    return Base;
}(Ext.Function.flexSetter));