RubyGems - dojo-rails - Versions diffs - 0.9.4 → 0.9.5 - Mend

dojo-rails 0.9.4 → 0.9.5

Files changed (7054) hide show

data/vendor/assets/javascripts/dojox/data/AndOrWriteStore.js.uncompressed.js DELETED Viewed

@@ -1,811 +0,0 @@
-define("dojox/data/AndOrWriteStore", ["dojo/_base/declare","dojo/_base/lang","dojo/_base/array", "dojo/_base/json", "dojo/date/stamp",
-		"dojo/_base/window", "./AndOrReadStore"],
-  function(declare, lang, arrayUtil, json, dateStamp, winUtil, AndOrReadStore) {
-/*===== var AndOrReadStore = dojox.data.AndOrReadStore; =====*/
-return declare("dojox.data.AndOrWriteStore", AndOrReadStore, {
-	constructor: function(/* object */ keywordParameters){
-		//	keywordParameters: {typeMap: object)
-		//		The structure of the typeMap object is as follows:
-		//		{
-		//			type0: function || object,
-		//			type1: function || object,
-		//			...
-		//			typeN: function || object
-		//		}
-		//		Where if it is a function, it is assumed to be an object constructor that takes the
-		//		value of _value as the initialization parameters.  It is serialized assuming object.toString()
-		//		serialization.  If it is an object, then it is assumed
-		//		to be an object of general form:
-		//		{
-		//			type: function, //constructor.
-		//			deserialize:	function(value) //The function that parses the value and constructs the object defined by type appropriately.
-		//			serialize:	function(object) //The function that converts the object back into the proper file format form.
-		//		}
-		// AndOrWriteStore duplicates ItemFileWriteStore, except extends AndOrReadStore, which offers complex queries.
-		// ItemFileWriteStore extends ItemFileReadStore to implement these additional dojo.data APIs
-		this._features['dojo.data.api.Write'] = true;
-		this._features['dojo.data.api.Notification'] = true;
-		// For keeping track of changes so that we can implement isDirty and revert
-		this._pending = {
-			_newItems:{},
-			_modifiedItems:{},
-			_deletedItems:{}
-		};
-		if(!this._datatypeMap['Date'].serialize){
-			this._datatypeMap['Date'].serialize = function(obj){
-				return dateStamp.toISOString(obj, {zulu:true});
-			};
-		}
-		//Disable only if explicitly set to false.
-		if(keywordParameters && (keywordParameters.referenceIntegrity === false)){
-			this.referenceIntegrity = false;
-		}
-		// this._saveInProgress is set to true, briefly, from when save() is first called to when it completes
-		this._saveInProgress = false;
-	},
-	referenceIntegrity: true, //Flag that defaultly enabled reference integrity tracking.  This way it can also be disabled pogrammatially or declaratively.
-	_assert: function(/* boolean */ condition){
-		if(!condition){
-			throw new Error("assertion failed in ItemFileWriteStore");
-		}
-	},
-	_getIdentifierAttribute: function(){
-		var identifierAttribute = this.getFeatures()['dojo.data.api.Identity'];
-		// this._assert((identifierAttribute === Number) || (dojo.isString(identifierAttribute)));
-		return identifierAttribute;
-	},
-/* dojo.data.api.Write */
-	newItem: function(/* Object? */ keywordArgs, /* Object? */ parentInfo){
-		// summary: See dojo.data.api.Write.newItem()
-		this._assert(!this._saveInProgress);
-		if(!this._loadFinished){
-			// We need to do this here so that we'll be able to find out what
-			// identifierAttribute was specified in the data file.
-			this._forceLoad();
-		}
-		if(typeof keywordArgs != "object" && typeof keywordArgs != "undefined"){
-			throw new Error("newItem() was passed something other than an object");
-		}
-		var newIdentity = null;
-		var identifierAttribute = this._getIdentifierAttribute();
-		if(identifierAttribute === Number){
-			newIdentity = this._arrayOfAllItems.length;
-		}else{
-			newIdentity = keywordArgs[identifierAttribute];
-			if(typeof newIdentity === "undefined"){
-				throw new Error("newItem() was not passed an identity for the new item");
-			}
-			if(lang.isArray(newIdentity)){
-				throw new Error("newItem() was not passed an single-valued identity");
-			}
-		}
-		// make sure this identity is not already in use by another item, if identifiers were
-		// defined in the file.  Otherwise it would be the item count,
-		// which should always be unique in this case.
-		if(this._itemsByIdentity){
-			this._assert(typeof this._itemsByIdentity[newIdentity] === "undefined");
-		}
-		this._assert(typeof this._pending._newItems[newIdentity] === "undefined");
-		this._assert(typeof this._pending._deletedItems[newIdentity] === "undefined");
-		var newItem = {};
-		newItem[this._storeRefPropName] = this;
-		newItem[this._itemNumPropName] = this._arrayOfAllItems.length;
-		if(this._itemsByIdentity){
-			this._itemsByIdentity[newIdentity] = newItem;
-			//We have to set the identifier now, otherwise we can't look it
-			//up at calls to setValueorValues in parentInfo handling.
-			newItem[identifierAttribute] = [newIdentity];
-		}
-		this._arrayOfAllItems.push(newItem);
-		//We need to construct some data for the onNew call too...
-		var pInfo = null;
-		// Now we need to check to see where we want to assign this thingm if any.
-		if(parentInfo && parentInfo.parent && parentInfo.attribute){
-			pInfo = {
-				item: parentInfo.parent,
-				attribute: parentInfo.attribute,
-				oldValue: undefined
-			};
-			//See if it is multi-valued or not and handle appropriately
-			//Generally, all attributes are multi-valued for this store
-			//So, we only need to append if there are already values present.
-			var values = this.getValues(parentInfo.parent, parentInfo.attribute);
-			if(values && values.length > 0){
-				var tempValues = values.slice(0, values.length);
-				if(values.length === 1){
-					pInfo.oldValue = values[0];
-				}else{
-					pInfo.oldValue = values.slice(0, values.length);
-				}
-				tempValues.push(newItem);
-				this._setValueOrValues(parentInfo.parent, parentInfo.attribute, tempValues, false);
-				pInfo.newValue = this.getValues(parentInfo.parent, parentInfo.attribute);
-			}else{
-				this._setValueOrValues(parentInfo.parent, parentInfo.attribute, newItem, false);
-				pInfo.newValue = newItem;
-			}
-		}else{
-			//Toplevel item, add to both top list as well as all list.
-			newItem[this._rootItemPropName]=true;
-			this._arrayOfTopLevelItems.push(newItem);
-		}
-		this._pending._newItems[newIdentity] = newItem;
-		//Clone over the properties to the new item
-		for(var key in keywordArgs){
-			if(key === this._storeRefPropName || key === this._itemNumPropName){
-				// Bummer, the user is trying to do something like
-				// newItem({_S:"foo"}).  Unfortunately, our superclass,
-				// ItemFileReadStore, is already using _S in each of our items
-				// to hold private info.  To avoid a naming collision, we
-				// need to move all our private info to some other property
-				// of all the items/objects.  So, we need to iterate over all
-				// the items and do something like:
-				//    item.__S = item._S;
-				//    item._S = undefined;
-				// But first we have to make sure the new "__S" variable is
-				// not in use, which means we have to iterate over all the
-				// items checking for that.
-				throw new Error("encountered bug in ItemFileWriteStore.newItem");
-			}
-			var value = keywordArgs[key];
-			if(!lang.isArray(value)){
-				value = [value];
-			}
-			newItem[key] = value;
-			if(this.referenceIntegrity){
-				for(var i = 0; i < value.length; i++){
-					var val = value[i];
-					if(this.isItem(val)){
-						this._addReferenceToMap(val, newItem, key);
-					}
-				}
-			}
-		}
-		this.onNew(newItem, pInfo); // dojo.data.api.Notification call
-		return newItem; // item
-	},
-	_removeArrayElement: function(/* Array */ array, /* anything */ element){
-		var index = arrayUtil.indexOf(array, element);
-		if(index != -1){
-			array.splice(index, 1);
-			return true;
-		}
-		return false;
-	},
-	deleteItem: function(/* item */ item){
-		// summary: See dojo.data.api.Write.deleteItem()
-		this._assert(!this._saveInProgress);
-		this._assertIsItem(item);
-		// Remove this item from the _arrayOfAllItems, but leave a null value in place
-		// of the item, so as not to change the length of the array, so that in newItem()
-		// we can still safely do: newIdentity = this._arrayOfAllItems.length;
-		var indexInArrayOfAllItems = item[this._itemNumPropName];
-		var identity = this.getIdentity(item);
-		//If we have reference integrity on, we need to do reference cleanup for the deleted item
-		if(this.referenceIntegrity){
-			//First scan all the attributes of this items for references and clean them up in the map
-			//As this item is going away, no need to track its references anymore.
-			//Get the attributes list before we generate the backup so it
-			//doesn't pollute the attributes list.
-			var attributes = this.getAttributes(item);
-			//Backup the map, we'll have to restore it potentially, in a revert.
-			if(item[this._reverseRefMap]){
-				item["backup_" + this._reverseRefMap] = lang.clone(item[this._reverseRefMap]);
-			}
-			//TODO:  This causes a reversion problem.  This list won't be restored on revert since it is
-			//attached to the 'value'. item, not ours.  Need to back tese up somehow too.
-			//Maybe build a map of the backup of the entries and attach it to the deleted item to be restored
-			//later.  Or just record them and call _addReferenceToMap on them in revert.
-			arrayUtil.forEach(attributes, function(attribute){
-				arrayUtil.forEach(this.getValues(item, attribute), function(value){
-					if(this.isItem(value)){
-						//We have to back up all the references we had to others so they can be restored on a revert.
-						if(!item["backupRefs_" + this._reverseRefMap]){
-							item["backupRefs_" + this._reverseRefMap] = [];
-						}
-						item["backupRefs_" + this._reverseRefMap].push({id: this.getIdentity(value), attr: attribute});
-						this._removeReferenceFromMap(value, item, attribute);
-					}
-				}, this);
-			}, this);
-			//Next, see if we have references to this item, if we do, we have to clean them up too.
-			var references = item[this._reverseRefMap];
-			if(references){
-				//Look through all the items noted as references to clean them up.
-				for(var itemId in references){
-					var containingItem = null;
-					if(this._itemsByIdentity){
-						containingItem = this._itemsByIdentity[itemId];
-					}else{
-						containingItem = this._arrayOfAllItems[itemId];
-					}
-					//We have a reference to a containing item, now we have to process the
-					//attributes and clear all references to the item being deleted.
-					if(containingItem){
-						for(var attribute in references[itemId]){
-							var oldValues = this.getValues(containingItem, attribute) || [];
-							var newValues = arrayUtil.filter(oldValues, function(possibleItem){
-								return !(this.isItem(possibleItem) && this.getIdentity(possibleItem) == identity);
-							}, this);
-							//Remove the note of the reference to the item and set the values on the modified attribute.
-							this._removeReferenceFromMap(item, containingItem, attribute);
-							if(newValues.length < oldValues.length){
-								this._setValueOrValues(containingItem, attribute, newValues);
-							}
-						}
-					}
-				}
-			}
-		}
-		this._arrayOfAllItems[indexInArrayOfAllItems] = null;
-		item[this._storeRefPropName] = null;
-		if(this._itemsByIdentity){
-			delete this._itemsByIdentity[identity];
-		}
-		this._pending._deletedItems[identity] = item;
-		//Remove from the toplevel items, if necessary...
-		if(item[this._rootItemPropName]){
-			this._removeArrayElement(this._arrayOfTopLevelItems, item);
-		}
-		this.onDelete(item); // dojo.data.api.Notification call
-		return true;
-	},
-	setValue: function(/* item */ item, /* attribute-name-string */ attribute, /* almost anything */ value){
-		// summary: See dojo.data.api.Write.set()
-		return this._setValueOrValues(item, attribute, value, true); // boolean
-	},
-	setValues: function(/* item */ item, /* attribute-name-string */ attribute, /* array */ values){
-		// summary: See dojo.data.api.Write.setValues()
-		return this._setValueOrValues(item, attribute, values, true); // boolean
-	},
-	unsetAttribute: function(/* item */ item, /* attribute-name-string */ attribute){
-		// summary: See dojo.data.api.Write.unsetAttribute()
-		return this._setValueOrValues(item, attribute, [], true);
-	},
-	_setValueOrValues: function(/* item */ item, /* attribute-name-string */ attribute, /* anything */ newValueOrValues, /*boolean?*/ callOnSet){
-		this._assert(!this._saveInProgress);
-		// Check for valid arguments
-		this._assertIsItem(item);
-		this._assert(lang.isString(attribute));
-		this._assert(typeof newValueOrValues !== "undefined");
-		// Make sure the user isn't trying to change the item's identity
-		var identifierAttribute = this._getIdentifierAttribute();
-		if(attribute == identifierAttribute){
-			throw new Error("ItemFileWriteStore does not have support for changing the value of an item's identifier.");
-		}
-		// To implement the Notification API, we need to make a note of what
-		// the old attribute value was, so that we can pass that info when
-		// we call the onSet method.
-		var oldValueOrValues = this._getValueOrValues(item, attribute);
-		var identity = this.getIdentity(item);
-		if(!this._pending._modifiedItems[identity]){
-			// Before we actually change the item, we make a copy of it to
-			// record the original state, so that we'll be able to revert if
-			// the revert method gets called.  If the item has already been
-			// modified then there's no need to do this now, since we already
-			// have a record of the original state.
-			var copyOfItemState = {};
-			for(var key in item){
-				if((key === this._storeRefPropName) || (key === this._itemNumPropName) || (key === this._rootItemPropName)){
-					copyOfItemState[key] = item[key];
-				}else if(key === this._reverseRefMap){
-					copyOfItemState[key] = lang.clone(item[key]);
-				}else{
-					copyOfItemState[key] = item[key].slice(0, item[key].length);
-				}
-			}
-			// Now mark the item as dirty, and save the copy of the original state
-			this._pending._modifiedItems[identity] = copyOfItemState;
-		}
-		// Okay, now we can actually change this attribute on the item
-		var success = false;
-		if(lang.isArray(newValueOrValues) && newValueOrValues.length === 0){
-			// If we were passed an empty array as the value, that counts
-			// as "unsetting" the attribute, so we need to remove this
-			// attribute from the item.
-			success = delete item[attribute];
-			newValueOrValues = undefined; // used in the onSet Notification call below
-			if(this.referenceIntegrity && oldValueOrValues){
-				var oldValues = oldValueOrValues;
-				if(!lang.isArray(oldValues)){
-					oldValues = [oldValues];
-				}
-				for(var i = 0; i < oldValues.length; i++){
-					var value = oldValues[i];
-					if(this.isItem(value)){
-						this._removeReferenceFromMap(value, item, attribute);
-					}
-				}
-			}
-		}else{
-			var newValueArray;
-			if(lang.isArray(newValueOrValues)){
-				var newValues = newValueOrValues;
-				// Unfortunately, it's not safe to just do this:
-				//    newValueArray = newValues;
-				// Instead, we need to copy the array, which slice() does very nicely.
-				// This is so that our internal data structure won't
-				// get corrupted if the user mucks with the values array *after*
-				// calling setValues().
-				newValueArray = newValueOrValues.slice(0, newValueOrValues.length);
-			}else{
-				newValueArray = [newValueOrValues];
-			}
-			//We need to handle reference integrity if this is on.
-			//In the case of set, we need to see if references were added or removed
-			//and update the reference tracking map accordingly.
-			if(this.referenceIntegrity){
-				if(oldValueOrValues){
-					var oldValues = oldValueOrValues;
-					if(!lang.isArray(oldValues)){
-						oldValues = [oldValues];
-					}
-					//Use an associative map to determine what was added/removed from the list.
-					//Should be O(n) performant.  First look at all the old values and make a list of them
-					//Then for any item not in the old list, we add it.  If it was already present, we remove it.
-					//Then we pass over the map and any references left it it need to be removed (IE, no match in
-					//the new values list).
-					var map = {};
-					arrayUtil.forEach(oldValues, function(possibleItem){
-						if(this.isItem(possibleItem)){
-							var id = this.getIdentity(possibleItem);
-							map[id.toString()] = true;
-						}
-					}, this);
-					arrayUtil.forEach(newValueArray, function(possibleItem){
-						if(this.isItem(possibleItem)){
-							var id = this.getIdentity(possibleItem);
-							if(map[id.toString()]){
-								delete map[id.toString()];
-							}else{
-								this._addReferenceToMap(possibleItem, item, attribute);
-							}
-						}
-					}, this);
-					for(var rId in map){
-						var removedItem;
-						if(this._itemsByIdentity){
-							removedItem = this._itemsByIdentity[rId];
-						}else{
-							removedItem = this._arrayOfAllItems[rId];
-						}
-						this._removeReferenceFromMap(removedItem, item, attribute);
-					}
-				}else{
-					//Everything is new (no old values) so we have to just
-					//insert all the references, if any.
-					for(var i = 0; i < newValueArray.length; i++){
-						var value = newValueArray[i];
-						if(this.isItem(value)){
-							this._addReferenceToMap(value, item, attribute);
-						}
-					}
-				}
-			}
-			item[attribute] = newValueArray;
-			success = true;
-		}
-		// Now we make the dojo.data.api.Notification call
-		if(callOnSet){
-			this.onSet(item, attribute, oldValueOrValues, newValueOrValues);
-		}
-		return success; // boolean
-	},
-	_addReferenceToMap: function(/*item*/ refItem, /*item*/ parentItem, /*string*/ attribute){
-		//	summary:
-		//		Method to add an reference map entry for an item and attribute.
-		//	description:
-		//		Method to add an reference map entry for an item and attribute. 		 //
-		//	refItem:
-		//		The item that is referenced.
-		//	parentItem:
-		//		The item that holds the new reference to refItem.
-		//	attribute:
-		//		The attribute on parentItem that contains the new reference.
-		var parentId = this.getIdentity(parentItem);
-		var references = refItem[this._reverseRefMap];
-		if(!references){
-			references = refItem[this._reverseRefMap] = {};
-		}
-		var itemRef = references[parentId];
-		if(!itemRef){
-			itemRef = references[parentId] = {};
-		}
-		itemRef[attribute] = true;
-	},
-	_removeReferenceFromMap: function(/* item */ refItem, /* item */ parentItem, /*strin*/ attribute){
-		//	summary:
-		//		Method to remove an reference map entry for an item and attribute.
-		//	description:
-		//		Method to remove an reference map entry for an item and attribute.  This will
-		//		also perform cleanup on the map such that if there are no more references at all to
-		//		the item, its reference object and entry are removed.
-		//
-		//	refItem:
-		//		The item that is referenced.
-		//	parentItem:
-		//		The item holding a reference to refItem.
-		//	attribute:
-		//		The attribute on parentItem that contains the reference.
-		var identity = this.getIdentity(parentItem);
-		var references = refItem[this._reverseRefMap];
-		var itemId;
-		if(references){
-			for(itemId in references){
-				if(itemId == identity){
-					delete references[itemId][attribute];
-					if(this._isEmpty(references[itemId])){
-						delete references[itemId];
-					}
-				}
-			}
-			if(this._isEmpty(references)){
-				delete refItem[this._reverseRefMap];
-			}
-		}
-	},
-	_dumpReferenceMap: function(){
-		//	summary:
-		//		Function to dump the reverse reference map of all items in the store for debug purposes.
-		//	description:
-		//		Function to dump the reverse reference map of all items in the store for debug purposes.
-		var i;
-		for(i = 0; i < this._arrayOfAllItems.length; i++){
-			var item = this._arrayOfAllItems[i];
-			if(item && item[this._reverseRefMap]){
-				console.log("Item: [" + this.getIdentity(item) + "] is referenced by: " + json.toJson(item[this._reverseRefMap]));
-			}
-		}
-	},
-	_getValueOrValues: function(/* item */ item, /* attribute-name-string */ attribute){
-		var valueOrValues = undefined;
-		if(this.hasAttribute(item, attribute)){
-			var valueArray = this.getValues(item, attribute);
-			if(valueArray.length == 1){
-				valueOrValues = valueArray[0];
-			}else{
-				valueOrValues = valueArray;
-			}
-		}
-		return valueOrValues;
-	},
-	_flatten: function(/* anything */ value){
-		if(this.isItem(value)){
-			var item = value;
-			// Given an item, return an serializable object that provides a
-			// reference to the item.
-			// For example, given kermit:
-			//    var kermit = store.newItem({id:2, name:"Kermit"});
-			// we want to return
-			//    {_reference:2}
-			var identity = this.getIdentity(item);
-			var referenceObject = {_reference: identity};
-			return referenceObject;
-		}else{
-			if(typeof value === "object"){
-				for(var type in this._datatypeMap){
-					var typeMap = this._datatypeMap[type];
-					if(lang.isObject(typeMap) && !lang.isFunction(typeMap)){
-						if(value instanceof typeMap.type){
-							if(!typeMap.serialize){
-								throw new Error("ItemFileWriteStore:  No serializer defined for type mapping: [" + type + "]");
-							}
-							return {_type: type, _value: typeMap.serialize(value)};
-						}
-					} else if(value instanceof typeMap){
-						//SImple mapping, therefore, return as a toString serialization.
-						return {_type: type, _value: value.toString()};
-					}
-				}
-			}
-			return value;
-		}
-	},
-	_getNewFileContentString: function(){
-		// summary:
-		//		Generate a string that can be saved to a file.
-		//		The result should look similar to:
-		//		http://trac.dojotoolkit.org/browser/dojo/trunk/tests/data/countries.json
-		var serializableStructure = {};
-		var identifierAttribute = this._getIdentifierAttribute();
-		if(identifierAttribute !== Number){
-			serializableStructure.identifier = identifierAttribute;
-		}
-		if(this._labelAttr){
-			serializableStructure.label = this._labelAttr;
-		}
-		serializableStructure.items = [];
-		for(var i = 0; i < this._arrayOfAllItems.length; ++i){
-			var item = this._arrayOfAllItems[i];
-			if(item !== null){
-				var serializableItem = {};
-				for(var key in item){
-					if(key !== this._storeRefPropName && key !== this._itemNumPropName && key !== this._reverseRefMap && key !== this._rootItemPropName){
-						var attribute = key;
-						var valueArray = this.getValues(item, attribute);
-						if(valueArray.length == 1){
-							serializableItem[attribute] = this._flatten(valueArray[0]);
-						}else{
-							var serializableArray = [];
-							for(var j = 0; j < valueArray.length; ++j){
-								serializableArray.push(this._flatten(valueArray[j]));
-								serializableItem[attribute] = serializableArray;
-							}
-						}
-					}
-				}
-				serializableStructure.items.push(serializableItem);
-			}
-		}
-		var prettyPrint = true;
-		return json.toJson(serializableStructure, prettyPrint);
-	},
-	_isEmpty: function(something){
-		//	summary:
-		//		Function to determine if an array or object has no properties or values.
-		//	something:
-		//		The array or object to examine.
-		var empty = true;
-		if(lang.isObject(something)){
-			var i;
-			for(i in something){
-				empty = false;
-				break;
-			}
-		}else if(lang.isArray(something)){
-			if(something.length > 0){
-				empty = false;
-			}
-		}
-		return empty; //boolean
-	},
-	save: function(/* object */ keywordArgs){
-		// summary: See dojo.data.api.Write.save()
-		this._assert(!this._saveInProgress);
-		// this._saveInProgress is set to true, briefly, from when save is first called to when it completes
-		this._saveInProgress = true;
-		var self = this;
-		var saveCompleteCallback = function(){
-			self._pending = {
-				_newItems:{},
-				_modifiedItems:{},
-				_deletedItems:{}
-			};
-			self._saveInProgress = false; // must come after this._pending is cleared, but before any callbacks
-			if(keywordArgs && keywordArgs.onComplete){
-				var scope = keywordArgs.scope || winUtil.global;
-				keywordArgs.onComplete.call(scope);
-			}
-		};
-		var saveFailedCallback = function(){
-			self._saveInProgress = false;
-			if(keywordArgs && keywordArgs.onError){
-				var scope = keywordArgs.scope || winUtil.global;
-				keywordArgs.onError.call(scope);
-			}
-		};
-		if(this._saveEverything){
-			var newFileContentString = this._getNewFileContentString();
-			this._saveEverything(saveCompleteCallback, saveFailedCallback, newFileContentString);
-		}
-		if(this._saveCustom){
-			this._saveCustom(saveCompleteCallback, saveFailedCallback);
-		}
-		if(!this._saveEverything && !this._saveCustom){
-			// Looks like there is no user-defined save-handler function.
-			// That's fine, it just means the datastore is acting as a "mock-write"
-			// store -- changes get saved in memory but don't get saved to disk.
-			saveCompleteCallback();
-		}
-	},
-	revert: function(){
-		// summary: See dojo.data.api.Write.revert()
-		this._assert(!this._saveInProgress);
-		var identity;
-		for(identity in this._pending._modifiedItems){
-			// find the original item and the modified item that replaced it
-			var copyOfItemState = this._pending._modifiedItems[identity];
-			var modifiedItem = null;
-			if(this._itemsByIdentity){
-				modifiedItem = this._itemsByIdentity[identity];
-			}else{
-				modifiedItem = this._arrayOfAllItems[identity];
-			}
-			// Restore the original item into a full-fledged item again, we want to try to
-			// keep the same object instance as if we don't it, causes bugs like #9022.
-			copyOfItemState[this._storeRefPropName] = this;
-			for(key in modifiedItem){
-				delete modifiedItem[key];
-			}
-			lang.mixin(modifiedItem, copyOfItemState);
-		}
-		var deletedItem;
-		for(identity in this._pending._deletedItems){
-			deletedItem = this._pending._deletedItems[identity];
-			deletedItem[this._storeRefPropName] = this;
-			var index = deletedItem[this._itemNumPropName];
-			//Restore the reverse refererence map, if any.
-			if(deletedItem["backup_" + this._reverseRefMap]){
-				deletedItem[this._reverseRefMap] = deletedItem["backup_" + this._reverseRefMap];
-				delete deletedItem["backup_" + this._reverseRefMap];
-			}
-			this._arrayOfAllItems[index] = deletedItem;
-			if(this._itemsByIdentity){
-				this._itemsByIdentity[identity] = deletedItem;
-			}
-			if(deletedItem[this._rootItemPropName]){
-				this._arrayOfTopLevelItems.push(deletedItem);
-			}
-		}
-		//We have to pass through it again and restore the reference maps after all the
-		//undeletes have occurred.
-		for(identity in this._pending._deletedItems){
-			deletedItem = this._pending._deletedItems[identity];
-			if(deletedItem["backupRefs_" + this._reverseRefMap]){
-				arrayUtil.forEach(deletedItem["backupRefs_" + this._reverseRefMap], function(reference){
-					var refItem;
-					if(this._itemsByIdentity){
-						refItem = this._itemsByIdentity[reference.id];
-					}else{
-						refItem = this._arrayOfAllItems[reference.id];
-					}
-					this._addReferenceToMap(refItem, deletedItem, reference.attr);
-				}, this);
-				delete deletedItem["backupRefs_" + this._reverseRefMap];
-			}
-		}
-		for(identity in this._pending._newItems){
-			var newItem = this._pending._newItems[identity];
-			newItem[this._storeRefPropName] = null;
-			// null out the new item, but don't change the array index so
-			// so we can keep using _arrayOfAllItems.length.
-			this._arrayOfAllItems[newItem[this._itemNumPropName]] = null;
-			if(newItem[this._rootItemPropName]){
-				this._removeArrayElement(this._arrayOfTopLevelItems, newItem);
-			}
-			if(this._itemsByIdentity){
-				delete this._itemsByIdentity[identity];
-			}
-		}
-		this._pending = {
-			_newItems:{},
-			_modifiedItems:{},
-			_deletedItems:{}
-		};
-		return true; // boolean
-	},
-	isDirty: function(/* item? */ item){
-		// summary: See dojo.data.api.Write.isDirty()
-		if(item){
-			// return true if the item is dirty
-			var identity = this.getIdentity(item);
-			return new Boolean(this._pending._newItems[identity] ||
-				this._pending._modifiedItems[identity] ||
-				this._pending._deletedItems[identity]).valueOf(); // boolean
-		}else{
-			// return true if the store is dirty -- which means return true
-			// if there are any new items, dirty items, or modified items
-			if(!this._isEmpty(this._pending._newItems) ||
-				!this._isEmpty(this._pending._modifiedItems) ||
-				!this._isEmpty(this._pending._deletedItems)){
-				return true;
-			}
-			return false; // boolean
-		}
-	},
-/* dojo.data.api.Notification */
-	onSet: function(/* item */ item,
-					/*attribute-name-string*/ attribute,
-					/*object | array*/ oldValue,
-					/*object | array*/ newValue){
-		// summary: See dojo.data.api.Notification.onSet()
-		// No need to do anything. This method is here just so that the
-		// client code can connect observers to it.
-	},
-	onNew: function(/* item */ newItem, /*object?*/ parentInfo){
-		// summary: See dojo.data.api.Notification.onNew()
-		// No need to do anything. This method is here just so that the
-		// client code can connect observers to it.
-	},
-	onDelete: function(/* item */ deletedItem){
-		// summary: See dojo.data.api.Notification.onDelete()
-		// No need to do anything. This method is here just so that the
-		// client code can connect observers to it.
-	},
-	close: function(/* object? */ request){
-		// summary:
-		//		Over-ride of base close function of ItemFileReadStore to add in check for store state.
-		// description:
-		//		Over-ride of base close function of ItemFileReadStore to add in check for store state.
-		//		If the store is still dirty (unsaved changes), then an error will be thrown instead of
-		//		clearing the internal state for reload from the url.
-		//Clear if not dirty ... or throw an error
-		if(this.clearOnClose){
-			if(!this.isDirty()){
-				this.inherited(arguments);
-			}else{
-				//Only throw an error if the store was dirty and we were loading from a url (cannot reload from url until state is saved).
-				throw new Error("dojox.data.AndOrWriteStore: There are unsaved changes present in the store.  Please save or revert the changes before invoking close.");
-			}
-		}
-	}
-});
-});