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;
		}
	};

}