|
|
|
|
/*==LICENSE==*
|
|
|
|
|
|
|
|
|
|
CyanWorlds.com Engine - MMOG client, server and tools
|
|
|
|
|
Copyright (C) 2011 Cyan Worlds, Inc.
|
|
|
|
|
|
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
|
|
|
|
|
You can contact Cyan Worlds, Inc. by email legal@cyan.com
|
|
|
|
|
or by snail mail at:
|
|
|
|
|
Cyan Worlds, Inc.
|
|
|
|
|
14617 N Newport Hwy
|
|
|
|
|
Mead, WA 99021
|
|
|
|
|
|
|
|
|
|
*==LICENSE==*/
|
|
|
|
|
/*****************************************************************************
|
|
|
|
|
*
|
|
|
|
|
* $/Plasma20/Sources/Plasma/NucleusLib/pnUtils/Private/pnUtSort.h
|
|
|
|
|
*
|
|
|
|
|
***/
|
|
|
|
|
|
|
|
|
|
#ifdef PLASMA20_SOURCES_PLASMA_NUCLEUSLIB_PNUTILS_PRIVATE_PNUTSORT_H
|
|
|
|
|
#error "Header $/Plasma20/Sources/Plasma/NucleusLib/pnUtils/Private/pnUtSort.h included more than once"
|
|
|
|
|
#endif
|
|
|
|
|
#define PLASMA20_SOURCES_PLASMA_NUCLEUSLIB_PNUTILS_PRIVATE_PNUTSORT_H
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
|
*
|
|
|
|
|
* QSORT
|
|
|
|
|
*
|
|
|
|
|
* This version of QuickSort is similar to the one in the C runtime library,
|
|
|
|
|
* but is implemented as a macro to allow more flexible usage.
|
|
|
|
|
*
|
|
|
|
|
* With the C runtime library version, when data external to the sort array
|
|
|
|
|
* is needed to make sorting decisions, that data must be stored in file- or
|
|
|
|
|
* global-scope variables. This creates thread safety problems which can
|
|
|
|
|
* only be resolved through the use of synchronization objects. The version
|
|
|
|
|
* of QuickSort provided here does not require function calls to make
|
|
|
|
|
* sorting decisions, so all data can be kept in stack variables.
|
|
|
|
|
*
|
|
|
|
|
* The expression used for making comparisons allows the same return values
|
|
|
|
|
* as the comparison function used by the C runtime library, and can in fact
|
|
|
|
|
* be a function call to a comparison function that was originally designed
|
|
|
|
|
* for use by the C runtime library.
|
|
|
|
|
* > 0 if elem1 greater than elem2
|
|
|
|
|
* = 0 if elem1 equivalent to elem2
|
|
|
|
|
* < 0 if elem1 less than elem2
|
|
|
|
|
*
|
|
|
|
|
* However, this implementation of QuickSort never requires a distinction
|
|
|
|
|
* between the case where elem1 is less than elem2 and the case where elem1
|
|
|
|
|
* is equivalent to elem2, so it is possible to use the following more
|
|
|
|
|
* efficient return values:
|
|
|
|
|
* > 0 if elem1 is greater than elem2
|
|
|
|
|
* <= 0 if elem1 is less than or equivalent to elem2
|
|
|
|
|
*
|
|
|
|
|
***/
|
|
|
|
|
|
|
|
|
|
//===========================================================================
|
|
|
|
|
#define QSORT(T, ptr, count, expr) { \
|
|
|
|
|
\
|
|
|
|
|
/* Largest possible stack count required is 1 + log2(size) */ \
|
|
|
|
|
T * loStack[32]; \
|
|
|
|
|
T * hiStack[32]; \
|
|
|
|
|
unsigned stackPos = 0; \
|
|
|
|
|
\
|
|
|
|
|
if ((count) >= 2) { \
|
|
|
|
|
T * lo = (ptr); \
|
|
|
|
|
T * hi = lo + (count); \
|
|
|
|
|
for (;;) { \
|
|
|
|
|
\
|
|
|
|
|
/* Pick a partitioning element */ \
|
|
|
|
|
T * mid = lo + (hi - lo) / 2; \
|
|
|
|
|
\
|
|
|
|
|
/* Swap it to the beginning of the array */ \
|
|
|
|
|
SWAP(*mid, *lo); \
|
|
|
|
|
\
|
|
|
|
|
/* Partition the array into three pieces, one consisting of */ \
|
|
|
|
|
/* elements <= the partitioning element, one of elements */ \
|
|
|
|
|
/* equal to it, and one of elements >= to it. */ \
|
|
|
|
|
T * loPart = lo; \
|
|
|
|
|
T * hiPart = hi; \
|
|
|
|
|
for (;;) { \
|
|
|
|
|
/* val(i) <= val(lo) for lo <= i <= loPart */ \
|
|
|
|
|
/* val(i) >= val(lo) for hiPart <= i <= hi */ \
|
|
|
|
|
\
|
|
|
|
|
for (;;) { \
|
|
|
|
|
if (++loPart == hi) \
|
|
|
|
|
break; \
|
|
|
|
|
T const & elem1 = *loPart; \
|
|
|
|
|
T const & elem2 = *lo; \
|
|
|
|
|
int result = (expr); \
|
|
|
|
|
if (result > 0) \
|
|
|
|
|
break; \
|
|
|
|
|
} \
|
|
|
|
|
\
|
|
|
|
|
for (;;) { \
|
|
|
|
|
if (--hiPart == lo) \
|
|
|
|
|
break; \
|
|
|
|
|
T const & elem1 = *lo; \
|
|
|
|
|
T const & elem2 = *hiPart; \
|
|
|
|
|
int result = (expr); \
|
|
|
|
|
if (result > 0) \
|
|
|
|
|
break; \
|
|
|
|
|
} \
|
|
|
|
|
\
|
|
|
|
|
if (hiPart < loPart) \
|
|
|
|
|
break; \
|
|
|
|
|
\
|
|
|
|
|
/* val(loPart) > val(lo) */ \
|
|
|
|
|
/* val(hiPart) < val(lo) */ \
|
|
|
|
|
\
|
|
|
|
|
SWAP(*loPart, *hiPart); \
|
|
|
|
|
\
|
|
|
|
|
/* val(loPart) < val(lo) */ \
|
|
|
|
|
/* val(hiPart) > val(lo) */ \
|
|
|
|
|
} \
|
|
|
|
|
\
|
|
|
|
|
/* val(i) <= val(lo) for lo <= i <= hiPart */ \
|
|
|
|
|
/* val(i) == val(lo) for hiPart < i < loPart */ \
|
|
|
|
|
/* val(i) >= val(lo) for loPart <= i <= hi */ \
|
|
|
|
|
\
|
|
|
|
|
/* Put the partitioning element in place */ \
|
|
|
|
|
SWAP(*lo, *hiPart); \
|
|
|
|
|
\
|
|
|
|
|
/* val(i) <= val(hiPart) for lo <= i < hiPart */ \
|
|
|
|
|
/* val(i) == val(lo) for hiPart <= i < loPart */ \
|
|
|
|
|
/* val(i) >= val(hiPart) for loPart <= i < hi */ \
|
|
|
|
|
\
|
|
|
|
|
/* Sort the subarrays [lo, hiPart-1] and [loPart, hi]. */ \
|
|
|
|
|
/* We sort the smaller one first to minimize stack usage. */ \
|
|
|
|
|
if (hiPart - lo >= hi - loPart) { \
|
|
|
|
|
if (lo + 1 < hiPart) { \
|
|
|
|
|
/* Store the bigger subarray */ \
|
|
|
|
|
loStack[stackPos] = lo; \
|
|
|
|
|
hiStack[stackPos] = hiPart; \
|
|
|
|
|
++stackPos; \
|
|
|
|
|
} \
|
|
|
|
|
if (loPart + 1 < hi) { \
|
|
|
|
|
/* Sort the smaller subarray */ \
|
|
|
|
|
lo = loPart; \
|
|
|
|
|
continue; \
|
|
|
|
|
} \
|
|
|
|
|
} \
|
|
|
|
|
else { \
|
|
|
|
|
if (loPart + 1 < hi) { \
|
|
|
|
|
/* Store the bigger subarray */ \
|
|
|
|
|
loStack[stackPos] = loPart; \
|
|
|
|
|
hiStack[stackPos] = hi; \
|
|
|
|
|
++stackPos; \
|
|
|
|
|
} \
|
|
|
|
|
if (lo + 1 < hiPart) { \
|
|
|
|
|
/* Sort the smaller subarray */ \
|
|
|
|
|
hi = hiPart; \
|
|
|
|
|
continue; \
|
|
|
|
|
} \
|
|
|
|
|
} \
|
|
|
|
|
\
|
|
|
|
|
/* Pop the next subarray off the stack */ \
|
|
|
|
|
if (stackPos--) { \
|
|
|
|
|
lo = loStack[stackPos]; \
|
|
|
|
|
hi = hiStack[stackPos]; \
|
|
|
|
|
continue; \
|
|
|
|
|
} \
|
|
|
|
|
\
|
|
|
|
|
break; \
|
|
|
|
|
} \
|
|
|
|
|
} \
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
|
*
|
|
|
|
|
* BSEARCH
|
|
|
|
|
*
|
|
|
|
|
* This macro binary searches a sorted array to find an existing entry or
|
|
|
|
|
* the position where a TRACKED_NEW entry should be placed. It returns the index of
|
|
|
|
|
* the first entry for which the expression is false (zero or negative), or
|
|
|
|
|
* count if the expression is true (positive) for all entries.
|
|
|
|
|
*
|
|
|
|
|
* Typically the expression will return:
|
|
|
|
|
* > 0 if (sortKey > elem)
|
|
|
|
|
* <= 0 if (sortKey <= elem)
|
|
|
|
|
*
|
|
|
|
|
* The final parameter to the macro is the address of a variable which is
|
|
|
|
|
* filled with the resulting index.
|
|
|
|
|
*
|
|
|
|
|
***/
|
|
|
|
|
|
|
|
|
|
//===========================================================================
|
|
|
|
|
#define BSEARCH(T, ptr, count, expr, addrOfIndex) { \
|
|
|
|
|
\
|
|
|
|
|
const T * low = (ptr); \
|
|
|
|
|
const T * high = (ptr) + (count); /* first entry for which */ \
|
|
|
|
|
/* expr is false */ \
|
|
|
|
|
\
|
|
|
|
|
if (low != high) \
|
|
|
|
|
for (;;) { \
|
|
|
|
|
const T & elem = *(low + (high - low) / 2); \
|
|
|
|
|
int result = (expr); \
|
|
|
|
|
if (result > 0) { \
|
|
|
|
|
if (&elem == low) \
|
|
|
|
|
break; \
|
|
|
|
|
low = &elem; \
|
|
|
|
|
} \
|
|
|
|
|
else { \
|
|
|
|
|
high = &elem; \
|
|
|
|
|
if (&elem == low) \
|
|
|
|
|
break; \
|
|
|
|
|
} \
|
|
|
|
|
} \
|
|
|
|
|
\
|
|
|
|
|
*(addrOfIndex) = high - (ptr); \
|
|
|
|
|
\
|
|
|
|
|
}
|
