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

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

	dojo.declare("dojox.data.OpmlStore", null, {
		/*
		 * summary: The OpmlStore implements the dojo.data.api.Read API.
		 */

		/*
		 * examples: var opmlStore = new
		 * dojo.data.OpmlStore({url:"geography.xml"}); var opmlStore = new
		 * dojo.data.OpmlStore({url:"http://example.com/geography.xml"});
		 */
		constructor : function(/* Object */keywordParameters) {
			// summary: constructor
			// keywordParameters: {url: String, label: String} Where label is
			// optional and configures what should be used as the return from
			// getLabel()
			this._xmlData = null;
			this._arrayOfTopLevelItems = [];
			this._arrayOfAllItems = [];
			this._metadataNodes = null;
			this._loadFinished = false;
			this.url = keywordParameters.url;
			this._opmlData = keywordParameters.data; // XML DOM Document
			if (keywordParameters.label) {
				this.label = keywordParameters.label;
			}
			this._loadInProgress = false; // Got to track the initial load to
											// prevent duelling loads of the
											// dataset.
			this._queuedFetches = [];
			this._identityMap = {};
			this._identCount = 0;
			this._idProp = "_I";
		},

		label : "text",

		url : "",

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

		_removeChildNodesThatAreNotElementNodes : function(/* node */node, /* boolean */
				recursive) {
			var childNodes = node.childNodes;
			if (childNodes.length === 0) {
				return;
			}
			var nodesToRemove = [];
			var i, childNode;
			for (i = 0; i < childNodes.length; ++i) {
				childNode = childNodes[i];
				if (childNode.nodeType != 1) {
					nodesToRemove.push(childNode);
				}
			}
			for (i = 0; i < nodesToRemove.length; ++i) {
				childNode = nodesToRemove[i];
				node.removeChild(childNode);
			}
			if (recursive) {
				for (i = 0; i < childNodes.length; ++i) {
					childNode = childNodes[i];
					this._removeChildNodesThatAreNotElementNodes(childNode,
							recursive);
				}
			}
		},

		_processRawXmlTree : function(/* xmlDoc */rawXmlTree) {
			this._loadFinished = true;
			this._xmlData = rawXmlTree;
			var headNodes = rawXmlTree.getElementsByTagName('head');
			var headNode = headNodes[0];
			if (headNode) {
				this._removeChildNodesThatAreNotElementNodes(headNode);
				this._metadataNodes = headNode.childNodes;
			}
			var bodyNodes = rawXmlTree.getElementsByTagName('body');
			var bodyNode = bodyNodes[0];
			if (bodyNode) {
				this._removeChildNodesThatAreNotElementNodes(bodyNode, true);

				var bodyChildNodes = bodyNodes[0].childNodes;
				for (var i = 0; i < bodyChildNodes.length; ++i) {
					var node = bodyChildNodes[i];
					if (node.tagName == 'outline') {
						this._identityMap[this._identCount] = node;
						this._identCount++;
						this._arrayOfTopLevelItems.push(node);
						this._arrayOfAllItems.push(node);
						this._checkChildNodes(node);
					}
				}
			}
		},

		_checkChildNodes : function(node /* Node */) {
			// summary:
			// Internal function to recurse over all child nodes from the store
			// and add them
			// As non-toplevel items
			// description:
			// Internal function to recurse over all child nodes from the store
			// and add them
			// As non-toplevel items
			//
			// node:
			// The child node to walk.
			if (node.firstChild) {
				for (var i = 0; i < node.childNodes.length; i++) {
					var child = node.childNodes[i];
					if (child.tagName == 'outline') {
						this._identityMap[this._identCount] = child;
						this._identCount++;
						this._arrayOfAllItems.push(child);
						this._checkChildNodes(child);
					}
				}
			}
		},

		_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;
		},

		/***********************************************************************
		 * dojo.data.api.Read API
		 **********************************************************************/
		getValue : function( /* item */item,
				/* attribute || attribute-name-string */attribute,
				/* value? */defaultValue) {
			// summary:
			// See dojo.data.api.Read.getValue()
			this._assertIsItem(item);
			this._assertIsAttribute(attribute);
			if (attribute == 'children') {
				return (item.firstChild || defaultValue); // Object
			} else {
				var value = item.getAttribute(attribute);
				return (value !== undefined) ? value : defaultValue; // Object
			}
		},

		getValues : function(/* item */item,
				/* attribute || attribute-name-string */attribute) {
			// summary:
			// See dojo.data.api.Read.getValues()
			this._assertIsItem(item);
			this._assertIsAttribute(attribute);
			var array = [];
			if (attribute == 'children') {
				for (var i = 0; i < item.childNodes.length; ++i) {
					array.push(item.childNodes[i]);
				}
			} else if (item.getAttribute(attribute) !== null) {
				array.push(item.getAttribute(attribute));
			}
			return array; // Array
		},

		getAttributes : function(/* item */item) {
			// summary:
			// See dojo.data.api.Read.getAttributes()
			this._assertIsItem(item);
			var attributes = [];
			var xmlNode = item;
			var xmlAttributes = xmlNode.attributes;
			for (var i = 0; i < xmlAttributes.length; ++i) {
				var xmlAttribute = xmlAttributes.item(i);
				attributes.push(xmlAttribute.nodeName);
			}
			if (xmlNode.childNodes.length > 0) {
				attributes.push('children');
			}
			return attributes; // Array
		},

		hasAttribute : function( /* item */item,
				/* attribute || attribute-name-string */attribute) {
			// summary:
			// See dojo.data.api.Read.hasAttribute()
			return (this.getValues(item, attribute).length > 0); // 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()
			// description:
			// Four things are verified to ensure that "something" is an item:
			// something can not be null, the nodeType must be an XML Element,
			// the tagName must be "outline", and the node must be a member of
			// XML document for this datastore.
			return (something && something.nodeType == 1
					&& something.tagName == 'outline' && something.ownerDocument === this._xmlData); // Boolean
		},

		isItemLoaded : function(/* anything */something) {
			// summary:
			// See dojo.data.api.Read.isItemLoaded()
			// OpmlStore loads every item, 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 OpmlStore 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.
		},

		getLabel : function(/* item */item) {
			// summary:
			// See dojo.data.api.Read.getLabel()
			if (this.isItem(item)) {
				return this.getValue(item, this.label); // String
			}
			return undefined; // undefined
		},

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

		// 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, arrayOfItems) {
				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 < arrayOfItems.length; ++i) {
						var match = true;
						var candidateItem = arrayOfItems[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 (arrayOfItems.length > 0) {
						items = arrayOfItems.slice(0, arrayOfItems.length);
					}
				}
				findCallback(items, requestArgs);
			};

			if (this._loadFinished) {
				filter(keywordArgs, this
								._getItemsArray(keywordArgs.queryOptions));
			} else {

				// 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 {
					if (this.url !== "") {
						this._loadInProgress = true;
						var getArgs = {
							url : self.url,
							handleAs : "xml"
						};
						var getHandler = dojo.xhrGet(getArgs);
						getHandler.addCallback(function(data) {
							self._processRawXmlTree(data);
							filter(
									keywordArgs,
									self
											._getItemsArray(keywordArgs.queryOptions));
							self._handleQueuedFetches();
						});
						getHandler.addErrback(function(error) {
									throw error;
								});
					} else if (this._opmlData) {
						this._processRawXmlTree(this._opmlData);
						this._opmlData = null;
						filter(keywordArgs,
								this._getItemsArray(keywordArgs.queryOptions));
					} else {
						throw new Error("dojox.data.OpmlStore: No OPML source data was provided as either URL or XML data input.");
					}
				}
			}
		},

		getFeatures : function() {
			// summary: See dojo.data.api.Read.getFeatures()
			var features = {
				'dojo.data.api.Read' : true,
				'dojo.data.api.Identity' : true
			};
			return features; // Object
		},

		/***********************************************************************
		 * dojo.data.api.Identity API
		 **********************************************************************/
		getIdentity : function(/* item */item) {
			// summary:
			// See dojo.data.api.Identity.getIdentity()
			if (this.isItem(item)) {
				// No ther way to do this other than O(n) without
				// complete rework of how the tree stores nodes.
				for (var i in this._identityMap) {
					if (this._identityMap[i] === item) {
						return i;
					}
				}
			}
			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 : "xml"
						};
						var getHandler = dojo.xhrGet(getArgs);
						getHandler.addCallback(function(data) {
							var scope = keywordArgs.scope
									? keywordArgs.scope
									: dojo.global;
							try {
								self._processRawXmlTree(data);
								var item = self._identityMap[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._opmlData) {
					this._processRawXmlTree(this._opmlData);
					this._opmlData = null;
					var item = this._identityMap[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._identityMap[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 node
			// count.
			// 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 delayedQuery = fData.args;
					var delayedFilter = fData.filter;
					if (delayedFilter) {
						delayedFilter(delayedQuery,
								this._getItemsArray(delayedQuery.queryOptions));
					} else {
						this.fetchItemByIdentity(delayedQuery);
					}
				}
				this._queuedFetches = [];
			}
		},

		close : function(
/* dojo.data.api.Request || keywordArgs || null */request) {
			// summary:
			// See dojo.data.api.Read.close()
		}
	});
	// Mix in the simple fetch implementation to this class.
	dojo.extend(dojox.data.OpmlStore, dojo.data.util.simpleFetch);

}