Archives/OpenTTD-patches
2
0
Fork 0
mirror of https://github.com/JGRennison/OpenTTD-patches.git synced 2024-11-02 09:40:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

Codechange: use std::sort() in EngList_Sort[Partial]()

Browse Source
This commit is contained in:
glx 2019-04-11 22:17:30 +02:00 committed by PeterN
parent 2db88953e7
commit b52561fd38
4 changed files with 123 additions and 131 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/autoreplace_gui.cpp
View File

@ -32,11 +32,9 @@
void DrawEngineList(VehicleType type, int x, int r, int y, const GUIEngineList *eng_list, uint16 min, uint16 max, EngineID selected_id, bool show_count, GroupID selected_group); void DrawEngineList(VehicleType type, int x, int r, int y, const GUIEngineList *eng_list, uint16 min, uint16 max, EngineID selected_id, bool show_count, GroupID selected_group);
static int CDECL EngineNumberSorter(const EngineID *a, const EngineID *b) static bool EngineNumberSorter(const EngineID &a, const EngineID &b)
{ {
int r = Engine::Get(*a)->list_position - Engine::Get(*b)->list_position; return Engine::Get(a)->list_position < Engine::Get(b)->list_position;
return r;
} }
/** /**

237
src/build_vehicle_gui.cpp
View File

@ -99,57 +99,54 @@ static CargoID _engine_sort_last_cargo_criteria[] = {CF_ANY, CF_ANY, CF_ANY, CF_
/** /**
* Determines order of engines by engineID * Determines order of engines by engineID
* @param *a first engine to compare * @param a first engine to compare
* @param *b second engine to compare * @param b second engine to compare
* @return for descending order: returns < 0 if a < b and > 0 for a > b. Vice versa for ascending order and 0 for equal * @return for descending order: returns true if a < b. Vice versa for ascending order
*/ */
static int CDECL EngineNumberSorter(const EngineID *a, const EngineID *b) static bool EngineNumberSorter(const EngineID &a, const EngineID &b)
{ {
int r = Engine::Get(*a)->list_position - Engine::Get(*b)->list_position; int r = Engine::Get(a)->list_position - Engine::Get(b)->list_position;
return _engine_sort_direction ? -r : r; return _engine_sort_direction ? r > 0 : r < 0;
} }
/** /**
* Determines order of engines by introduction date * Determines order of engines by introduction date
* @param *a first engine to compare * @param a first engine to compare
* @param *b second engine to compare * @param b second engine to compare
* @return for descending order: returns < 0 if a < b and > 0 for a > b. Vice versa for ascending order and 0 for equal * @return for descending order: returns true if a < b. Vice versa for ascending order
*/ */
static int CDECL EngineIntroDateSorter(const EngineID *a, const EngineID *b) static bool EngineIntroDateSorter(const EngineID &a, const EngineID &b)
{ {
const int va = Engine::Get(*a)->intro_date; const int va = Engine::Get(a)->intro_date;
const int vb = Engine::Get(*b)->intro_date; const int vb = Engine::Get(b)->intro_date;
const int r = va - vb; const int r = va - vb;
/* Use EngineID to sort instead since we want consistent sorting */ /* Use EngineID to sort instead since we want consistent sorting */
if (r == 0) return EngineNumberSorter(a, b); if (r == 0) return EngineNumberSorter(a, b);
return _engine_sort_direction ? -r : r; return _engine_sort_direction ? r > 0 : r < 0;
} }
/** /**
* Determines order of engines by name * Determines order of engines by name
* @param *a first engine to compare * @param a first engine to compare
* @param *b second engine to compare * @param b second engine to compare
* @return for descending order: returns < 0 if a < b and > 0 for a > b. Vice versa for ascending order and 0 for equal * @return for descending order: returns true if a < b. Vice versa for ascending order
*/ */
static int CDECL EngineNameSorter(const EngineID *a, const EngineID *b) static bool EngineNameSorter(const EngineID &a, const EngineID &b)
{ {
static EngineID last_engine[2] = { INVALID_ENGINE, INVALID_ENGINE }; static EngineID last_engine[2] = { INVALID_ENGINE, INVALID_ENGINE };
static char last_name[2][64] = { "\0", "\0" }; static char last_name[2][64] = { "\0", "\0" };
const EngineID va = *a; if (a != last_engine[0]) {
const EngineID vb = *b; last_engine[0] = a;
SetDParam(0, a);
if (va != last_engine[0]) {
last_engine[0] = va;
SetDParam(0, va);
GetString(last_name[0], STR_ENGINE_NAME, lastof(last_name[0])); GetString(last_name[0], STR_ENGINE_NAME, lastof(last_name[0]));
} }
if (vb != last_engine[1]) { if (b != last_engine[1]) {
last_engine[1] = vb; last_engine[1] = b;
SetDParam(0, vb); SetDParam(0, b);
GetString(last_name[1], STR_ENGINE_NAME, lastof(last_name[1])); GetString(last_name[1], STR_ENGINE_NAME, lastof(last_name[1]));
} }
@ -157,121 +154,121 @@ static int CDECL EngineNameSorter(const EngineID *a, const EngineID *b)
/* Use EngineID to sort instead since we want consistent sorting */ /* Use EngineID to sort instead since we want consistent sorting */
if (r == 0) return EngineNumberSorter(a, b); if (r == 0) return EngineNumberSorter(a, b);
return _engine_sort_direction ? -r : r; return _engine_sort_direction ? r > 0 : r < 0;
} }
/** /**
* Determines order of engines by reliability * Determines order of engines by reliability
* @param *a first engine to compare * @param a first engine to compare
* @param *b second engine to compare * @param b second engine to compare
* @return for descending order: returns < 0 if a < b and > 0 for a > b. Vice versa for ascending order and 0 for equal * @return for descending order: returns true if a < b. Vice versa for ascending order
*/ */
static int CDECL EngineReliabilitySorter(const EngineID *a, const EngineID *b) static bool EngineReliabilitySorter(const EngineID &a, const EngineID &b)
{ {
const int va = Engine::Get(*a)->reliability; const int va = Engine::Get(a)->reliability;
const int vb = Engine::Get(*b)->reliability; const int vb = Engine::Get(b)->reliability;
const int r = va - vb; const int r = va - vb;
/* Use EngineID to sort instead since we want consistent sorting */ /* Use EngineID to sort instead since we want consistent sorting */
if (r == 0) return EngineNumberSorter(a, b); if (r == 0) return EngineNumberSorter(a, b);
return _engine_sort_direction ? -r : r; return _engine_sort_direction ? r > 0 : r < 0;
} }
/** /**
* Determines order of engines by purchase cost * Determines order of engines by purchase cost
* @param *a first engine to compare * @param a first engine to compare
* @param *b second engine to compare * @param b second engine to compare
* @return for descending order: returns < 0 if a < b and > 0 for a > b. Vice versa for ascending order and 0 for equal * @return for descending order: returns true if a < b. Vice versa for ascending order
*/ */
static int CDECL EngineCostSorter(const EngineID *a, const EngineID *b) static bool EngineCostSorter(const EngineID &a, const EngineID &b)
{ {
Money va = Engine::Get(*a)->GetCost(); Money va = Engine::Get(a)->GetCost();
Money vb = Engine::Get(*b)->GetCost(); Money vb = Engine::Get(b)->GetCost();
int r = ClampToI32(va - vb); int r = ClampToI32(va - vb);
/* Use EngineID to sort instead since we want consistent sorting */ /* Use EngineID to sort instead since we want consistent sorting */
if (r == 0) return EngineNumberSorter(a, b); if (r == 0) return EngineNumberSorter(a, b);
return _engine_sort_direction ? -r : r; return _engine_sort_direction ? r > 0 : r < 0;
} }
/** /**
* Determines order of engines by speed * Determines order of engines by speed
* @param *a first engine to compare * @param a first engine to compare
* @param *b second engine to compare * @param b second engine to compare
* @return for descending order: returns < 0 if a < b and > 0 for a > b. Vice versa for ascending order and 0 for equal * @return for descending order: returns true if a < b. Vice versa for ascending order
*/ */
static int CDECL EngineSpeedSorter(const EngineID *a, const EngineID *b) static bool EngineSpeedSorter(const EngineID &a, const EngineID &b)
{ {
int va = Engine::Get(*a)->GetDisplayMaxSpeed(); int va = Engine::Get(a)->GetDisplayMaxSpeed();
int vb = Engine::Get(*b)->GetDisplayMaxSpeed(); int vb = Engine::Get(b)->GetDisplayMaxSpeed();
int r = va - vb; int r = va - vb;
/* Use EngineID to sort instead since we want consistent sorting */ /* Use EngineID to sort instead since we want consistent sorting */
if (r == 0) return EngineNumberSorter(a, b); if (r == 0) return EngineNumberSorter(a, b);
return _engine_sort_direction ? -r : r; return _engine_sort_direction ? r > 0 : r < 0;
} }
/** /**
* Determines order of engines by power * Determines order of engines by power
* @param *a first engine to compare * @param a first engine to compare
* @param *b second engine to compare * @param b second engine to compare
* @return for descending order: returns < 0 if a < b and > 0 for a > b. Vice versa for ascending order and 0 for equal * @return for descending order: returns true if a < b. Vice versa for ascending order
*/ */
static int CDECL EnginePowerSorter(const EngineID *a, const EngineID *b) static bool EnginePowerSorter(const EngineID &a, const EngineID &b)
{ {
int va = Engine::Get(*a)->GetPower(); int va = Engine::Get(a)->GetPower();
int vb = Engine::Get(*b)->GetPower(); int vb = Engine::Get(b)->GetPower();
int r = va - vb; int r = va - vb;
/* Use EngineID to sort instead since we want consistent sorting */ /* Use EngineID to sort instead since we want consistent sorting */
if (r == 0) return EngineNumberSorter(a, b); if (r == 0) return EngineNumberSorter(a, b);
return _engine_sort_direction ? -r : r; return _engine_sort_direction ? r > 0 : r < 0;
} }
/** /**
* Determines order of engines by tractive effort * Determines order of engines by tractive effort
* @param *a first engine to compare * @param a first engine to compare
* @param *b second engine to compare * @param b second engine to compare
* @return for descending order: returns < 0 if a < b and > 0 for a > b. Vice versa for ascending order and 0 for equal * @return for descending order: returns true if a < b. Vice versa for ascending order
*/ */
static int CDECL EngineTractiveEffortSorter(const EngineID *a, const EngineID *b) static bool EngineTractiveEffortSorter(const EngineID &a, const EngineID &b)
{ {
int va = Engine::Get(*a)->GetDisplayMaxTractiveEffort(); int va = Engine::Get(a)->GetDisplayMaxTractiveEffort();
int vb = Engine::Get(*b)->GetDisplayMaxTractiveEffort(); int vb = Engine::Get(b)->GetDisplayMaxTractiveEffort();
int r = va - vb; int r = va - vb;
/* Use EngineID to sort instead since we want consistent sorting */ /* Use EngineID to sort instead since we want consistent sorting */
if (r == 0) return EngineNumberSorter(a, b); if (r == 0) return EngineNumberSorter(a, b);
return _engine_sort_direction ? -r : r; return _engine_sort_direction ? r > 0 : r < 0;
} }
/** /**
* Determines order of engines by running costs * Determines order of engines by running costs
* @param *a first engine to compare * @param a first engine to compare
* @param *b second engine to compare * @param b second engine to compare
* @return for descending order: returns < 0 if a < b and > 0 for a > b. Vice versa for ascending order and 0 for equal * @return for descending order: returns true if a < b. Vice versa for ascending order
*/ */
static int CDECL EngineRunningCostSorter(const EngineID *a, const EngineID *b) static bool EngineRunningCostSorter(const EngineID &a, const EngineID &b)
{ {
Money va = Engine::Get(*a)->GetRunningCost(); Money va = Engine::Get(a)->GetRunningCost();
Money vb = Engine::Get(*b)->GetRunningCost(); Money vb = Engine::Get(b)->GetRunningCost();
int r = ClampToI32(va - vb); int r = ClampToI32(va - vb);
/* Use EngineID to sort instead since we want consistent sorting */ /* Use EngineID to sort instead since we want consistent sorting */
if (r == 0) return EngineNumberSorter(a, b); if (r == 0) return EngineNumberSorter(a, b);
return _engine_sort_direction ? -r : r; return _engine_sort_direction ? r > 0 : r < 0;
} }
/** /**
* Determines order of engines by running costs * Determines order of engines by running costs
* @param *a first engine to compare * @param a first engine to compare
* @param *b second engine to compare * @param b second engine to compare
* @return for descending order: returns < 0 if a < b and > 0 for a > b. Vice versa for ascending order and 0 for equal * @return for descending order: returns true if a < b. Vice versa for ascending order
*/ */
static int CDECL EnginePowerVsRunningCostSorter(const EngineID *a, const EngineID *b) static bool EnginePowerVsRunningCostSorter(const EngineID &a, const EngineID &b)
{ {
const Engine *e_a = Engine::Get(*a); const Engine *e_a = Engine::Get(a);
const Engine *e_b = Engine::Get(*b); const Engine *e_b = Engine::Get(b);
/* Here we are using a few tricks to get the right sort. /* Here we are using a few tricks to get the right sort.
* We want power/running cost, but since we usually got higher running cost than power and we store the result in an int, * We want power/running cost, but since we usually got higher running cost than power and we store the result in an int,
@ -285,79 +282,79 @@ static int CDECL EnginePowerVsRunningCostSorter(const EngineID *a, const EngineI
/* Use EngineID to sort instead since we want consistent sorting */ /* Use EngineID to sort instead since we want consistent sorting */
if (r == 0) return EngineNumberSorter(a, b); if (r == 0) return EngineNumberSorter(a, b);
return _engine_sort_direction ? -r : r; return _engine_sort_direction ? r > 0 : r < 0;
} }
/* Train sorting functions */ /* Train sorting functions */
/** /**
* Determines order of train engines by capacity * Determines order of train engines by capacity
* @param *a first engine to compare * @param a first engine to compare
* @param *b second engine to compare * @param b second engine to compare
* @return for descending order: returns < 0 if a < b and > 0 for a > b. Vice versa for ascending order and 0 for equal * @return for descending order: returns true if a < b. Vice versa for ascending order
*/ */
static int CDECL TrainEngineCapacitySorter(const EngineID *a, const EngineID *b) static bool TrainEngineCapacitySorter(const EngineID &a, const EngineID &b)
{ {
const RailVehicleInfo *rvi_a = RailVehInfo(*a); const RailVehicleInfo *rvi_a = RailVehInfo(a);
const RailVehicleInfo *rvi_b = RailVehInfo(*b); const RailVehicleInfo *rvi_b = RailVehInfo(b);
int va = GetTotalCapacityOfArticulatedParts(*a) * (rvi_a->railveh_type == RAILVEH_MULTIHEAD ? 2 : 1); int va = GetTotalCapacityOfArticulatedParts(a) * (rvi_a->railveh_type == RAILVEH_MULTIHEAD ? 2 : 1);
int vb = GetTotalCapacityOfArticulatedParts(*b) * (rvi_b->railveh_type == RAILVEH_MULTIHEAD ? 2 : 1); int vb = GetTotalCapacityOfArticulatedParts(b) * (rvi_b->railveh_type == RAILVEH_MULTIHEAD ? 2 : 1);
int r = va - vb; int r = va - vb;
/* Use EngineID to sort instead since we want consistent sorting */ /* Use EngineID to sort instead since we want consistent sorting */
if (r == 0) return EngineNumberSorter(a, b); if (r == 0) return EngineNumberSorter(a, b);
return _engine_sort_direction ? -r : r; return _engine_sort_direction ? r > 0 : r < 0;
} }
/** /**
* Determines order of train engines by engine / wagon * Determines order of train engines by engine / wagon
* @param *a first engine to compare * @param a first engine to compare
* @param *b second engine to compare * @param b second engine to compare
* @return for descending order: returns < 0 if a < b and > 0 for a > b. Vice versa for ascending order and 0 for equal * @return for descending order: returns true if a < b. Vice versa for ascending order
*/ */
static int CDECL TrainEnginesThenWagonsSorter(const EngineID *a, const EngineID *b) static bool TrainEnginesThenWagonsSorter(const EngineID &a, const EngineID &b)
{ {
int val_a = (RailVehInfo(*a)->railveh_type == RAILVEH_WAGON ? 1 : 0); int val_a = (RailVehInfo(a)->railveh_type == RAILVEH_WAGON ? 1 : 0);
int val_b = (RailVehInfo(*b)->railveh_type == RAILVEH_WAGON ? 1 : 0); int val_b = (RailVehInfo(b)->railveh_type == RAILVEH_WAGON ? 1 : 0);
int r = val_a - val_b; int r = val_a - val_b;
/* Use EngineID to sort instead since we want consistent sorting */ /* Use EngineID to sort instead since we want consistent sorting */
if (r == 0) return EngineNumberSorter(a, b); if (r == 0) return EngineNumberSorter(a, b);
return _engine_sort_direction ? -r : r; return _engine_sort_direction ? r > 0 : r < 0;
} }
/* Road vehicle sorting functions */ /* Road vehicle sorting functions */
/** /**
* Determines order of road vehicles by capacity * Determines order of road vehicles by capacity
* @param *a first engine to compare * @param a first engine to compare
* @param *b second engine to compare * @param b second engine to compare
* @return for descending order: returns < 0 if a < b and > 0 for a > b. Vice versa for ascending order and 0 for equal * @return for descending order: returns true if a < b. Vice versa for ascending order
*/ */
static int CDECL RoadVehEngineCapacitySorter(const EngineID *a, const EngineID *b) static bool RoadVehEngineCapacitySorter(const EngineID &a, const EngineID &b)
{ {
int va = GetTotalCapacityOfArticulatedParts(*a); int va = GetTotalCapacityOfArticulatedParts(a);
int vb = GetTotalCapacityOfArticulatedParts(*b); int vb = GetTotalCapacityOfArticulatedParts(b);
int r = va - vb; int r = va - vb;
/* Use EngineID to sort instead since we want consistent sorting */ /* Use EngineID to sort instead since we want consistent sorting */
if (r == 0) return EngineNumberSorter(a, b); if (r == 0) return EngineNumberSorter(a, b);
return _engine_sort_direction ? -r : r; return _engine_sort_direction ? r > 0 : r < 0;
} }
/* Ship vehicle sorting functions */ /* Ship vehicle sorting functions */
/** /**
* Determines order of ships by capacity * Determines order of ships by capacity
* @param *a first engine to compare * @param a first engine to compare
* @param *b second engine to compare * @param b second engine to compare
* @return for descending order: returns < 0 if a < b and > 0 for a > b. Vice versa for ascending order and 0 for equal * @return for descending order: returns true if a < b. Vice versa for ascending order
*/ */
static int CDECL ShipEngineCapacitySorter(const EngineID *a, const EngineID *b) static bool ShipEngineCapacitySorter(const EngineID &a, const EngineID &b)
{ {
const Engine *e_a = Engine::Get(*a); const Engine *e_a = Engine::Get(a);
const Engine *e_b = Engine::Get(*b); const Engine *e_b = Engine::Get(b);
int va = e_a->GetDisplayDefaultCapacity(); int va = e_a->GetDisplayDefaultCapacity();
int vb = e_b->GetDisplayDefaultCapacity(); int vb = e_b->GetDisplayDefaultCapacity();
@ -365,21 +362,21 @@ static int CDECL ShipEngineCapacitySorter(const EngineID *a, const EngineID *b)
/* Use EngineID to sort instead since we want consistent sorting */ /* Use EngineID to sort instead since we want consistent sorting */
if (r == 0) return EngineNumberSorter(a, b); if (r == 0) return EngineNumberSorter(a, b);
return _engine_sort_direction ? -r : r; return _engine_sort_direction ? r > 0 : r < 0;
} }
/* Aircraft sorting functions */ /* Aircraft sorting functions */
/** /**
* Determines order of aircraft by cargo * Determines order of aircraft by cargo
* @param *a first engine to compare * @param a first engine to compare
* @param *b second engine to compare * @param b second engine to compare
* @return for descending order: returns < 0 if a < b and > 0 for a > b. Vice versa for ascending order and 0 for equal * @return for descending order: returns true if a < b. Vice versa for ascending order
*/ */
static int CDECL AircraftEngineCargoSorter(const EngineID *a, const EngineID *b) static bool AircraftEngineCargoSorter(const EngineID &a, const EngineID &b)
{ {
const Engine *e_a = Engine::Get(*a); const Engine *e_a = Engine::Get(a);
const Engine *e_b = Engine::Get(*b); const Engine *e_b = Engine::Get(b);
uint16 mail_a, mail_b; uint16 mail_a, mail_b;
int va = e_a->GetDisplayDefaultCapacity(&mail_a); int va = e_a->GetDisplayDefaultCapacity(&mail_a);
@ -395,25 +392,25 @@ static int CDECL AircraftEngineCargoSorter(const EngineID *a, const EngineID *b)
return EngineNumberSorter(a, b); return EngineNumberSorter(a, b);
} }
} }
return _engine_sort_direction ? -r : r; return _engine_sort_direction ? r > 0 : r < 0;
} }
/** /**
* Determines order of aircraft by range. * Determines order of aircraft by range.
* @param *a first engine to compare. * @param a first engine to compare
* @param *b second engine to compare. * @param b second engine to compare
* @return for descending order: returns < 0 if a < b and > 0 for a > b. Vice versa for ascending order and 0 for equal. * @return for descending order: returns true if a < b. Vice versa for ascending order
*/ */
static int CDECL AircraftRangeSorter(const EngineID *a, const EngineID *b) static bool AircraftRangeSorter(const EngineID &a, const EngineID &b)
{ {
uint16 r_a = Engine::Get(*a)->GetRange(); uint16 r_a = Engine::Get(a)->GetRange();
uint16 r_b = Engine::Get(*b)->GetRange(); uint16 r_b = Engine::Get(b)->GetRange();
int r = r_a - r_b; int r = r_a - r_b;
/* Use EngineID to sort instead since we want consistent sorting */ /* Use EngineID to sort instead since we want consistent sorting */
if (r == 0) return EngineNumberSorter(a, b); if (r == 0) return EngineNumberSorter(a, b);
return _engine_sort_direction ? -r : r; return _engine_sort_direction ? r > 0 : r < 0;
} }
/** Sort functions for the vehicle sort criteria, for each vehicle type. */ /** Sort functions for the vehicle sort criteria, for each vehicle type. */

9
src/engine_gui.cpp
View File

@ -325,11 +325,8 @@ void DrawVehicleEngine(int left, int right, int preferred_x, int y, EngineID eng
*/ */
void EngList_Sort(GUIEngineList *el, EngList_SortTypeFunction compare) void EngList_Sort(GUIEngineList *el, EngList_SortTypeFunction compare)
{ {
size_t size = el->size(); if (el->size() < 2) return;
/* out-of-bounds access at the next line for size == 0 (even with operator[] at some systems) std::sort(el->begin(), el->end(), compare);
* generally, do not sort if there are less than 2 items */
if (size < 2) return;
QSortT(el->data(), size, compare);
} }
/** /**
@ -344,6 +341,6 @@ void EngList_SortPartial(GUIEngineList *el, EngList_SortTypeFunction compare, ui
if (num_items < 2) return; if (num_items < 2) return;
assert(begin < el->size()); assert(begin < el->size());
assert(begin + num_items <= el->size()); assert(begin + num_items <= el->size());
QSortT(el->data() + begin, num_items, compare); std::sort(el->begin() + begin, el->begin() + begin + num_items, compare);
} }

2
src/engine_gui.h
View File

@ -19,7 +19,7 @@
typedef GUIList<EngineID, CargoID> GUIEngineList; typedef GUIList<EngineID, CargoID> GUIEngineList;
typedef int CDECL EngList_SortTypeFunction(const EngineID*, const EngineID*); ///< argument type for #EngList_Sort. typedef bool EngList_SortTypeFunction(const EngineID&, const EngineID&); ///< argument type for #EngList_Sort.
void EngList_Sort(GUIEngineList *el, EngList_SortTypeFunction compare); void EngList_Sort(GUIEngineList *el, EngList_SortTypeFunction compare);
void EngList_SortPartial(GUIEngineList *el, EngList_SortTypeFunction compare, uint begin, uint num_items); void EngList_SortPartial(GUIEngineList *el, EngList_SortTypeFunction compare, uint begin, uint num_items);