e44a7e37b6
git-svn-id: https://semanticscuttle.svn.sourceforge.net/svnroot/semanticscuttle/trunk@151 b3834d28-1941-0410-a4f8-b48e95affb8f
515 lines
16 KiB
JavaScript
515 lines
16 KiB
JavaScript
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);
|
|
|
|
|
|
}
|