Subversion Repositories Applications.papyrus

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 [];

	}

});

}