Acore Namespace Reference

Namespaces
namespace	Asio
namespace	Banner
namespace	ChatCommands
namespace	Containers
namespace	Crypto
namespace	Encoding
namespace	Honor
namespace	Hyperlinks
namespace	Impl
namespace	Module
namespace	Net
namespace	PlayerCommand
namespace	SpellScripts
namespace	String
namespace	Time
namespace	TimeDiff
namespace	Types
namespace	XP

Classes
class	AbsorbAuraOrderPred
class	ACLogSink
class	AcoreStringChatBuilder
struct	AIRelocationNotifier
class	AllCreaturesOfEntryInRange
class	AllDeadCreaturesInRange
class	AllFriendlyCreaturesInGrid
class	AllGameObjectsWithEntryInRange
class	AllWorldObjectsInExactRange
class	AllWorldObjectsInRange
class	AnyAoETargetUnitInObjectRangeCheck
class	AnyAssistCreatureInRangeCheck
class	AnyAttackableUnitExceptForOriginalCasterInObjectRangeCheck
struct	AnyDeadUnitCheck
class	AnyDeadUnitObjectInRangeCheck
class	AnyDeadUnitSpellTargetInRangeCheck
class	AnyFriendlyNotSelfUnitInObjectRangeCheck
class	AnyFriendlyUnitInObjectRangeCheck
class	AnyGroupedUnitInObjectRangeCheck
class	AnyPlayerExactPositionInGameObjectRangeCheck
class	AnyPlayerInObjectRangeCheck
class	AnyUnfriendlyAttackableVisibleUnitInObjectRangeCheck
class	AnyUnfriendlyNoTotemUnitInObjectRangeCheck
class	AnyUnfriendlyUnitInObjectRangeCheck
class	AnyUnitInObjectRangeCheck
class	AsyncProcessResult
class	AsyncProcessResultImplementation
class	Battleground2ChatBuilder
class	BattlegroundChatBuilder
class	BroadcastTextBuilder
class	CallOfHelpCreatureInRangeDo
class	CheckedBufferOutputIterator
class	ClassLevelLockable
class	ContainerInserter
struct	CreatureLastSearcher
struct	CreatureListSearcher
struct	CreatureRelocationNotifier
struct	CreatureSearcher
struct	CreatureWorker
class	CustomChatTextBuilder
struct	dependant_false
class	EmoteChatBuilder
struct	find_type_if
struct	find_type_if< Check >
struct	find_type_if< Check, T1, Ts... >
class	FriendlyCCedInRange
class	FriendlyMissingBuffInRange
class	GameObjectFocusCheck
class	GameObjectInRangeCheck
struct	GameObjectLastSearcher
struct	GameObjectListSearcher
struct	GameObjectSearcher
struct	GameObjectWorker
class	GeneralLock
struct	has_type
struct	has_type< T, std::tuple< Us... > >
class	HealthPctOrderPred
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	LocalizedPacketDo
class	LocalizedPacketListDo
struct	MessageDistDeliverer
struct	MessageDistDelivererToHostile
class	MostHPMissingGroupInRange
class	MostHPMissingInRange
class	MostHPPercentMissingInRange
class	NearestAssistCreatureInCreatureRangeCheck
class	NearestAttackableNoTotemUnitInObjectRangeCheck
class	NearestAttackableUnitInObjectRangeCheck
class	NearestCreatureEntryWithLiveStateInObjectRangeCheck
class	NearestGameObjectCheck
class	NearestGameObjectEntryInObjectRangeCheck
class	NearestGameObjectFishingHole
class	NearestGameObjectTypeInObjectRangeCheck
class	NearestHostileUnitCheck
class	NearestHostileUnitInAttackDistanceCheck
class	NearestPlayerInObjectRangeCheck
class	NearestVisibleDetectableContestedGuardUnitCheck
class	ObjectDistanceOrderPred
class	ObjectGUIDCheck
class	ObjectLevelLockable
class	ObjectTypeIdCheck
struct	ObjectUpdater
class	PlayerAtMinimumRangeAway
struct	PlayerDistWorker
struct	PlayerLastSearcher
struct	PlayerListSearcher
struct	PlayerListSearcherWithSharedVision
struct	PlayerRelocationNotifier
struct	PlayerSearcher
struct	PlayerWorker
class	PowerCheck
class	PowerPctOrderPred
class	RaidCheck
class	RandomCheck
class	RespawnDo
class	Runnable
class	SignalHandler
	Handle termination signals. More...
class	SingleThreaded
class	Thread
class	ThreatOrderPred
struct	unary_function
class	UnitAuraCheck
struct	UnitLastSearcher
struct	UnitListSearcher
struct	UnitSearcher
struct	VisibleChangesNotifier
struct	VisibleNotifier
struct	WorldObjectLastSearcher
struct	WorldObjectListSearcher
struct	WorldObjectSearcher
struct	WorldObjectSpellAreaTargetCheck
struct	WorldObjectSpellConeTargetCheck
struct	WorldObjectSpellNearbyTargetCheck
struct	WorldObjectSpellTargetCheck
struct	WorldObjectSpellTrajTargetCheck
struct	WorldObjectWorker
class	WorldWorldTextBuilder

Typedefs
template<template< typename... > typename Check, typename... Ts>
using	find_type_if_t = typename find_type_if< Check, Ts... >::type

Enumerations
enum	Priority {   Priority_Idle ,   Priority_Lowest ,   Priority_Low ,   Priority_Normal ,   Priority_High ,   Priority_Highest ,   Priority_Realtime }

Functions
AC_COMMON_API void	Assert (std::string_view file, uint32 line, std::string_view function, std::string_view debugInfo, std::string_view message, std::string_view fmtMessage={})
AC_COMMON_API void	Fatal (std::string_view file, uint32 line, std::string_view function, std::string_view message, std::string_view fmtMessage={})
AC_COMMON_API void	Error (std::string_view file, uint32 line, std::string_view function, std::string_view message)
AC_COMMON_API void	Abort (std::string_view file, uint32 line, std::string_view function, std::string_view fmtMessage={})
template<typename... Args>
AC_COMMON_API void	Assert (std::string_view file, uint32 line, std::string_view function, std::string_view debugInfo, std::string_view message, std::string_view fmt, Args &&... args)
template<typename... Args>
AC_COMMON_API void	Fatal (std::string_view file, uint32 line, std::string_view function, std::string_view message, std::string_view fmt, Args &&... args)
template<typename... Args>
AC_COMMON_API void	Abort (std::string_view file, uint32 line, std::string_view function, std::string_view fmt, Args &&... args)
AC_COMMON_API void	Warning (std::string_view file, uint32 line, std::string_view function, std::string_view message)
AC_COMMON_API void	AbortHandler (int sigval)
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 (const ContainerMapList< SPECIFIC_TYPE > &elements, SPECIFIC_TYPE *)
template<class SPECIFIC_TYPE >
size_t	Count (const ContainerMapList< TypeNull > &, SPECIFIC_TYPE *)
template<class SPECIFIC_TYPE , class T >
size_t	Count (const ContainerMapList< T > &, SPECIFIC_TYPE *)
template<class SPECIFIC_TYPE , class T >
size_t	Count (const ContainerMapList< TypeList< SPECIFIC_TYPE, T > > &elements, SPECIFIC_TYPE *fake)
template<class SPECIFIC_TYPE , class H , class T >
size_t	Count (const ContainerMapList< TypeList< H, T > > &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 SPECIFIC_TYPE >
CountedPtr< SPECIFIC_TYPE > &	Find (ContainerMapList< SPECIFIC_TYPE > &elements, OBJECT_HANDLE hdl, CountedPtr< SPECIFIC_TYPE > *)
template<class SPECIFIC_TYPE >
CountedPtr< SPECIFIC_TYPE > &	Find (ContainerMapList< TypeNull > &elements, OBJECT_HANDLE hdl, CountedPtr< SPECIFIC_TYPE > *)
template<class SPECIFIC_TYPE , class T >
CountedPtr< SPECIFIC_TYPE > &	Find (ContainerMapList< T > &elements, OBJECT_HANDLE hdl, CountedPtr< SPECIFIC_TYPE > *)
template<class SPECIFIC_TYPE , class H , class T >
CountedPtr< SPECIFIC_TYPE > &	Find (ContainerMapList< TypeList< H, T > > &elements, OBJECT_HANDLE hdl, CountedPtr< SPECIFIC_TYPE > *fake)
template<class SPECIFIC_TYPE >
const CountedPtr< SPECIFIC_TYPE > &	Find (const ContainerMapList< SPECIFIC_TYPE > &elements, OBJECT_HANDLE hdl, CountedPtr< SPECIFIC_TYPE > *)
template<class SPECIFIC_TYPE >
const CountedPtr< SPECIFIC_TYPE > &	Find (const ContainerMapList< TypeNull > &elements, OBJECT_HANDLE hdl, CountedPtr< SPECIFIC_TYPE > *)
template<class SPECIFIC_TYPE , class T >
const CountedPtr< SPECIFIC_TYPE > &	Find (const ContainerMapList< T > &elements, OBJECT_HANDLE hdl, CountedPtr< SPECIFIC_TYPE > *)
template<class SPECIFIC_TYPE , class H , class T >
CountedPtr< SPECIFIC_TYPE > &	Find (const ContainerMapList< TypeList< H, T > > &elements, OBJECT_HANDLE hdl, CountedPtr< SPECIFIC_TYPE > *fake)
template<class SPECIFIC_TYPE >
CountedPtr< SPECIFIC_TYPE > &	Insert (ContainerMapList< SPECIFIC_TYPE > &elements, CountedPtr< SPECIFIC_TYPE > &obj, OBJECT_HANDLE hdl)
template<class SPECIFIC_TYPE >
CountedPtr< SPECIFIC_TYPE > &	Insert (ContainerMapList< TypeNull > &elements, CountedPtr< SPECIFIC_TYPE > &obj, OBJECT_HANDLE hdl)
template<class SPECIFIC_TYPE , class T >
CountedPtr< SPECIFIC_TYPE > &	Insert (ContainerMapList< T > &elements, CountedPtr< SPECIFIC_TYPE > &obj, OBJECT_HANDLE hdl)
template<class SPECIFIC_TYPE , class H , class T >
CountedPtr< SPECIFIC_TYPE > &	Insert (ContainerMapList< TypeList< H, T > > &elements, CountedPtr< SPECIFIC_TYPE > &obj, OBJECT_HANDLE hdl)
template<class SPECIFIC_TYPE >
bool	Remove (ContainerMapList< SPECIFIC_TYPE > &elements, CountedPtr< SPECIFIC_TYPE > &obj, OBJECT_HANDLE hdl)
template<class SPECIFIC_TYPE >
bool	Remove (ContainerMapList< TypeNull > &elements, CountedPtr< SPECIFIC_TYPE > &obj, OBJECT_HANDLE hdl)
template<class SPECIFIC_TYPE , class T >
bool	Remove (ContainerMapList< T > &elements, CountedPtr< SPECIFIC_TYPE > &obj, OBJECT_HANDLE hdl)
template<class SPECIFIC_TYPE , class T , class H >
bool	Remove (ContainerMapList< TypeList< H, T > > &elements, CountedPtr< SPECIFIC_TYPE > &obj, OBJECT_HANDLE hdl)
template<class T >
constexpr T *	AddressOrSelf (T *ptr)
template<class T >
constexpr T *	AddressOrSelf (T &not_ptr)
template<typename T >
auto	MakeACLogSink (T &&callback) -> ACLogSink< 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 AC string format function.
template<typename... Args>
std::string	StringFormatFmt (std::string_view fmt, Args &&... args)
bool	IsFormatEmptyOrNull (char const *fmt)
	Returns true if the given char pointer is null.
bool	IsFormatEmptyOrNull (std::string_view fmt)
	Returns true if the given std::string is empty.
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 T , class Tuple >
T *	new_from_tuple (Tuple &&args)
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)
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)

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 Acore::find_type_if_t = typedef typename find_type_if<Check, Ts...>::type

Enumeration Type Documentation

Priority

enum Acore::Priority

Enumerator
Priority_Idle
Priority_Lowest
Priority_Low
Priority_Normal
Priority_High
Priority_Highest
Priority_Realtime

    {
        Priority_Idle,
        Priority_Lowest,
        Priority_Low,
        Priority_Normal,
        Priority_High,
        Priority_Highest,
        Priority_Realtime,
    };

Function Documentation

Abort() [1/2]

template<typename... Args>

AC_COMMON_API void Acore::Abort ( std::string_view  file, uint32  line, std::string_view  function, std::string_view  fmt, Args &&...  args  )

inline

    {
        Abort(file, line, function, StringFormatFmt(fmt, std::forward<Args>(args)...));
    }

References Abort(), and StringFormatFmt().

Abort() [2/2]

void Acore::Abort	(	std::string_view	file,
		uint32	line,
		std::string_view	function,
		std::string_view	fmtMessage = {}
	)

{
    std::string formattedMessage = MakeAbortMessage(file, line, function, fmtMessage);
    fmt::print(stderr, "{}", formattedMessage);
    fflush(stderr);
    std::this_thread::sleep_for(10s);
    Crash(formattedMessage.c_str());
}

References Crash, and anonymous_namespace{Errors.cpp}::MakeAbortMessage().

Referenced by Abort().

AbortHandler()

void Acore::AbortHandler

(

int

sigval

)

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

References Crash, and StringFormatFmt().

Referenced by main().

AddressOrSelf() [1/2]

template<class T >

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

inlineconstexpr

    {
        return std::addressof(not_ptr);
    }

AddressOrSelf() [2/2]

template<class T >

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

inlineconstexpr

    {
        return ptr;
    }

Referenced by Acore::Containers::MapGetValuePtr().

Assert() [1/2]

template<typename... Args>

AC_COMMON_API void Acore::Assert ( std::string_view  file, uint32  line, std::string_view  function, std::string_view  debugInfo, std::string_view  message, std::string_view  fmt, Args &&...  args  )

inline

    {
        Assert(file, line, function, debugInfo, message, StringFormatFmt(fmt, std::forward<Args>(args)...));
    }

References Assert(), and StringFormatFmt().

Assert() [2/2]

void Acore::Assert	(	std::string_view	file,
		uint32	line,
		std::string_view	function,
		std::string_view	debugInfo,
		std::string_view	message,
		std::string_view	fmtMessage = {}
	)

{
    std::string formattedMessage = MakeMessage("ASSERTION FAILED", file, line, function, message, fmtMessage, debugInfo);
    fmt::print(stderr, "{}", formattedMessage);
    fflush(stderr);
    Crash(formattedMessage.c_str());
}

References Crash, and anonymous_namespace{Errors.cpp}::MakeMessage().

Referenced by Assert().

Compute()

template<class RET_TYPE , int CENTER_VAL>

RET_TYPE Acore::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.5f);
        int y_val = int(y_offset + CENTER_VAL + 0.5f);
        return RET_TYPE(x_val, y_val);
    }

ComputeCellCoord() [1/2]

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

inline

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

References CENTER_GRID_CELL_OFFSET, and SIZE_OF_GRID_CELL.

Referenced by ObjectMgr::AddCreatureToGrid(), ObjectMgr::AddGameobjectToGrid(), Map::AddPlayerToMap(), Map::AddToMap(), Cell::CalculateCellArea(), Cell::Cell(), Spell::CheckSpellFocus(), Corpse::Create(), WorldObject::GetCreaturesWithEntryInRange(), misc_commandscript::HandleGPSCommand(), WorldSession::HandleMoveWorldportAck(), misc_commandscript::HandleRespawnAllCommand(), WorldSession::HandleTextEmoteOpcode(), Corpse::LoadCorpseFromDB(), ObjectMgr::RemoveCreatureFromGrid(), ObjectMgr::RemoveGameobjectFromGrid(), boss_nalorakk::boss_nalorakkAI::ResetMobs(), Spell::SearchTargets(), AchievementMgr::SendAchievementEarned(), boss_nalorakk::boss_nalorakkAI::SendAttacker(), Map::SwitchGridContainers(), Cell::VisitAllObjects(), Cell::VisitGridObjects(), and Cell::VisitWorldObjects().

ComputeCellCoord() [2/2]

CellCoord Acore::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) - x_val + CENTER_GRID_CELL_ID) * SIZE_OF_GRID_CELL;
        y_off = (float(y_offset) - y_val + CENTER_GRID_CELL_ID) * SIZE_OF_GRID_CELL;
        return CellCoord(x_val, y_val);
    }

References CENTER_GRID_CELL_ID, CENTER_GRID_CELL_OFFSET, and SIZE_OF_GRID_CELL.

ComputeGridCoord()

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

inline

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

References CENTER_GRID_OFFSET, and SIZE_OF_GRIDS.

Referenced by MapMgr::ExistMapAndVMap(), misc_commandscript::HandleGPSCommand(), Map::IsGridLoaded(), and Map::IsRemovalGrid().

Count() [1/5]

template<class SPECIFIC_TYPE >

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

    {
        return elements._element.getSize();
    }

References ContainerMapList< OBJECT >::_element.

Referenced by TypeMapContainer< OBJECT_TYPES >::Count(), and Count().

Count() [2/5]

template<class SPECIFIC_TYPE , class T >

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

    {
        return 0;
    }

Count() [3/5]

template<class SPECIFIC_TYPE , class H , class T >

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

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

References Count().

Count() [4/5]

template<class SPECIFIC_TYPE , class T >

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

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

References Count().

Count() [5/5]

template<class SPECIFIC_TYPE >

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

    {
        return 0;
    }

CreateChildProcess()

template<typename T >

static int Acore::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)
        {
            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 = std::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 = std::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 = MakeACLogSink([&](std::string const& msg)
        {
            LOG_INFO(logger, "{}", msg);
        });
 
        auto outError = MakeACLogSink([&](std::string const& msg)
        {
            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)
        {
            LOG_TRACE(logger, ">> Process \"{}\" finished with return value {}.",
                executable, result);
        }
 
        return result;
    }

References LOG_ERROR, LOG_INFO, LOG_TRACE, and MakeACLogSink().

Referenced by Acore::AsyncProcessResultImplementation::StartProcess(), and StartProcess().

Error()

void Acore::Error	(	std::string_view	file,
		uint32	line,
		std::string_view	function,
		std::string_view	message
	)

{
    std::string formattedMessage = MakeMessage("ERROR", file, line, function, message);
    fmt::print(stderr, "{}", formattedMessage);
    fflush(stderr);
    std::this_thread::sleep_for(10s);
    Crash(formattedMessage.c_str());
}

References Crash, and anonymous_namespace{Errors.cpp}::MakeMessage().

Fatal() [1/2]

template<typename... Args>

AC_COMMON_API void Acore::Fatal ( std::string_view  file, uint32  line, std::string_view  function, std::string_view  message, std::string_view  fmt, Args &&...  args  )

inline

    {
        Fatal(file, line, function, message, StringFormatFmt(fmt, std::forward<Args>(args)...));
    }

References Fatal(), and StringFormatFmt().

Fatal() [2/2]

void Acore::Fatal	(	std::string_view	file,
		uint32	line,
		std::string_view	function,
		std::string_view	message,
		std::string_view	fmtMessage = {}
	)

{
    std::string formattedMessage = MakeMessage("FATAL ERROR", file, line, function, message, fmtMessage);
    fmt::print(stderr, "{}", formattedMessage);
    fflush(stderr);
    std::this_thread::sleep_for(10s);
    Crash(formattedMessage.c_str());
}

References Crash, and anonymous_namespace{Errors.cpp}::MakeMessage().

Referenced by Fatal().

Find() [1/12]

template<class SPECIFIC_TYPE >

const CountedPtr< SPECIFIC_TYPE > & Acore::Find	(	const ContainerMapList< SPECIFIC_TYPE > &	elements,
		OBJECT_HANDLE	hdl,
		CountedPtr< SPECIFIC_TYPE > *
	)

    {
        typename CountedPtr<SPECIFIC_TYPE>::iterator iter = elements._element.find(hdl);
        return (iter == elements._element.end() ? NullPtr<SPECIFIC_TYPE>((SPECIFIC_TYPE*)nullptr) : iter->second);
    };

References ContainerMapList< OBJECT >::_element.

Find() [2/12]

template<class SPECIFIC_TYPE , class T >

const CountedPtr< SPECIFIC_TYPE > & Acore::Find	(	const ContainerMapList< T > &	elements,
		OBJECT_HANDLE	hdl,
		CountedPtr< SPECIFIC_TYPE > *
	)

    {
        return NullPtr<SPECIFIC_TYPE>((SPECIFIC_TYPE*)nullptr);
    }

Find() [3/12]

template<class SPECIFIC_TYPE , class H , class T >

CountedPtr< SPECIFIC_TYPE > & Acore::Find	(	const ContainerMapList< TypeList< H, T > > &	elements,
		OBJECT_HANDLE	hdl,
		CountedPtr< SPECIFIC_TYPE > *	fake
	)

    {
        CountedPtr<SPECIFIC_TYPE>& t = Find(elements._elements, hdl, fake);
        if (!t)
        {
            t = Find(elements._TailElement, hdl, fake);
        }
 
        return t;
    }

References Find().

Find() [4/12]

template<class SPECIFIC_TYPE >

const CountedPtr< SPECIFIC_TYPE > & Acore::Find	(	const ContainerMapList< TypeNull > &	elements,
		OBJECT_HANDLE	hdl,
		CountedPtr< SPECIFIC_TYPE > *
	)

    {
        return NullPtr<SPECIFIC_TYPE>((SPECIFIC_TYPE*)nullptr);
    }

Find() [5/12]

template<class SPECIFIC_TYPE >

CountedPtr< SPECIFIC_TYPE > & Acore::Find	(	ContainerMapList< SPECIFIC_TYPE > &	elements,
		OBJECT_HANDLE	hdl,
		CountedPtr< SPECIFIC_TYPE > *
	)

    {
        typename std::map<OBJECT_HANDLE, CountedPtr<SPECIFIC_TYPE>>::iterator iter = elements._element.find(hdl);
        return (iter == elements._element.end() ? NullPtr<SPECIFIC_TYPE>((SPECIFIC_TYPE*)nullptr) : iter->second);
    };

References ContainerMapList< OBJECT >::_element.

Find() [6/12]

template<class SPECIFIC_TYPE , class T >

CountedPtr< SPECIFIC_TYPE > & Acore::Find	(	ContainerMapList< T > &	elements,
		OBJECT_HANDLE	hdl,
		CountedPtr< SPECIFIC_TYPE > *
	)

    {
        return NullPtr<SPECIFIC_TYPE>((SPECIFIC_TYPE*)nullptr);// this is a missed
    }

Find() [7/12]

template<class SPECIFIC_TYPE , class H , class T >

CountedPtr< SPECIFIC_TYPE > & Acore::Find	(	ContainerMapList< TypeList< H, T > > &	elements,
		OBJECT_HANDLE	hdl,
		CountedPtr< SPECIFIC_TYPE > *	fake
	)

    {
        CountedPtr<SPECIFIC_TYPE>& t = Find(elements._elements, hdl, fake);
        return (!t ? Find(elements._TailElements, hdl, fake) : t);
    }

References Find().

Find() [8/12]

template<class SPECIFIC_TYPE >

CountedPtr< SPECIFIC_TYPE > & Acore::Find	(	ContainerMapList< TypeNull > &	elements,
		OBJECT_HANDLE	hdl,
		CountedPtr< SPECIFIC_TYPE > *
	)

    {
        return NullPtr<SPECIFIC_TYPE>((SPECIFIC_TYPE*)nullptr);// terminate recursion
    }

Find() [9/12]

template<class SPECIFIC_TYPE , class KEY_TYPE >

SPECIFIC_TYPE * Acore::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;
        }
    }

References ContainerUnorderedMap< OBJECT, KEY_TYPE >::_element.

Referenced by Find(), and TypeUnorderedMapContainer< OBJECT_TYPES, KEY_TYPE >::Find().

Find() [10/12]

template<class SPECIFIC_TYPE , class KEY_TYPE , class T >

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

    {
        return nullptr;
    }

Find() [11/12]

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

SPECIFIC_TYPE * Acore::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);
    }

References Find().

Find() [12/12]

template<class SPECIFIC_TYPE , class KEY_TYPE >

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

    {
        return nullptr;
    }

Insert() [1/12]

template<class SPECIFIC_TYPE >

CountedPtr< SPECIFIC_TYPE > & Acore::Insert	(	ContainerMapList< SPECIFIC_TYPE > &	elements,
		CountedPtr< SPECIFIC_TYPE > &	obj,
		OBJECT_HANDLE	hdl
	)

    {
        elements._element[hdl] = obj;
        return obj;
    };

References ContainerMapList< OBJECT >::_element.

Insert() [2/12]

template<class SPECIFIC_TYPE >

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

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

References ContainerMapList< OBJECT >::_element.

Insert() [3/12]

template<class SPECIFIC_TYPE , class T >

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

    {
        return nullptr;                                        // a missed
    }

Insert() [4/12]

template<class SPECIFIC_TYPE , class T >

CountedPtr< SPECIFIC_TYPE > & Acore::Insert	(	ContainerMapList< T > &	elements,
		CountedPtr< SPECIFIC_TYPE > &	obj,
		OBJECT_HANDLE	hdl
	)

    {
        return NullPtr<SPECIFIC_TYPE>((SPECIFIC_TYPE*)nullptr);// a missed
    }

Insert() [5/12]

template<class SPECIFIC_TYPE , class H , class T >

CountedPtr< SPECIFIC_TYPE > & Acore::Insert	(	ContainerMapList< TypeList< H, T > > &	elements,
		CountedPtr< SPECIFIC_TYPE > &	obj,
		OBJECT_HANDLE	hdl
	)

    {
        CountedPtr<SPECIFIC_TYPE>& t = Insert(elements._elements, obj, hdl);
        return (!t ? Insert(elements._TailElements, obj, hdl) : t);
    }

References Insert().

Insert() [6/12]

template<class SPECIFIC_TYPE , class H , class T >

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

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

References Insert().

Insert() [7/12]

template<class SPECIFIC_TYPE >

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

    {
        return nullptr;
    }

Insert() [8/12]

template<class SPECIFIC_TYPE >

CountedPtr< SPECIFIC_TYPE > & Acore::Insert	(	ContainerMapList< TypeNull > &	elements,
		CountedPtr< SPECIFIC_TYPE > &	obj,
		OBJECT_HANDLE	hdl
	)

    {
        return NullPtr<SPECIFIC_TYPE>((SPECIFIC_TYPE*)nullptr);
    }

Insert() [9/12]

template<class SPECIFIC_TYPE , class KEY_TYPE >

bool Acore::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;
        }
    }

References ContainerUnorderedMap< OBJECT, KEY_TYPE >::_element, and ASSERT.

Referenced by Insert(), TypeUnorderedMapContainer< OBJECT_TYPES, KEY_TYPE >::Insert(), TypeMapContainer< OBJECT_TYPES >::insert(), Acore::CreatureListSearcher< Check >::Visit(), Acore::GameObjectListSearcher< Check >::Visit(), Acore::WorldObjectListSearcher< Check >::Visit(), Acore::UnitListSearcher< Check >::Visit(), and Acore::PlayerListSearcher< Check >::Visit().

Insert() [10/12]

template<class SPECIFIC_TYPE , class KEY_TYPE , class T >

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

    {
        return false;
    }

Insert() [11/12]

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

bool Acore::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);
    }

References Insert().

Insert() [12/12]

template<class SPECIFIC_TYPE , class KEY_TYPE >

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

    {
        return false;
    }

IsFormatEmptyOrNull() [1/2]

bool Acore::IsFormatEmptyOrNull ( char const *  fmt )

inline

Returns true if the given char pointer is null.

    {
        return fmt == nullptr;
    }

IsFormatEmptyOrNull() [2/2]

bool Acore::IsFormatEmptyOrNull ( std::string_view  fmt )

inline

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

    {
        return fmt.empty();
    }

IsValidMapCoord() [1/4]

bool Acore::IsValidMapCoord ( float  c )

inline

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

References MAP_HALFSIZE.

Referenced by RandomMovementGenerator< T >::_setRandomLocation(), PathGenerator::CalculatePath(), Map::CheckCollisionAndGetValidCoords(), Spell::EffectJumpDest(), WorldSession::HandleMovementOpcodes(), SmartAIMgr::IsEventValid(), Position::IsPositionValid(), IsValidMapCoord(), MapMgr::IsValidMapCoord(), Creature::LoadCreatureFromDB(), Player::LoadFromDB(), ObjectMgr::LoadPointsOfInterest(), ObjectMgr::LoadScripts(), WorldObject::MovePosition(), StaticTransport::RelocateToProgress(), Creature::SetPosition(), GameObject::SetPosition(), StaticTransport::UpdatePassengerPositions(), MotionTransport::UpdatePassengerPositions(), and Unit::UpdatePosition().

IsValidMapCoord() [2/4]

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

inline

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

References IsValidMapCoord().

IsValidMapCoord() [3/4]

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

inline

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

References IsValidMapCoord().

IsValidMapCoord() [4/4]

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

inline

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

References IsValidMapCoord().

MakeACLogSink()

template<typename T >

auto Acore::MakeACLogSink

(

T &&

callback

)

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

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

Referenced by CreateChildProcess().

new_from_tuple()

template<class T , class Tuple >

T * Acore::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 Acore::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);
    }

References MAP_HALFSIZE.

Referenced by ConfusedMovementGenerator< T >::DoInitialize(), WorldObject::GetNearPoint2D(), WorldObject::GetRandomPoint(), CreatureGroup::LeaderMoveTo(), WaypointMgr::Load(), WorldObject::MovePosition(), and WaypointMgr::ReloadPath().

Remove() [1/8]

template<class SPECIFIC_TYPE >

bool Acore::Remove	(	ContainerMapList< SPECIFIC_TYPE > &	elements,
		CountedPtr< SPECIFIC_TYPE > &	obj,
		OBJECT_HANDLE	hdl
	)

    {
        typename std::map<OBJECT_HANDLE, CountedPtr<SPECIFIC_TYPE>>::iterator iter = elements._element.find(hdl);
        if ( iter != elements._element.end() )
        {
            elements._element.erase(iter);
            return true;
        }
 
        return false;                                       // found... terminate the search
    }

References ContainerMapList< OBJECT >::_element.

Remove() [2/8]

template<class SPECIFIC_TYPE , class T >

bool Acore::Remove	(	ContainerMapList< T > &	elements,
		CountedPtr< SPECIFIC_TYPE > &	obj,
		OBJECT_HANDLE	hdl
	)

    {
        return false;
    }

Remove() [3/8]

template<class SPECIFIC_TYPE , class T , class H >

bool Acore::Remove	(	ContainerMapList< TypeList< H, T > > &	elements,
		CountedPtr< SPECIFIC_TYPE > &	obj,
		OBJECT_HANDLE	hdl
	)

    {
        // The head element is bad
        bool t = Remove(elements._elements, obj, hdl);
        return ( !t ? Remove(elements._TailElements, obj, hdl) : t );
    }

References Remove().

Remove() [4/8]

template<class SPECIFIC_TYPE >

bool Acore::Remove	(	ContainerMapList< TypeNull > &	elements,
		CountedPtr< SPECIFIC_TYPE > &	obj,
		OBJECT_HANDLE	hdl
	)

    {
        return false;
    }

Remove() [5/8]

template<class SPECIFIC_TYPE , class KEY_TYPE >

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

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

References ContainerUnorderedMap< OBJECT, KEY_TYPE >::_element.

Referenced by Remove(), and TypeUnorderedMapContainer< OBJECT_TYPES, KEY_TYPE >::Remove().

Remove() [6/8]

template<class SPECIFIC_TYPE , class KEY_TYPE , class T >

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

    {
        return false;
    }

Remove() [7/8]

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

bool Acore::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);
    }

References Remove().

Remove() [8/8]

template<class SPECIFIC_TYPE , class KEY_TYPE >

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

    {
        return false;
    }

SearchExecutableInPath()

AC_COMMON_API std::string Acore::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 "";
        }
    }

Referenced by DBUpdaterUtil::CheckExecutable().

Size() [1/4]

template<class SPECIFIC_TYPE , class KEY_TYPE >

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

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

References ContainerUnorderedMap< OBJECT, KEY_TYPE >::_element.

Referenced by TypeUnorderedMapContainer< OBJECT_TYPES, KEY_TYPE >::Size(), and Size().

Size() [2/4]

template<class SPECIFIC_TYPE , class KEY_TYPE , class T >

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

    {
        return false;
    }

Size() [3/4]

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

bool Acore::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);
    }

References Size().

Size() [4/4]

template<class SPECIFIC_TYPE , class KEY_TYPE >

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

    {
        return false;
    }

StartAsyncProcess()

AC_COMMON_API std::shared_ptr< AsyncProcessResult > Acore::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;
    }

StartProcess()

AC_COMMON_API int Acore::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);
    }

References CreateChildProcess().

Referenced by DBUpdater< T >::ApplyFile().

StringFormat()

template<typename Format , typename... Args>

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

inline

Default AC 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;
        }
    }

Referenced by DBUpdater< T >::ApplyFile(), SecretMgr::AttemptTransition(), ByteBufferInvalidValueException::ByteBufferInvalidValueException(), ExtractMapsFromMpq(), Acore::Impl::ChatCommands::FormatAcoreString(), message_commandscript::HandleAnnounceCommand(), character_commandscript::HandleCharacterTitlesCommand(), lookup_commandscript::HandleLookupSkillCommand(), lookup_commandscript::HandleLookupTitleCommand(), server_commandscript::HandleServerDebugCommand(), titles_commandscript::HandleTitlesAddCommand(), titles_commandscript::HandleTitlesCurrentCommand(), titles_commandscript::HandleTitlesRemoveCommand(), PlayerDump::InitializeTables(), DBCDatabaseLoader::Load(), PlayerDumpReader::LoadDump(), MMAP::MMapMgr::loadMap(), MMAP::MMapMgr::loadMapData(), WardenCheckMgr::LoadWardenChecks(), ChatHandler::PGetParseString(), ChatHandler::PSendSysMessage(), WardenPayloadMgr::RegisterPayload(), ArenaSpectator::SendCommand(), BattlegroundQueue::SendJoinMessageArenaQueue(), Acore::Impl::ChatCommands::ArgInfo< Acore::ChatCommands::Variant< Ts... > >::TryAtIndex(), Acore::Impl::ChatCommands::ArgInfo< Acore::ChatCommands::Variant< Ts... > >::TryConsume(), and Appender::write().

StringFormatFmt()

template<typename... Args>

std::string Acore::StringFormatFmt ( std::string_view  fmt, Args &&...  args  )

inline

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

Referenced by Abort(), AbortHandler(), TransactionBase::Append(), AppenderFile::AppenderFile(), Warden::ApplyPenalty(), Assert(), DatabaseWorkerPool< T >::DirectExecute(), DatabaseWorkerPool< T >::Execute(), Fatal(), Acore::Impl::ChatCommands::ChatCommandNode::GetAutoCompletionsFor(), debug_commandscript::HandleDebugGetItemStateCommand(), mmaps_commandscript::HandleMmapPathCommand(), mmaps_commandscript::HandleMmapTestArea(), send_commandscript::HandleSendItemsCommand(), server_commandscript::HandleServerDebugCommand(), AppenderConsole::InitColors(), LogCommandUsage(), Log::outCommand(), Log::outMessage(), anonymous_namespace{Config.cpp}::ParseFile(), anonymous_namespace{Config.cpp}::PrintError(), DatabaseWorkerPool< T >::Query(), Acore::Banner::Show(), ArenaScore::ToString(), PreparedStatementData::ToString(), Acore::Impl::ChatCommands::MultiConsumer< Tuple, Optional< NestedNextType >, offset >::TryConsumeTo(), and DBUpdater< T >::Update().

StringTo()

template<typename Result , typename... Params>

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

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

Tokenize() [1/4]

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

inline

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

References Tokenize().

Tokenize() [2/4]

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

delete

Tokenize() [3/4]

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

delete

Tokenize() [4/4]

std::vector< std::string_view > Acore::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;
}

Referenced by Player::_LoadCharacterSettings(), Object::_LoadIntoDataField(), Player::_LoadItem(), Player::BuildEnumData(), ConfigMgr::Configure(), Log::CreateAppenderFromConfig(), Log::CreateLoggerFromConfig(), Acore::Module::GetEnableModulesList(), WorldSession::HandleCharFactionOrRaceChangeCallback(), reload_commandscript::HandleReloadCreatureTemplateCommand(), send_commandscript::HandleSendItemsCommand(), misc_commandscript::HandleSkirmishCommand(), AppenderConsole::InitColors(), ChannelMgr::LoadChannelRights(), Acore::Impl::ChatCommands::ChatCommandNode::LoadCommandMap(), Acore::Impl::ChatCommands::ChatCommandNode::LoadCommandsIntoMap(), ObjectMgr::LoadCreatureAddons(), ObjectMgr::LoadCreatureCustomIDs(), ObjectMgr::LoadCreatureTemplateAddons(), DisableMgr::LoadDisables(), Metric::LoadFromConfigs(), Item::LoadFromDB(), CharmInfo::LoadPetActionBar(), PlayerTaxi::LoadTaxiDestinationsFromString(), PlayerTaxi::LoadTaxiMask(), MoneyStringToMoney(), MySQLConnectionInfo::MySQLConnectionInfo(), UpdateFetcher::ReceiveIncludedDirectories(), Acore::Impl::ChatCommands::ChatCommandNode::SendCommandHelpFor(), ChatHandler::SendGlobalGMSysMessage(), ChatHandler::SendGlobalSysMessage(), ChatHandler::SendSysMessage(), Motd::SetMotd(), and Tokenize().

ToString()

template<typename Type , typename... Params>

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

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

References ToString().

Referenced by ConfigMgr::GetValueDefault(), npc_commandscript::HandleNpcSetModelCommand(), and ToString().

Warning()

void Acore::Warning	(	std::string_view	file,
		uint32	line,
		std::string_view	function,
		std::string_view	message
	)

{
    std::string formattedMessage = MakeMessage("WARNING", file, line, function, message);
    fmt::print(stderr, "{}", formattedMessage);
}

References anonymous_namespace{Errors.cpp}::MakeMessage().

Variable Documentation

dependant_false_v

template<typename T >

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

constexpr

has_type_v

template<typename T , typename... Us>

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

constexpr

is_tuple_v

template<typename... Ts>

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

constexpr