API Preview tool | The Dojo Toolkit

dojox/data/HtmlStore.js

Provides:
- dojox.data.HtmlStore

dojox.data.HtmlStore

type
```
Function
```

parameters:

args: (typeof Object)

An anonymous object to initialize properties.  It expects the following values:

source: [view]
  if(args && "urlPreventCache" in args){
   this.urlPreventCache = args.urlPreventCache?true:false;
  }
  if(args && "trimWhitespace" in args){
   this.trimWhitespace = args.trimWhitespace?true:false;
  }
  if(args.url){
   if(!args.dataId){
    throw new Error("dojo.data.HtmlStore: Cannot instantiate using url without an id!");
   }
   this.url = args.url;
   this.dataId = args.dataId;
  }else{
   if(args.dataId){
    this.dataId = args.dataId;
   }
  }
  if(args && "fetchOnCreate" in args){
   this.fetchOnCreate = args.fetchOnCreate?true:false;
  }
  if(this.fetchOnCreate && this.dataId){
   this.fetch();
  }
summary
```
Initializer for the HTML table store.
```

description

The HtmlStore can be created in one of two ways: a) by parsing an existing
table or list DOM node on the current page or b) by referencing an external url and giving
the id of the table or list in that page.  The remote url will be parsed as an html page.

The HTML table or list should be of the following form:

	<table id="myTable">
		<thead>
			<tr>
				<th>Attribute1</th>
				<th>Attribute2</th>
			</tr>
		</thead>
		<tbody>
			<tr>
				<td>Value1.1</td>
				<td>Value1.2</td>
			</tr>
			<tr>
				<td>Value2.1</td>
				<td>Value2.2</td>
			</tr>
		</tbody>
	</table>

-or-

	<ul id="myUnorderedList">
		<li>Value.1</li>
		<li>Value.2</li>
	</ul>

-or-

	<ol id="myOrderedList">
		<li>Value.1</li>
		<li>Value.2</li>
	</ol>

mixins:
- dojo.data.util.simpleFetch: (prototype)

dojox.data.HtmlStore.url
- tags: public
- type
```
The
```
- summary
```
url of the remote page to load
```

dojox.data.HtmlStore.dataId

tags: public
type
```
The
```

summary

id of the table element in the remote page
and the option:

dojox.data.HtmlStore.trimWhitespace

type
```
Trim
```

summary

off any surrounding whitespace from the headers (attribute
names) and text content of the items in question.  Default is false for
backwards compatibility.

dojox.data.HtmlStore.urlPreventCache

tags: public
type
```
boolean
```

summary

Flag to denote if peventCache should be used on xhrGet calls.

dojox.data.HtmlStore.fetchOnCreate

tags: public
type
```
boolean
```

summary

Flag to denote if it should try to load from a data id (nested in the page)
The moment the store is created, instead of waiting for first
fetch call.

dojox.data.HtmlStore._indexItems
- type
```
Function
```
- source: [view]
    this._getHeadings();
    if(this._rootNode.rows){//tables
     if(this._rootNode.tBodies && this._rootNode.tBodies.length > 0){
      this._rootNode = this._rootNode.tBodies[0];
     }
     var i;
     for(i=0; i    this._rootNode.rows[i]._ident = i+1;
     }
    }else{//lists
     var c=1;
     for(i=0; i    if(this._rootNode.childNodes[i].nodeType === 1){
       this._rootNode.childNodes[i]._ident = c;
       c++;
      }
     }
    }
- summary
```
Function to index items found under the id.
```
- tags:
dojox.data.HtmlStore._getHeadings
- type
```
Function
```
- source: [view]
    this._headings = [];
    if(this._rootNode.tHead){
     dojo.forEach(this._rootNode.tHead.rows[0].cells, dojo.hitch(this, function(th){
      var text = dojox.xml.parser.textContent(th);
      this._headings.push(this.trimWhitespace?dojo.trim(text):text);
     }));
    }else{
     this._headings = ["name"];
    }
- summary
```
Function to load the attribute names from the table header so that the
attributes (cells in a row), can have a reasonable name.
For list items, returns single implicit heading, [&quot;name&quot;]
```
dojox.data.HtmlStore._getAllItems
- type
```
Function
```
- source: [view]
    var items = [];
    var i;
    if(this._rootNode.rows){//table
     for(i=0; i    items.push(this._rootNode.rows[i]);
     }
    }else{ //list
     for(i=0; i    if(this._rootNode.childNodes[i].nodeType === 1){
       items.push(this._rootNode.childNodes[i]);
      }
     }
    }
    return items; //array
- summary
```
Function to return all rows in the table as an array of items.
```
- returns
```
array
```
dojox.data.HtmlStore._assertIsItem
- type
```
Function
```
- parameters:
  - item: (typeof item)
```
The item to test for being contained by the store.
```
- source: [view]
    if(!this.isItem(item)){
     throw new Error("dojo.data.HtmlStore: a function was passed an item argument that was not an item");
    }
- summary
```
This function tests whether the item passed in is indeed an item in the store.
```
dojox.data.HtmlStore._assertIsAttribute
- type
```
Function
```
- parameters:
  - attribute: (typeof String)
```
The attribute to test for being contained by the store.
```
- source: [view]
    if(typeof attribute !== "string"){
     throw new Error("dojo.data.HtmlStore: a function was passed an attribute argument that was not an attribute name string");
     return -1;
    }
    return dojo.indexOf(this._headings, attribute); //int
- summary
```
This function tests whether the item passed in is indeed a valid 'attribute' like type for the store.
```
- return_summary
```
Returns the index (column) that the attribute resides in the row.
```
- returns
```
int
```
dojox.data.HtmlStore.getValue
- type
```
Function
```
- parameters:
  - item: (typeof item)
  - attribute: (typeof attribute-name-string)
  - defaultValue: (typeof value)
- source: [view]
  var values = this.getValues(item, attribute);
  return (values.length > 0)?values[0]:defaultValue; //Object || int || Boolean
- summary
```
See dojo.data.api.Read.getValue()
```
- returns
```
Object || int || Boolean
```
dojox.data.HtmlStore.getValues
- type
```
Function
```
- parameters:
  - item: (typeof item)
  - attribute: (typeof attribute-name-string)
- source: [view]
    this._assertIsItem(item);
    var index = this._assertIsAttribute(attribute);
    if(index>-1){
     var text;
     if(item.cells){
      text = dojox.xml.parser.textContent(item.cells[index]);
     }else{//return Value for lists
      text = dojox.xml.parser.textContent(item);
     }
     return [this.trimWhitespace?dojo.trim(text):text];
    }
    return []; //Array
- summary
```
See dojo.data.api.Read.getValues()
```
- returns
```
return Value for lists|Array
```
dojox.data.HtmlStore.getAttributes
- type
```
Function
```
- parameters:
  - item: (typeof item)
- source: [view]
    this._assertIsItem(item);
    var attributes = [];
    for(var i=0; i   if(this.hasAttribute(item, this._headings[i]))
      attributes.push(this._headings[i]);
    }
    return attributes; //Array
- summary
```
See dojo.data.api.Read.getAttributes()
```
- returns
```
Array
```
dojox.data.HtmlStore.hasAttribute
- type
```
Function
```
- parameters:
  - item: (typeof item)
  - attribute: (typeof attribute-name-string)
- source: [view]
  return this.getValues(item, attribute).length > 0;
- summary
```
See dojo.data.api.Read.hasAttribute()
```
dojox.data.HtmlStore.containsValue
- type
```
Function
```
- parameters:
  - item: (typeof item)
  - attribute: (typeof attribute-name-string)
  - value: (typeof anything)
- source: [view]
    var regexp = undefined;
    if(typeof value === "string"){
     regexp = dojo.data.util.filter.patternToRegExp(value, false);
    }
    return this._containsValue(item, attribute, value, regexp); //boolean.
- summary
```
See dojo.data.api.Read.containsValue()
```
- returns
```
boolean.
```

dojox.data.HtmlStore._containsValue

type
```
Function
```

parameters:

item: (typeof item)

The data item to examine for attribute values.

attribute: (typeof attribute-name-string)
```
The attribute to inspect.
```
value: (typeof anything)
```
The value to match.
```

regexp: (typeof 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'

source: [view]
  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

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)

returns
```
Boolean
```

dojox.data.HtmlStore.isItem
- type
```
Function
```
- parameters:
  - something: (typeof anything)
- source: [view]
  return something && dojo.isDescendant(something, this._rootNode);
- summary
```
See dojo.data.api.Read.isItem()
```
dojox.data.HtmlStore.isItemLoaded
- type
```
Function
```
- parameters:
  - something: (typeof anything)
- source: [view]
  return this.isItem(something);
- summary
```
See dojo.data.api.Read.isItemLoaded()
```
dojox.data.HtmlStore.loadItem
- type
```
Function
```
- parameters:
  - keywordArgs: (typeof Object)
- source: [view]
  this._assertIsItem(keywordArgs.item);
- summary
```
See dojo.data.api.Read.loadItem()
```
dojox.data.HtmlStore._fetchItems
- type
```
Function
```
- parameters:
  - request: (typeof A)
```
request object
```
  - fetchHandler: (typeof A)
```
function to call for fetched items
```
  - errorHandler: (typeof A)
```
function to call on error
```
- source: [view]
    if(this._rootNode){
     this._finishFetchItems(request, fetchHandler, errorHandler);
    }else{
     if(!this.url){
      this._rootNode = dojo.byId(this.dataId);
      this._indexItems();
      this._finishFetchItems(request, fetchHandler, errorHandler);
     }else{
      var getArgs = {
        url: this.url,
        handleAs: "text",
        preventCache: this.urlPreventCache
       };
      var self = this;
      var getHandler = dojo.xhrGet(getArgs);
      getHandler.addCallback(function(data){
       var findNode = function(node, id){
        if(node.id == id){
         return node; //object
        }
        if(node.childNodes){
         for(var i=0; i        var returnNode = findNode(node.childNodes[i], id);
          if(returnNode){
           return returnNode; //object
          }
         }
        }
        return null; //null
       }
  
       var d = document.createElement("div");
       d.innerHTML = data;
       self._rootNode = findNode(d, self.dataId);
       self._indexItems();
       self._finishFetchItems(request, fetchHandler, errorHandler);
      });
      getHandler.addErrback(function(error){
       errorHandler(error, request);
      });
     }
    }
- summary
```
Fetch items (XML elements) that match to a query
```
- description
```
If '_fetchUrl' is specified, it is used to load an XML document
with a query string.
Otherwise and if 'url' is specified, the XML document is
loaded and list XML elements that match to a query (set of element
names and their text attribute values that the items to contain).
A wildcard, "*" can be used to query values to match all
occurrences.
If '_rootItem' is specified, it is used to fetch items.
```
- returns
```
object|null
```
dojox.data.HtmlStore._finishFetchItems
- type
```
Function
```
- parameters:
  - request: (typeof )
  - fetchHandler: (typeof )
  - errorHandler: (typeof )
- source: [view]
    var items = [];
    var arrayOfAllItems = this._getAllItems();
    if(request.query){
     var ignoreCase = request.queryOptions ? request.queryOptions.ignoreCase : false;
     items = [];
  
     //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 = {};
     var key;
        var value;
     for(key in request.query){
      value = request.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(key in request.query){
       value = request.query[key]+'';
       if(!this._containsValue(candidateItem, key, value, regexpList[key])){
        match = false;
       }
      }
      if(match){
       items.push(candidateItem);
      }
     }
     fetchHandler(items, request);
    }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 listsand sort without affecting each other.
     if(arrayOfAllItems.length> 0){
      items = arrayOfAllItems.slice(0,arrayOfAllItems.length);
     }
     fetchHandler(items, request);
    }
- summary
```
Internal function for processing the passed in request and locating the requested items.
```
dojox.data.HtmlStore.getFeatures
- type
```
Function
```
- source: [view]
    return {
     'dojo.data.api.Read': true,
     'dojo.data.api.Identity': true
    };
- summary
```
See dojo.data.api.Read.getFeatures()
```
dojox.data.HtmlStore.close
- type
```
Function
```
- parameters:
  - request: (typeof dojo.data.api.Request || keywordArgs || null)
- source: [view]
    // summary:
    //  See dojo.data.api.Read.close()
    // nothing to do here!
- summary
```
See dojo.data.api.Read.close()
nothing to do here!
```
dojox.data.HtmlStore.getLabel
- type
```
Function
```
- parameters:
  - item: (typeof item)
- source: [view]
    if(this.isItem(item)){
     if(item.cells){
      return "Item #" + this.getIdentity(item);
     }else{
      return this.getValue(item,"name");
     }
    }
    return undefined;
- summary
```
See dojo.data.api.Read.getLabel()
```
dojox.data.HtmlStore.getLabelAttributes
- type
```
Function
```
- parameters:
  - item: (typeof item)
- source: [view]
    if(item.cells){
     return null;
    }else{
     return ["name"];
    }
- summary
```
See dojo.data.api.Read.getLabelAttributes()
```
dojox.data.HtmlStore.getIdentity
- type
```
Function
```
- parameters:
  - item: (typeof item)
- source: [view]
    this._assertIsItem(item);
    if(this.hasAttribute(item, "name")){
     return this.getValue(item,"name");
    }else{
     return item._ident;
    }
- summary
```
See dojo.data.api.Identity.getIdentity()
```
dojox.data.HtmlStore.getIdentityAttributes
- type
```
Function
```
- parameters:
  - item: (typeof item)
- source: [view]
  return null;
- summary
```
See dojo.data.api.Identity.getIdentityAttributes()
Identity isn't taken from a public attribute.
```
dojox.data.HtmlStore.fetchItemByIdentity
- type
```
Function
```
- parameters:
  - keywordArgs: (typeof )
- source: [view]
    var identity = keywordArgs.identity;
    var self = this;
    var item = null;
    var scope = null;
    if(!this._rootNode){
     if(!this.url){
      this._rootNode = dojo.byId(this.dataId);
      this._indexItems();
      if(self._rootNode.rows){ //Table
       item = this._rootNode.rows[identity + 1];
      }else{ //Lists
       for(var i = 0; i < self._rootNode.childNodes.length; i++){
        if(self._rootNode.childNodes[i].nodeType === 1 && identity === dojox.xml.parser.textContent(self._rootNode.childNodes[i])){
         item = self._rootNode.childNodes[i];
        }
       }
      }
      if(keywordArgs.onItem){
       scope = keywordArgs.scope?keywordArgs.scope:dojo.global;
       keywordArgs.onItem.call(scope, item);
      }
  
     }else{
      var getArgs = {
        url: this.url,
        handleAs: "text"
       };
      var getHandler = dojo.xhrGet(getArgs);
      getHandler.addCallback(function(data){
       var findNode = function(node, id){
        if(node.id == id){
         return node; //object
        }
        if(node.childNodes){
         for(var i=0; i        var returnNode = findNode(node.childNodes[i], id);
          if(returnNode){
           return returnNode; //object
          }
         }
        }
        return null; //null
       }
       var d = document.createElement("div");
       d.innerHTML = data;
       self._rootNode = findNode(d, self.dataId);
       self._indexItems();
       if(self._rootNode.rows && identity <= self._rootNode.rows.length){ //Table
        item = self._rootNode.rows[identity-1];
       }else{ //List
        for(var i = 0; i < self._rootNode.childNodes.length; i++){
         if(self._rootNode.childNodes[i].nodeType === 1 && identity === dojox.xml.parser.textContent(self._rootNode.childNodes[i])){
           item = self._rootNode.childNodes[i];
           break;
         }
        }
       }
       if(keywordArgs.onItem){
        scope = keywordArgs.scope?keywordArgs.scope:dojo.global;
        keywordArgs.onItem.call(scope, item);
       }
      });
      getHandler.addErrback(function(error){
       if(keywordArgs.onError){
        scope = keywordArgs.scope?keywordArgs.scope:dojo.global;
        keywordArgs.onError.call(scope, error);
  
       }
      });
     }
    }else{
     if(this._rootNode.rows[identity+1]){
      item = this._rootNode.rows[identity+1];
      if(keywordArgs.onItem){
       scope = keywordArgs.scope?keywordArgs.scope:dojo.global;
       keywordArgs.onItem.call(scope, item);
      }
     }
    }
- summary
```
See dojo.data.api.Identity.fetchItemByIdentity()
```
- returns
```
object|null
```
- chains:
  - keywordArgs.onItem: (call)
  - keywordArgs.onError: (call)
dojox.data.HtmlStore._rootNode
- summary
dojox.data.HtmlStore._headings
- summary
dojox.data
- type
```
Object
```
- summary
dojox
- type
```
Object
```
- summary

dojox/data/HtmlStore.js

Provides:

dojox.data.HtmlStore

dojox.data.HtmlStore.url

dojox.data.HtmlStore.dataId

dojox.data.HtmlStore.trimWhitespace

dojox.data.HtmlStore.urlPreventCache

dojox.data.HtmlStore.fetchOnCreate

dojox.data.HtmlStore._indexItems

dojox.data.HtmlStore._getHeadings

dojox.data.HtmlStore._getAllItems

dojox.data.HtmlStore._assertIsItem

dojox.data.HtmlStore._assertIsAttribute

dojox.data.HtmlStore.getValue

dojox.data.HtmlStore.getValues

dojox.data.HtmlStore.getAttributes

dojox.data.HtmlStore.hasAttribute

dojox.data.HtmlStore.containsValue

dojox.data.HtmlStore._containsValue

dojox.data.HtmlStore.isItem

dojox.data.HtmlStore.isItemLoaded

dojox.data.HtmlStore.loadItem

dojox.data.HtmlStore._fetchItems

dojox.data.HtmlStore._finishFetchItems

dojox.data.HtmlStore.getFeatures

dojox.data.HtmlStore.close

dojox.data.HtmlStore.getLabel

dojox.data.HtmlStore.getLabelAttributes

dojox.data.HtmlStore.getIdentity

dojox.data.HtmlStore.getIdentityAttributes

dojox.data.HtmlStore.fetchItemByIdentity

dojox.data.HtmlStore._rootNode

dojox.data.HtmlStore._headings

dojox.data

dojox