Ext JS Sencha Docs

Ext.data.schema.Schema

Hierarchy

Ext.Base
Ext.data.schema.Schema

Mixins

Requires

Ext.data.schema.ManyToOne

Files

A Schema is a collection of related entities and their respective 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 schema config either specified or inherited. This is sufficient in most cases.

When an entity does specify a 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 schema config like this:

 Ext.define('MyApp.models.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.models.Foo" has an entityName of "Foo" and the schema has a namespace of "MyApp.models".

If you use deeper nesting for entities, you may need to set the namespace config to account for this. For example:

 Ext.define('MyApp.models.Base', {
     extend: 'Ext.data.Model',

     schema: {
         namespace: 'MyApp.models'
     }
 });

Your derived classes now will generate proper default entityName values even if they have further namespaces. For example, "MyApp.models.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.models.User" and "App.models.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.

  • role - @TODO

  • inverse - @TODO

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.models.Base', {
     extend: 'Ext.data.Model',

     schema: {
         namespace: 'MyApp.models',
         namer: 'custom'
     }
 });

This will create a class using the alias "namer.custom". For example:

 Ext.define('MyApp.models.CustomNamer', {
     extend: 'Ext.data.schema.Namer',

     alias: 'namer.custom',
     ...
 });

For details see the documentation for Namer.

Defined By

Config options

Ext.data.schema.Schema
view source
: Object

This config is used to initialize the Ext.data.Model.identifier config for classes that do not define one.

This config is used to initialize the Ext.data.Model.identifier config for classes that do not define one.

Ext.data.schema.Schema
view source
: Numberprivate
The time to wait (in ms) before checking for null foreign keys on records that will cause them to be dropped. ...

The time to wait (in ms) before checking for null foreign keys on records that will cause them to be dropped. This is useful for allowing records to be moved to a different source.

Defaults to: 10

Available since: 5.0.1

Specifies or configures the name generator for the schema. ...

Specifies or configures the name generator for the schema.

Defaults to: 'default'

Ext.data.schema.Schema
view source
: String

The namespace for entity classes in this schema.

The namespace for entity classes in this schema.

This is a template used to produce Ext.data.proxy.Proxy configurations for Models that do not define an explicit proxy. ...

This is a template used to produce Ext.data.proxy.Proxy configurations for Models that do not define an explicit 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 name of the Model (for example, "User").
  • schema - This instance.

Defaults to: {type: 'ajax', url: '{prefix}/{entityName}'}

Ext.data.schema.Schema
view source
: String
This is the URL prefix used for all requests to the server. ...

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".

Defaults to: ""

Properties

Defined By

Instance properties

...

Defaults to: 'Ext.Base'

The value true causes config values to be stored on instances using a property name prefixed with an underscore ("_")...

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).

Defaults to: false

Available since: 5.0.0

Overrides: Ext.Component.$configPrefixed, Ext.layout.Layout.$configPrefixed, Ext.data.AbstractStore.$configPrefixed, Ext.layout.container.boxOverflow.None.$configPrefixed

The value true instructs the initConfig method to only honor values for properties declared in the config block of a ...

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.

Defaults to: true

Available since: 5.0.0

Overrides: Ext.Component.$configStrict, Ext.layout.Layout.$configStrict, Ext.data.AbstractStore.$configStrict, Ext.layout.container.boxOverflow.None.$configStrict

Ext.data.schema.Schema
view source
: Stringprivate
also configures Factoryable ...

also configures Factoryable

Defaults to: 'schema.'

Ext.data.schema.Schema
view source
: Numberreadonly
The number of associations in this schema. ...

The number of associations in this schema.

Defaults to: 0

Ext.data.schema.Schema
view source
: Numberreadonly
The number of entities in this schema. ...

The number of entities in this schema.

Defaults to: 0

If this property is specified by the target class of this mixin its properties are used to configure the created Ext....

If this property is specified by the target class of this mixin its properties are used to configure the created Ext.Factory.

This property is set to true during the call to initConfig. ...

This property is set to true during the call to initConfig.

Defaults to: false

Available since: 5.0.0

This property is set to true if this instance is the first of its class. ...

This property is set to true if this instance is the first of its class.

Defaults to: false

Available since: 5.0.0

This value is true and is used to identify plain objects from instances of a defined class. ...

This value is true and is used to identify plain objects from instances of a defined class.

Defaults to: true

Ext.data.schema.Schema
view source
: Booleanprivate
...

Defaults to: true

...

Defaults to: 'factoryable'

Overrides: Ext.mixin.Identifiable.mixinId

Ext.data.schema.Schema
view source
: Objectprivate

Private


Private

Get the reference to the current class from which this object was instantiated. ...

Get the reference to the current class from which this object was instantiated. Unlike statics, this.self is scope-dependent and it's meant to be used for dynamic inheritance. See 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'
Ext.data.schema.Schema
view source
: Stringreadonly
The name of the schema's type. ...

The name of the schema's type. This should be the suffix of the alias for this class following the "schema." prefix. For example, if the alias for a schema is "schema.foo" then type should "foo". If an alias is specified on the derived class, this property is set automatically.

Defaults to: 'default'

Defined By

Static properties

...

Defaults to: []

Ext.data.schema.Schema
view source
: Objectprivatereadonlystatic
A collection of Schema instances keyed by its type. ...

A collection of Schema instances keyed by its type.

 var mySchema = Ext.data.schema.Schema.instances.mySchema;

If the Schema may not have been created yet, use the get method to create the instance on first request:

 var mySchema = Ext.data.schema.Schema.get('mySchema');

Defaults to: {}

Methods

Defined By

Instance methods

Ext.data.schema.Schema
view source
new( config ) : Ext.data.schema.Schema
...

Parameters

Returns

Fires

    ( deprecations )private
    This method applies a versioned, deprecation declaration to this class. ...

    This method applies a versioned, deprecation declaration to this class. This is typically called by the deprecated config.

    Parameters

    Ext.data.schema.Schema
    view source
    ( entityType )private
    Adds an entity to this schema. ...

    Adds an entity to this schema.

    Parameters

    Fires

      Ext.data.schema.Schema
      view source
      ( entityType, matrices )private
      Adds the matrix associations of an entity to this schema. ...

      Adds the matrix associations of an entity to this schema.

      Parameters

      Fires

        Ext.data.schema.Schema
        view source
        ( entityType, matrixName, [relation], left, right )protected
        Adds an entry from a matrix config declared by an entity. ...

        Adds an entry from a matrix config declared by an entity.

        This is the ideal method to override in a derived class if the standard, default naming conventions need to be adjusted. In the override, apply whatever logic is appropriate to determine the missing values and pass along the proper results to this method in the callParent.

        Parameters

        • entityType : Ext.Class

          A class derived from Ext.data.Model.

        • matrixName : String

          The name of the matrix association.

        • relation : String (optional)

          A base name for the matrix. For information about the meaning of this see Ext.data.Model.manyToMany.

        • left : Object

          The descriptor for the "left" of the matrix.

          • type : String

            The type of the entity on the "left" of the matrix.

          • field : String (optional)

            The name of the field in the matrix table for the "left" side entity. If not provided, this defaults to the left.type name singularized and uncapitalized followed by "Id". For example, "userId" for a left.type of "Users".

          • role : String (optional)

            The name of the relationship from the left.type to the right.type. If not provided, this defaults to the left.type name pluralized and uncapitalized. For exmaple, "users" for a left.type of "User".

        • right : Object

          The descriptor for the "right" of the matrix.

          • type : String

            The type of the entity on the "right" of the matrix.

          • field : String (optional)

            The name of the field in the matrix table for the "right" side entity. If not provided, this defaults in the same way as left.field except this is based on right.type.

          • role : String (optional)

            The name of the relationship from the right.type to the left.type. If not provided, this defaults in the same way as left.role except this is based on right.type.

        Fires

          Ext.data.schema.Schema
          view source
          ( entityType, [matrixName], matrixDef )private
          Adds an entry from a matrix config declared by an entity. ...

          Adds an entry from a matrix config declared by an entity.

          Parameters

          Fires

            Ext.data.schema.Schema
            view source
            ( entityType, referenceField, [association], [role], [inverse], type, [descr], [unique] )protected
            Adds a reference field association for an entity to this schema. ...

            Adds a reference field association for an entity to this schema.

            This is the ideal method to override in a derived class if the standard, default naming conventions need to be adjusted. In the override, apply whatever logic is appropriate to determine the missing values and pass along the proper results to this method in the callParent.

            Parameters

            • entityType : Ext.Class

              A class derived from Ext.data.Model.

            • referenceField : Ext.data.field.Field

              The field with the reference config.

            • association : String (optional)

              The name of the association. If empty or null, this will be derived from entityType, role, inverse and referenceField.unique.

            • role : String (optional)

              The name of the relationship from entityType to the target type. If not specified, the default is the referenceField.name (minus any "Id" suffix if present).

            • inverse : String (optional)

              The name of the relationship from the target type to the entityType. If not specifed, this is derived from the entityName of the entityType (singularized or pluralized based on referenceField.unique).

            • type : String

              The entityName of the target of the reference.

            • descr : Object (optional)

              The reference descriptor from the referenceField if one was given in the field definition.

            • unique : Boolean (optional)

              Indicates if the reference is one-to-one.

              Defaults to: false

            Fires

              Ext.data.schema.Schema
              view source
              ( entityType, referenceField )private
              Adds a reference field association for an entity to this schema. ...

              Adds a reference field association for an entity to this schema. This method decodes the reference config of the referenceField and calls addReference.

              Parameters

              Fires

                Ext.data.schema.Schema
                view source
                ( identifier )private
                Config ...

                Config

                Parameters

                Ext.data.schema.Schema
                view source
                ( namer )private
                ...

                Parameters

                Ext.data.schema.Schema
                view source
                ( namespace )private
                ...

                Parameters

                Ext.data.schema.Schema
                view source
                ( proxy )private
                ...

                Parameters

                ( args ) : Objectdeprecatedprotected
                Call the original method that was previously overridden with override Ext.define('My.Cat', { constructor: functi...

                Call the original method that was previously overridden with 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"
                

                This method has been deprecated

                Use callParent instead.

                Parameters

                • args : Array/Arguments

                  The arguments, either an array or the arguments object from the current method, for example: this.callOverridden(arguments)

                Returns

                • Object

                  Returns the result of calling the overridden method

                Call the "parent" method of the current method. ...

                Call the "parent" method of the current method. That is the method previously overridden by derivation or by an override (see 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 methods.

                 Ext.define('My.Derived2', {
                     extend: 'My.Base',
                
                     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',
                
                     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 callSuper. This is often done to patch a method to fix a bug.

                Parameters

                • args : Array/Arguments

                  The arguments, either an array or the arguments object from the current method, for example: this.callParent(arguments)

                Returns

                • Object

                  Returns the result of calling the parent method

                This method is used by an override to call the superclass method but bypass any overridden method. ...

                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 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".

                Parameters

                • args : Array/Arguments

                  The arguments, either an array or the arguments object from the current method, for example: this.callSuper(arguments)

                Returns

                • Object

                  Returns the result of calling the superclass method

                This method is called to cleanup an object and its resources. ...
                Ext.data.schema.Schema
                view source
                ( fn, scope )private
                Public ...

                Public

                Parameters

                Ext.data.schema.Schema
                view source
                ( fn, scope )private
                ...

                Parameters

                Returns an Association by name. ...

                Returns an Association by name.

                Parameters

                • name : String

                  The name of the association.

                Returns

                Returns a specified config property value. ...

                Returns a specified config property value. If the name parameter is not passed, all current configuration options will be returned as key value pairs.

                Parameters

                • name : String (optional)

                  The name of the config property to get.

                • peek : Boolean (optional)

                  true to peek at the raw value without calling the getter.

                  Defaults to: false

                Returns

                • Object

                  The config property value.

                Ext.data.schema.Schema
                view source
                ( ) : Object
                Returns the value of defaultIdentifier. ...

                Returns the value of defaultIdentifier.

                Returns

                Ext.data.schema.Schema
                view source
                ( name ) : Ext.data.Model
                Returns an entity by name. ...

                Returns an entity by name.

                Parameters

                • name : String

                  The name of the entity

                Returns

                Ext.data.schema.Schema
                view source
                ( cls ) : String
                Get the entity name taking into account the namespace. ...

                Get the entity name taking into account the namespace.

                Parameters

                Returns

                Fires

                  Returns the initial configuration passed to constructor when instantiating this class. ...

                  Returns the initial configuration passed to constructor when instantiating this class.

                  Parameters

                  • name : String (optional)

                    Name of the config option to return.

                  Returns

                  • Object/Mixed

                    The full config object or a single config value when name parameter specified.

                  Ext.data.schema.Schema
                  view source
                  ( ) : Numberprivate
                  Returns the value of keyCheckDelay. ...

                  Returns the value of keyCheckDelay.

                  Available since: 5.0.1

                  Returns

                  Returns the value of namer. ...

                  Returns the value of namer.

                  Returns

                  Ext.data.schema.Schema
                  view source
                  ( ) : String
                  Returns the value of namespace. ...

                  Returns the value of namespace.

                  Returns

                  Returns the value of proxy. ...

                  Returns the value of proxy.

                  Returns

                  Ext.data.schema.Schema
                  view source
                  ( ) : String
                  Returns the value of urlPrefix. ...

                  Returns the value of urlPrefix.

                  Returns

                  Ext.data.schema.Schema
                  view source
                  ( The ) : Boolean
                  Checks if the passed entity has attached associations that need to be read when using nested loading. ...

                  Checks if the passed entity has attached associations that need to be read when using nested loading.

                  Parameters

                  Returns

                  • Boolean

                    true if there are associations attached to the entity.

                  ...

                  Parameters

                  Ext.data.schema.Schema
                  view source
                  ( entity ) : Boolean
                  Checks if an entity is defined ...

                  Checks if an entity is defined

                  Parameters

                  Returns

                  • Boolean

                    True if this entity is defined

                  Fires

                    ( config ) : Ext.Basechainableprotected
                    Initialize configuration for this class. ...

                    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'
                    

                    Parameters

                    Returns

                    Fires

                      Ext.data.schema.Schema
                      view source
                      ( cls, data )private
                      ...

                      Parameters

                      ...

                      Parameters

                      ( name, [value] ) : Ext.Basechainable
                      Sets a single/multiple configuration options. ...

                      Sets a single/multiple configuration options.

                      Parameters

                      • name : String/Object

                        The name of the property to set, or a set of key value pairs to set.

                      • value : Object (optional)

                        The value to set for the name parameter.

                      Returns

                      Fires

                        Ext.data.schema.Schema
                        view source
                        ( defaultIdentifier )
                        Sets the value of defaultIdentifier. ...

                        Sets the value of defaultIdentifier.

                        Parameters

                        Ext.data.schema.Schema
                        view source
                        ( keyCheckDelay )private
                        Sets the value of keyCheckDelay. ...

                        Sets the value of keyCheckDelay.

                        Available since: 5.0.1

                        Parameters

                        Ext.data.schema.Schema
                        view source
                        ( namer )
                        Sets the value of namer. ...

                        Sets the value of namer.

                        Parameters

                        Ext.data.schema.Schema
                        view source
                        ( namespace )
                        Sets the value of namespace. ...

                        Sets the value of namespace.

                        Parameters

                        Ext.data.schema.Schema
                        view source
                        ( proxy )
                        Sets the value of proxy. ...

                        Sets the value of proxy.

                        Parameters

                        Ext.data.schema.Schema
                        view source
                        ( urlPrefix )
                        Sets the value of urlPrefix. ...

                        Sets the value of urlPrefix.

                        Parameters

                        Get the reference to the class from which this object was instantiated. ...

                        Get the reference to the class from which this object was instantiated. Note that unlike 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
                        

                        Returns

                        Defined By

                        Static methods

                        ( config, [mixinClass] )privatestatic
                        Adds new config properties to this class. ...

                        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.

                        Parameters

                        • config : Object
                        • mixinClass : Class (optional)

                          The mixin class if the configs are from a mixin.

                        ( members )chainableprivatestatic
                        ...

                        Parameters

                        ( name, member )chainableprivatestatic
                        ...

                        Parameters

                        ( members, [isStatic], [privacy] )chainablestatic
                        Add methods / properties to the prototype of this class. ...

                        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();
                        

                        Parameters

                        • members : Object

                          The members to add to this class.

                        • isStatic : Boolean (optional)

                          Pass true if the members are static.

                          Defaults to: false

                        • privacy : Boolean (optional)

                          Pass true if the members are private. This only has meaning in debug mode and only for methods.

                          Defaults to: false

                        ( members ) : Ext.Basechainablestatic
                        Add / override static properties of this class. ...

                        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() { ... };
                        });
                        

                        Parameters

                        Returns

                        ( fromClass, members ) : Ext.Baseprivatestatic
                        Borrow another class' members to the prototype of this class. ...

                        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 '$$$$$$$'
                        

                        Parameters

                        • fromClass : Ext.Base

                          The class to borrow members from

                        • members : Array/String

                          The names of the members to borrow

                        Returns

                        ( args )protectedstatic
                        ...

                        Parameters

                        ( args )protectedstatic
                        ...

                        Parameters

                        Create a new instance of this Class. ...

                        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.

                        Returns

                        ( alias, origin )static
                        Create aliases for existing prototype methods. ...

                        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()
                        

                        Parameters

                        ( config )privatestatic
                        ...

                        Parameters

                        Ext.data.schema.Schema
                        view source
                        ( config ) : Ext.data.schema.Schemastatic
                        Returns the Schema instance given its id or config object. ...

                        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.

                        Parameters

                        • config : String/Object

                          The id, type or config object of the schema.

                          • type : String (optional)

                            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.

                        Returns

                        Returns the Ext.Configurator for this class. ...

                        Returns the Ext.Configurator for this class.

                        Returns

                        Get the current class' name in string format. ...

                        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'
                        

                        Returns

                        Ext.data.schema.Schema
                        view source
                        ( entity )privatestatic
                        ...

                        Parameters

                        ( name, mixinClass )privatestatic
                        Used internally by the mixins pre-processor ...

                        Used internally by the mixins pre-processor

                        Parameters

                        ( fn, scope )chainableprivatestatic
                        ...

                        Parameters

                        Override members of this class. ...

                        Override members of this class. Overridden methods can be invoked via 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 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 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).

                        Parameters

                        • members : Object

                          The properties to add to this class. This should be specified as an object literal containing one or more properties.

                        Returns