Trinity Namespace Reference

Namespaces
	Asio
	Banner
	ChatCommands
	Containers
	Crypto
	Currency
	Encoding
	Honor
	Hyperlinks
	Impl
	Legacy
	Net
	Predicates
	SpellScripts
	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
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	NearestCreatureEntryWithLiveStateInObjectRangeCheck
class	NearestGameObjectCheck
class	NearestGameObjectEntryInObjectRangeCheck
class	NearestGameObjectFishingHole
class	NearestGameObjectTypeInObjectRangeCheck
class	NearestHostileUnitCheck
class	NearestHostileUnitInAggroRangeCheck
class	NearestHostileUnitInAttackDistanceCheck
class	NearestPlayerInObjectRangeCheck
class	NearestUnspawnedGameObjectEntryInObjectRangeCheck
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	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<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<class T >
constexpr T *	AddressOrSelf (T *ptr)
template<class T >
constexpr T *	AddressOrSelf (T &not_ptr)
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 Format , typename... Args>
std::string	StringFormat (Format &&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...
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<class SPECIFIC_TYPE , class KEY_TYPE >
bool	Insert (ContainerUnorderedMap< SPECIFIC_TYPE, KEY_TYPE > &elements, KEY_TYPE const &handle, SPECIFIC_TYPE *obj)
template<class SPECIFIC_TYPE , class KEY_TYPE >
bool	Insert (ContainerUnorderedMap< TypeNull, KEY_TYPE > &, KEY_TYPE const &, SPECIFIC_TYPE *)
template<class SPECIFIC_TYPE , class KEY_TYPE , class T >
bool	Insert (ContainerUnorderedMap< T, KEY_TYPE > &, KEY_TYPE const &, SPECIFIC_TYPE *)
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 >
SPECIFIC_TYPE *	Find (ContainerUnorderedMap< SPECIFIC_TYPE, KEY_TYPE > const &elements, KEY_TYPE const &handle, SPECIFIC_TYPE *)
template<class SPECIFIC_TYPE , class KEY_TYPE >
SPECIFIC_TYPE *	Find (ContainerUnorderedMap< TypeNull, KEY_TYPE > const &, KEY_TYPE const &, SPECIFIC_TYPE *)
template<class SPECIFIC_TYPE , class KEY_TYPE , class T >
SPECIFIC_TYPE *	Find (ContainerUnorderedMap< T, KEY_TYPE > const &, KEY_TYPE const &, SPECIFIC_TYPE *)
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 *)
template<class SPECIFIC_TYPE , class KEY_TYPE >
bool	Remove (ContainerUnorderedMap< SPECIFIC_TYPE, KEY_TYPE > &elements, KEY_TYPE const &handle, SPECIFIC_TYPE *)
template<class SPECIFIC_TYPE , class KEY_TYPE >
bool	Remove (ContainerUnorderedMap< TypeNull, KEY_TYPE > &, KEY_TYPE const &, SPECIFIC_TYPE *)
template<class SPECIFIC_TYPE , class KEY_TYPE , class T >
bool	Remove (ContainerUnorderedMap< T, KEY_TYPE > &, KEY_TYPE const &, SPECIFIC_TYPE *)
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 *)
template<class SPECIFIC_TYPE , class KEY_TYPE >
bool	Size (ContainerUnorderedMap< SPECIFIC_TYPE, KEY_TYPE > const &elements, std::size_t *size, SPECIFIC_TYPE *)
template<class SPECIFIC_TYPE , class KEY_TYPE >
bool	Size (ContainerUnorderedMap< TypeNull, KEY_TYPE > const &, std::size_t *, SPECIFIC_TYPE *)
template<class SPECIFIC_TYPE , class KEY_TYPE , class T >
bool	Size (ContainerUnorderedMap< T, KEY_TYPE > const &, std::size_t *, SPECIFIC_TYPE *)
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 *)
template<class SPECIFIC_TYPE >
size_t	Count (ContainerMapList< SPECIFIC_TYPE > const &elements, SPECIFIC_TYPE *)
template<class SPECIFIC_TYPE >
size_t	Count (ContainerMapList< TypeNull > const &, SPECIFIC_TYPE *)
template<class SPECIFIC_TYPE , class T >
size_t	Count (ContainerMapList< T > const &, SPECIFIC_TYPE *)
template<class SPECIFIC_TYPE , class T >
size_t	Count (ContainerMapList< TypeList< SPECIFIC_TYPE, T >> const &elements, SPECIFIC_TYPE *fake)
template<class SPECIFIC_TYPE , class H , class T >
size_t	Count (ContainerMapList< TypeList< H, T >> const &elements, SPECIFIC_TYPE *fake)
template<class SPECIFIC_TYPE >
SPECIFIC_TYPE *	Insert (ContainerMapList< SPECIFIC_TYPE > &elements, SPECIFIC_TYPE *obj)
template<class SPECIFIC_TYPE >
SPECIFIC_TYPE *	Insert (ContainerMapList< TypeNull > &, SPECIFIC_TYPE *)
template<class SPECIFIC_TYPE , class T >
SPECIFIC_TYPE *	Insert (ContainerMapList< T > &, SPECIFIC_TYPE *)
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

regex

using Trinity::regex = typedef TC_REGEX_NAMESPACE :: regex

wregex

using Trinity::wregex = typedef TC_REGEX_NAMESPACE :: wregex

Function Documentation

Abort() [1/2]

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

{
 std::string formattedMessage = StringFormat("\n%s:%i in %s 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:

Here is the caller graph for this function:

Abort() [2/2]

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

{
 va_list args;
 va_start(args, message);

 std::string formattedMessage = StringFormat("\n%s:%i in %s 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

)

{
 // nothing useful to log here, no way to pass args
 std::string formattedMessage = StringFormat("Caught signal %i\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:

AddressOrSelf() [1/2]

template<class T >

constexpr T* Trinity::AddressOrSelf ( T *  ptr )

inline

 {
 return ptr;
 }

Here is the caller graph for this function:

AddressOrSelf() [2/2]

template<class T >

constexpr T* Trinity::AddressOrSelf ( T &  not_ptr )

inline

 {
 return std::addressof(not_ptr);
 }

Assert() [1/2]

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

{
 std::string formattedMessage = StringFormat("\n%s:%i in %s ASSERTION FAILED:\n %s\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,
			...
	)

{
 va_list args;
 va_start(args, format);

 std::string formattedMessage = StringFormat("\n%s:%i in %s ASSERTION FAILED:\n %s\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

 {
 // 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);
 }

ComputeCellCoord() [1/2]

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

inline

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

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

 {
 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);
 }

ComputeGridCoord()

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

inline

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

Here is the caller graph for this function:

ComputeGridCoordSimple()

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

inline

 {
 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 caller graph for this function:

Count() [1/5]

template<class SPECIFIC_TYPE >

size_t Trinity::Count	(	ContainerMapList< SPECIFIC_TYPE > const &	elements,
		SPECIFIC_TYPE *
	)

 {
 return elements._element.getSize();
 }

Here is the caller graph for this function:

Count() [2/5]

template<class SPECIFIC_TYPE >

size_t Trinity::Count	(	ContainerMapList< TypeNull > const &	,
		SPECIFIC_TYPE *
	)

 {
 return 0;
 }

Count() [3/5]

template<class SPECIFIC_TYPE , class T >

size_t Trinity::Count	(	ContainerMapList< T > const &	,
		SPECIFIC_TYPE *
	)

 {
 return 0;
 }

Count() [4/5]

template<class SPECIFIC_TYPE , class T >

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

 {
 return Count(elements._elements, fake);
 }

Here is the call graph for this function:

Count() [5/5]

template<class SPECIFIC_TYPE , class H , class T >

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

 {
 return Count(elements._TailElements, fake);
 }

Here is the call 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

{
 ipstream outStream;
 ipstream errStream;

 if (!secure)
 {
 TC_LOG_TRACE(logger, "Starting process \"%s\" with arguments: \"%s\".",
 executable.c_str(), boost::algorithm::join(argsVector, " ").c_str());
 }

 // 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, STRING_VIEW_FMT, STRING_VIEW_FMT_ARG(msg));
 });

 auto outError = MakeTCLogSink([&](std::string_view msg)
 {
 TC_LOG_ERROR(logger, STRING_VIEW_FMT, STRING_VIEW_FMT_ARG(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 \"%s\" finished with return value %i.",
 executable.c_str(), 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
	)

{
 std::string formattedMessage = StringFormat("\n%s:%i in %s ERROR:\n %s\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:

Here is the caller 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,
			...
	)

{
 va_list args;
 va_start(args, message);

 std::string formattedMessage = StringFormat("\n%s:%i in %s 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() [1/4]

template<class SPECIFIC_TYPE , class KEY_TYPE >

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

 {
 auto i = elements._element.find(handle);
 if (i == elements._element.end())
 return nullptr;
 else
 return i->second;
 }

Here is the caller graph for this function:

Find() [2/4]

template<class SPECIFIC_TYPE , class KEY_TYPE >

SPECIFIC_TYPE* Trinity::Find	(	ContainerUnorderedMap< TypeNull, KEY_TYPE > const &	,
		KEY_TYPE const &	,
		SPECIFIC_TYPE *
	)

 {
 return nullptr;
 }

Find() [3/4]

template<class SPECIFIC_TYPE , class KEY_TYPE , class T >

SPECIFIC_TYPE* Trinity::Find	(	ContainerUnorderedMap< T, KEY_TYPE > const &	,
		KEY_TYPE const &	,
		SPECIFIC_TYPE *
	)

 {
 return nullptr;
 }

Find() [4/4]

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 *
	)

 {
 SPECIFIC_TYPE* ret = Find(elements._elements, handle, (SPECIFIC_TYPE*)nullptr);
 return ret ? ret : Find(elements._TailElements, handle, (SPECIFIC_TYPE*)nullptr);
 }

Here is the call graph for this function:

GetExpansionForLevel()

uint32 Trinity::GetExpansionForLevel ( uint32  level )

inline

 {
 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:

hash_combine()

template<typename T >

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

inline

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

Here is the caller graph for this function:

Insert() [1/8]

template<class SPECIFIC_TYPE , class KEY_TYPE >

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

 {
 auto i = elements._element.find(handle);
 if (i == elements._element.end())
 {
 elements._element[handle] = obj;
 return true;
 }
 else
 {
 ASSERT(i->second == obj, "Object with certain key already in but objects are different!");
 return false;
 }
 }

Here is the caller graph for this function:

Insert() [2/8]

template<class SPECIFIC_TYPE , class KEY_TYPE >

bool Trinity::Insert	(	ContainerUnorderedMap< TypeNull, KEY_TYPE > &	,
		KEY_TYPE const &	,
		SPECIFIC_TYPE *
	)

 {
 return false;
 }

Insert() [3/8]

template<class SPECIFIC_TYPE , class KEY_TYPE , class T >

bool Trinity::Insert	(	ContainerUnorderedMap< T, KEY_TYPE > &	,
		KEY_TYPE const &	,
		SPECIFIC_TYPE *
	)

 {
 return false;
 }

Insert() [4/8]

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
	)

 {
 bool ret = Insert(elements._elements, handle, obj);
 return ret ? ret : Insert(elements._TailElements, handle, obj);
 }

Here is the call graph for this function:

Insert() [5/8]

template<class SPECIFIC_TYPE >

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

 {
 //elements._element[hdl] = obj;
 obj->AddToGrid(elements._element);
 return obj;
 }

Insert() [6/8]

template<class SPECIFIC_TYPE >

SPECIFIC_TYPE* Trinity::Insert	(	ContainerMapList< TypeNull > &	,
		SPECIFIC_TYPE *
	)

 {
 return nullptr;
 }

Insert() [7/8]

template<class SPECIFIC_TYPE , class T >

SPECIFIC_TYPE* Trinity::Insert	(	ContainerMapList< T > &	,
		SPECIFIC_TYPE *
	)

 {
 return nullptr; // a missed
 }

Insert() [8/8]

template<class SPECIFIC_TYPE , class H , class T >

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

 {
 SPECIFIC_TYPE* t = Insert(elements._elements, obj);
 return (t != nullptr ? t : Insert(elements._TailElements, obj));
 }

Here is the call graph for this function:

IsFormatEmptyOrNull() [1/2]

bool Trinity::IsFormatEmptyOrNull ( char const *  fmt )

inline

Returns true if the given char pointer is null.

 {
 return fmt == nullptr;
 }

Here is the caller graph for this function:

IsFormatEmptyOrNull() [2/2]

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

inline

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

 {
 return fmt.empty();
 }

IsValidMapCoord() [1/4]

bool Trinity::IsValidMapCoord ( float  c )

inline

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

Here is the caller graph for this function:

IsValidMapCoord() [2/4]

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

inline

 {
 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

 {
 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

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

Here is the caller 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
	)

{
 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>

{
 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

)

 {
 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

 {
 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 caller graph for this function:

Remove() [1/4]

template<class SPECIFIC_TYPE , class KEY_TYPE >

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

 {
 elements._element.erase(handle);
 return true;
 }

Here is the caller graph for this function:

Remove() [2/4]

template<class SPECIFIC_TYPE , class KEY_TYPE >

bool Trinity::Remove	(	ContainerUnorderedMap< TypeNull, KEY_TYPE > &	,
		KEY_TYPE const &	,
		SPECIFIC_TYPE *
	)

 {
 return false;
 }

Remove() [3/4]

template<class SPECIFIC_TYPE , class KEY_TYPE , class T >

bool Trinity::Remove	(	ContainerUnorderedMap< T, KEY_TYPE > &	,
		KEY_TYPE const &	,
		SPECIFIC_TYPE *
	)

 {
 return false;
 }

Remove() [4/4]

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 *
	)

 {
 bool ret = Remove(elements._elements, handle, (SPECIFIC_TYPE*)nullptr);
 return ret ? ret : Remove(elements._TailElements, handle, (SPECIFIC_TYPE*)nullptr);
 }

Here is the call 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.

{
 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
	)

{
 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() [1/4]

template<class SPECIFIC_TYPE , class KEY_TYPE >

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

 {
 *size = elements._element.size();
 return true;
 }

Here is the caller graph for this function:

Size() [2/4]

template<class SPECIFIC_TYPE , class KEY_TYPE >

bool Trinity::Size	(	ContainerUnorderedMap< TypeNull, KEY_TYPE > const &	,
		std::size_t *	,
		SPECIFIC_TYPE *
	)

 {
 return false;
 }

Size() [3/4]

template<class SPECIFIC_TYPE , class KEY_TYPE , class T >

bool Trinity::Size	(	ContainerUnorderedMap< T, KEY_TYPE > const &	,
		std::size_t *	,
		SPECIFIC_TYPE *
	)

 {
 return false;
 }

Size() [4/4]

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 *
	)

 {
 bool ret = Size(elements._elements, size, (SPECIFIC_TYPE*)nullptr);
 return ret ? ret : Size(elements._TailElements, size, (SPECIFIC_TYPE*)nullptr);
 }

Here is the call 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.

{
 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;
}

Here is the caller graph for this function:

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.

{
 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 Format , typename... Args>

std::string Trinity::StringFormat ( Format &&  fmt, Args &&...  args  )

inline

Default TC string format function.

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

Here is the caller graph for this function:

StringTo()

template<typename Result , typename... Params>

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

 {
 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	(	std::string_view	str,
		char	sep,
		bool	keepEmpty
	)

{
 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 call graph for this function:

Here is the caller 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 ( char const *  str, char  sep, bool  keepEmpty  )

inline

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

Here is the call graph for this function:

ToString()

template<typename Type , typename... Params>

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

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

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
	)

{
 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

has_type_v

template<typename T , typename... Us>

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

is_tuple_v

template<typename... Ts>

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