text: /**
   * @private
   */
  Ext.define('Ext.AbstractManager', {
  
      /* Begin Definitions */
  
      requires: ['Ext.util.HashMap'],
  
      /* End Definitions */
  
      typeName: 'type',
  
      constructor: function(config) {
          Ext.apply(this, config || {});
  
          /**
           * @property {Ext.util.HashMap} all
           * Contains all of the items currently managed
           */
          this.all = Ext.create('Ext.util.HashMap');
  
          this.types = {};
      },
  
      /**
       * Returns an item by id.
       * For additional details see {@link Ext.util.HashMap#get}.
       * @param {String} id The id of the item
       * @return {Object} The item, undefined if not found.
       */
      get : function(id) {
          return this.all.get(id);
      },
  
      /**
       * Registers an item to be managed
       * @param {Object} item The item to register
       */
      register: function(item) {
          this.all.add(item);
      },
  
      /**
       * Unregisters an item by removing it from this manager
       * @param {Object} item The item to unregister
       */
      unregister: function(item) {
          this.all.remove(item);
      },
  
      /**
       * Registers a new item constructor, keyed by a type key.
       * @param {String} type The mnemonic string by which the class may be looked up.
       * @param {Function} cls The new instance class.
       */
      registerType : function(type, cls) {
          this.types[type] = cls;
          cls[this.typeName] = type;
      },
  
      /**
       * Checks if an item type is registered.
       * @param {String} type The mnemonic string by which the class may be looked up
       * @return {Boolean} Whether the type is registered.
       */
      isRegistered : function(type){
          return this.types[type] !== undefined;
      },
  
      /**
       * Creates and returns an instance of whatever this manager manages, based on the supplied type and
       * config object.
       * @param {Object} config The config object
       * @param {String} defaultType If no type is discovered in the config object, we fall back to this type
       * @return {Object} The instance of whatever this manager is managing
       */
      create: function(config, defaultType) {
          var type        = config[this.typeName] || config.type || defaultType,
              Constructor = this.types[type];
  
          //<debug>
          if (Constructor == undefined) {
              Ext.Error.raise("The '" + type + "' type has not been registered with this manager");
          }
          //</debug>
  
          return new Constructor(config);
      },
  
      /**
       * Registers a function that will be called when an item with the specified id is added to the manager.
       * This will happen on instantiation.
       * @param {String} id The item id
       * @param {Function} fn The callback function. Called with a single parameter, the item.
       * @param {Object} scope The scope (this reference) in which the callback is executed.
       * Defaults to the item.
       */
      onAvailable : function(id, fn, scope){
          var all = this.all,
              item;
  
          if (all.containsKey(id)) {
              item = all.get(id);
              fn.call(scope || item, item);
          } else {
              all.on('add', function(map, key, item){
                  if (key == id) {
                      fn.call(scope || item, item);
                      all.un('add', fn, scope);
                  }
              });
          }
      },
  
      /**
       * Executes the specified function once for each item in the collection.
       * @param {Function} fn The function to execute.
       * @param {String} fn.key The key of the item
       * @param {Number} fn.value The value of the item
       * @param {Number} fn.length The total number of items in the collection
       * @param {Boolean} fn.return False to cease iteration.
       * @param {Object} scope The scope to execute in. Defaults to `this`.
       */
      each: function(fn, scope){
          this.all.each(fn, scope || this);
      },
  
      /**
       * Gets the number of items in the collection.
       * @return {Number} The number of items in the collection.
       */
      getCount: function(){
          return this.all.getCount();
      }
  });
  