Page Menu
Home
Code
Search
Configure Global Search
Log In
Files
F946849
Provider.js
No One
Temporary
Actions
View File
Edit File
Delete File
View Transforms
Subscribe
Mute Notifications
Award Token
Flag For Later
Size
12 KB
Subscribers
None
Provider.js
View Options
if
(
!
dojo
.
_hasResource
[
"dojox.storage.Provider"
]){
//_hasResource checks added by build. Do not use _hasResource directly in your code.
dojo
.
_hasResource
[
"dojox.storage.Provider"
]
=
true
;
dojo
.
provide
(
"dojox.storage.Provider"
);
dojo
.
declare
(
"dojox.storage.Provider"
,
null
,
{
// summary: A singleton for working with dojox.storage.
// description:
// dojox.storage exposes the current available storage provider on this
// platform. It gives you methods such as dojox.storage.put(),
// dojox.storage.get(), etc.
//
// For more details on dojox.storage, see the primary documentation
// page at
// http://manual.dojotoolkit.org/storage.html
//
// Note for storage provider developers who are creating subclasses-
// This is the base class for all storage providers Specific kinds of
// Storage Providers should subclass this and implement these methods.
// You should avoid initialization in storage provider subclass's
// constructor; instead, perform initialization in your initialize()
// method.
constructor
:
function
(){
},
// SUCCESS: String
// Flag that indicates a put() call to a
// storage provider was succesful.
SUCCESS
:
"success"
,
// FAILED: String
// Flag that indicates a put() call to
// a storage provider failed.
FAILED
:
"failed"
,
// PENDING: String
// Flag that indicates a put() call to a
// storage provider is pending user approval.
PENDING
:
"pending"
,
// SIZE_NOT_AVAILABLE: String
// Returned by getMaximumSize() if this storage provider can not determine
// the maximum amount of data it can support.
SIZE_NOT_AVAILABLE
:
"Size not available"
,
// SIZE_NO_LIMIT: String
// Returned by getMaximumSize() if this storage provider has no theoretical
// limit on the amount of data it can store.
SIZE_NO_LIMIT
:
"No size limit"
,
// DEFAULT_NAMESPACE: String
// The namespace for all storage operations. This is useful if several
// applications want access to the storage system from the same domain but
// want different storage silos.
DEFAULT_NAMESPACE
:
"default"
,
// onHideSettingsUI: Function
// If a function is assigned to this property, then when the settings
// provider's UI is closed this function is called. Useful, for example,
// if the user has just cleared out all storage for this provider using
// the settings UI, and you want to update your UI.
onHideSettingsUI
:
null
,
initialize
:
function
(){
// summary:
// Allows this storage provider to initialize itself. This is
// called after the page has finished loading, so you can not do
// document.writes(). Storage Provider subclasses should initialize
// themselves inside of here rather than in their function
// constructor.
console
.
warn
(
"dojox.storage.initialize not implemented"
);
},
isAvailable
:
function
(){
/*Boolean*/
// summary:
// Returns whether this storage provider is available on this
// platform.
console
.
warn
(
"dojox.storage.isAvailable not implemented"
);
},
put
:
function
(
/*string*/
key
,
/*object*/
value
,
/*function*/
resultsHandler
,
/*string?*/
namespace
){
// summary:
// Puts a key and value into this storage system.
// description:
// Example-
// var resultsHandler = function(status, key, message){
// alert("status="+status+", key="+key+", message="+message);
// };
// dojox.storage.put("test", "hello world", resultsHandler);
//
// Important note: if you are using Dojo Storage in conjunction with
// Dojo Offline, then you don't need to provide
// a resultsHandler; this is because for Dojo Offline we
// use Google Gears to persist data, which has unlimited data
// once the user has given permission. If you are using Dojo
// Storage apart from Dojo Offline, then under the covers hidden
// Flash might be used, which is both asychronous and which might
// get denied; in this case you must provide a resultsHandler.
// key:
// A string key to use when retrieving this value in the future.
// value:
// A value to store; this can be any JavaScript type.
// resultsHandler:
// A callback function that will receive three arguments. The
// first argument is one of three values: dojox.storage.SUCCESS,
// dojox.storage.FAILED, or dojox.storage.PENDING; these values
// determine how the put request went. In some storage systems
// users can deny a storage request, resulting in a
// dojox.storage.FAILED, while in other storage systems a storage
// request must wait for user approval, resulting in a
// dojox.storage.PENDING status until the request is either
// approved or denied, resulting in another call back with
// dojox.storage.SUCCESS.
// The second argument in the call back is the key name that was being stored.
// The third argument in the call back is an optional message that
// details possible error messages that might have occurred during
// the storage process.
// namespace:
// Optional string namespace that this value will be placed into;
// if left off, the value will be placed into dojox.storage.DEFAULT_NAMESPACE
console
.
warn
(
"dojox.storage.put not implemented"
);
},
get
:
function
(
/*string*/
key
,
/*string?*/
namespace
){
/*Object*/
// summary:
// Gets the value with the given key. Returns null if this key is
// not in the storage system.
// key:
// A string key to get the value of.
// namespace:
// Optional string namespace that this value will be retrieved from;
// if left off, the value will be retrieved from dojox.storage.DEFAULT_NAMESPACE
// return: Returns any JavaScript object type; null if the key is not present
console
.
warn
(
"dojox.storage.get not implemented"
);
},
hasKey
:
function
(
/*string*/
key
,
/*string?*/
namespace
){
/*Boolean*/
// summary: Determines whether the storage has the given key.
return
(
this
.
get
(
key
)
!=
null
);
},
getKeys
:
function
(
/*string?*/
namespace
){
/*Array*/
// summary: Enumerates all of the available keys in this storage system.
// return: Array of available keys
console
.
warn
(
"dojox.storage.getKeys not implemented"
);
},
clear
:
function
(
/*string?*/
namespace
){
// summary:
// Completely clears this storage system of all of it's values and
// keys. If 'namespace' is provided just clears the keys in that
// namespace.
console
.
warn
(
"dojox.storage.clear not implemented"
);
},
remove
:
function
(
/*string*/
key
,
/*string?*/
namespace
){
// summary: Removes the given key from this storage system.
console
.
warn
(
"dojox.storage.remove not implemented"
);
},
getNamespaces
:
function
(){
/*string[]*/
console
.
warn
(
"dojox.storage.getNamespaces not implemented"
);
},
isPermanent
:
function
(){
/*Boolean*/
// summary:
// Returns whether this storage provider's values are persisted
// when this platform is shutdown.
console
.
warn
(
"dojox.storage.isPermanent not implemented"
);
},
getMaximumSize
:
function
(){
/* mixed */
// summary: The maximum storage allowed by this provider
// returns:
// Returns the maximum storage size
// supported by this provider, in
// thousands of bytes (i.e., if it
// returns 60 then this means that 60K
// of storage is supported).
//
// If this provider can not determine
// it's maximum size, then
// dojox.storage.SIZE_NOT_AVAILABLE is
// returned; if there is no theoretical
// limit on the amount of storage
// this provider can return, then
// dojox.storage.SIZE_NO_LIMIT is
// returned
console
.
warn
(
"dojox.storage.getMaximumSize not implemented"
);
},
putMultiple
:
function
(
/*array*/
keys
,
/*array*/
values
,
/*function*/
resultsHandler
,
/*string?*/
namespace
){
// summary:
// Puts multiple keys and values into this storage system.
// description:
// Example-
// var resultsHandler = function(status, key, message){
// alert("status="+status+", key="+key+", message="+message);
// };
// dojox.storage.put(["test"], ["hello world"], resultsHandler);
//
// Important note: if you are using Dojo Storage in conjunction with
// Dojo Offline, then you don't need to provide
// a resultsHandler; this is because for Dojo Offline we
// use Google Gears to persist data, which has unlimited data
// once the user has given permission. If you are using Dojo
// Storage apart from Dojo Offline, then under the covers hidden
// Flash might be used, which is both asychronous and which might
// get denied; in this case you must provide a resultsHandler.
// keys:
// An array of string keys to use when retrieving this value in the future,
// one per value to be stored
// values:
// An array of values to store; this can be any JavaScript type, though the
// performance of plain strings is considerably better
// resultsHandler:
// A callback function that will receive three arguments. The
// first argument is one of three values: dojox.storage.SUCCESS,
// dojox.storage.FAILED, or dojox.storage.PENDING; these values
// determine how the put request went. In some storage systems
// users can deny a storage request, resulting in a
// dojox.storage.FAILED, while in other storage systems a storage
// request must wait for user approval, resulting in a
// dojox.storage.PENDING status until the request is either
// approved or denied, resulting in another call back with
// dojox.storage.SUCCESS.
// The second argument in the call back is the key name that was being stored.
// The third argument in the call back is an optional message that
// details possible error messages that might have occurred during
// the storage process.
// namespace:
// Optional string namespace that this value will be placed into;
// if left off, the value will be placed into dojox.storage.DEFAULT_NAMESPACE
console
.
warn
(
"dojox.storage.putMultiple not implemented"
);
// JAC: We could implement a 'default' puMultiple here by just doing each put individually
},
getMultiple
:
function
(
/*array*/
keys
,
/*string?*/
namespace
){
/*Object*/
// summary:
// Gets the valuse corresponding to each of the given keys.
// Returns a null array element for each given key that is
// not in the storage system.
// keys:
// An array of string keys to get the value of.
// namespace:
// Optional string namespace that this value will be retrieved from;
// if left off, the value will be retrieved from dojox.storage.DEFAULT_NAMESPACE
// return: Returns any JavaScript object type; null if the key is not present
console
.
warn
(
"dojox.storage.getMultiple not implemented"
);
// JAC: We could implement a 'default' getMultiple here by just doing each get individually
},
removeMultiple
:
function
(
/*array*/
keys
,
/*string?*/
namespace
)
{
// summary: Removes the given keys from this storage system.
// JAC: We could implement a 'default' removeMultiple here by just doing each remove individually
console
.
warn
(
"dojox.storage.remove not implemented"
);
},
isValidKeyArray
:
function
(
keys
)
{
if
(
keys
===
null
||
typeof
keys
===
"undefined"
||
!
keys
instanceof
Array
){
return
false
;
}
// JAC: This could be optimized by running the key validity test directly over a joined string
for
(
var
k
=
0
;
k
<
keys
.
length
;
k
++
){
if
(
!
this
.
isValidKey
(
keys
[
k
])){
return
false
;
}
}
return
true
;
},
hasSettingsUI
:
function
(){
/*Boolean*/
// summary: Determines whether this provider has a settings UI.
return
false
;
},
showSettingsUI
:
function
(){
// summary: If this provider has a settings UI, determined
// by calling hasSettingsUI(), it is shown.
console
.
warn
(
"dojox.storage.showSettingsUI not implemented"
);
},
hideSettingsUI
:
function
(){
// summary: If this provider has a settings UI, hides it.
console
.
warn
(
"dojox.storage.hideSettingsUI not implemented"
);
},
isValidKey
:
function
(
/*string*/
keyName
){
/*Boolean*/
// summary:
// Subclasses can call this to ensure that the key given is valid
// in a consistent way across different storage providers. We use
// the lowest common denominator for key values allowed: only
// letters, numbers, and underscores are allowed. No spaces.
if
((
keyName
==
null
)
||
(
typeof
keyName
==
"undefined"
)){
return
false
;
}
return
/^[0-9A-Za-z_]*$/
.
test
(
keyName
);
},
getResourceList
:
function
(){
/* Array[] */
// summary:
// Returns a list of URLs that this
// storage provider might depend on.
// description:
// This method returns a list of URLs that this
// storage provider depends on to do its work.
// This list is used by the Dojo Offline Toolkit
// to cache these resources to ensure the machinery
// used by this storage provider is available offline.
// What is returned is an array of URLs.
return
[];
}
});
}
File Metadata
Details
Attached
Mime Type
text/plain
Expires
Sat, Apr 26, 09:16 (1 d, 13 h)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
27159
Default Alt Text
Provider.js (12 KB)
Attached To
rZEDHG ZedLegacy
Event Timeline
Log In to Comment