TorqueGameEngines/Torque3D
1
0
Fork 0
mirror of https://github.com/TorqueGameEngines/Torque3D.git synced 2026-07-12 23:24:41 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Merge pull request #121 from DavidWyand-GG/issue120-InvertedArrayObjectSort

Browse source 
Fix for Issue #120 for Inverted ArrayObject Sort
This commit is contained in:
David Wyand 2012-11-07 16:47:18 -08:00
commit a6d86a13c6
2 changed files with 40 additions and 40 deletions
Download patch file Download diff file Expand all files Collapse all files

70
Engine/source/console/arrayObject.cpp
View file

@ -55,7 +55,7 @@ ConsoleDocClass( ArrayObject,
); );
bool ArrayObject::smIncreasing = false; bool ArrayObject::smDecreasing = false;
bool ArrayObject::smCaseSensitive = false; bool ArrayObject::smCaseSensitive = false;
const char* ArrayObject::smCompareFunction; const char* ArrayObject::smCompareFunction;
@ -65,7 +65,7 @@ S32 QSORT_CALLBACK ArrayObject::_valueCompare( const void* a, const void* b )
ArrayObject::Element *ea = (ArrayObject::Element *) (a); ArrayObject::Element *ea = (ArrayObject::Element *) (a);
ArrayObject::Element *eb = (ArrayObject::Element *) (b); ArrayObject::Element *eb = (ArrayObject::Element *) (b);
S32 result = smCaseSensitive ? dStrnatcmp(ea->value, eb->value) : dStrnatcasecmp(ea->value, eb->value); S32 result = smCaseSensitive ? dStrnatcmp(ea->value, eb->value) : dStrnatcasecmp(ea->value, eb->value);
return ( smIncreasing ? -result : result ); return ( smDecreasing ? -result : result );
} }
S32 QSORT_CALLBACK ArrayObject::_valueNumCompare( const void* a, const void* b ) S32 QSORT_CALLBACK ArrayObject::_valueNumCompare( const void* a, const void* b )
@ -76,7 +76,7 @@ S32 QSORT_CALLBACK ArrayObject::_valueNumCompare( const void* a, const void* b )
F32 bCol = dAtof(eb->value); F32 bCol = dAtof(eb->value);
F32 result = aCol - bCol; F32 result = aCol - bCol;
S32 res = result < 0 ? -1 : (result > 0 ? 1 : 0); S32 res = result < 0 ? -1 : (result > 0 ? 1 : 0);
return ( smIncreasing ? res : -res ); return ( smDecreasing ? res : -res );
} }
S32 QSORT_CALLBACK ArrayObject::_keyCompare( const void* a, const void* b ) S32 QSORT_CALLBACK ArrayObject::_keyCompare( const void* a, const void* b )
@ -84,7 +84,7 @@ S32 QSORT_CALLBACK ArrayObject::_keyCompare( const void* a, const void* b )
ArrayObject::Element *ea = (ArrayObject::Element *) (a); ArrayObject::Element *ea = (ArrayObject::Element *) (a);
ArrayObject::Element *eb = (ArrayObject::Element *) (b); ArrayObject::Element *eb = (ArrayObject::Element *) (b);
S32 result = smCaseSensitive ? dStrnatcmp(ea->key, eb->key) : dStrnatcasecmp(ea->key, eb->key); S32 result = smCaseSensitive ? dStrnatcmp(ea->key, eb->key) : dStrnatcasecmp(ea->key, eb->key);
return ( smIncreasing ? -result : result ); return ( smDecreasing ? -result : result );
} }
S32 QSORT_CALLBACK ArrayObject::_keyNumCompare( const void* a, const void* b ) S32 QSORT_CALLBACK ArrayObject::_keyNumCompare( const void* a, const void* b )
@ -95,7 +95,7 @@ S32 QSORT_CALLBACK ArrayObject::_keyNumCompare( const void* a, const void* b )
const char* bCol = eb->key; const char* bCol = eb->key;
F32 result = dAtof(aCol) - dAtof(bCol); F32 result = dAtof(aCol) - dAtof(bCol);
S32 res = result < 0 ? -1 : (result > 0 ? 1 : 0); S32 res = result < 0 ? -1 : (result > 0 ? 1 : 0);
return ( smIncreasing ? res : -res ); return ( smDecreasing ? res : -res );
} }
S32 QSORT_CALLBACK ArrayObject::_keyFunctionCompare( const void* a, const void* b ) S32 QSORT_CALLBACK ArrayObject::_keyFunctionCompare( const void* a, const void* b )
@ -110,7 +110,7 @@ S32 QSORT_CALLBACK ArrayObject::_keyFunctionCompare( const void* a, const void*
S32 result = dAtoi( Con::execute( 3, argv ) ); S32 result = dAtoi( Con::execute( 3, argv ) );
S32 res = result < 0 ? -1 : ( result > 0 ? 1 : 0 ); S32 res = result < 0 ? -1 : ( result > 0 ? 1 : 0 );
return ( smIncreasing ? res : -res ); return ( smDecreasing ? res : -res );
} }
S32 QSORT_CALLBACK ArrayObject::_valueFunctionCompare( const void* a, const void* b ) S32 QSORT_CALLBACK ArrayObject::_valueFunctionCompare( const void* a, const void* b )
@ -125,7 +125,7 @@ S32 QSORT_CALLBACK ArrayObject::_valueFunctionCompare( const void* a, const void
S32 result = dAtoi( Con::execute( 3, argv ) ); S32 result = dAtoi( Con::execute( 3, argv ) );
S32 res = result < 0 ? -1 : ( result > 0 ? 1 : 0 ); S32 res = result < 0 ? -1 : ( result > 0 ? 1 : 0 );
return ( smIncreasing ? res : -res ); return ( smDecreasing ? res : -res );
} }
@ -472,12 +472,12 @@ void ArrayObject::setValue( const String &value, S32 index )
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void ArrayObject::sort( bool valsort, bool desc, bool numeric ) void ArrayObject::sort( bool valsort, bool asc, bool numeric )
{ {
if ( mArray.size() <= 1 ) if ( mArray.size() <= 1 )
return; return;
smIncreasing = desc ? false : true; smDecreasing = asc ? false : true;
smCaseSensitive = isCaseSensitive(); smCaseSensitive = isCaseSensitive();
if ( numeric ) if ( numeric )
@ -498,12 +498,12 @@ void ArrayObject::sort( bool valsort, bool desc, bool numeric )
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void ArrayObject::sort( bool valsort, bool desc, const char* callbackFunctionName ) void ArrayObject::sort( bool valsort, bool asc, const char* callbackFunctionName )
{ {
if( mArray.size() <= 1 ) if( mArray.size() <= 1 )
return; return;
smIncreasing = desc ? false : true; smDecreasing = asc ? false : true;
smCompareFunction = callbackFunctionName; smCompareFunction = callbackFunctionName;
if( valsort ) if( valsort )
@ -767,80 +767,80 @@ DefineEngineMethod( ArrayObject, append, bool, ( ArrayObject* target ),,
return false; return false;
} }
DefineEngineMethod( ArrayObject, sort, void, ( bool descending ), ( false ), DefineEngineMethod( ArrayObject, sort, void, ( bool ascending ), ( false ),
"Alpha sorts the array by value\n\n" "Alpha sorts the array by value\n\n"
"@param descending [optional] True for descending sort, false for ascending sort\n" ) "@param ascending [optional] True for ascending sort, false for descending sort\n" )
{ {
object->sort( true, descending, false ); object->sort( true, ascending, false );
} }
DefineEngineMethod( ArrayObject, sorta, void, (),, DefineEngineMethod( ArrayObject, sorta, void, (),,
"Alpha sorts the array by value in ascending order" ) "Alpha sorts the array by value in ascending order" )
{ {
object->sort( true, false, false ); object->sort( true, true, false );
} }
DefineEngineMethod( ArrayObject, sortd, void, (),, DefineEngineMethod( ArrayObject, sortd, void, (),,
"Alpha sorts the array by value in descending order" ) "Alpha sorts the array by value in descending order" )
{ {
object->sort( true, true, false ); object->sort( true, false, false );
} }
DefineEngineMethod( ArrayObject, sortk, void, ( bool descending ), ( false ), DefineEngineMethod( ArrayObject, sortk, void, ( bool ascending ), ( false ),
"Alpha sorts the array by key\n\n" "Alpha sorts the array by key\n\n"
"@param descending [optional] True for descending sort, false for ascending sort\n" ) "@param ascending [optional] True for ascending sort, false for descending sort\n" )
{ {
object->sort( false, descending, false ); object->sort( false, ascending, false );
} }
DefineEngineMethod( ArrayObject, sortka, void, (),, DefineEngineMethod( ArrayObject, sortka, void, (),,
"Alpha sorts the array by key in ascending order" ) "Alpha sorts the array by key in ascending order" )
{ {
object->sort( false, false, false ); object->sort( false, true, false );
} }
DefineEngineMethod( ArrayObject, sortkd, void, (),, DefineEngineMethod( ArrayObject, sortkd, void, (),,
"Alpha sorts the array by key in descending order" ) "Alpha sorts the array by key in descending order" )
{ {
object->sort( false, true, false ); object->sort( false, false, false );
} }
DefineEngineMethod( ArrayObject, sortn, void, ( bool descending ), ( false ), DefineEngineMethod( ArrayObject, sortn, void, ( bool ascending ), ( false ),
"Numerically sorts the array by value\n\n" "Numerically sorts the array by value\n\n"
"@param descending [optional] True for descending sort, false for ascending sort\n" ) "@param ascending [optional] True for ascending sort, false for descending sort\n" )
{ {
object->sort( true, descending, true ); object->sort( true, ascending, true );
} }
DefineEngineMethod( ArrayObject, sortna, void, (),, DefineEngineMethod( ArrayObject, sortna, void, (),,
"Numerically sorts the array by value in ascending order" ) "Numerically sorts the array by value in ascending order" )
{ {
object->sort( true, false, true ); object->sort( true, true, true );
} }
DefineEngineMethod( ArrayObject, sortnd, void, (),, DefineEngineMethod( ArrayObject, sortnd, void, (),,
"Numerically sorts the array by value in descending order" ) "Numerically sorts the array by value in descending order" )
{ {
object->sort( true, true, true ); object->sort( true, false, true );
} }
DefineEngineMethod( ArrayObject, sortnk, void, ( bool descending ), ( false ), DefineEngineMethod( ArrayObject, sortnk, void, ( bool ascending ), ( false ),
"Numerically sorts the array by key\n\n" "Numerically sorts the array by key\n\n"
"@param descending [optional] True for descending sort, false for ascending sort\n" ) "@param ascending [optional] True for ascending sort, false for descending sort\n" )
{ {
object->sort( false, descending, true ); object->sort( false, ascending, true );
} }
DefineEngineMethod( ArrayObject, sortnka, void, (),, DefineEngineMethod( ArrayObject, sortnka, void, (),,
"Numerical sorts the array by key in ascending order" ) "Numerical sorts the array by key in ascending order" )
{ {
object->sort( false, false, true ); object->sort( false, true, true );
} }
DefineEngineMethod( ArrayObject, sortnkd, void, (),, DefineEngineMethod( ArrayObject, sortnkd, void, (),,
"Numerical sorts the array by key in descending order" ) "Numerical sorts the array by key in descending order" )
{ {
object->sort( false, true, true ); object->sort( false, false, true );
} }
DefineEngineMethod( ArrayObject, sortf, void, ( const char* functionName ),, DefineEngineMethod( ArrayObject, sortf, void, ( const char* functionName ),,
@ -854,7 +854,7 @@ DefineEngineMethod( ArrayObject, sortf, void, ( const char* functionName ),,
"%array.sortf( \"mySortCallback\" );\n" "%array.sortf( \"mySortCallback\" );\n"
"@endtsexample\n" ) "@endtsexample\n" )
{ {
object->sort( true, false, functionName ); object->sort( true, true, functionName );
} }
DefineEngineMethod( ArrayObject, sortfk, void, ( const char* functionName ),, DefineEngineMethod( ArrayObject, sortfk, void, ( const char* functionName ),,
@ -862,7 +862,7 @@ DefineEngineMethod( ArrayObject, sortfk, void, ( const char* functionName ),,
"@param functionName Name of a function that takes two arguments A and B and returns -1 if A is less, 1 if B is less, and 0 if both are equal." "@param functionName Name of a function that takes two arguments A and B and returns -1 if A is less, 1 if B is less, and 0 if both are equal."
"@see sortf\n" ) "@see sortf\n" )
{ {
object->sort( false, false, functionName ); object->sort( false, true, functionName );
} }
DefineEngineMethod( ArrayObject, sortfd, void, ( const char* functionName ),, DefineEngineMethod( ArrayObject, sortfd, void, ( const char* functionName ),,
@ -870,7 +870,7 @@ DefineEngineMethod( ArrayObject, sortfd, void, ( const char* functionName ),,
"@param functionName Name of a function that takes two arguments A and B and returns -1 if A is less, 1 if B is less, and 0 if both are equal." "@param functionName Name of a function that takes two arguments A and B and returns -1 if A is less, 1 if B is less, and 0 if both are equal."
"@see sortf\n" ) "@see sortf\n" )
{ {
object->sort( true, true, functionName ); object->sort( true, false, functionName );
} }
DefineEngineMethod( ArrayObject, sortfkd, void, ( const char* functionName ),, DefineEngineMethod( ArrayObject, sortfkd, void, ( const char* functionName ),,
@ -878,7 +878,7 @@ DefineEngineMethod( ArrayObject, sortfkd, void, ( const char* functionName ),,
"@param functionName Name of a function that takes two arguments A and B and returns -1 if A is less, 1 if B is less, and 0 if both are equal." "@param functionName Name of a function that takes two arguments A and B and returns -1 if A is less, 1 if B is less, and 0 if both are equal."
"@see sortf\n" ) "@see sortf\n" )
{ {
object->sort( false, true, functionName ); object->sort( false, false, functionName );
} }
DefineEngineMethod( ArrayObject, moveFirst, S32, (),, DefineEngineMethod( ArrayObject, moveFirst, S32, (),,

10
Engine/source/console/arrayObject.h
View file

@ -57,7 +57,7 @@ protected:
/// @name Sorting /// @name Sorting
/// @{ /// @{
static bool smIncreasing; static bool smDecreasing;
static bool smCaseSensitive; static bool smCaseSensitive;
static const char* smCompareFunction; static const char* smCompareFunction;
@ -175,15 +175,15 @@ public:
/// This sorts the array. /// This sorts the array.
/// @param valtest Determines whether sorting by value or key. /// @param valtest Determines whether sorting by value or key.
/// @param desc Determines if sorting ascending or descending. /// @param asc Determines if sorting ascending or descending.
/// @param numeric Determines if sorting alpha or numeric search. /// @param numeric Determines if sorting alpha or numeric search.
void sort( bool valtest, bool desc, bool numeric ); void sort( bool valtest, bool asc, bool numeric );
/// This sorts the array using a script callback. /// This sorts the array using a script callback.
/// @param valtest Determines whether sorting by value or key. /// @param valtest Determines whether sorting by value or key.
/// @param desc Determines if sorting ascending or descending. /// @param asc Determines if sorting ascending or descending.
/// @param callbackFunctionName Name of the script function. /// @param callbackFunctionName Name of the script function.
void sort( bool valtest, bool desc, const char* callbackFunctionName ); void sort( bool valtest, bool asc, const char* callbackFunctionName );
/// @} /// @}