aboutsummaryrefslogtreecommitdiff
path: root/includes/js/dojo/data/api/Write.js
diff options
context:
space:
mode:
Diffstat (limited to 'includes/js/dojo/data/api/Write.js')
-rw-r--r--includes/js/dojo/data/api/Write.js226
1 files changed, 226 insertions, 0 deletions
diff --git a/includes/js/dojo/data/api/Write.js b/includes/js/dojo/data/api/Write.js
new file mode 100644
index 0000000..b02eb6e
--- /dev/null
+++ b/includes/js/dojo/data/api/Write.js
@@ -0,0 +1,226 @@
+if(!dojo._hasResource["dojo.data.api.Write"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojo.data.api.Write"] = true;
+dojo.provide("dojo.data.api.Write");
+dojo.require("dojo.data.api.Read");
+
+dojo.declare("dojo.data.api.Write", dojo.data.api.Read, {
+ // summary:
+ // This is an abstract API that data provider implementations conform to.
+ // This file defines function signatures and intentionally leaves all the
+ // functionss unimplemented.
+
+ getFeatures: function(){
+ // summary:
+ // See dojo.data.api.Read.getFeatures()
+ return {
+ 'dojo.data.api.Read': true,
+ 'dojo.data.api.Write': true
+ };
+ },
+
+ newItem: function(/* Object? */ keywordArgs, /*Object?*/ parentInfo){
+ // summary:
+ // Returns a newly created item. Sets the attributes of the new
+ // item based on the *keywordArgs* provided. In general, the attribute
+ // names in the keywords become the attributes in the new item and as for
+ // the attribute values in keywordArgs, they become the values of the attributes
+ // in the new item. In addition, for stores that support hierarchical item
+ // creation, an optional second parameter is accepted that defines what item is the parent
+ // of the new item and what attribute of that item should the new item be assigned to.
+ // In general, this will assume that the attribute targetted is multi-valued and a new item
+ // is appended onto the list of values for that attribute.
+ //
+ // keywordArgs:
+ // A javascript object defining the initial content of the item as a set of JavaScript 'property name: value' pairs.
+ // parentInfo:
+ // An optional javascript object defining what item is the parent of this item (in a hierarchical store. Not all stores do hierarchical items),
+ // and what attribute of that parent to assign the new item to. If this is present, and the attribute specified
+ // is a multi-valued attribute, it will append this item into the array of values for that attribute. The structure
+ // of the object is as follows:
+ // {
+ // parent: someItem,
+ // attribute: "attribute-name-string"
+ // }
+ //
+ // exceptions:
+ // Throws an exception if *keywordArgs* is a string or a number or
+ // anything other than a simple anonymous object.
+ // Throws an exception if the item in parentInfo is not an item from the store
+ // or if the attribute isn't an attribute name string.
+ // example:
+ // | var kermit = store.newItem({name: "Kermit", color:[blue, green]});
+
+ var newItem;
+ throw new Error('Unimplemented API: dojo.data.api.Write.newItem');
+ return newItem; // item
+ },
+
+ deleteItem: function(/* item */ item){
+ // summary:
+ // Deletes an item from the store.
+ //
+ // item:
+ // The item to delete.
+ //
+ // exceptions:
+ // Throws an exception if the argument *item* is not an item
+ // (if store.isItem(item) returns false).
+ // example:
+ // | var success = store.deleteItem(kermit);
+ throw new Error('Unimplemented API: dojo.data.api.Write.deleteItem');
+ return false; // boolean
+ },
+
+ setValue: function( /* item */ item,
+ /* string */ attribute,
+ /* almost anything */ value){
+ // summary:
+ // Sets the value of an attribute on an item.
+ // Replaces any previous value or values.
+ //
+ // item:
+ // The item to modify.
+ // attribute:
+ // The attribute of the item to change represented as a string name.
+ // value:
+ // The value to assign to the item.
+ //
+ // exceptions:
+ // Throws an exception if *item* is not an item, or if *attribute*
+ // is neither an attribute object or a string.
+ // Throws an exception if *value* is undefined.
+ // example:
+ // | var success = store.set(kermit, "color", "green");
+ throw new Error('Unimplemented API: dojo.data.api.Write.setValue');
+ return false; // boolean
+ },
+
+ setValues: function(/* item */ item,
+ /* string */ attribute,
+ /* array */ values){
+ // summary:
+ // Adds each value in the *values* array as a value of the given
+ // attribute on the given item.
+ // Replaces any previous value or values.
+ // Calling store.setValues(x, y, []) (with *values* as an empty array) has
+ // the same effect as calling store.unsetAttribute(x, y).
+ //
+ // item:
+ // The item to modify.
+ // attribute:
+ // The attribute of the item to change represented as a string name.
+ // values:
+ // An array of values to assign to the attribute..
+ //
+ // exceptions:
+ // Throws an exception if *values* is not an array, if *item* is not an
+ // item, or if *attribute* is neither an attribute object or a string.
+ // example:
+ // | var success = store.setValues(kermit, "color", ["green", "aqua"]);
+ // | success = store.setValues(kermit, "color", []);
+ // | if (success) {assert(!store.hasAttribute(kermit, "color"));}
+ throw new Error('Unimplemented API: dojo.data.api.Write.setValues');
+ return false; // boolean
+ },
+
+ unsetAttribute: function( /* item */ item,
+ /* string */ attribute){
+ // summary:
+ // Deletes all the values of an attribute on an item.
+ //
+ // item:
+ // The item to modify.
+ // attribute:
+ // The attribute of the item to unset represented as a string.
+ //
+ // exceptions:
+ // Throws an exception if *item* is not an item, or if *attribute*
+ // is neither an attribute object or a string.
+ // example:
+ // | var success = store.unsetAttribute(kermit, "color");
+ // | if (success) {assert(!store.hasAttribute(kermit, "color"));}
+ throw new Error('Unimplemented API: dojo.data.api.Write.clear');
+ return false; // boolean
+ },
+
+ save: function(/* object */ keywordArgs){
+ // summary:
+ // Saves to the server all the changes that have been made locally.
+ // The save operation may take some time and is generally performed
+ // in an asynchronous fashion. The outcome of the save action is
+ // is passed into the set of supported callbacks for the save.
+ //
+ // keywordArgs:
+ // {
+ // onComplete: function
+ // onError: function
+ // scope: object
+ // }
+ //
+ // The *onComplete* parameter.
+ // function();
+ //
+ // If an onComplete callback function is provided, the callback function
+ // will be called just once, after the save has completed. No parameters
+ // are generally passed to the onComplete.
+ //
+ // The *onError* parameter.
+ // function(errorData);
+ //
+ // If an onError callback function is provided, the callback function
+ // will be called if there is any sort of error while attempting to
+ // execute the save. The onError function will be based one parameter, the
+ // error.
+ //
+ // The *scope* parameter.
+ // If a scope object is provided, all of the callback function (
+ // onComplete, onError, etc) will be invoked in the context of the scope
+ // object. In the body of the callback function, the value of the "this"
+ // keyword will be the scope object. If no scope object is provided,
+ // the callback functions will be called in the context of dojo.global.
+ // For example, onComplete.call(scope) vs.
+ // onComplete.call(dojo.global)
+ //
+ // returns:
+ // Nothing. Since the saves are generally asynchronous, there is
+ // no need to return anything. All results are passed via callbacks.
+ // example:
+ // | store.save({onComplete: onSave});
+ // | store.save({scope: fooObj, onComplete: onSave, onError: saveFailed});
+ throw new Error('Unimplemented API: dojo.data.api.Write.save');
+ },
+
+ revert: function(){
+ // summary:
+ // Discards any unsaved changes.
+ // description:
+ // Discards any unsaved changes.
+ //
+ // example:
+ // | var success = store.revert();
+ throw new Error('Unimplemented API: dojo.data.api.Write.revert');
+ return false; // boolean
+ },
+
+ isDirty: function(/* item? */ item){
+ // summary:
+ // Given an item, isDirty() returns true if the item has been modified
+ // since the last save(). If isDirty() is called with no *item* argument,
+ // then this function returns true if any item has been modified since
+ // the last save().
+ //
+ // item:
+ // The item to check.
+ //
+ // exceptions:
+ // Throws an exception if isDirty() is passed an argument and the
+ // argument is not an item.
+ // example:
+ // | var trueOrFalse = store.isDirty(kermit); // true if kermit is dirty
+ // | var trueOrFalse = store.isDirty(); // true if any item is dirty
+ throw new Error('Unimplemented API: dojo.data.api.Write.isDirty');
+ return false; // boolean
+ }
+});
+
+}