summaryrefslogtreecommitdiff
path: root/includes/js/dojo/data/util
diff options
context:
space:
mode:
Diffstat (limited to 'includes/js/dojo/data/util')
-rw-r--r--includes/js/dojo/data/util/filter.js69
-rw-r--r--includes/js/dojo/data/util/simpleFetch.js90
-rw-r--r--includes/js/dojo/data/util/sorter.js81
3 files changed, 0 insertions, 240 deletions
diff --git a/includes/js/dojo/data/util/filter.js b/includes/js/dojo/data/util/filter.js
deleted file mode 100644
index 125d264..0000000
--- a/includes/js/dojo/data/util/filter.js
+++ /dev/null
@@ -1,69 +0,0 @@
-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
- }
-
-};
-
-}
diff --git a/includes/js/dojo/data/util/simpleFetch.js b/includes/js/dojo/data/util/simpleFetch.js
deleted file mode 100644
index f54d763..0000000
--- a/includes/js/dojo/data/util/simpleFetch.js
+++ /dev/null
@@ -1,90 +0,0 @@
-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
-};
-
-}
diff --git a/includes/js/dojo/data/util/sorter.js b/includes/js/dojo/data/util/sorter.js
deleted file mode 100644
index e13fedc..0000000
--- a/includes/js/dojo/data/util/sorter.js
+++ /dev/null
@@ -1,81 +0,0 @@
-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
-};
-
-}