if (!dojo._hasResource["dojox.data.CsvStore"]) { // _hasResource checks added
													// by build. Do not use
													// _hasResource directly in
													// your code.
	dojo._hasResource["dojox.data.CsvStore"] = true;
	dojo.provide("dojox.data.CsvStore");

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

	dojo.declare("dojox.data.CsvStore", null, {
		// summary:
		// The CsvStore implements the dojo.data.api.Read API and reads
		// data from files in CSV (Comma Separated Values) format.
		// All values are simple string values. References to other items
		// are not supported as attribute values in this datastore.
		//
		// Example data file:
		// name, color, age, tagline
		// Kermit, green, 12, "Hi, I'm Kermit the Frog."
		// Fozzie Bear, orange, 10, "Wakka Wakka Wakka!"
		// Miss Piggy, pink, 11, "Kermie!"
		//
		// Note that values containing a comma must be enclosed with quotes ("")
		// Also note that values containing quotes must be escaped with two
		// consecutive quotes (""quoted"")

		/*
		 * examples: var csvStore = new dojox.data.CsvStore({url:"movies.csv");
		 * var csvStore = new
		 * dojox.data.CsvStore({url:"http://example.com/movies.csv");
		 */

		constructor : function(/* Object */keywordParameters) {
			// summary: initializer
			// keywordParameters: {url: String}
			// keywordParameters: {data: String}
			// keywordParameters: {label: String} The column label for the
			// column to use for the label returned by getLabel.

			this._attributes = []; // e.g. ["Title", "Year", "Producer"]
			this._attributeIndexes = {}; // e.g. {Title: 0, Year: 1,
											// Producer: 2}
			this._dataArray = []; // e.g. [[<Item0>],[<Item1>],[<Item2>]]
			this._arrayOfAllItems = []; // e.g. [{_csvId:0,_csvStore:store},...]
			this._loadFinished = false;
			if (keywordParameters.url) {
				this.url = keywordParameters.url;
			}
			this._csvData = keywordParameters.data;
			if (keywordParameters.label) {
				this.label = keywordParameters.label;
			} else if (this.label === "") {
				this.label = undefined;
			}
			this._storeProp = "_csvStore"; // Property name for the store
											// reference on every item.
			this._idProp = "_csvId"; // Property name for the Item Id on
										// every item.
			this._features = {
				'dojo.data.api.Read' : true,
				'dojo.data.api.Identity' : true
			};
			this._loadInProgress = false; // Got to track the initial load to
											// prevent duelling loads of the
											// dataset.
			this._queuedFetches = [];
		},

		url : "", // Declarative hook for setting Csv source url.

		label : "", // Declarative hook for setting the label attribute.

		_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("dojox.data.CsvStore: a function was passed an item argument that was not an item");
			}
		},

		_assertIsAttribute : function(/* item || 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 (!dojo.isString(attribute)) {
				throw new Error("dojox.data.CsvStore: a function was passed an attribute argument that was not an attribute object nor an attribute name string");
			}
		},

		/***********************************************************************
		 * dojo.data.api.Read API
		 **********************************************************************/
		getValue : function( /* item */item,
				/* attribute || attribute-name-string */attribute,
				/* value? */defaultValue) {
			// summary:
			// See dojo.data.api.Read.getValue()
			// Note that for the CsvStore, an empty string value is the same as
			// no value,
			// so the defaultValue would be returned instead of an empty string.
			this._assertIsItem(item);
			this._assertIsAttribute(attribute);
			var itemValue = defaultValue;
			if (this.hasAttribute(item, attribute)) {
				var itemData = this._dataArray[this.getIdentity(item)];
				itemValue = itemData[this._attributeIndexes[attribute]];
			}
			return itemValue; // String
		},

		getValues : function(/* item */item,
				/* attribute || attribute-name-string */attribute) {
			// summary:
			// See dojo.data.api.Read.getValues()
			// CSV syntax does not support multi-valued attributes, so this is
			// just a
			// wrapper function for getValue().
			var value = this.getValue(item, attribute);
			return (value ? [value] : []); // Array
		},

		getAttributes : function(/* item */item) {
			// summary:
			// See dojo.data.api.Read.getAttributes()
			this._assertIsItem(item);
			var attributes = [];
			var itemData = this._dataArray[this.getIdentity(item)];
			for (var i = 0; i < itemData.length; i++) {
				// Check for empty string values. CsvStore treats empty strings
				// as no value.
				if (itemData[i] != "") {
					attributes.push(this._attributes[i]);
				}
			}
			return attributes; // Array
		},

		hasAttribute : function( /* item */item,
				/* attribute || attribute-name-string */attribute) {
			// summary:
			// See dojo.data.api.Read.hasAttribute()
			// The hasAttribute test is true if attribute has an index number
			// within the item's array length
			// AND if the item has a value for that attribute. Note that for the
			// CsvStore, an
			// empty string value is the same as no value.
			this._assertIsItem(item);
			this._assertIsAttribute(attribute);
			var attributeIndex = this._attributeIndexes[attribute];
			var itemData = this._dataArray[this.getIdentity(item)];
			return (typeof attributeIndex != "undefined"
					&& attributeIndex < itemData.length && itemData[attributeIndex] != ""); // Boolean
		},

		containsValue : function(/* item */item,
				/* attribute || 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 || 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'
			var values = this.getValues(item, attribute);
			for (var i = 0; i < values.length; ++i) {
				var possibleValue = values[i];
				if (typeof possibleValue === "string" && regexp) {
					return (possibleValue.match(regexp) !== null);
				} else {
					// Non-string matching.
					if (value === possibleValue) {
						return true; // Boolean
					}
				}
			}
			return false; // Boolean
		},

		isItem : function(/* anything */something) {
			// summary:
			// See dojo.data.api.Read.isItem()
			if (something && something[this._storeProp] === this) {
				var identity = something[this._idProp];
				if (identity >= 0 && identity < this._dataArray.length) {
					return true; // Boolean
				}
			}
			return false; // Boolean
		},

		isItemLoaded : function(/* anything */something) {
			// summary:
			// See dojo.data.api.Read.isItemLoaded()
			// The CsvStore always loads all items, so if it's an item, then
			// it's loaded.
			return this.isItem(something); // Boolean
		},

		loadItem : function(/* item */item) {
			// summary:
			// See dojo.data.api.Read.loadItem()
			// description:
			// The CsvStore always loads all items, so if it's an item, then
			// it's loaded.
			// From the dojo.data.api.Read.loadItem docs:
			// If a call to isItemLoaded() returns true before loadItem() is
			// even called,
			// then loadItem() need not do any work at all and will not even
			// invoke
			// the callback handlers.
		},

		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.label && this.isItem(item)) {
				return this.getValue(item, this.label); // String
			}
			return undefined; // undefined
		},

		getLabelAttributes : function(/* item */item) {
			// summary:
			// See dojo.data.api.Read.getLabelAttributes()
			if (this.label) {
				return [this.label]; // array
			}
			return null; // null
		},

		// The dojo.data.api.Read.fetch() function is implemented as
		// a mixin from dojo.data.util.simpleFetch.
		// That mixin requires us to define _fetchItems().
		_fetchItems : function( /* Object */keywordArgs,
				/* Function */findCallback,
				/* Function */errorCallback) {
			// summary:
			// See dojo.data.util.simpleFetch.fetch()

			var self = this;

			var filter = function(requestArgs, arrayOfAllItems) {
				var items = null;
				if (requestArgs.query) {
					items = [];
					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 < arrayOfAllItems.length; ++i) {
						var match = true;
						var candidateItem = arrayOfAllItems[i];
						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);
						}
					}
				} 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.
					if (arrayOfAllItems.length > 0) {
						items = arrayOfAllItems
								.slice(0, arrayOfAllItems.length);
					}
				}
				findCallback(items, requestArgs);
			};

			if (this._loadFinished) {
				filter(keywordArgs, this._arrayOfAllItems);
			} else {
				if (this.url !== "") {
					// 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.url,
							handleAs : "text"
						};
						var getHandler = dojo.xhrGet(getArgs);
						getHandler.addCallback(function(data) {
									self._processData(data);
									filter(keywordArgs, self._arrayOfAllItems);
									self._handleQueuedFetches();
								});
						getHandler.addErrback(function(error) {
									self._loadInProgress = false;
									throw error;
								});
					}
				} else if (this._csvData) {
					this._processData(this._csvData);
					this._csvData = null;
					filter(keywordArgs, this._arrayOfAllItems);
				} else {
					throw new Error("dojox.data.CsvStore: No CSV source data was provided as either URL or String data input.");
				}
			}
		},

		close : function(
/* dojo.data.api.Request || keywordArgs || null */request) {
			// summary:
			// See dojo.data.api.Read.close()
		},

		// -------------------------------------------------------------------
		// Private methods
		_getArrayOfArraysFromCsvFileContents : function(
/* string */	csvFileContents) {
			/*
			 * summary: Parses a string of CSV records into a nested array
			 * structure. description: Given a string containing CSV records,
			 * this method parses the string and returns a data structure
			 * containing the parsed content. The data structure we return is an
			 * array of length R, where R is the number of rows (lines) in the
			 * CSV data. The return array contains one sub-array for each CSV
			 * line, and each sub-array contains C string values, where C is the
			 * number of columns in the CSV data.
			 */

			/*
			 * example: For example, given this CSV string as input: "Title,
			 * Year, Producer \n Alien, 1979, Ridley Scott \n Blade Runner,
			 * 1982, Ridley Scott" this._dataArray will be set to: [["Alien",
			 * "1979", "Ridley Scott"], ["Blade Runner", "1982", "Ridley
			 * Scott"]] And this._attributes will be set to: ["Title", "Year",
			 * "Producer"] And this._attributeIndexes will be set to: {
			 * "Title":0, "Year":1, "Producer":2 }
			 */
			if (dojo.isString(csvFileContents)) {
				var lineEndingCharacters = new RegExp("\r\n|\n|\r");
				var leadingWhiteSpaceCharacters = new RegExp("^\\s+", 'g');
				var trailingWhiteSpaceCharacters = new RegExp("\\s+$", 'g');
				var doubleQuotes = new RegExp('""', 'g');
				var arrayOfOutputRecords = [];

				var arrayOfInputLines = csvFileContents
						.split(lineEndingCharacters);
				for (var i = 0; i < arrayOfInputLines.length; ++i) {
					var singleLine = arrayOfInputLines[i];
					if (singleLine.length > 0) {
						var listOfFields = singleLine.split(',');
						var j = 0;
						while (j < listOfFields.length) {
							var space_field_space = listOfFields[j];
							var field_space = space_field_space.replace(
									leadingWhiteSpaceCharacters, ''); // trim
																		// leading
																		// whitespace
							var field = field_space.replace(
									trailingWhiteSpaceCharacters, ''); // trim
																		// trailing
																		// whitespace
							var firstChar = field.charAt(0);
							var lastChar = field.charAt(field.length - 1);
							var secondToLastChar = field.charAt(field.length
									- 2);
							var thirdToLastChar = field
									.charAt(field.length - 3);
							if (field.length === 2 && field == "\"\"") {
								listOfFields[j] = ""; // Special case empty
														// string field.
							} else if ((firstChar == '"')
									&& ((lastChar != '"') || ((lastChar == '"')
											&& (secondToLastChar == '"') && (thirdToLastChar != '"')))) {
								if (j + 1 === listOfFields.length) {
									// alert("The last field in record " + i + "
									// is corrupted:\n" + field);
									return null; // null
								}
								var nextField = listOfFields[j + 1];
								listOfFields[j] = field_space + ',' + nextField;
								listOfFields.splice(j + 1, 1); // delete
																// element [j+1]
																// from the list
							} else {
								if ((firstChar == '"') && (lastChar == '"')) {
									field = field.slice(1, (field.length - 1)); // trim
																				// the
																				// "
																				// characters
																				// off
																				// the
																				// ends
									field = field.replace(doubleQuotes, '"'); // replace
																				// ""
																				// with
																				// "
								}
								listOfFields[j] = field;
								j += 1;
							}
						}
						arrayOfOutputRecords.push(listOfFields);
					}
				}

				// The first item of the array must be the header row with
				// attribute names.
				this._attributes = arrayOfOutputRecords.shift();
				for (var i = 0; i < this._attributes.length; i++) {
					// Store the index of each attribute
					this._attributeIndexes[this._attributes[i]] = i;
				}
				this._dataArray = arrayOfOutputRecords; // Array
			}
		},

		_processData : function(/* String */data) {
			this._getArrayOfArraysFromCsvFileContents(data);
			this._arrayOfAllItems = [];
			for (var i = 0; i < this._dataArray.length; i++) {
				this._arrayOfAllItems.push(this._createItemFromIdentity(i));
			}
			this._loadFinished = true;
			this._loadInProgress = false;
		},

		_createItemFromIdentity : function(/* String */identity) {
			var item = {};
			item[this._storeProp] = this;
			item[this._idProp] = identity;
			return item; // Object
		},

		/***********************************************************************
		 * dojo.data.api.Identity API
		 **********************************************************************/
		getIdentity : function(/* item */item) {
			// summary:
			// See dojo.data.api.Identity.getIdentity()
			if (this.isItem(item)) {
				return item[this._idProp]; // 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.url !== "") {
					// 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
								});
					} else {
						this._loadInProgress = true;
						var getArgs = {
							url : self.url,
							handleAs : "text"
						};
						var getHandler = dojo.xhrGet(getArgs);
						getHandler.addCallback(function(data) {
							var scope = keywordArgs.scope
									? keywordArgs.scope
									: dojo.global;
							try {
								self._processData(data);
								var item = self
										._createItemFromIdentity(keywordArgs.identity);
								if (!self.isItem(item)) {
									item = null;
								}
								if (keywordArgs.onItem) {
									keywordArgs.onItem.call(scope, item);
								}
								self._handleQueuedFetches();
							} catch (error) {
								if (keywordArgs.onError) {
									keywordArgs.onError.call(scope, error);
								}
							}
						});
						getHandler.addErrback(function(error) {
									this._loadInProgress = false;
									if (keywordArgs.onError) {
										var scope = keywordArgs.scope
												? keywordArgs.scope
												: dojo.global;
										keywordArgs.onError.call(scope, error);
									}
								});
					}
				} else if (this._csvData) {
					self._processData(self._csvData);
					self._csvData = null;
					var item = self
							._createItemFromIdentity(keywordArgs.identity);
					if (!self.isItem(item)) {
						item = null;
					}
					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._createItemFromIdentity(keywordArgs.identity);
				if (!this.isItem(item)) {
					item = null;
				}
				if (keywordArgs.onItem) {
					var scope = keywordArgs.scope
							? keywordArgs.scope
							: dojo.global;
					keywordArgs.onItem.call(scope, item);
				}
			}
		},

		getIdentityAttributes : function(/* item */item) {
			// summary:
			// See dojo.data.api.Identity.getIdentifierAttributes()

			// Identity isn't a public attribute in the item, it's the row
			// position index.
			// So, return null.
			return null;
		},

		_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 delayedFilter = fData.filter;
					var delayedQuery = fData.args;
					if (delayedFilter) {
						delayedFilter(delayedQuery, this._arrayOfAllItems);
					} else {
						this.fetchItemByIdentity(fData.args);
					}
				}
				this._queuedFetches = [];
			}
		}
	});
	// Mix in the simple fetch implementation to this class.
	dojo.extend(dojox.data.CsvStore, dojo.data.util.simpleFetch);

}