New file |
0,0 → 1,515 |
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); |
|
|
} |