| New file |
|---|
| 0,0 → 1,327 |
|---|
| 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 []; |
| } |
| }); |
| |
| } |