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
|
/*
Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
Available via Academic Free License >= 2.1 OR the modified BSD license.
see: http://dojotoolkit.org/license for details
*/
if(!dojo._hasResource["dojo.store.Cache"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
dojo._hasResource["dojo.store.Cache"] = true;
dojo.provide("dojo.store.Cache");
dojo.getObject("store", true, dojo);
/*=====
dojo.declare("dojo.store.__CacheArgs", null, {
constructor: function(){
// summary:
// These are additional options for how caching is handled.
// isLoaded: Function?
// This is a function that will be called for each item in a query response to determine
// if it is cacheable. If isLoaded returns true, the item will be cached, otherwise it
// will not be cached. If isLoaded is not provided, all items will be cached.
this.isLoaded = isLoaded;
}
});
=====*/
dojo.store.Cache = function(masterStore, cachingStore, /*dojo.store.__CacheArgs*/ options){
// summary:
// The Cache store wrapper takes a master store and a caching store,
// caches data from the master into the caching store for faster
// lookup. Normally one would use a memory store for the caching
// store and a server store like JsonRest for the master store.
// masterStore:
// This is the authoritative store, all uncached requests or non-safe requests will
// be made against this store.
// cachingStore:
// This is the caching store that will be used to store responses for quick access.
// Typically this should be a local store.
// options:
// These are additional options for how caching is handled.
options = options || {};
return dojo.delegate(masterStore, {
query: function(query, directives){
var results = masterStore.query(query, directives);
results.forEach(function(object){
if(!options.isLoaded || options.isLoaded(object)){
cachingStore.put(object);
}
});
return results;
},
// look for a queryEngine in either store
queryEngine: masterStore.queryEngine || cachingStore.queryEngine,
get: function(id, directives){
return dojo.when(cachingStore.get(id), function(result){
return result || dojo.when(masterStore.get(id, directives), function(result){
if(result){
cachingStore.put(result, {id: id});
}
return result;
});
});
},
add: function(object, directives){
return dojo.when(masterStore.add(object, directives), function(result){
// now put result in cache
return cachingStore.add(typeof result == "object" ? result : object, directives);
});
},
put: function(object, directives){
// first remove from the cache, so it is empty until we get a response from the master store
cachingStore.remove((directives && directives.id) || this.getIdentity(object));
return dojo.when(masterStore.put(object, directives), function(result){
// now put result in cache
return cachingStore.put(typeof result == "object" ? result : object, directives);
});
},
remove: function(id, directives){
return dojo.when(masterStore.remove(id, directives), function(result){
return cachingStore.remove(id, directives);
});
},
evict: function(id){
return cachingStore.remove(id);
}
});
};
/*=====
dojo.declare("dojo.store.Cache", null, {
// example:
// | var master = new dojo.store.Memory(data);
// | var cacher = new dojo.store.Memory();
// | var store = new dojo.store.Cache(master, cacher);
//
query: function(query, directives){
// summary:
// Query the underlying master store and cache any results.
// query: Object|String
// The object or string containing query information. Dependent on the query engine used.
// directives: dojo.store.util.SimpleQueryEngine.__queryOptions?
// An optional keyword arguments object with additional parameters describing the query.
// returns: dojo.store.util.QueryResults
// A QueryResults object that can be used to iterate over.
},
get: function(id, directives){
// summary:
// Get the object with the specific id.
// id: Number
// The identifier for the object in question.
// directives: dojo.store.__GetOptions?
// Any additional parameters needed to describe how the get should be performed.
// returns: dojo.store.util.QueryResults
// A QueryResults object.
},
add: function(object, directives){
// summary:
// Add the given object to the store.
// object: Object
// The object to add to the store.
// directives: dojo.store.__AddOptions?
// Any additional parameters needed to describe how the add should be performed.
// returns: Number
// The new id for the object.
},
put: function(object, directives){
// summary:
// Put the object into the store (similar to an HTTP PUT).
// object: Object
// The object to put to the store.
// directives: dojo.store.__PutOptions?
// Any additional parameters needed to describe how the put should be performed.
// returns: Number
// The new id for the object.
},
remove: function(id, directives){
// summary:
// Remove the object with the specific id.
// id: Number
// The identifier for the object in question.
// directives: dojo.store.__RemoveOptions?
// Any additional parameters needed to describe how the remove should be performed.
},
evict: function(id){
// summary:
// Remove the object with the given id from the underlying caching store.
// id: Number
// The identifier for the object in question.
}
});
=====*/
}
|
