diff options
author | Andrew Dolgov <[email protected]> | 2011-03-04 19:02:28 +0300 |
---|---|---|
committer | Andrew Dolgov <[email protected]> | 2011-03-04 19:02:59 +0300 |
commit | a089699c8915636ba4f158d77dba9b012bc93208 (patch) | |
tree | b2d7d051f1f55d44a6be07d3ee137e5a7ccfcefb /lib/dojo/data/ItemFileWriteStore.js | |
parent | cfad9259a6feacfa8194b1312770ae6db1ecce50 (diff) |
build custom layer of Dojo to speed up loading of tt-rss (refs #293)
Diffstat (limited to 'lib/dojo/data/ItemFileWriteStore.js')
-rw-r--r-- | lib/dojo/data/ItemFileWriteStore.js | 1308 |
1 files changed, 807 insertions, 501 deletions
diff --git a/lib/dojo/data/ItemFileWriteStore.js b/lib/dojo/data/ItemFileWriteStore.js index c891c14e7..8782dce05 100644 --- a/lib/dojo/data/ItemFileWriteStore.js +++ b/lib/dojo/data/ItemFileWriteStore.js @@ -5,507 +5,813 @@ */ -if(!dojo._hasResource["dojo.data.ItemFileWriteStore"]){ -dojo._hasResource["dojo.data.ItemFileWriteStore"]=true; +if(!dojo._hasResource["dojo.data.ItemFileWriteStore"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. +dojo._hasResource["dojo.data.ItemFileWriteStore"] = true; dojo.provide("dojo.data.ItemFileWriteStore"); dojo.require("dojo.data.ItemFileReadStore"); -dojo.declare("dojo.data.ItemFileWriteStore",dojo.data.ItemFileReadStore,{constructor:function(_1){ -this._features["dojo.data.api.Write"]=true; -this._features["dojo.data.api.Notification"]=true; -this._pending={_newItems:{},_modifiedItems:{},_deletedItems:{}}; -if(!this._datatypeMap["Date"].serialize){ -this._datatypeMap["Date"].serialize=function(_2){ -return dojo.date.stamp.toISOString(_2,{zulu:true}); -}; -} -if(_1&&(_1.referenceIntegrity===false)){ -this.referenceIntegrity=false; -} -this._saveInProgress=false; -},referenceIntegrity:true,_assert:function(_3){ -if(!_3){ -throw new Error("assertion failed in ItemFileWriteStore"); -} -},_getIdentifierAttribute:function(){ -var _4=this.getFeatures()["dojo.data.api.Identity"]; -return _4; -},newItem:function(_5,_6){ -this._assert(!this._saveInProgress); -if(!this._loadFinished){ -this._forceLoad(); -} -if(typeof _5!="object"&&typeof _5!="undefined"){ -throw new Error("newItem() was passed something other than an object"); -} -var _7=null; -var _8=this._getIdentifierAttribute(); -if(_8===Number){ -_7=this._arrayOfAllItems.length; -}else{ -_7=_5[_8]; -if(typeof _7==="undefined"){ -throw new Error("newItem() was not passed an identity for the new item"); -} -if(dojo.isArray(_7)){ -throw new Error("newItem() was not passed an single-valued identity"); -} -} -if(this._itemsByIdentity){ -this._assert(typeof this._itemsByIdentity[_7]==="undefined"); -} -this._assert(typeof this._pending._newItems[_7]==="undefined"); -this._assert(typeof this._pending._deletedItems[_7]==="undefined"); -var _9={}; -_9[this._storeRefPropName]=this; -_9[this._itemNumPropName]=this._arrayOfAllItems.length; -if(this._itemsByIdentity){ -this._itemsByIdentity[_7]=_9; -_9[_8]=[_7]; -} -this._arrayOfAllItems.push(_9); -var _a=null; -if(_6&&_6.parent&&_6.attribute){ -_a={item:_6.parent,attribute:_6.attribute,oldValue:undefined}; -var _b=this.getValues(_6.parent,_6.attribute); -if(_b&&_b.length>0){ -var _c=_b.slice(0,_b.length); -if(_b.length===1){ -_a.oldValue=_b[0]; -}else{ -_a.oldValue=_b.slice(0,_b.length); -} -_c.push(_9); -this._setValueOrValues(_6.parent,_6.attribute,_c,false); -_a.newValue=this.getValues(_6.parent,_6.attribute); -}else{ -this._setValueOrValues(_6.parent,_6.attribute,_9,false); -_a.newValue=_9; -} -}else{ -_9[this._rootItemPropName]=true; -this._arrayOfTopLevelItems.push(_9); -} -this._pending._newItems[_7]=_9; -for(var _d in _5){ -if(_d===this._storeRefPropName||_d===this._itemNumPropName){ -throw new Error("encountered bug in ItemFileWriteStore.newItem"); -} -var _e=_5[_d]; -if(!dojo.isArray(_e)){ -_e=[_e]; -} -_9[_d]=_e; -if(this.referenceIntegrity){ -for(var i=0;i<_e.length;i++){ -var _f=_e[i]; -if(this.isItem(_f)){ -this._addReferenceToMap(_f,_9,_d); -} -} -} -} -this.onNew(_9,_a); -return _9; -},_removeArrayElement:function(_10,_11){ -var _12=dojo.indexOf(_10,_11); -if(_12!=-1){ -_10.splice(_12,1); -return true; -} -return false; -},deleteItem:function(_13){ -this._assert(!this._saveInProgress); -this._assertIsItem(_13); -var _14=_13[this._itemNumPropName]; -var _15=this.getIdentity(_13); -if(this.referenceIntegrity){ -var _16=this.getAttributes(_13); -if(_13[this._reverseRefMap]){ -_13["backup_"+this._reverseRefMap]=dojo.clone(_13[this._reverseRefMap]); -} -dojo.forEach(_16,function(_17){ -dojo.forEach(this.getValues(_13,_17),function(_18){ -if(this.isItem(_18)){ -if(!_13["backupRefs_"+this._reverseRefMap]){ -_13["backupRefs_"+this._reverseRefMap]=[]; -} -_13["backupRefs_"+this._reverseRefMap].push({id:this.getIdentity(_18),attr:_17}); -this._removeReferenceFromMap(_18,_13,_17); -} -},this); -},this); -var _19=_13[this._reverseRefMap]; -if(_19){ -for(var _1a in _19){ -var _1b=null; -if(this._itemsByIdentity){ -_1b=this._itemsByIdentity[_1a]; -}else{ -_1b=this._arrayOfAllItems[_1a]; -} -if(_1b){ -for(var _1c in _19[_1a]){ -var _1d=this.getValues(_1b,_1c)||[]; -var _1e=dojo.filter(_1d,function(_1f){ -return !(this.isItem(_1f)&&this.getIdentity(_1f)==_15); -},this); -this._removeReferenceFromMap(_13,_1b,_1c); -if(_1e.length<_1d.length){ -this._setValueOrValues(_1b,_1c,_1e,true); -} -} -} -} -} -} -this._arrayOfAllItems[_14]=null; -_13[this._storeRefPropName]=null; -if(this._itemsByIdentity){ -delete this._itemsByIdentity[_15]; -} -this._pending._deletedItems[_15]=_13; -if(_13[this._rootItemPropName]){ -this._removeArrayElement(this._arrayOfTopLevelItems,_13); -} -this.onDelete(_13); -return true; -},setValue:function(_20,_21,_22){ -return this._setValueOrValues(_20,_21,_22,true); -},setValues:function(_23,_24,_25){ -return this._setValueOrValues(_23,_24,_25,true); -},unsetAttribute:function(_26,_27){ -return this._setValueOrValues(_26,_27,[],true); -},_setValueOrValues:function(_28,_29,_2a,_2b){ -this._assert(!this._saveInProgress); -this._assertIsItem(_28); -this._assert(dojo.isString(_29)); -this._assert(typeof _2a!=="undefined"); -var _2c=this._getIdentifierAttribute(); -if(_29==_2c){ -throw new Error("ItemFileWriteStore does not have support for changing the value of an item's identifier."); -} -var _2d=this._getValueOrValues(_28,_29); -var _2e=this.getIdentity(_28); -if(!this._pending._modifiedItems[_2e]){ -var _2f={}; -for(var key in _28){ -if((key===this._storeRefPropName)||(key===this._itemNumPropName)||(key===this._rootItemPropName)){ -_2f[key]=_28[key]; -}else{ -if(key===this._reverseRefMap){ -_2f[key]=dojo.clone(_28[key]); -}else{ -_2f[key]=_28[key].slice(0,_28[key].length); -} -} -} -this._pending._modifiedItems[_2e]=_2f; -} -var _30=false; -if(dojo.isArray(_2a)&&_2a.length===0){ -_30=delete _28[_29]; -_2a=undefined; -if(this.referenceIntegrity&&_2d){ -var _31=_2d; -if(!dojo.isArray(_31)){ -_31=[_31]; -} -for(var i=0;i<_31.length;i++){ -var _32=_31[i]; -if(this.isItem(_32)){ -this._removeReferenceFromMap(_32,_28,_29); -} -} -} -}else{ -var _33; -if(dojo.isArray(_2a)){ -var _34=_2a; -_33=_2a.slice(0,_2a.length); -}else{ -_33=[_2a]; -} -if(this.referenceIntegrity){ -if(_2d){ -var _31=_2d; -if(!dojo.isArray(_31)){ -_31=[_31]; -} -var map={}; -dojo.forEach(_31,function(_35){ -if(this.isItem(_35)){ -var id=this.getIdentity(_35); -map[id.toString()]=true; -} -},this); -dojo.forEach(_33,function(_36){ -if(this.isItem(_36)){ -var id=this.getIdentity(_36); -if(map[id.toString()]){ -delete map[id.toString()]; -}else{ -this._addReferenceToMap(_36,_28,_29); -} -} -},this); -for(var rId in map){ -var _37; -if(this._itemsByIdentity){ -_37=this._itemsByIdentity[rId]; -}else{ -_37=this._arrayOfAllItems[rId]; -} -this._removeReferenceFromMap(_37,_28,_29); -} -}else{ -for(var i=0;i<_33.length;i++){ -var _32=_33[i]; -if(this.isItem(_32)){ -this._addReferenceToMap(_32,_28,_29); -} -} -} -} -_28[_29]=_33; -_30=true; -} -if(_2b){ -this.onSet(_28,_29,_2d,_2a); -} -return _30; -},_addReferenceToMap:function(_38,_39,_3a){ -var _3b=this.getIdentity(_39); -var _3c=_38[this._reverseRefMap]; -if(!_3c){ -_3c=_38[this._reverseRefMap]={}; -} -var _3d=_3c[_3b]; -if(!_3d){ -_3d=_3c[_3b]={}; -} -_3d[_3a]=true; -},_removeReferenceFromMap:function(_3e,_3f,_40){ -var _41=this.getIdentity(_3f); -var _42=_3e[this._reverseRefMap]; -var _43; -if(_42){ -for(_43 in _42){ -if(_43==_41){ -delete _42[_43][_40]; -if(this._isEmpty(_42[_43])){ -delete _42[_43]; -} -} -} -if(this._isEmpty(_42)){ -delete _3e[this._reverseRefMap]; -} -} -},_dumpReferenceMap:function(){ -var i; -for(i=0;i<this._arrayOfAllItems.length;i++){ -var _44=this._arrayOfAllItems[i]; -if(_44&&_44[this._reverseRefMap]){ -} -} -},_getValueOrValues:function(_45,_46){ -var _47=undefined; -if(this.hasAttribute(_45,_46)){ -var _48=this.getValues(_45,_46); -if(_48.length==1){ -_47=_48[0]; -}else{ -_47=_48; -} -} -return _47; -},_flatten:function(_49){ -if(this.isItem(_49)){ -var _4a=_49; -var _4b=this.getIdentity(_4a); -var _4c={_reference:_4b}; -return _4c; -}else{ -if(typeof _49==="object"){ -for(var _4d in this._datatypeMap){ -var _4e=this._datatypeMap[_4d]; -if(dojo.isObject(_4e)&&!dojo.isFunction(_4e)){ -if(_49 instanceof _4e.type){ -if(!_4e.serialize){ -throw new Error("ItemFileWriteStore: No serializer defined for type mapping: ["+_4d+"]"); -} -return {_type:_4d,_value:_4e.serialize(_49)}; -} -}else{ -if(_49 instanceof _4e){ -return {_type:_4d,_value:_49.toString()}; -} -} -} -} -return _49; -} -},_getNewFileContentString:function(){ -var _4f={}; -var _50=this._getIdentifierAttribute(); -if(_50!==Number){ -_4f.identifier=_50; -} -if(this._labelAttr){ -_4f.label=this._labelAttr; -} -_4f.items=[]; -for(var i=0;i<this._arrayOfAllItems.length;++i){ -var _51=this._arrayOfAllItems[i]; -if(_51!==null){ -var _52={}; -for(var key in _51){ -if(key!==this._storeRefPropName&&key!==this._itemNumPropName&&key!==this._reverseRefMap&&key!==this._rootItemPropName){ -var _53=key; -var _54=this.getValues(_51,_53); -if(_54.length==1){ -_52[_53]=this._flatten(_54[0]); -}else{ -var _55=[]; -for(var j=0;j<_54.length;++j){ -_55.push(this._flatten(_54[j])); -_52[_53]=_55; -} -} -} -} -_4f.items.push(_52); -} -} -var _56=true; -return dojo.toJson(_4f,_56); -},_isEmpty:function(_57){ -var _58=true; -if(dojo.isObject(_57)){ -var i; -for(i in _57){ -_58=false; -break; -} -}else{ -if(dojo.isArray(_57)){ -if(_57.length>0){ -_58=false; -} -} -} -return _58; -},save:function(_59){ -this._assert(!this._saveInProgress); -this._saveInProgress=true; -var _5a=this; -var _5b=function(){ -_5a._pending={_newItems:{},_modifiedItems:{},_deletedItems:{}}; -_5a._saveInProgress=false; -if(_59&&_59.onComplete){ -var _5c=_59.scope||dojo.global; -_59.onComplete.call(_5c); -} -}; -var _5d=function(err){ -_5a._saveInProgress=false; -if(_59&&_59.onError){ -var _5e=_59.scope||dojo.global; -_59.onError.call(_5e,err); -} -}; -if(this._saveEverything){ -var _5f=this._getNewFileContentString(); -this._saveEverything(_5b,_5d,_5f); -} -if(this._saveCustom){ -this._saveCustom(_5b,_5d); -} -if(!this._saveEverything&&!this._saveCustom){ -_5b(); -} -},revert:function(){ -this._assert(!this._saveInProgress); -var _60; -for(_60 in this._pending._modifiedItems){ -var _61=this._pending._modifiedItems[_60]; -var _62=null; -if(this._itemsByIdentity){ -_62=this._itemsByIdentity[_60]; -}else{ -_62=this._arrayOfAllItems[_60]; -} -_61[this._storeRefPropName]=this; -for(key in _62){ -delete _62[key]; -} -dojo.mixin(_62,_61); -} -var _63; -for(_60 in this._pending._deletedItems){ -_63=this._pending._deletedItems[_60]; -_63[this._storeRefPropName]=this; -var _64=_63[this._itemNumPropName]; -if(_63["backup_"+this._reverseRefMap]){ -_63[this._reverseRefMap]=_63["backup_"+this._reverseRefMap]; -delete _63["backup_"+this._reverseRefMap]; -} -this._arrayOfAllItems[_64]=_63; -if(this._itemsByIdentity){ -this._itemsByIdentity[_60]=_63; -} -if(_63[this._rootItemPropName]){ -this._arrayOfTopLevelItems.push(_63); -} -} -for(_60 in this._pending._deletedItems){ -_63=this._pending._deletedItems[_60]; -if(_63["backupRefs_"+this._reverseRefMap]){ -dojo.forEach(_63["backupRefs_"+this._reverseRefMap],function(_65){ -var _66; -if(this._itemsByIdentity){ -_66=this._itemsByIdentity[_65.id]; -}else{ -_66=this._arrayOfAllItems[_65.id]; -} -this._addReferenceToMap(_66,_63,_65.attr); -},this); -delete _63["backupRefs_"+this._reverseRefMap]; -} -} -for(_60 in this._pending._newItems){ -var _67=this._pending._newItems[_60]; -_67[this._storeRefPropName]=null; -this._arrayOfAllItems[_67[this._itemNumPropName]]=null; -if(_67[this._rootItemPropName]){ -this._removeArrayElement(this._arrayOfTopLevelItems,_67); -} -if(this._itemsByIdentity){ -delete this._itemsByIdentity[_60]; -} -} -this._pending={_newItems:{},_modifiedItems:{},_deletedItems:{}}; -return true; -},isDirty:function(_68){ -if(_68){ -var _69=this.getIdentity(_68); -return new Boolean(this._pending._newItems[_69]||this._pending._modifiedItems[_69]||this._pending._deletedItems[_69]).valueOf(); -}else{ -if(!this._isEmpty(this._pending._newItems)||!this._isEmpty(this._pending._modifiedItems)||!this._isEmpty(this._pending._deletedItems)){ -return true; -} -return false; -} -},onSet:function(_6a,_6b,_6c,_6d){ -},onNew:function(_6e,_6f){ -},onDelete:function(_70){ -},close:function(_71){ -if(this.clearOnClose){ -if(!this.isDirty()){ -this.inherited(arguments); -}else{ -throw new Error("dojo.data.ItemFileWriteStore: There are unsaved changes present in the store. Please save or revert the changes before invoking close."); -} -} -}}); + +dojo.declare("dojo.data.ItemFileWriteStore", dojo.data.ItemFileReadStore, { + 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. + // } + + // 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 dojo.date.stamp.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(dojo.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(!dojo.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 = dojo.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] = dojo.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. + dojo.forEach(attributes, function(attribute){ + dojo.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 = dojo.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, true); + } + } + } + } + } + } + + 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(dojo.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] = dojo.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(dojo.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(!dojo.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(dojo.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(!dojo.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 = {}; + dojo.forEach(oldValues, function(possibleItem){ + if(this.isItem(possibleItem)){ + var id = this.getIdentity(possibleItem); + map[id.toString()] = true; + } + }, this); + dojo.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: " + dojo.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(dojo.isObject(typeMap) && !dojo.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 dojo.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(dojo.isObject(something)){ + var i; + for(i in something){ + empty = false; + break; + } + }else if(dojo.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 || dojo.global; + keywordArgs.onComplete.call(scope); + } + }; + var saveFailedCallback = function(err){ + self._saveInProgress = false; + if(keywordArgs && keywordArgs.onError){ + var scope = keywordArgs.scope || dojo.global; + keywordArgs.onError.call(scope, err); + } + }; + + 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]; + } + dojo.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]){ + dojo.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("dojo.data.ItemFileWriteStore: There are unsaved changes present in the store. Please save or revert the changes before invoking close."); + } + } + } +}); + } |