docs/source/ModelManager.html

   1 <!DOCTYPE html>
   2 <html>
   3 <head>
   4   <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
   5   <title>The source code</title>
   6   <link href="../resources/prettify/prettify.css" type="text/css" rel="stylesheet" />
   7   <script type="text/javascript" src="../resources/prettify/prettify.js"></script>
   8   <style type="text/css">
   9     .highlight { display: block; background-color: #ddd; }
  10   </style>
  11   <script type="text/javascript">
  12     function highlight() {
  13       document.getElementById(location.hash.replace(/#/, "")).className = "highlight";
  14     }
  15   </script>
  16 </head>
  17 <body onload="prettyPrint(); highlight();">
  18   <pre class="prettyprint lang-js"><span id='Ext-ModelManager'>/**
  19 </span> * @author Ed Spencer
  20  * @class Ext.ModelManager
  21  * @extends Ext.AbstractManager
  22
  23 The ModelManager keeps track of all {@link Ext.data.Model} types defined in your application.
  24
  25 __Creating Model Instances__
  26
  27 Model instances can be created by using the {@link Ext#create Ext.create} method. Ext.create replaces
  28 the deprecated {@link #create Ext.ModelManager.create} method. It is also possible to create a model instance
  29 this by using the Model type directly. The following 3 snippets are equivalent:
  30
  31     Ext.define('User', {
  32         extend: 'Ext.data.Model',
  33         fields: ['first', 'last']
  34     });
  35
  36     // method 1, create using Ext.create (recommended)
  37     Ext.create('User', {
  38         first: 'Ed',
  39         last: 'Spencer'
  40     });
  41
  42     // method 2, create through the manager (deprecated)
  43     Ext.ModelManager.create({
  44         first: 'Ed',
  45         last: 'Spencer'
  46     }, 'User');
  47
  48     // method 3, create on the type directly
  49     new User({
  50         first: 'Ed',
  51         last: 'Spencer'
  52     });
  53
  54 __Accessing Model Types__
  55
  56 A reference to a Model type can be obtained by using the {@link #getModel} function. Since models types
  57 are normal classes, you can access the type directly. The following snippets are equivalent:
  58
  59     Ext.define('User', {
  60         extend: 'Ext.data.Model',
  61         fields: ['first', 'last']
  62     });
  63
  64     // method 1, access model type through the manager
  65     var UserType = Ext.ModelManager.getModel('User');
  66
  67     // method 2, reference the type directly
  68     var UserType = User;
  69
  70  * @markdown
  71  * @singleton
  72  */
  73 Ext.define('Ext.ModelManager', {
  74     extend: 'Ext.AbstractManager',
  75     alternateClassName: 'Ext.ModelMgr',
  76     requires: ['Ext.data.Association'],
  77
  78     singleton: true,
  79
  80     typeName: 'mtype',
  81
  82 <span id='Ext-ModelManager-property-associationStack'>    /**
  83 </span>     * Private stack of associations that must be created once their associated model has been defined
  84      * @property {Ext.data.Association[]} associationStack
  85      */
  86     associationStack: [],
  87
  88 <span id='Ext-ModelManager-method-registerType'>    /**
  89 </span>     * Registers a model definition. All model plugins marked with isDefault: true are bootstrapped
  90      * immediately, as are any addition plugins defined in the model config.
  91      * @private
  92      */
  93     registerType: function(name, config) {
  94         var proto = config.prototype,
  95             model;
  96         if (proto &amp;&amp; proto.isModel) {
  97             // registering an already defined model
  98             model = config;
  99         } else {
 100             // passing in a configuration
 101             if (!config.extend) {
 102                 config.extend = 'Ext.data.Model';
 103             }
 104             model = Ext.define(name, config);
 105         }
 106         this.types[name] = model;
 107         return model;
 108     },
 109
 110 <span id='Ext-ModelManager-method-onModelDefined'>    /**
 111 </span>     * @private
 112      * Private callback called whenever a model has just been defined. This sets up any associations
 113      * that were waiting for the given model to be defined
 114      * @param {Function} model The model that was just created
 115      */
 116     onModelDefined: function(model) {
 117         var stack  = this.associationStack,
 118             length = stack.length,
 119             create = [],
 120             association, i, created;
 121
 122         for (i = 0; i &lt; length; i++) {
 123             association = stack[i];
 124
 125             if (association.associatedModel == model.modelName) {
 126                 create.push(association);
 127             }
 128         }
 129
 130         for (i = 0, length = create.length; i &lt; length; i++) {
 131             created = create[i];
 132             this.types[created.ownerModel].prototype.associations.add(Ext.data.Association.create(created));
 133             Ext.Array.remove(stack, created);
 134         }
 135     },
 136
 137 <span id='Ext-ModelManager-method-registerDeferredAssociation'>    /**
 138 </span>     * Registers an association where one of the models defined doesn't exist yet.
 139      * The ModelManager will check when new models are registered if it can link them
 140      * together
 141      * @private
 142      * @param {Ext.data.Association} association The association
 143      */
 144     registerDeferredAssociation: function(association){
 145         this.associationStack.push(association);
 146     },
 147
 148 <span id='Ext-ModelManager-method-getModel'>    /**
 149 </span>     * Returns the {@link Ext.data.Model} for a given model name
 150      * @param {String/Object} id The id of the model or the model instance.
 151      * @return {Ext.data.Model} a model class.
 152      */
 153     getModel: function(id) {
 154         var model = id;
 155         if (typeof model == 'string') {
 156             model = this.types[model];
 157         }
 158         return model;
 159     },
 160
 161 <span id='Ext-ModelManager-method-create'>    /**
 162 </span>     * Creates a new instance of a Model using the given data.
 163      *
 164      * This method is deprecated.  Use {@link Ext#create Ext.create} instead.  For example:
 165      *
 166      *     Ext.create('User', {
 167      *         first: 'Ed',
 168      *         last: 'Spencer'
 169      *     });
 170      *
 171      * @param {Object} data Data to initialize the Model's fields with
 172      * @param {String} name The name of the model to create
 173      * @param {Number} id (Optional) unique id of the Model instance (see {@link Ext.data.Model})
 174      */
 175     create: function(config, name, id) {
 176         var con = typeof name == 'function' ? name : this.types[name || config.name];
 177
 178         return new con(config, id);
 179     }
 180 }, function() {
 181
 182 <span id='Ext-method-regModel'>    /**
 183 </span>     * Old way for creating Model classes.  Instead use:
 184      *
 185      *     Ext.define(&quot;MyModel&quot;, {
 186      *         extend: &quot;Ext.data.Model&quot;,
 187      *         fields: []
 188      *     });
 189      *
 190      * @param {String} name Name of the Model class.
 191      * @param {Object} config A configuration object for the Model you wish to create.
 192      * @return {Ext.data.Model} The newly registered Model
 193      * @member Ext
 194      * @deprecated 4.0.0 Use {@link Ext#define} instead.
 195      */
 196     Ext.regModel = function() {
 197         //&lt;debug&gt;
 198         if (Ext.isDefined(Ext.global.console)) {
 199             Ext.global.console.warn('Ext.regModel has been deprecated. Models can now be created by extending Ext.data.Model: Ext.define(&quot;MyModel&quot;, {extend: &quot;Ext.data.Model&quot;, fields: []});.');
 200         }
 201         //&lt;/debug&gt;
 202         return this.ModelManager.registerType.apply(this.ModelManager, arguments);
 203     };
 204 });
 205 </pre>
 206 </body>
 207 </html>