dojox.storage.manager
dojo.require("dojox.storage.manager");
defined in dojox/storage/manager.js
Initializes the storage systems and figures out the best available
storage options on this platform.
Usage
function () (view source)
this.currentProvider = null;
// available: Boolean
// Whether storage of some kind is available.
this.available = false;
// providers: Array
// Array of all the static provider instances, useful if you want to
// loop through and see what providers have been registered.
this.providers = [];
this._initialized = false;
this._onLoadListeners = [];
this.initialize = function(){
// summary:
// Initializes the storage system and autodetects the best storage
// provider we can provide on this platform
this.autodetect();
};
this.register = function(/*string*/ name, /*Object*/ instance){
// summary:
// Registers the existence of a new storage provider; used by
// subclasses to inform the manager of their existence. The
// storage manager will select storage providers based on
// their ordering, so the order in which you call this method
// matters.
// name:
// The full class name of this provider, such as
// "dojox.storage.FlashStorageProvider".
// instance:
// An instance of this provider, which we will use to call
// isAvailable() on.
// keep list of providers as a list so that we can know what order
// storage providers are preferred; also, store the providers hashed
// by name in case someone wants to get a provider that uses
// a particular storage backend
this.providers.push(instance);
this.providers[name] = instance;
};
this.setProvider = function(storageClass){
// summary:
// Instructs the storageManager to use the given storage class for
// all storage requests.
// description:
// Example-
// dojox.storage.setProvider(
// dojox.storage.IEStorageProvider)
};
this.autodetect = function(){
// summary:
// Autodetects the best possible persistent storage provider
// available on this platform.
//console.debug("dojox.storage.manager.autodetect");
if(this._initialized){ // already finished
return;
}
// a flag to force the storage manager to use a particular
// storage provider type, such as
// djConfig = {forceStorageProvider: "dojox.storage.WhatWGStorageProvider"};
var forceProvider = dojo.config["forceStorageProvider"] || false;
// go through each provider, seeing if it can be used
var providerToUse;
//FIXME: use dojo.some
for(var i = 0; i < this.providers.length; i++){
providerToUse = this.providers[i];
if(forceProvider && forceProvider == providerToUse.declaredClass){
// still call isAvailable for this provider, since this helps some
// providers internally figure out if they are available
// FIXME: This should be refactored since it is non-intuitive
// that isAvailable() would initialize some state
providerToUse.isAvailable();
break;
}else if(!forceProvider && providerToUse.isAvailable()){
break;
}
}
if(!providerToUse){ // no provider available
this._initialized = true;
this.available = false;
this.currentProvider = null;
console.warn("No storage provider found for this platform");
this.loaded();
return;
}
// create this provider and mix in it's properties
// so that developers can do dojox.storage.put rather
// than dojox.storage.currentProvider.put, for example
this.currentProvider = providerToUse;
dojo.mixin(dojox.storage, this.currentProvider);
// have the provider initialize itself
dojox.storage.initialize();
this._initialized = true;
this.available = true;
};
this.isAvailable = function(){ /*Boolean*/
// summary: Returns whether any storage options are available.
return this.available;
};
this.addOnLoad = function(func){ /* void */
// summary:
// Adds an onload listener to know when Dojo Offline can be used.
// description:
// Adds a listener to know when Dojo Offline can be used. This
// ensures that the Dojo Offline framework is loaded and that the
// local dojox.storage system is ready to be used. This method is
// useful if you don't want to have a dependency on Dojo Events
// when using dojox.storage.
// func: Function
// A function to call when Dojo Offline is ready to go
this._onLoadListeners.push(func);
if(this.isInitialized()){
this._fireLoaded();
}
};
this.removeOnLoad = function(func){ /* void */
// summary: Removes the given onLoad listener
for(var i = 0; i < this._onLoadListeners.length; i++){
if(func == this._onLoadListeners[i]){
this._onLoadListeners = this._onLoadListeners.splice(i, 1);
break;
}
}
};
this.isInitialized = function(){ /*Boolean*/
// summary:
// Returns whether the storage system is initialized and ready to
// be used.
// FIXME: This should REALLY not be in here, but it fixes a tricky
// Flash timing bug.
// Confirm that this is still needed with the newly refactored Dojo
// Flash. Used to be for Internet Explorer. -- Brad Neuberg
if(this.currentProvider != null
&& this.currentProvider.declaredClass == "dojox.storage.FlashStorageProvider"
&& dojox.flash.ready == false){
return false;
}else{
return this._initialized;
}
};
this.supportsProvider = function(/*string*/ storageClass){ /* Boolean */
// summary: Determines if this platform supports the given storage provider.
// description:
// Example-
// dojox.storage.manager.supportsProvider(
// "dojox.storage.InternetExplorerStorageProvider");
// construct this class dynamically
try{
// dynamically call the given providers class level isAvailable()
// method
var provider = eval("new " + storageClass + "()");
var results = provider.isAvailable();
if(!results){ return false; }
return results;
}catch(e){
return false;
}
};
this.getProvider = function(){ /* Object */
// summary: Gets the current provider
return this.currentProvider;
};
this.loaded = function(){
// summary:
// The storage provider should call this method when it is loaded
// and ready to be used. Clients who will use the provider will
// connect to this method to know when they can use the storage
// system. You can either use dojo.connect to connect to this
// function, or can use dojox.storage.manager.addOnLoad() to add
// a listener that does not depend on the dojo.event package.
// description:
// Example 1-
// if(dojox.storage.manager.isInitialized() == false){
// dojo.connect(dojox.storage.manager, "loaded", TestStorage, "initialize");
// }else{
// dojo.connect(dojo, "loaded", TestStorage, "initialize");
// }
// Example 2-
// dojox.storage.manager.addOnLoad(someFunction);
// FIXME: we should just provide a Deferred for this. That way you
// don't care when this happens or has happened. Deferreds are in Base
this._fireLoaded();
};
this._fireLoaded = function(){
//console.debug("dojox.storage.manager._fireLoaded");
dojo.forEach(this._onLoadListeners, function(i){
try{
i();
}catch(e){ console.debug(e); }
});
};
this.getResourceList = function(){
// summary:
// Returns a list of whatever resources are necessary for storage
// providers to work.
// description:
// This will return all files needed by all storage providers for
// this particular environment type. For example, if we are in the
// browser environment, then this will return the hidden SWF files
// needed by the FlashStorageProvider, even if we don't need them
// for the particular browser we are working within. This is meant
// to faciliate Dojo Offline, which must retrieve all resources we
// need offline into the offline cache -- we retrieve everything
// needed, in case another browser that requires different storage
// mechanisms hits the local offline cache. For example, if we
// were to sync against Dojo Offline on Firefox 2, then we would
// not grab the FlashStorageProvider resources needed for Safari.
var results = [];
dojo.forEach(dojox.storage.manager.providers, function(currentProvider){
results = results.concat(currentProvider.getResourceList());
});
return results;
}
Only private and/or inherited functions are available.
void Adds an onload listener to know when Dojo Offline can be used.
Autodetects the best possible persistent storage provider
Object Gets the current provider
Returns a list of whatever resources are necessary for storage providers to work.
Initializes the storage system and autodetects the best storage provider we can provide on this platform
Boolean Returns whether any storage options are available.
Boolean Returns whether the storage system is initialized and ready to be used.
The storage provider should call this method when it is loaded and ready to be used. Clients who will use the provider will connect to this method to know when they can use the storage system. You can either use dojo.connect to connect to this function, or can use dojox.storage.manager.addOnLoad() to add a listener that does not depend on the dojo.event package.
Registers the existence of a new storage provider; used by subclasses to inform the manager of their existence. The storage manager will select storage providers based on their ordering, so the order in which you call this method matters.
void Removes the given onLoad listener
Instructs the storageManager to use the given storage class for all storage requests.
Boolean Determines if this platform supports the given storage provider.
Only private and/or inherited properties are available.
The storage provider that was automagically chosen to do storage on this platform, such as dojox.storage.FlashStorageProvider.