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