| /trunk/api/js/dojo1.0/dojo/data/util/simpleFetch.js |
|---|
| New file |
| 0,0 → 1,90 |
| if(!dojo._hasResource["dojo.data.util.simpleFetch"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. |
| dojo._hasResource["dojo.data.util.simpleFetch"] = true; |
| dojo.provide("dojo.data.util.simpleFetch"); |
| dojo.require("dojo.data.util.sorter"); |
| dojo.data.util.simpleFetch.fetch = function(/* Object? */ request){ |
| // summary: |
| // The simpleFetch mixin is designed to serve as a set of function(s) that can |
| // be mixed into other datastore implementations to accelerate their development. |
| // The simpleFetch mixin should work well for any datastore that can respond to a _fetchItems() |
| // call by returning an array of all the found items that matched the query. The simpleFetch mixin |
| // is not designed to work for datastores that respond to a fetch() call by incrementally |
| // loading items, or sequentially loading partial batches of the result |
| // set. For datastores that mixin simpleFetch, simpleFetch |
| // implements a fetch method that automatically handles eight of the fetch() |
| // arguments -- onBegin, onItem, onComplete, onError, start, count, sort and scope |
| // The class mixing in simpleFetch should not implement fetch(), |
| // but should instead implement a _fetchItems() method. The _fetchItems() |
| // method takes three arguments, the keywordArgs object that was passed |
| // to fetch(), a callback function to be called when the result array is |
| // available, and an error callback to be called if something goes wrong. |
| // The _fetchItems() method should ignore any keywordArgs parameters for |
| // start, count, onBegin, onItem, onComplete, onError, sort, and scope. |
| // The _fetchItems() method needs to correctly handle any other keywordArgs |
| // parameters, including the query parameter and any optional parameters |
| // (such as includeChildren). The _fetchItems() method should create an array of |
| // result items and pass it to the fetchHandler along with the original request object |
| // -- or, the _fetchItems() method may, if it wants to, create an new request object |
| // with other specifics about the request that are specific to the datastore and pass |
| // that as the request object to the handler. |
| // |
| // For more information on this specific function, see dojo.data.api.Read.fetch() |
| request = request || {}; |
| if(!request.store){ |
| request.store = this; |
| } |
| var self = this; |
| var _errorHandler = function(errorData, requestObject){ |
| if(requestObject.onError){ |
| var scope = requestObject.scope || dojo.global; |
| requestObject.onError.call(scope, errorData, requestObject); |
| } |
| }; |
| var _fetchHandler = function(items, requestObject){ |
| var oldAbortFunction = requestObject.abort || null; |
| var aborted = false; |
| var startIndex = requestObject.start?requestObject.start:0; |
| var endIndex = requestObject.count?(startIndex + requestObject.count):items.length; |
| requestObject.abort = function(){ |
| aborted = true; |
| if(oldAbortFunction){ |
| oldAbortFunction.call(requestObject); |
| } |
| }; |
| var scope = requestObject.scope || dojo.global; |
| if(!requestObject.store){ |
| requestObject.store = self; |
| } |
| if(requestObject.onBegin){ |
| requestObject.onBegin.call(scope, items.length, requestObject); |
| } |
| if(requestObject.sort){ |
| items.sort(dojo.data.util.sorter.createSortFunction(requestObject.sort, self)); |
| } |
| if(requestObject.onItem){ |
| for(var i = startIndex; (i < items.length) && (i < endIndex); ++i){ |
| var item = items[i]; |
| if(!aborted){ |
| requestObject.onItem.call(scope, item, requestObject); |
| } |
| } |
| } |
| if(requestObject.onComplete && !aborted){ |
| var subset = null; |
| if (!requestObject.onItem) { |
| subset = items.slice(startIndex, endIndex); |
| } |
| requestObject.onComplete.call(scope, subset, requestObject); |
| } |
| }; |
| this._fetchItems(request, _fetchHandler, _errorHandler); |
| return request; // Object |
| }; |
| } |
| /trunk/api/js/dojo1.0/dojo/data/util/filter.js |
|---|
| New file |
| 0,0 → 1,69 |
| if(!dojo._hasResource["dojo.data.util.filter"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. |
| dojo._hasResource["dojo.data.util.filter"] = true; |
| dojo.provide("dojo.data.util.filter"); |
| dojo.data.util.filter.patternToRegExp = function(/*String*/pattern, /*boolean?*/ ignoreCase){ |
| // summary: |
| // Helper function to convert a simple pattern to a regular expression for matching. |
| // description: |
| // Returns a regular expression object that conforms to the defined conversion rules. |
| // For example: |
| // ca* -> /^ca.*$/ |
| // *ca* -> /^.*ca.*$/ |
| // *c\*a* -> /^.*c\*a.*$/ |
| // *c\*a?* -> /^.*c\*a..*$/ |
| // and so on. |
| // |
| // pattern: string |
| // A simple matching pattern to convert that follows basic rules: |
| // * Means match anything, so ca* means match anything starting with ca |
| // ? Means match single character. So, b?b will match to bob and bab, and so on. |
| // \ is an escape character. So for example, \* means do not treat * as a match, but literal character *. |
| // To use a \ as a character in the string, it must be escaped. So in the pattern it should be |
| // represented by \\ to be treated as an ordinary \ character instead of an escape. |
| // |
| // ignoreCase: |
| // An optional flag to indicate if the pattern matching should be treated as case-sensitive or not when comparing |
| // By default, it is assumed case sensitive. |
| var rxp = "^"; |
| var c = null; |
| for(var i = 0; i < pattern.length; i++){ |
| c = pattern.charAt(i); |
| switch (c) { |
| case '\\': |
| rxp += c; |
| i++; |
| rxp += pattern.charAt(i); |
| break; |
| case '*': |
| rxp += ".*"; break; |
| case '?': |
| rxp += "."; break; |
| case '$': |
| case '^': |
| case '/': |
| case '+': |
| case '.': |
| case '|': |
| case '(': |
| case ')': |
| case '{': |
| case '}': |
| case '[': |
| case ']': |
| rxp += "\\"; //fallthrough |
| default: |
| rxp += c; |
| } |
| } |
| rxp += "$"; |
| if(ignoreCase){ |
| return new RegExp(rxp,"i"); //RegExp |
| }else{ |
| return new RegExp(rxp); //RegExp |
| } |
| }; |
| } |
| /trunk/api/js/dojo1.0/dojo/data/util/sorter.js |
|---|
| New file |
| 0,0 → 1,81 |
| if(!dojo._hasResource["dojo.data.util.sorter"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. |
| dojo._hasResource["dojo.data.util.sorter"] = true; |
| dojo.provide("dojo.data.util.sorter"); |
| dojo.data.util.sorter.basicComparator = function( /*anything*/ a, |
| /*anything*/ b){ |
| // summary: |
| // Basic comparision function that compares if an item is greater or less than another item |
| // description: |
| // returns 1 if a > b, -1 if a < b, 0 if equal. |
| // undefined values are treated as larger values so that they're pushed to the end of the list. |
| var ret = 0; |
| if(a > b || typeof a === "undefined" || a === null){ |
| ret = 1; |
| }else if(a < b || typeof b === "undefined" || b === null){ |
| ret = -1; |
| } |
| return ret; //int, {-1,0,1} |
| }; |
| dojo.data.util.sorter.createSortFunction = function( /* attributes array */sortSpec, |
| /*dojo.data.core.Read*/ store){ |
| // summary: |
| // Helper function to generate the sorting function based off the list of sort attributes. |
| // description: |
| // The sort function creation will look for a property on the store called 'comparatorMap'. If it exists |
| // it will look in the mapping for comparisons function for the attributes. If one is found, it will |
| // use it instead of the basic comparator, which is typically used for strings, ints, booleans, and dates. |
| // Returns the sorting function for this particular list of attributes and sorting directions. |
| // |
| // sortSpec: array |
| // A JS object that array that defines out what attribute names to sort on and whether it should be descenting or asending. |
| // The objects should be formatted as follows: |
| // { |
| // attribute: "attributeName-string" || attribute, |
| // descending: true|false; // Default is false. |
| // } |
| // store: object |
| // The datastore object to look up item values from. |
| // |
| var sortFunctions=[]; |
| function createSortFunction(attr, dir){ |
| return function(itemA, itemB){ |
| var a = store.getValue(itemA, attr); |
| var b = store.getValue(itemB, attr); |
| //See if we have a override for an attribute comparison. |
| var comparator = null; |
| if(store.comparatorMap){ |
| if(typeof attr !== "string"){ |
| attr = store.getIdentity(attr); |
| } |
| comparator = store.comparatorMap[attr]||dojo.data.util.sorter.basicComparator; |
| } |
| comparator = comparator||dojo.data.util.sorter.basicComparator; |
| return dir * comparator(a,b); //int |
| }; |
| } |
| for(var i = 0; i < sortSpec.length; i++){ |
| sortAttribute = sortSpec[i]; |
| if(sortAttribute.attribute){ |
| var direction = (sortAttribute.descending) ? -1 : 1; |
| sortFunctions.push(createSortFunction(sortAttribute.attribute, direction)); |
| } |
| } |
| return function(rowA, rowB){ |
| var i=0; |
| while(i < sortFunctions.length){ |
| var ret = sortFunctions[i++](rowA, rowB); |
| if(ret !== 0){ |
| return ret;//int |
| } |
| } |
| return 0; //int |
| }; // Function |
| }; |
| } |