/**
 * @class Ext.data.schema.Schema
 * @extend Ext.Base
 * @mixins Ext.mixin.Factoryable
 * @alias schema.default
 *
 * A Schema is a collection of related {@link Ext.data.Model entities} and their respective
 * {@link Ext.data.schema.Association associations}.
 * 
 * # Schema Instances
 * 
 * By default a single instance of this class is created which serves as the schema for all
 * entities that do not have an explicit `{@link Ext.data.Model#cfg-schema schema}` config
 * either specified or inherited. This is sufficient in most cases.
 * 
 * When an entity does specify a `{@link Ext.data.Model#cfg-schema schema}`, however, that
 * looks up (or creates) an instance for that entity class which is then inherited.
 * 
 * **Important:** All related entities *must* belong to a single schema instance in order
 * to properly link up their associations.
 * 
 * ## Configuring Schemas
 * 
 * The best way to control the configuration of your `schema` is to define a base class for
 * all of your entities and use the `{@link Ext.data.Model#cfg-schema schema}` config like
 * this:
 * 
 *      Ext.define('MyApp.model.Base', {
 *          extend: 'Ext.data.Model',
 *
 *          // This configures the default schema because we don't assign an "id":
 *          schema: {
 *              // configs go here
 *          }
 *      });
 * 
 * **Note:** Only one explicit configuration can be applied to the default schema. In most
 * applications this will not be an issue.
 *
 * By using a base class for your entities you can ensure that the default schema is fully
 * configured before declaration of your classes proceeds. This is especially helpful if
 * you need to set the `namespace` for your schema (see below).
 *
 * ## Relative Naming
 * 
 * When describing associations between entities, it is desirable to use shorthand names
 * that do not contain the common namespace portion. This is called the `entityName` as
 * opposed to its class name. By default, the `entityName` is the full class name. However,
 * if a namespace is used, the common portion can be discarded and we can derive a shorter name.
 * In the following code, `"MyApp.model.Foo"` has an `entityName` of `"Foo"` and the schema has
 * a `namespace` of "MyApp.model".
 * 
 * If you use deeper nesting for entities, you may need to set the `namespace` config to
 * account for this. For example:
 * 
 *      Ext.define('MyApp.model.Base', {
 *          extend: 'Ext.data.Model',
 *
 *          schema: {
 *              namespace: 'MyApp.model'
 *          }
 *      });
 *
 * Your derived classes now will generate proper default `entityName` values even if they
 * have further namespaces. For example, "MyApp.model.foo.Thing" will produce "foo.Thing"
 * as the `entityName` given the above as a base class.
 *
 * # Association Naming
 * 
 * There are various terms involved when describing associations. Perhaps the simplest
 * example that will clarify these terms is that of the common many-to-many association
 * of User and Group.
 * 
 *   * `entityName` - The names "User" and "Group" are the `entityName` values associated
 *   with these two classes. These are derived from their full classnames (perhaps
 *   something like "App.model.User" and "App.model.Group").
 *   
 *   * `associationName` - When talking about associations, especially the many-to-many
 *   variety, it is important to give them names. Associations are not owned by either of
 *   the entities involved, so this name is similar to an `entityName`. In the case of
 *   "User" and "Group", the default `associationName` would be "GroupUsers".
 *   
 *   * `left` and `right` - Associations describe a relationship between two entities. To
 *   talk about specific associations we would use the `entityName` of the parties (such
 *   as "User" or "Group"). When discussing associations in the abstract, however, it is
 *   very helpful to be able to talk about the entities in an association in a general way.
 *   In the case of the "GroupUsers" association, "User" is said to be the `left` while
 *   "Group" is said to be the `right`. In a many-to-many association the selection of
 *   `left` and `right` is arbitrary. When a foreign-key is involved, the `left` entity
 *   is the one containing the foreign-key.
 *
 * ## Custom Naming Conventions
 * 
 * One of the jobs the the `Schema` is to manage name generation (such as `entityName`).
 * This job is delegated to a class called the `namer`. If you need to generate names in
 * other ways, you can provide a custom `namer` for your classes:
 *
 *      Ext.define('MyApp.model.Base', {
 *          extend: 'Ext.data.Model',
 *
 *          schema: {
 *              namespace: 'MyApp.model',
 *              namer: 'custom'
 *          }
 *      });
 *
 * This will create a class using the alias "namer.custom". For example:
 *
 *      Ext.define('MyApp.model.CustomNamer', {
 *          extend: 'Ext.data.schema.Namer',
 *
 *          alias: 'namer.custom',
 *          ...
 *      });
 *
 * For details see the documentation for {@link Ext.data.schema.Namer Namer}.
 */
 
/**
 * @method get
 * Returns the `Schema` instance given its `id` or config object. If only the `id`
 * is specified, that `Schema` instance is looked up and returned. If there is no
 * instance already created, the `id` is assumed to be the `type`. For example:
 *
 *      schema: 'foo'
 *
 * Would be created from the alias `"schema.foo"` and assigned the `id` of "foo"
 * as well.
 *
 * @param {String/Object} config The id, type or config object of the schema.
 * @param {String} [config.type] The type alias of the schema. A "schema." prefix
 * is added to this string, if provided, to complete the alias. This should match
 * match the "alias" of some class derived from `Ext.data.schema.Schema`.
 * @return {Ext.data.schema.Schema} The previously existing or newly created
 * instance.
 * @static
 */
 
/**
 * @cfg {Object} defaultIdentifier 
 * This config is used to initialize the `{@link Ext.data.Model#identifier}` config
 * for classes that do not define one.
 * @accessor
 */
 
/**
 * @cfg {String/Object/Ext.data.schema.Namer} [namer="default"]
 * Specifies or configures the name generator for the schema.
 * @accessor
 */
 
/**
 * @cfg {String} namespace 
 * The namespace for entity classes in this schema.
 * @accessor
 */
 
/**
 * @cfg {Object/Ext.util.ObjectTemplate} proxy
 * This is a template used to produce `Ext.data.proxy.Proxy` configurations for
 * Models that do not define an explicit `{@link Ext.data.Model#cfg-proxy proxy}`.
 *
 * This template is processed with the Model class as the data object which means
 * any static properties of the Model are available. The most useful of these are
 *
 *  * `prefix` - The `urlPrefix` property of this instance.
 *  * `entityName` - The {@link Ext.data.Model#entityName name} of the Model
 *      (for example, "User").
 *  * `schema` - This instance.
 *  @accessor
 */
 
/**
 * @cfg {String} [urlPrefix=""]
 * This is the URL prefix used for all requests to the server. It could be something
 * like "/~api". This value is included in the `proxy` template data as "prefix".
 * @accessor
 */
 
/**
 * @method getAssociation
 * Returns an `Association` by name.
 * @param {String} name The name of the association.
 * @return {Ext.data.schema.Association} The association instance.
 */
 
/**
 * @method getEntity
 * Returns an entity by name.
 * @param {String} name The name of the entity
 * @return {Ext.data.Model} The entity class.
 */
 
/**
 * @method getEntityName
 * Get the entity name taking into account the {@link #namespace}.
 * @param {String/Ext.data.Model} cls The model class or name of the class.
 * @return {String} The entity name
 */
 
/**
 * @method hasAssociations
 * Checks if the passed entity has attached associations that need to be read when
 * using nested loading.
 *
 * @param {String/Ext.Class/Ext.data.Model} name The name, instance, or Model class.
 * @return {Boolean} `true` if there are associations attached to the entity.
 */
 
/**
 * @method hasEntity
 * Checks if an entity is defined
 * @param {String/Ext.data.Model} entity The name or model
 * @return {Boolean} True if this entity is defined
 */