Trinity Namespace Reference

Namespaces
namespace	Asio
namespace	Banner
namespace	ChatCommands
namespace	Containers
namespace	Crypto
namespace	Currency
namespace	Encoding
namespace	Honor
namespace	Hyperlinks
namespace	Impl
namespace	Legacy
namespace	Net
namespace	Predicates
namespace	SpellScripts
namespace	XP

Classes
class	AbsorbAuraOrderPred
struct	AIRelocationNotifier
class	AllCreaturesOfEntryInRange
class	AllFriendlyCreaturesInGrid
class	AllGameObjectsWithEntryInRange
class	AllWorldObjectsInRange
class	AnyAoETargetUnitInObjectRangeCheck
class	AnyAssistCreatureInRangeCheck
struct	AnyDeadUnitCheck
class	AnyDeadUnitObjectInRangeCheck
class	AnyDeadUnitSpellTargetInRangeCheck
class	AnyFriendlyUnitInObjectRangeCheck
class	AnyGroupedUnitInObjectRangeCheck
class	AnyPlayerInObjectRangeCheck
class	AnyPlayerInPositionRangeCheck
class	AnyUnfriendlyUnitInObjectRangeCheck
class	AnyUnitInObjectRangeCheck
class	AsyncProcessResult
class	AsyncProcessResultImplementation
class	BroadcastTextBuilder
class	CallOfHelpCreatureInRangeDo
class	ChatPacketSender
class	CheckedBufferOutputIterator
class	ContainerInserter
struct	CreatureLastSearcher
struct	CreatureListSearcher
struct	CreatureRelocationNotifier
struct	CreatureSearcher
class	CreatureTextTextBuilder
class	CreatureWithOptionsInObjectRangeCheck
struct	CreatureWorker
class	CustomChatTextBuilder
struct	DelayedUnitRelocation
struct	dependant_false
struct	find_type_if
struct	find_type_if< Check >
struct	find_type_if< Check, T1, Ts... >
class	FriendlyBelowHpPctEntryInRange
class	FriendlyCCedInRange
class	FriendlyMissingBuffInRange
class	GameObjectFocusCheck
class	GameObjectInRangeCheck
struct	GameObjectLastSearcher
struct	GameObjectListSearcher
struct	GameObjectSearcher
struct	GameObjectWorker
struct	GridUpdater
struct	has_type
struct	has_type< T, std::tuple< Us... > >
class	HealthPctOrderPred
class	HeightDifferenceCheck
struct	is_tuple
struct	is_tuple< std::tuple< Ts... > >
class	IteratorPair
	Utility class to enable range for loop syntax for multimap.equal_range uses. More...
class	LocalizedDo
struct	MessageDistDeliverer
struct	MessageDistDelivererToHostile
class	MostHPMissingInRange
class	MostHPPercentMissingInRange
class	NearestAssistCreatureInCreatureRangeCheck
class	NearestAttackableNoTotemUnitInObjectRangeCheck
class	NearestAttackableUnitInObjectRangeCheck
class	NearestCheckCustomizer
class	NearestCreatureEntryWithLiveStateInObjectRangeCheck
class	NearestGameObjectCheck
class	NearestGameObjectEntryInObjectRangeCheck
class	NearestGameObjectFishingHole
class	NearestGameObjectTypeInObjectRangeCheck
class	NearestHostileUnitCheck
class	NearestHostileUnitInAggroRangeCheck
class	NearestHostileUnitInAttackDistanceCheck
class	NearestPlayerInObjectRangeCheck
class	NearestUnspawnedGameObjectEntryInObjectRangeCheck
class	NoopCheckCustomizer
class	ObjectDistanceOrderPred
class	ObjectEntryAndPrivateOwnerIfExistsCheck
class	ObjectGUIDCheck
class	ObjectTypeIdCheck
struct	ObjectUpdater
struct	PacketSenderOwning
struct	PacketSenderRef
class	PlayerAtMinimumRangeAway
struct	PlayerDistWorker
struct	PlayerLastSearcher
struct	PlayerListSearcher
struct	PlayerRelocationNotifier
struct	PlayerSearcher
struct	PlayerWorker
class	PowerPctOrderPred
struct	RaceMask
class	RespawnDo
class	TCLogSink
class	ThreadPool
class	TrinityStringChatBuilder
class	UnitAuraCheck
struct	UnitLastSearcher
struct	UnitListSearcher
struct	UnitSearcher
struct	VisibleChangesNotifier
struct	VisibleNotifier
struct	WorldObjectLastSearcher
struct	WorldObjectListSearcher
struct	WorldObjectSearcher
struct	WorldObjectSpellAreaTargetCheck
struct	WorldObjectSpellConeTargetCheck
struct	WorldObjectSpellLineTargetCheck
struct	WorldObjectSpellNearbyTargetCheck
struct	WorldObjectSpellTargetCheck
struct	WorldObjectSpellTrajTargetCheck
struct	WorldObjectWorker
class	WorldWorldTextBuilder

Typedefs
using	regex = TC_REGEX_NAMESPACE ::regex
using	wregex = TC_REGEX_NAMESPACE ::wregex
template<typename... Args>
using	FormatString = fmt::format_string< Args... >
template<template< typename... > typename Check, typename... Ts>
using	find_type_if_t = typename find_type_if< Check, Ts... >::type

Functions
void	Assert (char const *file, int line, char const *function, std::string debugInfo, char const *message)
void	Assert (char const *file, int line, char const *function, std::string debugInfo, char const *message, char const *format,...)
void	Fatal (char const *file, int line, char const *function, char const *message,...)
void	Error (char const *file, int line, char const *function, char const *message)
void	Warning (char const *file, int line, char const *function, char const *message)
void	Abort (char const *file, int line, char const *function)
void	Abort (char const *file, int line, char const *function, char const *message,...)
void	AbortHandler (int sigval)
template<typename T >
void	hash_combine (std::size_t &seed, T const &val)
template<typename T , typename Del >
auto	make_unique_ptr_with_deleter (T ptr, Del &&deleter)
template<typename T >
auto	MakeTCLogSink (T &&callback) -> TCLogSink< typename std::decay< T >::type >
template<typename T >
static int	CreateChildProcess (T waiter, std::string const &executable, std::vector< std::string > const &argsVector, std::string const &logger, std::string const &input, bool secure)
int	StartProcess (std::string const &executable, std::vector< std::string > const &args, std::string const &logger, std::string input_file, bool secure)
std::shared_ptr< AsyncProcessResult >	StartAsyncProcess (std::string executable, std::vector< std::string > args, std::string logger, std::string input_file, bool secure)
std::string	SearchExecutableInPath (std::string const &filename)
template<typename Result , typename... Params>
Optional< Result >	StringTo (std::string_view str, Params &&... params)
template<typename Type , typename... Params>
std::string	ToString (Type &&val, Params &&... params)
template<typename... Args>
std::string	StringFormat (FormatString< Args... > fmt, Args &&... args)
	Default TC string format function. More...
bool	IsFormatEmptyOrNull (char const *fmt)
	Returns true if the given char pointer is null. More...
bool	IsFormatEmptyOrNull (std::string const &fmt)
	Returns true if the given std::string is empty. More...
constexpr bool	IsFormatEmptyOrNull (std::string_view fmt)
	Returns true if the given std::string_view is empty. More...
constexpr bool	IsFormatEmptyOrNull (fmt::string_view fmt)
template<class T , class Tuple >
T *	new_from_tuple (Tuple &&args)
TC_COMMON_API std::vector< std::string_view >	Tokenize (std::string_view str, char sep, bool keepEmpty)
std::vector< std::string_view >	Tokenize (std::string &&, char, bool)=delete
std::vector< std::string_view >	Tokenize (std::string const &&, char, bool)=delete
std::vector< std::string_view >	Tokenize (char const *str, char sep, bool keepEmpty)
template<typename T >
std::string	GetTypeName ()
template<typename T >
std::string	GetTypeName (T &&v)
template<class SPECIFIC_TYPE , class KEY_TYPE , class H , class T >
bool	Insert (ContainerUnorderedMap< TypeList< H, T >, KEY_TYPE > &elements, KEY_TYPE const &handle, SPECIFIC_TYPE *obj)
template<class SPECIFIC_TYPE , class KEY_TYPE , class H , class T >
SPECIFIC_TYPE *	Find (ContainerUnorderedMap< TypeList< H, T >, KEY_TYPE > const &elements, KEY_TYPE const &handle, SPECIFIC_TYPE *obj)
template<class SPECIFIC_TYPE , class KEY_TYPE , class H , class T >
bool	Remove (ContainerUnorderedMap< TypeList< H, T >, KEY_TYPE > &elements, KEY_TYPE const &handle, SPECIFIC_TYPE *obj)
template<class SPECIFIC_TYPE , class KEY_TYPE , class H , class T >
bool	Size (ContainerUnorderedMap< TypeList< H, T >, KEY_TYPE > const &elements, std::size_t *size, SPECIFIC_TYPE *obj)
template<class SPECIFIC_TYPE , class H , class T >
size_t	Count (ContainerMapList< TypeList< H, T > > const &elements, SPECIFIC_TYPE *fake)
template<class SPECIFIC_TYPE , class H , class T >
SPECIFIC_TYPE *	Insert (ContainerMapList< TypeList< H, T > > &elements, SPECIFIC_TYPE *obj)
template<class RET_TYPE , int CENTER_VAL>
RET_TYPE	Compute (float x, float y, float center_offset, float size)
GridCoord	ComputeGridCoord (float x, float y)
GridCoord	ComputeGridCoordSimple (float x, float y)
CellCoord	ComputeCellCoord (float x, float y)
CellCoord	ComputeCellCoord (float x, float y, float &x_off, float &y_off)
void	NormalizeMapCoord (float &c)
bool	IsValidMapCoord (float c)
bool	IsValidMapCoord (float x, float y)
bool	IsValidMapCoord (float x, float y, float z)
bool	IsValidMapCoord (float x, float y, float z, float o)
uint32	GetExpansionForLevel (uint32 level)
void	SelectRandomInjuredTargets (std::list< WorldObject * > &targets, size_t maxTargets, bool prioritizePlayers)

Variables
template<typename T , typename... Us>
constexpr bool	has_type_v = has_type<T, Us...>::value
template<typename... Ts>
constexpr bool	is_tuple_v = is_tuple<Ts...>::value
template<typename T >
constexpr bool	dependant_false_v = dependant_false<T>::value

Typedef Documentation

find_type_if_t

template<template< typename... > typename Check, typename... Ts>

using Trinity::find_type_if_t = typedef typename find_type_if<Check, Ts...>::type

Definition at line 65 of file Types.h.

FormatString

template<typename... Args>

using Trinity::FormatString = typedef fmt::format_string<Args...>

Definition at line 26 of file StringFormat.h.

regex

using Trinity::regex = typedef TC_REGEX_NAMESPACE :: regex

Definition at line 28 of file Regex.h.

wregex

using Trinity::wregex = typedef TC_REGEX_NAMESPACE :: wregex

Definition at line 29 of file Regex.h.

Function Documentation

Abort() [1/2]

TC_COMMON_API void Trinity::Abort	(	char const *	file,
		int	line,
		char const *	function
	)

Definition at line 124 of file Errors.cpp.

{
 std::string formattedMessage = StringFormat("\n{}:{} in {} ABORTED.\n", file, line, function);
 fprintf(stderr, "%s", formattedMessage.c_str());
 fflush(stderr);
 Crash(formattedMessage.c_str());
}

Here is the call graph for this function:

Abort() [2/2]

TC_COMMON_API void Trinity::Abort	(	char const *	file,
		int	line,
		char const *	function,
		char const *	message,
			...
	)

Definition at line 132 of file Errors.cpp.

{
 va_list args;
 va_start(args, message);
 
 std::string formattedMessage = StringFormat("\n{}:{} in {} ABORTED:\n", file, line, function) + FormatAssertionMessage(message, args) + '\n';
 va_end(args);
 
 fprintf(stderr, "%s", formattedMessage.c_str());
 fflush(stderr);
 
 Crash(formattedMessage.c_str());
}

Here is the call graph for this function:

AbortHandler()

TC_COMMON_API void Trinity::AbortHandler

(

int

sigval

)

Definition at line 146 of file Errors.cpp.

{
 // nothing useful to log here, no way to pass args
 std::string formattedMessage = StringFormat("Caught signal {}\n", sigval);
 fprintf(stderr, "%s", formattedMessage.c_str());
 fflush(stderr);
 Crash(formattedMessage.c_str());
}

Here is the call graph for this function:

Here is the caller graph for this function:

Assert() [1/2]

TC_COMMON_API void Trinity::Assert	(	char const *	file,
		int	line,
		char const *	function,
		std::string	debugInfo,
		char const *	message
	)

Definition at line 73 of file Errors.cpp.

{
 std::string formattedMessage = StringFormat("\n{}:{} in {} ASSERTION FAILED:\n {}\n", file, line, function, message) + debugInfo + '\n';
 fprintf(stderr, "%s", formattedMessage.c_str());
 fflush(stderr);
 Crash(formattedMessage.c_str());
}

Here is the call graph for this function:

Assert() [2/2]

TC_COMMON_API void Trinity::Assert	(	char const *	file,
		int	line,
		char const *	function,
		std::string	debugInfo,
		char const *	message,
		char const *	format,
			...
	)

Definition at line 81 of file Errors.cpp.

{
 va_list args;
 va_start(args, format);
 
 std::string formattedMessage = StringFormat("\n{}:{} in {} ASSERTION FAILED:\n {}\n", file, line, function, message) + FormatAssertionMessage(format, args) + '\n' + debugInfo + '\n';
 va_end(args);
 
 fprintf(stderr, "%s", formattedMessage.c_str());
 fflush(stderr);
 
 Crash(formattedMessage.c_str());
}

Here is the call graph for this function:

Compute()

template<class RET_TYPE , int CENTER_VAL>

RET_TYPE Trinity::Compute ( float  x, float  y, float  center_offset, float  size  )

inline

Definition at line 193 of file GridDefines.h.

 {
 // calculate and store temporary values in double format for having same result as same mySQL calculations
 double x_offset = (double(x) - center_offset)/size;
 double y_offset = (double(y) - center_offset)/size;
 
 int x_val = int(x_offset + CENTER_VAL + 0.5);
 int y_val = int(y_offset + CENTER_VAL + 0.5);
 return RET_TYPE(x_val, y_val);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ComputeCellCoord() [1/2]

CellCoord Trinity::ComputeCellCoord ( float  x, float  y  )

inline

Definition at line 216 of file GridDefines.h.

 {
 return Compute<CellCoord, CENTER_GRID_CELL_ID>(x, y, CENTER_GRID_CELL_OFFSET, SIZE_OF_GRID_CELL);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ComputeCellCoord() [2/2]

CellCoord Trinity::ComputeCellCoord ( float  x, float  y, float &  x_off, float &  y_off  )

inline

Definition at line 221 of file GridDefines.h.

 {
 double x_offset = (double(x) - CENTER_GRID_CELL_OFFSET)/SIZE_OF_GRID_CELL;
 double y_offset = (double(y) - CENTER_GRID_CELL_OFFSET)/SIZE_OF_GRID_CELL;
 
 int x_val = int(x_offset + CENTER_GRID_CELL_ID + 0.5f);
 int y_val = int(y_offset + CENTER_GRID_CELL_ID + 0.5f);
 x_off = (float(x_offset) - float(x_val) + CENTER_GRID_CELL_ID) * SIZE_OF_GRID_CELL;
 y_off = (float(y_offset) - float(y_val) + CENTER_GRID_CELL_ID) * SIZE_OF_GRID_CELL;
 return CellCoord(x_val, y_val);
 }

Here is the call graph for this function:

ComputeGridCoord()

GridCoord Trinity::ComputeGridCoord ( float  x, float  y  )

inline

Definition at line 204 of file GridDefines.h.

 {
 return Compute<GridCoord, CENTER_GRID_ID>(x, y, CENTER_GRID_OFFSET, SIZE_OF_GRIDS);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ComputeGridCoordSimple()

GridCoord Trinity::ComputeGridCoordSimple ( float  x, float  y  )

inline

Definition at line 209 of file GridDefines.h.

 {
 int gx = (int)(CENTER_GRID_ID - x / SIZE_OF_GRIDS);
 int gy = (int)(CENTER_GRID_ID - y / SIZE_OF_GRIDS);
 return GridCoord((MAX_NUMBER_OF_GRIDS - 1) - gx, (MAX_NUMBER_OF_GRIDS - 1) - gy);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Count()

template<class SPECIFIC_TYPE , class H , class T >

size_t Trinity::Count ( ContainerMapList< TypeList< H, T > > const &  elements, SPECIFIC_TYPE *  fake  )

inline

Definition at line 112 of file TypeContainerFunctions.h.

 {
 if constexpr (std::is_same_v<H, SPECIFIC_TYPE>)
 {
 return elements._elements._element.getSize();
 }
 
 if constexpr (std::is_same_v<T, TypeNull>)
 return 0;
 else
 return Count(elements._TailElements, fake);
 }

Here is the caller graph for this function:

CreateChildProcess()

template<typename T >

static int Trinity::CreateChildProcess ( T  waiter, std::string const &  executable, std::vector< std::string > const &  argsVector, std::string const &  logger, std::string const &  input, bool  secure  )

static

Definition at line 80 of file StartProcess.cpp.

{
 ipstream outStream;
 ipstream errStream;
 
 if (!secure)
 {
 TC_LOG_TRACE(logger, "Starting process \"{}\" with arguments: \"{}\".",
 executable, boost::algorithm::join(argsVector, " "));
 }
 
 // prepare file with only read permission (boost process opens with read_write)
 std::shared_ptr<FILE> inputFile(!input.empty() ? fopen(input.c_str(), "rb") : nullptr, [](FILE* ptr)
 {
 if (ptr != nullptr)
 fclose(ptr);
 });
 
 // Start the child process
 child c = [&]()
 {
 if (inputFile)
 {
 // With binding stdin
 return child{
 exe = boost::filesystem::absolute(executable).string(),
 args = argsVector,
 env = environment(boost::this_process::environment()),
 std_in = inputFile.get(),
 std_out = outStream,
 std_err = errStream
 };
 }
 else
 {
 // Without binding stdin
 return child{
 exe = boost::filesystem::absolute(executable).string(),
 args = argsVector,
 env = environment(boost::this_process::environment()),
 std_in = boost::process::close,
 std_out = outStream,
 std_err = errStream
 };
 }
 }();
 
 auto outInfo = MakeTCLogSink([&](std::string_view msg)
 {
 TC_LOG_INFO(logger, "{}", msg);
 });
 
 auto outError = MakeTCLogSink([&](std::string_view msg)
 {
 TC_LOG_ERROR(logger, "{}", msg);
 });
 
 copy(outStream, outInfo);
 copy(errStream, outError);
 
 // Call the waiter in the current scope to prevent
 // the streams from closing too early on leaving the scope.
 int const result = waiter(c);
 
 if (!secure)
 {
 TC_LOG_TRACE(logger, ">> Process \"{}\" finished with return value {}.",
 executable, result);
 }
 
 return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Error()

TC_COMMON_API void TC_COMMON_API void TC_COMMON_API void Trinity::Error	(	char const *	file,
		int	line,
		char const *	function,
		char const *	message
	)

Definition at line 110 of file Errors.cpp.

{
 std::string formattedMessage = StringFormat("\n{}:{} in {} ERROR:\n {}\n", file, line, function, message);
 fprintf(stderr, "%s", formattedMessage.c_str());
 fflush(stderr);
 Crash(formattedMessage.c_str());
}

Here is the call graph for this function:

Fatal()

TC_COMMON_API void TC_COMMON_API void Trinity::Fatal	(	char const *	file,
		int	line,
		char const *	function,
		char const *	message,
			...
	)

Definition at line 95 of file Errors.cpp.

{
 va_list args;
 va_start(args, message);
 
 std::string formattedMessage = StringFormat("\n{}:{} in {} FATAL ERROR:\n", file, line, function) + FormatAssertionMessage(message, args) + '\n';
 va_end(args);
 
 fprintf(stderr, "%s", formattedMessage.c_str());
 fflush(stderr);
 
 std::this_thread::sleep_for(std::chrono::seconds(10));
 Crash(formattedMessage.c_str());
}

Here is the call graph for this function:

Find()

template<class SPECIFIC_TYPE , class KEY_TYPE , class H , class T >

SPECIFIC_TYPE * Trinity::Find ( ContainerUnorderedMap< TypeList< H, T >, KEY_TYPE > const &  elements, KEY_TYPE const &  handle, SPECIFIC_TYPE *  obj  )

inline

Definition at line 60 of file TypeContainerFunctions.h.

 {
 if constexpr (std::is_same_v<H, SPECIFIC_TYPE>)
 {
 auto i = elements._elements._element.find(handle);
 if (i == elements._elements._element.end())
 return nullptr;
 else
 return i->second;
 }
 
 if constexpr (std::is_same_v<T, TypeNull>)
 return nullptr;
 else
 return Find(elements._TailElements, handle, obj);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

GetExpansionForLevel()

uint32 Trinity::GetExpansionForLevel ( uint32  level )

inline

Definition at line 31 of file Formulas.h.

 {
 if (level < 60)
 return EXPANSION_CLASSIC;
 else if (level < 70)
 return EXPANSION_THE_BURNING_CRUSADE;
 else if (level < 80)
 return EXPANSION_WRATH_OF_THE_LICH_KING;
 else if (level < 85)
 return EXPANSION_CATACLYSM;
 else if (level < 90)
 return EXPANSION_MISTS_OF_PANDARIA;
 else if (level < 100)
 return EXPANSION_WARLORDS_OF_DRAENOR;
 else
 return CURRENT_EXPANSION;
 }

Here is the caller graph for this function:

GetTypeName() [1/2]

template<typename T >

std::string Trinity::GetTypeName

(

)

Definition at line 498 of file Util.h.

{ return Impl::GetTypeName(typeid(T)); }

Here is the call graph for this function:

Here is the caller graph for this function:

GetTypeName() [2/2]

template<typename T >

std::string Trinity::GetTypeName

(

T &&

v

)

Definition at line 500 of file Util.h.

{
 if constexpr (std::is_same_v<std::remove_cv_t<T>, std::type_info>)
 return Impl::GetTypeName(v);
 else
 return Impl::GetTypeName(typeid(v));
}

Here is the call graph for this function:

hash_combine()

template<typename T >

void Trinity::hash_combine ( std::size_t &  seed, T const &  val  )

inline

Definition at line 27 of file Hash.h.

 {
 seed ^= std::hash<T>()(val) + 0x9E3779B9 + (seed << 6) + (seed >> 2);
 }

Here is the caller graph for this function:

Insert() [1/2]

template<class SPECIFIC_TYPE , class H , class T >

SPECIFIC_TYPE * Trinity::Insert ( ContainerMapList< TypeList< H, T > > &  elements, SPECIFIC_TYPE *  obj  )

inline

Definition at line 127 of file TypeContainerFunctions.h.

 {
 if constexpr (std::is_same_v<H, SPECIFIC_TYPE>)
 {
 obj->AddToGrid(elements._elements._element);
 return obj;
 }
 
 if constexpr (std::is_same_v<T, TypeNull>)
 return nullptr;
 else
 return Insert(elements._TailElements, obj);
 }

Here is the call graph for this function:

Insert() [2/2]

template<class SPECIFIC_TYPE , class KEY_TYPE , class H , class T >

bool Trinity::Insert ( ContainerUnorderedMap< TypeList< H, T >, KEY_TYPE > &  elements, KEY_TYPE const &  handle, SPECIFIC_TYPE *  obj  )

inline

Definition at line 35 of file TypeContainerFunctions.h.

 {
 if constexpr (std::is_same_v<H, SPECIFIC_TYPE>)
 {
 auto i = elements._elements._element.find(handle);
 if (i == elements._elements._element.end())
 {
 elements._elements._element[handle] = obj;
 return true;
 }
 else
 {
 ASSERT(i->second == obj, "Object with certain key already in but objects are different!");
 return false;
 }
 }
 
 if constexpr (std::is_same_v<T, TypeNull>)
 return false;
 else
 return Insert(elements._TailElements, handle, obj);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

IsFormatEmptyOrNull() [1/4]

bool Trinity::IsFormatEmptyOrNull ( char const *  fmt )

inline

Returns true if the given char pointer is null.

Definition at line 43 of file StringFormat.h.

 {
 return fmt == nullptr;
 }

Here is the caller graph for this function:

IsFormatEmptyOrNull() [2/4]

constexpr bool Trinity::IsFormatEmptyOrNull ( fmt::string_view  fmt )

inlineconstexpr

Definition at line 60 of file StringFormat.h.

 {
 return fmt.size() == 0;
 }

IsFormatEmptyOrNull() [3/4]

bool Trinity::IsFormatEmptyOrNull ( std::string const &  fmt )

inline

Returns true if the given std::string is empty.

Definition at line 49 of file StringFormat.h.

 {
 return fmt.empty();
 }

IsFormatEmptyOrNull() [4/4]

constexpr bool Trinity::IsFormatEmptyOrNull ( std::string_view  fmt )

inlineconstexpr

Returns true if the given std::string_view is empty.

Definition at line 55 of file StringFormat.h.

 {
 return fmt.empty();
 }

IsValidMapCoord() [1/4]

bool Trinity::IsValidMapCoord ( float  c )

inline

Definition at line 241 of file GridDefines.h.

 {
 return std::isfinite(c) && (std::fabs(c) <= MAP_HALFSIZE - 0.5f);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

IsValidMapCoord() [2/4]

bool Trinity::IsValidMapCoord ( float  x, float  y  )

inline

Definition at line 246 of file GridDefines.h.

 {
 return IsValidMapCoord(x) && IsValidMapCoord(y);
 }

Here is the call graph for this function:

IsValidMapCoord() [3/4]

bool Trinity::IsValidMapCoord ( float  x, float  y, float  z  )

inline

Definition at line 251 of file GridDefines.h.

 {
 return IsValidMapCoord(x, y) && IsValidMapCoord(z);
 }

Here is the call graph for this function:

IsValidMapCoord() [4/4]

bool Trinity::IsValidMapCoord ( float  x, float  y, float  z, float  o  )

inline

Definition at line 256 of file GridDefines.h.

 {
 return IsValidMapCoord(x, y, z) && std::isfinite(o);
 }

Here is the call graph for this function:

make_unique_ptr_with_deleter()

template<typename T , typename Del >

auto Trinity::make_unique_ptr_with_deleter	(	T	ptr,
		Del &&	deleter
	)

Definition at line 41 of file Memory.h.

{
 using Deleter_t = Impl::unique_ptr_deleter<T, Del>;
 
 return std::unique_ptr<T, Deleter_t>(ptr, Deleter_t(std::forward<Del>(deleter)));
}

Here is the caller graph for this function:

MakeTCLogSink()

template<typename T >

auto Trinity::MakeTCLogSink

(

T &&

callback

)

-> TCLogSink<typename std::decay<T>::type>

Definition at line 73 of file StartProcess.cpp.

{
 return { std::forward<T>(callback) };
}

Here is the caller graph for this function:

new_from_tuple()

template<class T , class Tuple >

T * Trinity::new_from_tuple

(

Tuple &&

args

)

Definition at line 59 of file Tuples.h.

 {
 return Impl::new_from_tuple<T>(std::forward<Tuple>(args), std::make_index_sequence<std::tuple_size_v<std::remove_reference_t<Tuple>>>{});
 }

NormalizeMapCoord()

void Trinity::NormalizeMapCoord ( float &  c )

inline

Definition at line 233 of file GridDefines.h.

 {
 if (c > MAP_HALFSIZE - 0.5f)
 c = MAP_HALFSIZE - 0.5f;
 else if (c < -(MAP_HALFSIZE - 0.5f))
 c = -(MAP_HALFSIZE - 0.5f);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Remove()

template<class SPECIFIC_TYPE , class KEY_TYPE , class H , class T >

bool Trinity::Remove ( ContainerUnorderedMap< TypeList< H, T >, KEY_TYPE > &  elements, KEY_TYPE const &  handle, SPECIFIC_TYPE *  obj  )

inline

Definition at line 79 of file TypeContainerFunctions.h.

 {
 if constexpr (std::is_same_v<H, SPECIFIC_TYPE>)
 {
 elements._elements._element.erase(handle);
 return true;
 }
 
 if constexpr (std::is_same_v<T, TypeNull>)
 return false;
 else
 return Remove(elements._TailElements, handle, obj);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

SearchExecutableInPath()

TC_COMMON_API std::string Trinity::SearchExecutableInPath

(

std::string const &

filename

)

Searches for the given executable in the PATH variable and returns a non-empty string when it was found.

Definition at line 268 of file StartProcess.cpp.

{
 try
 {
 return search_path(filename).string();
 }
 catch (...)
 {
 return "";
 }
}

Here is the caller graph for this function:

SelectRandomInjuredTargets()

TC_GAME_API void Trinity::SelectRandomInjuredTargets	(	std::list< WorldObject * > &	targets,
		size_t	maxTargets,
		bool	prioritizePlayers
	)

Definition at line 9049 of file Spell.cpp.

{
 if (targets.size() <= maxTargets)
 return;
 
 std::vector<WorldObject*> tempTargets(targets.begin(), targets.end());
 
 auto begin = tempTargets.begin();
 auto end = tempTargets.end();
 
 if (prioritizePlayers)
 {
 auto playersEnd = std::stable_partition(begin, end, [](WorldObject const* target)
 {
 return target->IsPlayer();
 });
 
 size_t playerCount = std::distance(begin, playersEnd);
 if (playerCount < maxTargets)
 {
 // not enough players, add nonplayer targets
 // prioritize injured nonplayers over full health nonplayers
 auto injuredNonPlayersEnd = std::stable_partition(playersEnd, end, [](WorldObject const* target)
 {
 return target->IsUnit() && !target->ToUnit()->IsFullHealth();
 });
 
 size_t injuredNonPlayersCount = std::distance(playersEnd, injuredNonPlayersEnd);
 if (playerCount + injuredNonPlayersCount < maxTargets)
 {
 // not enough players + injured nonplayers
 // fill remainder with random full health nonplayers
 Containers::RandomShuffle(injuredNonPlayersEnd, end);
 }
 else if (playerCount + injuredNonPlayersCount > maxTargets)
 {
 // randomize injured nonplayers order
 // final list will contain all players + random injured nonplayers
 Containers::RandomShuffle(playersEnd, injuredNonPlayersEnd);
 }
 
 targets.assign(tempTargets.begin(), tempTargets.begin() + maxTargets);
 return;
 }
 
 // We have more players than we requested, proceed checking injured targets
 end = playersEnd;
 }
 
 auto injuredUnitsEnd = std::stable_partition(begin, end, [](WorldObject const* target)
 {
 return target->IsUnit() && !target->ToUnit()->IsFullHealth();
 });
 
 size_t injuredUnitsCount = std::distance(begin, injuredUnitsEnd);
 if (injuredUnitsCount < maxTargets)
 {
 // not enough injured units
 // fill remainder with full health units
 Containers::RandomShuffle(injuredUnitsEnd, end);
 }
 else if (injuredUnitsCount > maxTargets)
 {
 // select random injured units
 Containers::RandomShuffle(begin, injuredUnitsEnd);
 }
 
 targets.assign(tempTargets.begin(), tempTargets.begin() + maxTargets);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Size()

template<class SPECIFIC_TYPE , class KEY_TYPE , class H , class T >

bool Trinity::Size ( ContainerUnorderedMap< TypeList< H, T >, KEY_TYPE > const &  elements, std::size_t *  size, SPECIFIC_TYPE *  obj  )

inline

Definition at line 95 of file TypeContainerFunctions.h.

 {
 if constexpr (std::is_same_v<H, SPECIFIC_TYPE>)
 {
 *size = elements._elements._element.size();
 return true;
 }
 
 if constexpr (std::is_same_v<T, TypeNull>)
 return false;
 else
 return Size(elements._TailElements, size, obj);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

StartAsyncProcess()

TC_COMMON_API std::shared_ptr< AsyncProcessResult > Trinity::StartAsyncProcess	(	std::string	executable,
		std::vector< std::string >	args,
		std::string	logger,
		std::string	input_file = "",
		bool	secure = false
	)

Starts a process asynchronously with the given arguments and parameters and returns an AsyncProcessResult immediately which is set, when the process exits. When an input path is given, the file will be routed to the processes stdin. When the process is marked as secure no arguments are leaked to logs. Note that most executables expect it's name as the first argument.

Definition at line 258 of file StartProcess.cpp.

{
 auto handle = std::make_shared<AsyncProcessResultImplementation>(
 std::move(executable), std::move(args), std::move(logger), std::move(input_file), secure);
 
 handle->SetFuture(std::async(std::launch::async, [handle] { return handle->StartProcess(); }));
 return handle;
}

StartProcess()

TC_COMMON_API int Trinity::StartProcess	(	std::string const &	executable,
		std::vector< std::string > const &	args,
		std::string const &	logger,
		std::string	input_file = "",
		bool	secure = false
	)

Starts a process with the given arguments and parameters and will block until the process is finished. When an input path is given, the file will be routed to the processes stdin. When the process is marked as secure no arguments are leaked to logs. Note that most executables expect it's name as the first argument.

Definition at line 156 of file StartProcess.cpp.

{
 return CreateChildProcess([](child& c) -> int
 {
 try
 {
 c.wait();
 return c.exit_code();
 }
 catch (...)
 {
 return EXIT_FAILURE;
 }
 }, executable, args, logger, input_file, secure);
}

Here is the call graph for this function:

Here is the caller graph for this function:

StringFormat()

template<typename... Args>

std::string Trinity::StringFormat ( FormatString< Args... >  fmt, Args &&...  args  )

inline

Default TC string format function.

Definition at line 30 of file StringFormat.h.

 {
 try
 {
 return fmt::format(fmt, std::forward<Args>(args)...);
 }
 catch (std::exception const& formatError)
 {
 return fmt::format("An error occurred formatting string \"{}\" : {}", fmt, formatError.what());
 }
 }

Here is the caller graph for this function:

StringTo()

template<typename Result , typename... Params>

Optional< Result > Trinity::StringTo	(	std::string_view	str,
		Params &&...	params
	)

Definition at line 263 of file StringConvert.h.

 {
 return Trinity::Impl::StringConvertImpl::For<Result>::FromString(str, std::forward<Params>(params)...);
 }

Here is the caller graph for this function:

Tokenize() [1/4]

std::vector< std::string_view > Trinity::Tokenize ( char const *  str, char  sep, bool  keepEmpty  )

inline

Definition at line 50 of file Util.h.

{ return Tokenize(std::string_view(str ? str : ""), sep, keepEmpty); }

Here is the call graph for this function:

Tokenize() [2/4]

std::vector< std::string_view > Trinity::Tokenize ( std::string &&  , char  , bool    )

delete

Tokenize() [3/4]

std::vector< std::string_view > Trinity::Tokenize ( std::string const &&  , char  , bool    )

delete

Tokenize() [4/4]

std::vector< std::string_view > Trinity::Tokenize	(	std::string_view	str,
		char	sep,
		bool	keepEmpty
	)

Definition at line 40 of file Util.cpp.

{
 std::vector<std::string_view> tokens;
 
 size_t start = 0;
 for (size_t end = str.find(sep); end != std::string_view::npos; end = str.find(sep, start))
 {
 if (keepEmpty || (start < end))
 tokens.push_back(str.substr(start, end - start));
 start = end+1;
 }
 
 if (keepEmpty || (start < str.length()))
 tokens.push_back(str.substr(start));
 
 return tokens;
}

Here is the caller graph for this function:

ToString()

template<typename Type , typename... Params>

std::string Trinity::ToString	(	Type &&	val,
		Params &&...	params
	)

Definition at line 269 of file StringConvert.h.

 {
 return Trinity::Impl::StringConvertImpl::For<std::decay_t<Type>>::ToString(std::forward<Type>(val), std::forward<Params>(params)...);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Warning()

TC_COMMON_API void Trinity::Warning	(	char const *	file,
		int	line,
		char const *	function,
		char const *	message
	)

Definition at line 118 of file Errors.cpp.

{
 fprintf(stderr, "\n%s:%i in %s WARNING:\n %s\n",
 file, line, function, message);
}

Variable Documentation

dependant_false_v

template<typename T >

constexpr bool Trinity::dependant_false_v = dependant_false<T>::value

constexpr

Definition at line 71 of file Types.h.

has_type_v

template<typename T , typename... Us>

constexpr bool Trinity::has_type_v = has_type<T, Us...>::value

constexpr

Definition at line 34 of file Tuples.h.

is_tuple_v

template<typename... Ts>

constexpr bool Trinity::is_tuple_v = is_tuple<Ts...>::value

constexpr

Definition at line 47 of file Tuples.h.