docs/source/Types.html

   1 <!DOCTYPE html><html><head><title>Sencha Documentation Project</title><link rel="stylesheet" href="../reset.css" type="text/css"><link rel="stylesheet" href="../prettify.css" type="text/css"><link rel="stylesheet" href="../prettify_sa.css" type="text/css"><script type="text/javascript" src="../prettify.js"></script></head><body onload="prettyPrint()"><pre class="prettyprint"><pre><span id='Ext-data.Types'>/**
   2 </span> * @class Ext.data.Types
   3  * &lt;p&gt;This is s static class containing the system-supplied data types which may be given to a {@link Ext.data.Field Field}.&lt;p/&gt;
   4  * &lt;p&gt;The properties in this class are used as type indicators in the {@link Ext.data.Field Field} class, so to
   5  * test whether a Field is of a certain type, compare the {@link Ext.data.Field#type type} property against properties
   6  * of this class.&lt;/p&gt;
   7  * &lt;p&gt;Developers may add their own application-specific data types to this class. Definition names must be UPPERCASE.
   8  * each type definition must contain three properties:&lt;/p&gt;
   9  * &lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
  10  * &lt;li&gt;&lt;code&gt;convert&lt;/code&gt; : &lt;i&gt;Function&lt;/i&gt;&lt;div class=&quot;sub-desc&quot;&gt;A function to convert raw data values from a data block into the data
  11  * to be stored in the Field. The function is passed the collowing parameters:
  12  * &lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
  13  * &lt;li&gt;&lt;b&gt;v&lt;/b&gt; : Mixed&lt;div class=&quot;sub-desc&quot;&gt;The data value as read by the Reader, if undefined will use
  14  * the configured &lt;tt&gt;{@link Ext.data.Field#defaultValue defaultValue}&lt;/tt&gt;.&lt;/div&gt;&lt;/li&gt;
  15  * &lt;li&gt;&lt;b&gt;rec&lt;/b&gt; : Mixed&lt;div class=&quot;sub-desc&quot;&gt;The data object containing the row as read by the Reader.
  16  * Depending on the Reader type, this could be an Array ({@link Ext.data.reader.Array ArrayReader}), an object
  17  * ({@link Ext.data.reader.Json JsonReader}), or an XML element.&lt;/div&gt;&lt;/li&gt;
  18  * &lt;/ul&gt;&lt;/div&gt;&lt;/div&gt;&lt;/li&gt;
  19  * &lt;li&gt;&lt;code&gt;sortType&lt;/code&gt; : &lt;i&gt;Function&lt;/i&gt; &lt;div class=&quot;sub-desc&quot;&gt;A function to convert the stored data into comparable form, as defined by {@link Ext.data.SortTypes}.&lt;/div&gt;&lt;/li&gt;
  20  * &lt;li&gt;&lt;code&gt;type&lt;/code&gt; : &lt;i&gt;String&lt;/i&gt; &lt;div class=&quot;sub-desc&quot;&gt;A textual data type name.&lt;/div&gt;&lt;/li&gt;
  21  * &lt;/ul&gt;&lt;/div&gt;
  22  * &lt;p&gt;For example, to create a VELatLong field (See the Microsoft Bing Mapping API) containing the latitude/longitude value of a datapoint on a map from a JsonReader data block
  23  * which contained the properties &lt;code&gt;lat&lt;/code&gt; and &lt;code&gt;long&lt;/code&gt;, you would define a new data type like this:&lt;/p&gt;
  24  *&lt;pre&gt;&lt;code&gt;
  25 // Add a new Field data type which stores a VELatLong object in the Record.
  26 Ext.data.Types.VELATLONG = {
  27     convert: function(v, data) {
  28         return new VELatLong(data.lat, data.long);
  29     },
  30     sortType: function(v) {
  31         return v.Latitude;  // When sorting, order by latitude
  32     },
  33     type: 'VELatLong'
  34 };
  35 &lt;/code&gt;&lt;/pre&gt;
  36  * &lt;p&gt;Then, when declaring a Model, use &lt;pre&gt;&lt;code&gt;
  37 var types = Ext.data.Types; // allow shorthand type access
  38 Ext.define('Unit',
  39     extend: 'Ext.data.Model',
  40     fields: [
  41         { name: 'unitName', mapping: 'UnitName' },
  42         { name: 'curSpeed', mapping: 'CurSpeed', type: types.INT },
  43         { name: 'latitude', mapping: 'lat', type: types.FLOAT },
  44         { name: 'latitude', mapping: 'lat', type: types.FLOAT },
  45         { name: 'position', type: types.VELATLONG }
  46     ]
  47 });
  48 &lt;/code&gt;&lt;/pre&gt;
  49  * @singleton
  50  */
  51 Ext.define('Ext.data.Types', {
  52     singleton: true,
  53     requires: ['Ext.data.SortTypes']
  54 }, function() {
  55     var st = Ext.data.SortTypes;
  56
  57     Ext.apply(Ext.data.Types, {
  58 <span id='Ext-data.Types-property-stripRe'>        /**
  59 </span>         * @type Regexp
  60          * @property stripRe
  61          * A regular expression for stripping non-numeric characters from a numeric value. Defaults to &lt;tt&gt;/[\$,%]/g&lt;/tt&gt;.
  62          * This should be overridden for localization.
  63          */
  64         stripRe: /[\$,%]/g,
  65
  66 <span id='Ext-data.Types-property-AUTO'>        /**
  67 </span>         * @type Object.
  68          * @property AUTO
  69          * This data type means that no conversion is applied to the raw data before it is placed into a Record.
  70          */
  71         AUTO: {
  72             convert: function(v) {
  73                 return v;
  74             },
  75             sortType: st.none,
  76             type: 'auto'
  77         },
  78
  79 <span id='Ext-data.Types-property-STRING'>        /**
  80 </span>         * @type Object.
  81          * @property STRING
  82          * This data type means that the raw data is converted into a String before it is placed into a Record.
  83          */
  84         STRING: {
  85             convert: function(v) {
  86                 var defaultValue = this.useNull ? null : '';
  87                 return (v === undefined || v === null) ? defaultValue : String(v);
  88             },
  89             sortType: st.asUCString,
  90             type: 'string'
  91         },
  92
  93 <span id='Ext-data.Types-property-INT'>        /**
  94 </span>         * @type Object.
  95          * @property INT
  96          * This data type means that the raw data is converted into an integer before it is placed into a Record.
  97          * &lt;p&gt;The synonym &lt;code&gt;INTEGER&lt;/code&gt; is equivalent.&lt;/p&gt;
  98          */
  99         INT: {
 100             convert: function(v) {
 101                 return v !== undefined &amp;&amp; v !== null &amp;&amp; v !== '' ?
 102                     parseInt(String(v).replace(Ext.data.Types.stripRe, ''), 10) : (this.useNull ? null : 0);
 103             },
 104             sortType: st.none,
 105             type: 'int'
 106         },
 107
 108 <span id='Ext-data.Types-property-FLOAT'>        /**
 109 </span>         * @type Object.
 110          * @property FLOAT
 111          * This data type means that the raw data is converted into a number before it is placed into a Record.
 112          * &lt;p&gt;The synonym &lt;code&gt;NUMBER&lt;/code&gt; is equivalent.&lt;/p&gt;
 113          */
 114         FLOAT: {
 115             convert: function(v) {
 116                 return v !== undefined &amp;&amp; v !== null &amp;&amp; v !== '' ?
 117                     parseFloat(String(v).replace(Ext.data.Types.stripRe, ''), 10) : (this.useNull ? null : 0);
 118             },
 119             sortType: st.none,
 120             type: 'float'
 121         },
 122
 123 <span id='Ext-data.Types-property-BOOL'>        /**
 124 </span>         * @type Object.
 125          * @property BOOL
 126          * &lt;p&gt;This data type means that the raw data is converted into a boolean before it is placed into
 127          * a Record. The string &quot;true&quot; and the number 1 are converted to boolean &lt;code&gt;true&lt;/code&gt;.&lt;/p&gt;
 128          * &lt;p&gt;The synonym &lt;code&gt;BOOLEAN&lt;/code&gt; is equivalent.&lt;/p&gt;
 129          */
 130         BOOL: {
 131             convert: function(v) {
 132                 if (this.useNull &amp;&amp; v === undefined || v === null || v === '') {
 133                     return null;
 134                 }
 135                 return v === true || v === 'true' || v == 1;
 136             },
 137             sortType: st.none,
 138             type: 'bool'
 139         },
 140
 141 <span id='Ext-data.Types-property-DATE'>        /**
 142 </span>         * @type Object.
 143          * @property DATE
 144          * This data type means that the raw data is converted into a Date before it is placed into a Record.
 145          * The date format is specified in the constructor of the {@link Ext.data.Field} to which this type is
 146          * being applied.
 147          */
 148         DATE: {
 149             convert: function(v) {
 150                 var df = this.dateFormat;
 151                 if (!v) {
 152                     return null;
 153                 }
 154                 if (Ext.isDate(v)) {
 155                     return v;
 156                 }
 157                 if (df) {
 158                     if (df == 'timestamp') {
 159                         return new Date(v*1000);
 160                     }
 161                     if (df == 'time') {
 162                         return new Date(parseInt(v, 10));
 163                     }
 164                     return Ext.Date.parse(v, df);
 165                 }
 166
 167                 var parsed = Date.parse(v);
 168                 return parsed ? new Date(parsed) : null;
 169             },
 170             sortType: st.asDate,
 171             type: 'date'
 172         }
 173     });
 174
 175     Ext.apply(Ext.data.Types, {
 176 <span id='Ext-data.Types-property-BOOLEAN'>        /**
 177 </span>         * @type Object.
 178          * @property BOOLEAN
 179          * &lt;p&gt;This data type means that the raw data is converted into a boolean before it is placed into
 180          * a Record. The string &quot;true&quot; and the number 1 are converted to boolean &lt;code&gt;true&lt;/code&gt;.&lt;/p&gt;
 181          * &lt;p&gt;The synonym &lt;code&gt;BOOL&lt;/code&gt; is equivalent.&lt;/p&gt;
 182          */
 183         BOOLEAN: this.BOOL,
 184
 185 <span id='Ext-data.Types-property-INTEGER'>        /**
 186 </span>         * @type Object.
 187          * @property INTEGER
 188          * This data type means that the raw data is converted into an integer before it is placed into a Record.
 189          * &lt;p&gt;The synonym &lt;code&gt;INT&lt;/code&gt; is equivalent.&lt;/p&gt;
 190          */
 191         INTEGER: this.INT,
 192
 193 <span id='Ext-data.Types-property-NUMBER'>        /**
 194 </span>         * @type Object.
 195          * @property NUMBER
 196          * This data type means that the raw data is converted into a number before it is placed into a Record.
 197          * &lt;p&gt;The synonym &lt;code&gt;FLOAT&lt;/code&gt; is equivalent.&lt;/p&gt;
 198          */
 199         NUMBER: this.FLOAT
 200     });
 201 });
 202 </pre></pre></body></html>