Provider2.html
6.84 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>The source code</title>
<link href="../resources/prettify/prettify.css" type="text/css" rel="stylesheet" />
<script type="text/javascript" src="../resources/prettify/prettify.js"></script>
<style type="text/css">
.highlight { display: block; background-color: #ddd; }
</style>
<script type="text/javascript">
function highlight() {
document.getElementById(location.hash.replace(/#/, "")).className = "highlight";
}
</script>
</head>
<body onload="prettyPrint(); highlight();">
<pre class="prettyprint lang-js"><span id='Ext-state-Provider'>/**
</span> * @class Ext.state.Provider
* <p>Abstract base class for state provider implementations. The provider is responsible
* for setting values and extracting values to/from the underlying storage source. The
* storage source can vary and the details should be implemented in a subclass. For example
* a provider could use a server side database or the browser localstorage where supported.</p>
*
* <p>This class provides methods for encoding and decoding <b>typed</b> variables including
* dates and defines the Provider interface. By default these methods put the value and the
* type information into a delimited string that can be stored. These should be overridden in
* a subclass if you want to change the format of the encoded value and subsequent decoding.</p>
*/
Ext.define('Ext.state.Provider', {
mixins: {
observable: 'Ext.util.Observable'
},
<span id='Ext-state-Provider-cfg-prefix'> /**
</span> * @cfg {String} prefix A string to prefix to items stored in the underlying state store.
* Defaults to <tt>'ext-'</tt>
*/
prefix: 'ext-',
constructor : function(config){
config = config || {};
var me = this;
Ext.apply(me, config);
<span id='Ext-state-Provider-event-statechange'> /**
</span> * @event statechange
* Fires when a state change occurs.
* @param {Ext.state.Provider} this This state provider
* @param {String} key The state key which was changed
* @param {String} value The encoded value for the state
*/
me.addEvents("statechange");
me.state = {};
me.mixins.observable.constructor.call(me);
},
<span id='Ext-state-Provider-method-get'> /**
</span> * Returns the current value for a key
* @param {String} name The key name
* @param {Object} defaultValue A default value to return if the key's value is not found
* @return {Object} The state data
*/
get : function(name, defaultValue){
return typeof this.state[name] == "undefined" ?
defaultValue : this.state[name];
},
<span id='Ext-state-Provider-method-clear'> /**
</span> * Clears a value from the state
* @param {String} name The key name
*/
clear : function(name){
var me = this;
delete me.state[name];
me.fireEvent("statechange", me, name, null);
},
<span id='Ext-state-Provider-method-set'> /**
</span> * Sets the value for a key
* @param {String} name The key name
* @param {Object} value The value to set
*/
set : function(name, value){
var me = this;
me.state[name] = value;
me.fireEvent("statechange", me, name, value);
},
<span id='Ext-state-Provider-method-decodeValue'> /**
</span> * Decodes a string previously encoded with {@link #encodeValue}.
* @param {String} value The value to decode
* @return {Object} The decoded value
*/
decodeValue : function(value){
// a -> Array
// n -> Number
// d -> Date
// b -> Boolean
// s -> String
// o -> Object
// -> Empty (null)
var me = this,
re = /^(a|n|d|b|s|o|e)\:(.*)$/,
matches = re.exec(unescape(value)),
all,
type,
keyValue,
values,
vLen,
v;
if(!matches || !matches[1]){
return; // non state
}
type = matches[1];
value = matches[2];
switch (type) {
case 'e':
return null;
case 'n':
return parseFloat(value);
case 'd':
return new Date(Date.parse(value));
case 'b':
return (value == '1');
case 'a':
all = [];
if(value != ''){
values = value.split('^');
vLen = values.length;
for (v = 0; v < vLen; v++) {
value = values[v];
all.push(me.decodeValue(value));
}
}
return all;
case 'o':
all = {};
if(value != ''){
values = value.split('^');
vLen = values.length;
for (v = 0; v < vLen; v++) {
value = values[v];
keyValue = value.split('=');
all[keyValue[0]] = me.decodeValue(keyValue[1]);
}
}
return all;
default:
return value;
}
},
<span id='Ext-state-Provider-method-encodeValue'> /**
</span> * Encodes a value including type information. Decode with {@link #decodeValue}.
* @param {Object} value The value to encode
* @return {String} The encoded value
*/
encodeValue : function(value){
var flat = '',
i = 0,
enc,
len,
key;
if (value == null) {
return 'e:1';
} else if(typeof value == 'number') {
enc = 'n:' + value;
} else if(typeof value == 'boolean') {
enc = 'b:' + (value ? '1' : '0');
} else if(Ext.isDate(value)) {
enc = 'd:' + value.toGMTString();
} else if(Ext.isArray(value)) {
for (len = value.length; i < len; i++) {
flat += this.encodeValue(value[i]);
if (i != len - 1) {
flat += '^';
}
}
enc = 'a:' + flat;
} else if (typeof value == 'object') {
for (key in value) {
if (typeof value[key] != 'function' && value[key] !== undefined) {
flat += key + '=' + this.encodeValue(value[key]) + '^';
}
}
enc = 'o:' + flat.substring(0, flat.length-1);
} else {
enc = 's:' + value;
}
return escape(enc);
}
});</pre>
</body>
</html>