100 lines
3.0 KiB
JavaScript
100 lines
3.0 KiB
JavaScript
define("dojo/data/util/sorter", ["../../_base/lang"], function(lang){
|
|
// module:
|
|
// dojo/data/util/sorter
|
|
// summary:
|
|
// TODOC
|
|
|
|
var sorter = {};
|
|
lang.setObject("dojo.data.util.sorter", sorter);
|
|
|
|
sorter.basicComparator = function( /*anything*/ a,
|
|
/*anything*/ b){
|
|
// summary:
|
|
// Basic comparison 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.
|
|
// 'null' values (null, undefined) are treated as larger values so that they're pushed to the end of the list.
|
|
// And compared to each other, null is equivalent to undefined.
|
|
|
|
//null is a problematic compare, so if null, we set to undefined.
|
|
//Makes the check logic simple, compact, and consistent
|
|
//And (null == undefined) === true, so the check later against null
|
|
//works for undefined and is less bytes.
|
|
var r = -1;
|
|
if(a === null){
|
|
a = undefined;
|
|
}
|
|
if(b === null){
|
|
b = undefined;
|
|
}
|
|
if(a == b){
|
|
r = 0;
|
|
}else if(a > b || a == null){
|
|
r = 1;
|
|
}
|
|
return r; //int {-1,0,1}
|
|
};
|
|
|
|
sorter.createSortFunction = function( /* attributes[] */sortSpec, /*dojo/data/api/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:
|
|
// 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:
|
|
// The datastore object to look up item values from.
|
|
|
|
var sortFunctions=[];
|
|
|
|
function createSortFunction(attr, dir, comp, s){
|
|
//Passing in comp and s (comparator and store), makes this
|
|
//function much faster.
|
|
return function(itemA, itemB){
|
|
var a = s.getValue(itemA, attr);
|
|
var b = s.getValue(itemB, attr);
|
|
return dir * comp(a,b); //int
|
|
};
|
|
}
|
|
var sortAttribute;
|
|
var map = store.comparatorMap;
|
|
var bc = sorter.basicComparator;
|
|
for(var i = 0; i < sortSpec.length; i++){
|
|
sortAttribute = sortSpec[i];
|
|
var attr = sortAttribute.attribute;
|
|
if(attr){
|
|
var dir = (sortAttribute.descending) ? -1 : 1;
|
|
var comp = bc;
|
|
if(map){
|
|
if(typeof attr !== "string" && ("toString" in attr)){
|
|
attr = attr.toString();
|
|
}
|
|
comp = map[attr] || bc;
|
|
}
|
|
sortFunctions.push(createSortFunction(attr,
|
|
dir, comp, store));
|
|
}
|
|
}
|
|
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
|
|
};
|
|
|
|
return sorter;
|
|
});
|