Subversion Repositories Applications.papyrus

if(!dojo._hasResource["dojo.data.ItemFileReadStore"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.

dojo._hasResource["dojo.data.ItemFileReadStore"] = true;

dojo.provide("dojo.data.ItemFileReadStore");

dojo.require("dojo.data.util.filter");

dojo.require("dojo.data.util.simpleFetch");

dojo.require("dojo.date.stamp");

dojo.declare("dojo.data.ItemFileReadStore", null,{

	//	summary:

	//		The ItemFileReadStore implements the dojo.data.api.Read API and reads

	//		data from JSON files that have contents in this format --

	//		{ items: [

	//			{ name:'Kermit', color:'green', age:12, friends:['Gonzo', {_reference:{name:'Fozzie Bear'}}]},

	//			{ name:'Fozzie Bear', wears:['hat', 'tie']},

	//			{ name:'Miss Piggy', pets:'Foo-Foo'}

	//		]}

	//		Note that it can also contain an 'identifer' property that specified which attribute on the items

	//		in the array of items that acts as the unique identifier for that item.

	//

	constructor: function(/* Object */ keywordParameters){

		//	summary: constructor

		//	keywordParameters: {url: String}

		//	keywordParameters: {data: jsonObject}

		//	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.  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.

		//		}

		this._arrayOfAllItems = [];

		this._arrayOfTopLevelItems = [];

		this._loadFinished = false;

		this._jsonFileUrl = keywordParameters.url;

		this._jsonData = keywordParameters.data;

		this._datatypeMap = keywordParameters.typeMap || {};

		if(!this._datatypeMap['Date']){

			//If no default mapping for dates, then set this as default.

			//We use the dojo.date.stamp here because the ISO format is the 'dojo way'

			//of generically representing dates.

			this._datatypeMap['Date'] = {

											type: Date,

											deserialize: function(value){

												return dojo.date.stamp.fromISOString(value);

											}

										};

		}

		this._features = {'dojo.data.api.Read':true, 'dojo.data.api.Identity':true};

		this._itemsByIdentity = null;

		this._storeRefPropName = "_S";  // Default name for the store reference to attach to every item.

		this._itemNumPropName = "_0"; // Default Item Id for isItem to attach to every item.

		this._rootItemPropName = "_RI"; // Default Item Id for isItem to attach to every item.

		this._loadInProgress = false;	//Got to track the initial load to prevent duelling loads of the dataset.

		this._queuedFetches = [];

	},

	url: "",	// use "" rather than undefined for the benefit of the parser (#3539)

	_assertIsItem: function(/* item */ item){

		//	summary:

		//		This function tests whether the item passed in is indeed an item in the store.

		//	item:

		//		The item to test for being contained by the store.

		if(!this.isItem(item)){

			throw new Error("dojo.data.ItemFileReadStore: Invalid item argument.");

		}

	},

	_assertIsAttribute: function(/* attribute-name-string */ attribute){

		//	summary:

		//		This function tests whether the item passed in is indeed a valid 'attribute' like type for the store.

		//	attribute:

		//		The attribute to test for being contained by the store.

		if(typeof attribute !== "string"){

			throw new Error("dojo.data.ItemFileReadStore: Invalid attribute argument.");

		}

	},

	getValue: function(	/* item */ item,

						/* attribute-name-string */ attribute,

						/* value? */ defaultValue){

		//	summary:

		//		See dojo.data.api.Read.getValue()

		var values = this.getValues(item, attribute);

		return (values.length > 0)?values[0]:defaultValue; // mixed

	},

	getValues: function(/* item */ item,

						/* attribute-name-string */ attribute){

		//	summary:

		//		See dojo.data.api.Read.getValues()

		this._assertIsItem(item);

		this._assertIsAttribute(attribute);

		return item[attribute] || []; // Array

	},

	getAttributes: function(/* item */ item){

		//	summary:

		//		See dojo.data.api.Read.getAttributes()

		this._assertIsItem(item);

		var attributes = [];

		for(var key in item){

			// Save off only the real item attributes, not the special id marks for O(1) isItem.

			if((key !== this._storeRefPropName) && (key !== this._itemNumPropName) && (key !== this._rootItemPropName)){

				attributes.push(key);

			}

		}

		return attributes; // Array

	},

	hasAttribute: function(	/* item */ item,

							/* attribute-name-string */ attribute) {

		//	summary:

		//		See dojo.data.api.Read.hasAttribute()

		return this.getValues(item, attribute).length > 0;

	},

	containsValue: function(/* item */ item,

							/* attribute-name-string */ attribute,

							/* anything */ value){

		//	summary:

		//		See dojo.data.api.Read.containsValue()

		var regexp = undefined;

		if(typeof value === "string"){

			regexp = dojo.data.util.filter.patternToRegExp(value, false);

		}

		return this._containsValue(item, attribute, value, regexp); //boolean.

	},

	_containsValue: function(	/* item */ item,

								/* attribute-name-string */ attribute,

								/* anything */ value,

								/* RegExp?*/ regexp){

		//	summary:

		//		Internal function for looking at the values contained by the item.

		//	description:

		//		Internal function for looking at the values contained by the item.  This

		//		function allows for denoting if the comparison should be case sensitive for

		//		strings or not (for handling filtering cases where string case should not matter)

		//

		//	item:

		//		The data item to examine for attribute values.

		//	attribute:

		//		The attribute to inspect.

		//	value:

		//		The value to match.

		//	regexp:

		//		Optional regular expression generated off value if value was of string type to handle wildcarding.

		//		If present and attribute values are string, then it can be used for comparison instead of 'value'

		return dojo.some(this.getValues(item, attribute), function(possibleValue){

			if(possibleValue !== null && !dojo.isObject(possibleValue) && regexp){

				if(possibleValue.toString().match(regexp)){

					return true; // Boolean

				}

			}else if(value === possibleValue){

				return true; // Boolean

			}

		});

	},

	isItem: function(/* anything */ something){

		//	summary:

		//		See dojo.data.api.Read.isItem()

		if(something && something[this._storeRefPropName] === this){

			if(this._arrayOfAllItems[something[this._itemNumPropName]] === something){

				return true;

			}

		}

		return false; // Boolean

	},

	isItemLoaded: function(/* anything */ something){

		//	summary:

		//		See dojo.data.api.Read.isItemLoaded()

		return this.isItem(something); //boolean

	},

	loadItem: function(/* object */ keywordArgs){

		//	summary:

		//		See dojo.data.api.Read.loadItem()

		this._assertIsItem(keywordArgs.item);

	},

	getFeatures: function(){

		//	summary:

		//		See dojo.data.api.Read.getFeatures()

		return this._features; //Object

	},

	getLabel: function(/* item */ item){

		//	summary:

		//		See dojo.data.api.Read.getLabel()

		if(this._labelAttr && this.isItem(item)){

			return this.getValue(item,this._labelAttr); //String

		}

		return undefined; //undefined

	},

	getLabelAttributes: function(/* item */ item){

		//	summary:

		//		See dojo.data.api.Read.getLabelAttributes()

		if(this._labelAttr){

			return [this._labelAttr]; //array

		}

		return null; //null

	},

	_fetchItems: function(	/* Object */ keywordArgs,

							/* Function */ findCallback,

							/* Function */ errorCallback){

		//	summary:

		//		See dojo.data.util.simpleFetch.fetch()

		var self = this;

		var filter = function(requestArgs, arrayOfItems){

			var items = [];

			if(requestArgs.query){

				var ignoreCase = requestArgs.queryOptions ? requestArgs.queryOptions.ignoreCase : false;

				//See if there are any string values that can be regexp parsed first to avoid multiple regexp gens on the

				//same value for each item examined.  Much more efficient.

				var regexpList = {};

				for(var key in requestArgs.query){

					var value = requestArgs.query[key];

					if(typeof value === "string"){

						regexpList[key] = dojo.data.util.filter.patternToRegExp(value, ignoreCase);

					}

				}

				for(var i = 0; i < arrayOfItems.length; ++i){

					var match = true;

					var candidateItem = arrayOfItems[i];

					if(candidateItem === null){

						match = false;

					}else{

						for(var key in requestArgs.query) {

							var value = requestArgs.query[key];

							if (!self._containsValue(candidateItem, key, value, regexpList[key])){

								match = false;

							}

						}

					}

					if(match){

						items.push(candidateItem);

					}

				}

				findCallback(items, requestArgs);

			}else{

				// We want a copy to pass back in case the parent wishes to sort the array.

				// We shouldn't allow resort of the internal list, so that multiple callers

				// can get lists and sort without affecting each other.  We also need to

				// filter out any null values that have been left as a result of deleteItem()

				// calls in ItemFileWriteStore.

				for(var i = 0; i < arrayOfItems.length; ++i){

					var item = arrayOfItems[i];

					if(item !== null){

						items.push(item);

					}

				}

				findCallback(items, requestArgs);

			}

		};

		if(this._loadFinished){

			filter(keywordArgs, this._getItemsArray(keywordArgs.queryOptions));

		}else{

			if(this._jsonFileUrl){

				//If fetches come in before the loading has finished, but while

				//a load is in progress, we have to defer the fetching to be

				//invoked in the callback.

				if(this._loadInProgress){

					this._queuedFetches.push({args: keywordArgs, filter: filter});

				}else{

					this._loadInProgress = true;

					var getArgs = {

							url: self._jsonFileUrl,

							handleAs: "json-comment-optional"

						};

					var getHandler = dojo.xhrGet(getArgs);

					getHandler.addCallback(function(data){

						try{

							self._getItemsFromLoadedData(data);

							self._loadFinished = true;

							self._loadInProgress = false;

							filter(keywordArgs, self._getItemsArray(keywordArgs.queryOptions));

							self._handleQueuedFetches();

						}catch(e){

							self._loadFinished = true;

							self._loadInProgress = false;

							errorCallback(e, keywordArgs);

						}

					});

					getHandler.addErrback(function(error){

						self._loadInProgress = false;

						errorCallback(error, keywordArgs);

					});

				}

			}else if(this._jsonData){

				try{

					this._loadFinished = true;

					this._getItemsFromLoadedData(this._jsonData);

					this._jsonData = null;

					filter(keywordArgs, this._getItemsArray(keywordArgs.queryOptions));

				}catch(e){

					errorCallback(e, keywordArgs);

				}

			}else{

				errorCallback(new Error("dojo.data.ItemFileReadStore: No JSON source data was provided as either URL or a nested Javascript object."), keywordArgs);

			}

		}

	},

	_handleQueuedFetches: function(){

		//	summary:

		//		Internal function to execute delayed request in the store.

		//Execute any deferred fetches now.

		if (this._queuedFetches.length > 0) {

			for(var i = 0; i < this._queuedFetches.length; i++){

				var fData = this._queuedFetches[i];

				var delayedQuery = fData.args;

				var delayedFilter = fData.filter;

				if(delayedFilter){

					delayedFilter(delayedQuery, this._getItemsArray(delayedQuery.queryOptions));

				}else{

					this.fetchItemByIdentity(delayedQuery);

				}

			}

			this._queuedFetches = [];

		}

	},

	_getItemsArray: function(/*object?*/queryOptions){

		//	summary:

		//		Internal function to determine which list of items to search over.

		//	queryOptions: The query options parameter, if any.

		if(queryOptions && queryOptions.deep) {

			return this._arrayOfAllItems;

		}

		return this._arrayOfTopLevelItems;

	},

	close: function(/*dojo.data.api.Request || keywordArgs || null */ request){

		 //	summary:

		 //		See dojo.data.api.Read.close()

	},

	_getItemsFromLoadedData: function(/* Object */ dataObject){

		//	summary:

		//		Function to parse the loaded data into item format and build the internal items array.

		//	description:

		//		Function to parse the loaded data into item format and build the internal items array.

		//

		//	dataObject:

		//		The JS data object containing the raw data to convery into item format.

		//

		// 	returns: array

		//		Array of items in store item format.

		// First, we define a couple little utility functions...

		function valueIsAnItem(/* anything */ aValue){

			// summary:

			//		Given any sort of value that could be in the raw json data,

			//		return true if we should interpret the value as being an

			//		item itself, rather than a literal value or a reference.

			// example:

			// 	|	false == valueIsAnItem("Kermit");

			// 	|	false == valueIsAnItem(42);

			// 	|	false == valueIsAnItem(new Date());

			// 	|	false == valueIsAnItem({_type:'Date', _value:'May 14, 1802'});

			// 	|	false == valueIsAnItem({_reference:'Kermit'});

			// 	|	true == valueIsAnItem({name:'Kermit', color:'green'});

			// 	|	true == valueIsAnItem({iggy:'pop'});

			// 	|	true == valueIsAnItem({foo:42});

			var isItem = (

				(aValue != null) &&

				(typeof aValue == "object") &&

				(!dojo.isArray(aValue)) &&

				(!dojo.isFunction(aValue)) &&

				(aValue.constructor == Object) &&

				(typeof aValue._reference == "undefined") &&

				(typeof aValue._type == "undefined") &&

				(typeof aValue._value == "undefined")

			);

			return isItem;

		}

		var self = this;

		function addItemAndSubItemsToArrayOfAllItems(/* Item */ anItem){

			self._arrayOfAllItems.push(anItem);

			for(var attribute in anItem){

				var valueForAttribute = anItem[attribute];

				if(valueForAttribute){

					if(dojo.isArray(valueForAttribute)){

						var valueArray = valueForAttribute;

						for(var k = 0; k < valueArray.length; ++k){

							var singleValue = valueArray[k];

							if(valueIsAnItem(singleValue)){

								addItemAndSubItemsToArrayOfAllItems(singleValue);

							}

						}

					}else{

						if(valueIsAnItem(valueForAttribute)){

							addItemAndSubItemsToArrayOfAllItems(valueForAttribute);

						}

					}

				}

			}

		}

		this._labelAttr = dataObject.label;

		// We need to do some transformations to convert the data structure

		// that we read from the file into a format that will be convenient

		// to work with in memory.

		// Step 1: Walk through the object hierarchy and build a list of all items

		var i;

		var item;

		this._arrayOfAllItems = [];

		this._arrayOfTopLevelItems = dataObject.items;

		for(i = 0; i < this._arrayOfTopLevelItems.length; ++i){

			item = this._arrayOfTopLevelItems[i];

			addItemAndSubItemsToArrayOfAllItems(item);

			item[this._rootItemPropName]=true;

		}

		// Step 2: Walk through all the attribute values of all the items,

		// and replace single values with arrays.  For example, we change this:

		//		{ name:'Miss Piggy', pets:'Foo-Foo'}

		// into this:

		//		{ name:['Miss Piggy'], pets:['Foo-Foo']}

		//

		// We also store the attribute names so we can validate our store

		// reference and item id special properties for the O(1) isItem

		var allAttributeNames = {};

		var key;

		for(i = 0; i < this._arrayOfAllItems.length; ++i){

			item = this._arrayOfAllItems[i];

			for(key in item){

				if (key !== this._rootItemPropName)

				{

					var value = item[key];

					if(value !== null){

						if(!dojo.isArray(value)){

							item[key] = [value];

						}

					}else{

						item[key] = [null];

					}

				}

				allAttributeNames[key]=key;

			}

		}

		// Step 3: Build unique property names to use for the _storeRefPropName and _itemNumPropName

		// This should go really fast, it will generally never even run the loop.

		while(allAttributeNames[this._storeRefPropName]){

			this._storeRefPropName += "_";

		}

		while(allAttributeNames[this._itemNumPropName]){

			this._itemNumPropName += "_";

		}

		// Step 4: Some data files specify an optional 'identifier', which is

		// the name of an attribute that holds the identity of each item.

		// If this data file specified an identifier attribute, then build a

		// hash table of items keyed by the identity of the items.

		var arrayOfValues;

		var identifier = dataObject.identifier;

		if(identifier){

			this._itemsByIdentity = {};

			this._features['dojo.data.api.Identity'] = identifier;

			for(i = 0; i < this._arrayOfAllItems.length; ++i){

				item = this._arrayOfAllItems[i];

				arrayOfValues = item[identifier];

				var identity = arrayOfValues[0];

				if(!this._itemsByIdentity[identity]){

					this._itemsByIdentity[identity] = item;

				}else{

					if(this._jsonFileUrl){

						throw new Error("dojo.data.ItemFileReadStore:  The json data as specified by: [" + this._jsonFileUrl + "] is malformed.  Items within the list have identifier: [" + identifier + "].  Value collided: [" + identity + "]");

					}else if(this._jsonData){

						throw new Error("dojo.data.ItemFileReadStore:  The json data provided by the creation arguments is malformed.  Items within the list have identifier: [" + identifier + "].  Value collided: [" + identity + "]");

					}

				}

			}

		}else{

			this._features['dojo.data.api.Identity'] = Number;

		}

		// Step 5: Walk through all the items, and set each item's properties

		// for _storeRefPropName and _itemNumPropName, so that store.isItem() will return true.

		for(i = 0; i < this._arrayOfAllItems.length; ++i){

			item = this._arrayOfAllItems[i];

			item[this._storeRefPropName] = this;

			item[this._itemNumPropName] = i;

		}

		// Step 6: We walk through all the attribute values of all the items,

		// looking for type/value literals and item-references.

		//

		// We replace item-references with pointers to items.  For example, we change:

		//		{ name:['Kermit'], friends:[{_reference:{name:'Miss Piggy'}}] }

		// into this:

		//		{ name:['Kermit'], friends:[miss_piggy] }

		// (where miss_piggy is the object representing the 'Miss Piggy' item).

		//

		// We replace type/value pairs with typed-literals.  For example, we change:

		//		{ name:['Nelson Mandela'], born:[{_type:'Date', _value:'July 18, 1918'}] }

		// into this:

		//		{ name:['Kermit'], born:(new Date('July 18, 1918')) }

		//

		// We also generate the associate map for all items for the O(1) isItem function.

		for(i = 0; i < this._arrayOfAllItems.length; ++i){

			item = this._arrayOfAllItems[i]; // example: { name:['Kermit'], friends:[{_reference:{name:'Miss Piggy'}}] }

			for(key in item){

				arrayOfValues = item[key]; // example: [{_reference:{name:'Miss Piggy'}}]

				for(var j = 0; j < arrayOfValues.length; ++j) {

					value = arrayOfValues[j]; // example: {_reference:{name:'Miss Piggy'}}

					if(value !== null && typeof value == "object"){

						if(value._type && value._value){

							var type = value._type; // examples: 'Date', 'Color', or 'ComplexNumber'

							var mappingObj = this._datatypeMap[type]; // examples: Date, dojo.Color, foo.math.ComplexNumber, {type: dojo.Color, deserialize(value){ return new dojo.Color(value)}}

							if(!mappingObj){

								throw new Error("dojo.data.ItemFileReadStore: in the typeMap constructor arg, no object class was specified for the datatype '" + type + "'");

							}else if(dojo.isFunction(mappingObj)){

								arrayOfValues[j] = new mappingObj(value._value);

							}else if(dojo.isFunction(mappingObj.deserialize)){

								arrayOfValues[j] = mappingObj.deserialize(value._value);

							}else{

								throw new Error("dojo.data.ItemFileReadStore: Value provided in typeMap was neither a constructor, nor a an object with a deserialize function");

							}

						}

						if(value._reference){

							var referenceDescription = value._reference; // example: {name:'Miss Piggy'}

							if(dojo.isString(referenceDescription)){

								// example: 'Miss Piggy'

								// from an item like: { name:['Kermit'], friends:[{_reference:'Miss Piggy'}]}

								arrayOfValues[j] = this._itemsByIdentity[referenceDescription];

							}else{

								// example: {name:'Miss Piggy'}

								// from an item like: { name:['Kermit'], friends:[{_reference:{name:'Miss Piggy'}}] }

								for(var k = 0; k < this._arrayOfAllItems.length; ++k){

									var candidateItem = this._arrayOfAllItems[k];

									var found = true;

									for(var refKey in referenceDescription){

										if(candidateItem[refKey] != referenceDescription[refKey]){

											found = false;

										}

									}

									if(found){

										arrayOfValues[j] = candidateItem;

									}

								}

							}

						}

					}

				}

			}

		}

	},

	getIdentity: function(/* item */ item){

		//	summary:

		//		See dojo.data.api.Identity.getIdentity()

		var identifier = this._features['dojo.data.api.Identity'];

		if(identifier === Number){

			return item[this._itemNumPropName]; // Number

		}else{

			var arrayOfValues = item[identifier];

			if(arrayOfValues){

				return arrayOfValues[0]; // Object || String

			}

		}

		return null; // null

	},

	fetchItemByIdentity: function(/* Object */ keywordArgs){

		//	summary:

		//		See dojo.data.api.Identity.fetchItemByIdentity()

		// Hasn't loaded yet, we have to trigger the load.

		if(!this._loadFinished){

			var self = this;

			if(this._jsonFileUrl){

				if(this._loadInProgress){

					this._queuedFetches.push({args: keywordArgs});

				}else{

					this._loadInProgress = true;

					var getArgs = {

							url: self._jsonFileUrl,

							handleAs: "json-comment-optional"

					};

					var getHandler = dojo.xhrGet(getArgs);

					getHandler.addCallback(function(data){

						var scope =  keywordArgs.scope?keywordArgs.scope:dojo.global;

						try{

							self._getItemsFromLoadedData(data);

							self._loadFinished = true;

							self._loadInProgress = false;

							var item = self._getItemByIdentity(keywordArgs.identity);

							if(keywordArgs.onItem){

								keywordArgs.onItem.call(scope, item);

							}

							self._handleQueuedFetches();

						}catch(error){

							self._loadInProgress = false;

							if(keywordArgs.onError){

								keywordArgs.onError.call(scope, error);

							}

						}

					});

					getHandler.addErrback(function(error){

						self._loadInProgress = false;

						if(keywordArgs.onError){

							var scope =  keywordArgs.scope?keywordArgs.scope:dojo.global;

							keywordArgs.onError.call(scope, error);

						}

					});

				}

			}else if(this._jsonData){

				// Passed in data, no need to xhr.

				self._getItemsFromLoadedData(self._jsonData);

				self._jsonData = null;

				self._loadFinished = true;

				var item = self._getItemByIdentity(keywordArgs.identity);

				if(keywordArgs.onItem){

					var scope =  keywordArgs.scope?keywordArgs.scope:dojo.global;

					keywordArgs.onItem.call(scope, item);

				}

			}

		}else{

			// Already loaded.  We can just look it up and call back.

			var item = this._getItemByIdentity(keywordArgs.identity);

			if(keywordArgs.onItem){

				var scope =  keywordArgs.scope?keywordArgs.scope:dojo.global;

				keywordArgs.onItem.call(scope, item);

			}

		}

	},

	_getItemByIdentity: function(/* Object */ identity){

		//	summary:

		//		Internal function to look an item up by its identity map.

		var item = null;

		if(this._itemsByIdentity){

			item = this._itemsByIdentity[identity];

		}else{

			item = this._arrayOfAllItems[identity];

		}

		if(item === undefined){

			item = null;

		}

		return item; // Object

	},

	getIdentityAttributes: function(/* item */ item){

		//	summary:

		//		See dojo.data.api.Identity.getIdentifierAttributes()

		var identifier = this._features['dojo.data.api.Identity'];

		if(identifier === Number){

			// If (identifier === Number) it means getIdentity() just returns

			// an integer item-number for each item.  The dojo.data.api.Identity

			// spec says we need to return null if the identity is not composed

			// of attributes

			return null; // null

		}else{

			return [identifier]; // Array

		}

	},

	_forceLoad: function(){

		//	summary:

		//		Internal function to force a load of the store if it hasn't occurred yet.  This is required

		//		for specific functions to work properly.

		var self = this;

		if(this._jsonFileUrl){

				var getArgs = {

					url: self._jsonFileUrl,

					handleAs: "json-comment-optional",

					sync: true

				};

			var getHandler = dojo.xhrGet(getArgs);

			getHandler.addCallback(function(data){

				try{

					//Check to be sure there wasn't another load going on concurrently

					//So we don't clobber data that comes in on it.  If there is a load going on

					//then do not save this data.  It will potentially clobber current data.

					//We mainly wanted to sync/wait here.

					//TODO:  Revisit the loading scheme of this store to improve multi-initial

					//request handling.

					if (self._loadInProgress !== true && !self._loadFinished) {

						self._getItemsFromLoadedData(data);

						self._loadFinished = true;

					}

				}catch(e){

					console.log(e);

					throw e;

				}

			});

			getHandler.addErrback(function(error){

				throw error;

			});

		}else if(this._jsonData){

			self._getItemsFromLoadedData(self._jsonData);

			self._jsonData = null;

			self._loadFinished = true;

		}

	}

});

//Mix in the simple fetch implementation to this class.

dojo.extend(dojo.data.ItemFileReadStore,dojo.data.util.simpleFetch);

}