Page MenuHomeCode
Files F947854

manager.js
No OneTemporary
Actions

manager.js
View Options

if(!dojo._hasResource["dojox.storage.manager"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
dojo._hasResource["dojox.storage.manager"] = true;
dojo.provide("dojox.storage.manager");
//dojo.require("dojo.AdapterRegistry");
// FIXME: refactor this to use an AdapterRegistry
dojox.storage.manager = new function(){
// summary: A singleton class in charge of the dojox.storage system
// description:
// Initializes the storage systems and figures out the best available
// storage options on this platform.
// currentProvider: Object
// The storage provider that was automagically chosen to do storage
// on this platform, such as dojox.storage.FlashStorageProvider.
this.currentProvider = null;
// available: Boolean
// Whether storage of some kind is available.
this.available = false;
this._initialized = false;
this._providers = [];
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.
this._providers[this._providers.length] = instance; //FIXME: push?
this._providers[name] = instance; // FIXME: this._providers is an array, not a hash
};
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
//console.debug("dojox.storage.manager already initialized; returning");
return;
}
// a flag to force the storage manager to use a particular
// storage provider type, such as
// djConfig = {forceStorageProvider: "dojox.storage.WhatWGStorageProvider"};
var forceProvider = djConfig["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 == 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(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
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;
}
};
}

File Metadata

Mime Type
text/plain
Expires
Sat, Apr 26, 13:41 (21 h, 18 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
26703
Default Alt Text
manager.js (8 KB)

Event Timeline