5#include "../BasicTypes.h" 
    8
    9
   10
   11
   12
   13template <
typename T = 
void>
 
   16    FORCEINLINE 
bool operator()(
const T& A, 
const T& B) 
const 
   26    FORCEINLINE 
bool operator()(
const T& A, 
const T& B) 
const 
static unsigned int GetBuildUniqueId()
 
ARK_API LPVOID GetDataAddress(const std::string &name)
 
ARK_API BitField GetBitField(LPVOID base, const std::string &name)
 
ARK_API BitField GetBitField(const void *base, const std::string &name)
 
ARK_API DWORD64 GetAddress(const void *base, const std::string &name)
 
ARK_API LPVOID GetAddress(const std::string &name)
 
FPlatformTypes::CHAR16 UCS2CHAR
A 16-bit character containing a UCS2 (Unicode, 16-bit, fixed-width) code unit, used for compatibility...
 
FWindowsPlatformTypes FPlatformTypes
 
#define PLATFORM_LITTLE_ENDIAN
 
FPlatformTypes::CHAR8 UTF8CHAR
An 8-bit character containing a UTF8 (Unicode, 8-bit, variable-width) code unit.
 
#define ensureMsgf(Expr, Expr2)
 
FPlatformTypes::CHAR16 UTF16CHAR
A 16-bit character containing a UTF16 (Unicode, 16-bit, variable-width) code unit.
 
FPlatformTypes::CHAR32 UTF32CHAR
A 32-bit character containing a UTF32 (Unicode, 32-bit, fixed-width) code unit.
 
TCString< TCHAR > FCString
 
FORCEINLINE int32 DefaultCalculateSlackShrink(int32 NumElements, int32 NumAllocatedElements, SIZE_T BytesPerElement, bool bAllowQuantize, uint32 Alignment=DEFAULT_ALIGNMENT)
 
#define DEFAULT_MIN_NUMBER_OF_HASHED_ELEMENTS
 
#define DEFAULT_NUMBER_OF_ELEMENTS_PER_HASH_BUCKET
 
#define DEFAULT_BASE_NUMBER_OF_HASH_BUCKETS
 
FORCEINLINE int32 DefaultCalculateSlackGrow(int32 NumElements, int32 NumAllocatedElements, SIZE_T BytesPerElement, bool bAllowQuantize, uint32 Alignment=DEFAULT_ALIGNMENT)
 
FORCEINLINE int32 DefaultCalculateSlackReserve(int32 NumElements, SIZE_T BytesPerElement, bool bAllowQuantize, uint32 Alignment=DEFAULT_ALIGNMENT)
 
int32 FindMatchingClosingParenthesis(const FString &TargetString, const int32 StartSearch)
 
int32 HexToBytes(const FString &HexString, uint8 *OutBytes)
 
const TCHAR * GetData(const FString &String)
 
const uint8 TCharToNibble(const TCHAR Char)
 
const bool CheckTCharIsHex(const TCHAR Char)
 
FORCEINLINE uint32 GetTypeHash(const FString &Thing)
 
TCHAR * GetData(FString &String)
 
SIZE_T GetNum(const FString &String)
 
void ByteToHex(uint8 In, FString &Result)
 
static const uint32 MaxSupportedEscapeChars
 
FString BytesToHex(const uint8 *In, int32 Count)
 
int32 StringToBytes(const FString &String, uint8 *OutBytes, int32 MaxBufferSize)
 
static const TCHAR * CharToEscapeSeqMap[][2]
 
TCHAR NibbleToTChar(uint8 Num)
 
FString BytesToString(const uint8 *In, int32 Count)
 
FORCEINLINE auto Invoke(ReturnType ObjType::*pdm, CallableType &&Callable) -> decltype(UE4Invoke_Private::DereferenceIfNecessary< ObjType >(Forward< CallableType >(Callable)).*pdm)
 
FORCEINLINE auto Invoke(FuncType &&Func, ArgTypes &&... Args) -> decltype(Forward< FuncType >(Func)(Forward< ArgTypes >(Args)...))
 
FORCEINLINE auto Invoke(ReturnType(ObjType::*PtrMemFun)(PMFArgTypes...), CallableType &&Callable, ArgTypes &&... Args) -> decltype((UE4Invoke_Private::DereferenceIfNecessary< ObjType >(Forward< CallableType >(Callable)).*PtrMemFun)(Forward< ArgTypes >(Args)...))
 
ARK_API std::vector< spdlog::sink_ptr > &APIENTRY GetLogSinks()
 
FORCEINLINE TEnableIf<!TIsTriviallyCopyAssignable< ElementType >::Value >::Type CopyAssignItems(ElementType *Dest, const ElementType *Source, int32 Count)
 
FORCEINLINE TEnableIf< UE4MemoryOps_Private::TCanBitwiseRelocate< DestinationElementType, SourceElementType >::Value >::Type RelocateConstructItems(void *Dest, const SourceElementType *Source, int32 Count)
 
FORCEINLINE TEnableIf< TIsZeroConstructType< ElementType >::Value >::Type DefaultConstructItems(void *Elements, int32 Count)
 
FORCEINLINE TEnableIf<!TIsTriviallyCopyConstructible< ElementType >::Value >::Type MoveConstructItems(void *Dest, const ElementType *Source, int32 Count)
 
FORCEINLINE TEnableIf< TIsTriviallyCopyConstructible< ElementType >::Value >::Type MoveConstructItems(void *Dest, const ElementType *Source, int32 Count)
 
FORCEINLINE TEnableIf<!TIsZeroConstructType< ElementType >::Value >::Type DefaultConstructItems(void *Address, int32 Count)
 
FORCEINLINE TEnableIf<!TIsTriviallyDestructible< ElementType >::Value >::Type DestructItem(ElementType *Element)
 
FORCEINLINE TEnableIf< TTypeTraits< ElementType >::IsBytewiseComparable, bool >::Type CompareItems(const ElementType *A, const ElementType *B, int32 Count)
 
FORCEINLINE TEnableIf< TIsTriviallyCopyAssignable< ElementType >::Value >::Type MoveAssignItems(ElementType *Dest, const ElementType *Source, int32 Count)
 
FORCEINLINE TEnableIf< TIsTriviallyDestructible< ElementType >::Value >::Type DestructItem(ElementType *Element)
 
FORCEINLINE TEnableIf<!TIsTriviallyDestructible< ElementType >::Value >::Type DestructItems(ElementType *Element, int32 Count)
 
FORCEINLINE TEnableIf<!TIsTriviallyCopyAssignable< ElementType >::Value >::Type MoveAssignItems(ElementType *Dest, const ElementType *Source, int32 Count)
 
FORCEINLINE TEnableIf<!TTypeTraits< ElementType >::IsBytewiseComparable, bool >::Type CompareItems(const ElementType *A, const ElementType *B, int32 Count)
 
FORCEINLINE TEnableIf<!TIsBitwiseConstructible< DestinationElementType, SourceElementType >::Value >::Type ConstructItems(void *Dest, const SourceElementType *Source, int32 Count)
 
FORCEINLINE TEnableIf<!UE4MemoryOps_Private::TCanBitwiseRelocate< DestinationElementType, SourceElementType >::Value >::Type RelocateConstructItems(void *Dest, const SourceElementType *Source, int32 Count)
 
FORCEINLINE TEnableIf< TIsTriviallyDestructible< ElementType >::Value >::Type DestructItems(ElementType *Elements, int32 Count)
 
FORCEINLINE TEnableIf< TIsTriviallyCopyAssignable< ElementType >::Value >::Type CopyAssignItems(ElementType *Dest, const ElementType *Source, int32 Count)
 
FORCEINLINE TEnableIf< TIsBitwiseConstructible< DestinationElementType, SourceElementType >::Value >::Type ConstructItems(void *Dest, const SourceElementType *Source, int32 Count)
 
#define WIN32_LEAN_AND_MEAN
 
void StableSort(T **First, const int32 Num, const PREDICATE_CLASS &Predicate)
 
void StableSort(T *First, const int32 Num, const PREDICATE_CLASS &Predicate)
 
void StableSortInternal(T *First, const int32 Num, const PREDICATE_CLASS &Predicate)
 
void Sort(T **First, const int32 Num)
 
void StableSort(T *First, const int32 Num)
 
void StableSort(T **First, const int32 Num)
 
void Merge(T *Out, T *In, const int32 Mid, const int32 Num, const PREDICATE_CLASS &Predicate)
 
void Sort(T **First, const int32 Num, const PREDICATE_CLASS &Predicate)
 
void Sort(T *First, const int32 Num, const PREDICATE_CLASS &Predicate)
 
void Sort(T *First, const int32 Num)
 
#define TARRAY_RANGED_FOR_CHECKS
 
FORCEINLINE TIndexedContainerIterator< ContainerType, ElementType, IndexType > operator+(int32 Offset, TIndexedContainerIterator< ContainerType, ElementType, IndexType > RHS)
 
void * operator new(size_t Size, TArray< T, Allocator > &Array, int32 Index)
 
void * operator new(size_t Size, TArray< T, Allocator > &Array)
 
#define IMPLEMENT_ALIGNED_STORAGE(Align)
 
#define THRESH_VECTOR_NORMALIZED
 
#define THRESH_NORMALS_ARE_PARALLEL
 
#define THRESH_POINTS_ARE_SAME
 
#define THRESH_POINT_ON_PLANE
 
#define THRESH_NORMALS_ARE_ORTHOGONAL
 
#define KINDA_SMALL_NUMBER
 
CONSTEXPR SIZE_T GetNum(T(&Container)[N])
 
FORCEINLINE T && Forward(typename TRemoveReference< T >::Type &&Obj)
 
FORCEINLINE TRemoveReference< T >::Type && MoveTempIfPossible(T &&Obj)
 
auto GetData(T &&Container) -> decltype(Container.GetData())
 
TEnableIf< TUseBitwiseSwap< T >::Value >::Type Swap(T &A, T &B)
 
ForwardIt MaxElement(ForwardIt First, ForwardIt Last, PredicateType Predicate)
 
ForwardIt MinElement(ForwardIt First, ForwardIt Last, PredicateType Predicate)
 
SIZE_T GetNum(T &&Container)
 
#define ARRAY_COUNT(array)
 
FORCEINLINE ReferencedType * IfPThenAElseB(PredicateType Predicate, ReferencedType *A, ReferencedType *B)
 
FORCEINLINE T && CopyTemp(T &&Val)
 
void Exchange(T &A, T &B)
 
FORCEINLINE T CopyTemp(T &Val)
 
FORCEINLINE TRemoveReference< T >::Type && MoveTemp(T &&Obj)
 
CONSTEXPR T * GetData(T(&Container)[N])
 
FORCEINLINE T && Forward(typename TRemoveReference< T >::Type &Obj)
 
FORCEINLINE void Move(T &A, typename TMoveSupportTraits< T >::Copy B)
 
FORCEINLINE TEnableIf< TAreTypesEqual< T, uint32 >::Value, T >::Type ReverseBits(T Bits)
 
FORCEINLINE ReferencedType * IfAThenAElseB(ReferencedType *A, ReferencedType *B)
 
FORCEINLINE T CopyTemp(const T &Val)
 
ForwardIt MaxElement(ForwardIt First, ForwardIt Last)
 
ForwardIt MinElement(ForwardIt First, ForwardIt Last)
 
FORCEINLINE void Move(T &A, typename TMoveSupportTraits< T >::Move B)
 
TEnableIf<!TUseBitwiseSwap< T >::Value >::Type Swap(T &A, T &B)
 
FORCEINLINE T StaticCast(ArgType &&Arg)
 
#define Expose_TNameOf(type)
 
#define Expose_TFormatSpecifier(type, format)
 
FORCEINLINE float ComputeSquaredDistanceFromBoxToPoint(const FVector &Mins, const FVector &Maxs, const FVector &Point)
 
FORCEINLINE FVector ClampVector(const FVector &V, const FVector &Min, const FVector &Max)
 
FORCEINLINE FVector operator*(float Scale, const FVector &V)
 
ApiUtils & operator=(ApiUtils &&)=delete
 
void SetCheatManager(UShooterCheatManager *cheatmanager)
 
void SetWorld(UWorld *uworld)
 
ApiUtils & operator=(const ApiUtils &)=delete
 
void SetShooterGameMode(AShooterGameMode *shooter_game_mode)
 
std::unordered_map< uint64, AShooterPlayerController * > steam_id_map_
 
UShooterCheatManager * GetCheatManager() const override
Returns a point to URCON CheatManager.
 
ApiUtils(ApiUtils &&)=delete
 
AShooterGameMode * shooter_game_mode_
 
AShooterGameMode * GetShooterGameMode() const override
Returns a pointer to AShooterGameMode.
 
void RemovePlayerController(AShooterPlayerController *player_controller)
 
UShooterCheatManager * cheatmanager_
 
void SetPlayerController(AShooterPlayerController *player_controller)
 
ServerStatus GetStatus() const override
Returns the current server status.
 
AShooterPlayerController * FindPlayerFromSteamId_Internal(uint64 steam_id) const override
 
~ApiUtils() override=default
 
void SetStatus(ServerStatus status)
 
UWorld * GetWorld() const override
Returns a pointer to UWorld.
 
ApiUtils(const ApiUtils &)=delete
 
static FString GetSteamName(AController *player_controller)
Returns the steam name of player.
 
static FORCEINLINE FString GetItemBlueprint(UPrimalItem *item)
Returns blueprint from UPrimalItem.
 
static FVector GetPosition(APlayerController *player_controller)
Returns the position of a player.
 
uint64 GetSteamIDForPlayerID(int player_id) const
 
static FORCEINLINE FString GetClassBlueprint(UClass *the_class)
Returns blueprint path from any UClass.
 
void SendServerMessageToAll(FLinearColor msg_color, const T *msg, Args &&... args)
Sends server message to all players. Using fmt::format.
 
virtual UShooterCheatManager * GetCheatManager() const =0
Returns a point to URCON CheatManager.
 
UPrimalGameData * GetGameData()
Returns pointer to Primal Game Data.
 
static bool IsRidingDino(AShooterPlayerController *player_controller)
Returns true if character is riding a dino, false otherwise.
 
AShooterGameState * GetGameState()
Get Shooter Game State.
 
virtual ~IApiUtils()=default
 
AShooterPlayerController * FindPlayerFromSteamName(const FString &steam_name) const
Finds player from the given steam name.
 
static UShooterCheatManager * GetCheatManagerByPC(AShooterPlayerController *SPC)
Get UShooterCheatManager* of player controller.
 
static uint64 GetPlayerID(AController *controller)
 
static bool IsPlayerDead(AShooterPlayerController *player)
Returns true if player is dead, false otherwise.
 
void SendNotificationToAll(FLinearColor color, float display_scale, float display_time, UTexture2D *icon, const T *msg, Args &&... args)
Sends notification (on-screen message) to all players. Using fmt::format.
 
APrimalDinoCharacter * SpawnDino(AShooterPlayerController *player, FString blueprint, FVector *location, int lvl, bool force_tame, bool neutered) const
Spawns a dino near player or at specific coordinates.
 
TArray< AShooterPlayerController * > FindPlayerFromCharacterName(const FString &character_name, ESearchCase::Type search, bool full_match) const
Finds all matching players from the given character name.
 
static FORCEINLINE FString GetBlueprint(UObjectBase *object)
Returns blueprint path from any UObject.
 
static FString GetCharacterName(AShooterPlayerController *player_controller, bool include_first_name=true, bool include_last_name=true)
Returns the character name of player.
 
TArray< AActor * > GetAllActorsInRange(FVector location, float radius, EServerOctreeGroup::Type ActorType)
Gets all actors in radius at location.
 
void SendChatMessageToAll(const FString &sender_name, const T *msg, Args &&... args)
Sends chat message to all players. Using fmt::format.
 
TArray< AActor * > GetAllActorsInRange(FVector location, float radius, EServerOctreeGroup::Type ActorType, TArray< AActor * > ignores)
Gets all actors in radius at location, with ignore actors.
 
virtual AShooterGameMode * GetShooterGameMode() const =0
Returns a pointer to AShooterGameMode.
 
static uint64 GetSteamIdFromController(AController *controller)
Returns Steam ID from player controller.
 
virtual UWorld * GetWorld() const =0
Returns a pointer to UWorld.
 
static bool TeleportToPos(AShooterPlayerController *player_controller, const FVector &pos)
Teleports player to the given position.
 
void SendNotification(AShooterPlayerController *player_controller, FLinearColor color, float display_scale, float display_time, UTexture2D *icon, const T *msg, Args &&... args)
Sends notification (on-screen message) to the specific player. Using fmt::format.
 
static uint64 GetPlayerID(APrimalCharacter *character)
 
virtual AShooterPlayerController * FindPlayerFromSteamId_Internal(uint64 steam_id) const =0
 
AShooterPlayerController * FindControllerFromCharacter(AShooterCharacter *character) const
Finds player controller from the given player character.
 
static APrimalDinoCharacter * GetRidingDino(AShooterPlayerController *player_controller)
Returns the dino the character is riding.
 
static FString GetIPAddress(AShooterPlayerController *player_controller)
Returns IP address of player.
 
AShooterPlayerController * FindPlayerFromSteamId(uint64 steam_id) const
Finds player from the given steam id.
 
virtual ServerStatus GetStatus() const =0
Returns the current server status.
 
void SendServerMessage(AShooterPlayerController *player_controller, FLinearColor msg_color, const T *msg, Args &&... args)
Sends server message to the specific player. Using fmt::format.
 
static std::optional< FString > TeleportToPlayer(AShooterPlayerController *me, AShooterPlayerController *him, bool check_for_dino, float max_dist)
Teleport one player to another.
 
static int GetInventoryItemCount(AShooterPlayerController *player_controller, const FString &item_name)
Counts a specific items quantity.
 
void SendChatMessage(AShooterPlayerController *player_controller, const FString &sender_name, const T *msg, Args &&... args)
Sends chat message to the specific player. Using fmt::format.
 
BitFieldValue & operator=(RT other)
 
DataValue & operator=(const T &other)
 
void MoveToEmpty(ForElementType &Other)
 
int32 CalculateSlackGrow(int32 NumElements, int32 CurrentNumSlackElements, SIZE_T NumBytesPerElement) const
 
int32 CalculateSlack(int32 NumElements, int32 CurrentNumSlackElements, SIZE_T NumBytesPerElement) const
 
int32 CalculateSlackShrink(int32 NumElements, int32 CurrentNumSlackElements, SIZE_T NumBytesPerElement) const
 
SIZE_T GetAllocatedSize(int32 NumAllocatedElements, SIZE_T NumBytesPerElement) const
 
void ResizeAllocation(int32 PreviousNumElements, int32 NumElements, SIZE_T NumBytesPerElement)
 
ElementType * GetAllocation() const
 
ForElementType< FScriptContainerElement > ForAnyElementType
 
TInlineAllocator< 4 > Typedef
 
TSparseArrayAllocator Typedef
 
static int32 GCD(int32 A, int32 B)
 
FORCEINLINE FScriptContainerElement * GetAllocation() const
 
FORCEINLINE void ResizeAllocation(int32 PreviousNumElements, int32 NumElements, SIZE_T NumBytesPerElement)
 
FORCEINLINE int32 CalculateSlackGrow(int32 NumElements, int32 NumAllocatedElements, int32 NumBytesPerElement) const
 
SIZE_T GetAllocatedSize(int32 NumAllocatedElements, SIZE_T NumBytesPerElement) const
 
FScriptContainerElement * Data
 
ForAnyElementType & operator=(const ForAnyElementType &)
 
ForAnyElementType(const ForAnyElementType &)
 
FORCEINLINE int32 CalculateSlackReserve(int32 NumElements, int32 NumBytesPerElement) const
 
FORCEINLINE int32 CalculateSlackShrink(int32 NumElements, int32 NumAllocatedElements, int32 NumBytesPerElement) const
 
FORCEINLINE ~ForAnyElementType()
 
FORCEINLINE void MoveToEmpty(ForAnyElementType &Other)
 
FORCEINLINE ElementType * GetAllocation() const
 
FNoncopyable(const FNoncopyable &)
 
FNoncopyable & operator=(const FNoncopyable &)
 
FORCEINLINE const DataType & GetCharArray() const
 
FORCEINLINE friend bool operator<=(const FString &Lhs, const CharType *Rhs)
 
FORCEINLINE void RemoveAt(int32 Index, int32 Count=1, bool bAllowShrinking=true)
 
FORCEINLINE friend FString operator+(FString &&Lhs, FString &&Rhs)
 
FORCEINLINE FString & Append(const FString &Text)
 
FORCEINLINE uint32 GetAllocatedSize() const
 
FString TrimStart() const &
 
int32 Find(const TCHAR *SubStr, ESearchCase::Type SearchCase=ESearchCase::IgnoreCase, ESearchDir::Type SearchDir=ESearchDir::FromStart, int32 StartPosition=INDEX_NONE) const
 
FORCEINLINE friend FString operator/(const FString &Lhs, const FString &Rhs)
 
FORCEINLINE FString(const std::string &str)
 
int32 ParseIntoArray(TArray< FString > &OutArray, const TCHAR **DelimArray, int32 NumDelims, bool InCullEmpty=true) const
 
FORCEINLINE friend FString operator+(const FString &Lhs, const TCHAR *Rhs)
 
FORCEINLINE friend bool operator!=(const FString &Lhs, const CharType *Rhs)
 
FORCEINLINE int32 Find(const FString &SubStr, ESearchCase::Type SearchCase=ESearchCase::IgnoreCase, ESearchDir::Type SearchDir=ESearchDir::FromStart, int32 StartPosition=INDEX_NONE) const
 
FORCEINLINE friend DataType::RangedForIteratorType end(FString &Str)
 
FORCEINLINE friend FString operator+(FString &&Lhs, const FString &Rhs)
 
FString(FString &&)=default
 
FORCEINLINE FString & operator=(const TCHAR *Other)
 
FORCEINLINE friend bool operator<(const CharType *Lhs, const FString &Rhs)
 
FString TrimEnd() const &
 
FString Replace(const TCHAR *From, const TCHAR *To, ESearchCase::Type SearchCase=ESearchCase::IgnoreCase) const
 
FORCEINLINE FString LeftChop(int32 Count) const
 
FORCEINLINE bool FindChar(TCHAR InChar, int32 &Index) const
 
FORCEINLINE friend bool operator!=(const FString &Lhs, const FString &Rhs)
 
int32 ReplaceInline(const TCHAR *SearchText, const TCHAR *ReplacementText, ESearchCase::Type SearchCase=ESearchCase::IgnoreCase)
 
FORCEINLINE FString Mid(int32 Start, int32 Count=INT_MAX) const
 
FORCEINLINE FString(FString &&Other, int32 ExtraSlack)
 
static FORCEINLINE FString ConcatFStrings(typename TIdentity< LhsType >::Type Lhs, typename TIdentity< RhsType >::Type Rhs)
 
static FString Chr(TCHAR Ch)
 
FORCEINLINE friend DataType::RangedForIteratorType begin(FString &Str)
 
FORCEINLINE friend FString operator+(const FString &Lhs, FString &&Rhs)
 
FORCEINLINE DataType & GetCharArray()
 
FORCEINLINE friend bool operator==(const FString &Lhs, const CharType *Rhs)
 
static FORCEINLINE FString FromInt(int32 Num)
 
FORCEINLINE FString & operator+=(const FString &Str)
 
FString & Append(const TCHAR *Text, int32 Count)
 
FORCEINLINE FString & operator/=(const FString &Str)
 
FORCEINLINE friend FString operator+(const FString &Lhs, const FString &Rhs)
 
FORCEINLINE int32 Compare(const FString &Other, ESearchCase::Type SearchCase=ESearchCase::CaseSensitive) const
 
FORCEINLINE friend bool operator<=(const CharType *Lhs, const FString &Rhs)
 
FORCEINLINE friend bool operator==(const FString &Lhs, const FString &Rhs)
 
FString TrimStartAndEnd() &&
 
FORCEINLINE friend FString operator+(const TCHAR *Lhs, const FString &Rhs)
 
FORCEINLINE TIterator CreateIterator()
 
FORCEINLINE void Reserve(const uint32 CharacterCount)
 
FString ReplaceQuotesWithEscapedQuotes() const
 
FString & operator=(FString &&)=default
 
static int32 CullArray(TArray< FString > *InArray)
 
bool MatchesWildcard(const FString &Wildcard, ESearchCase::Type SearchCase=ESearchCase::IgnoreCase) const
 
FString ConvertTabsToSpaces(const int32 InSpacesPerTab)
 
bool StartsWith(const TCHAR *InSuffix, ESearchCase::Type SearchCase=ESearchCase::IgnoreCase) const
 
FORCEINLINE friend bool operator!=(const CharType *Lhs, const FString &Rhs)
 
static FORCEINLINE FString ConcatTCHARsToFString(const TCHAR *Lhs, typename TIdentity< RhsType >::Type Rhs)
 
FORCEINLINE FString Left(int32 Count) const
 
static bool ToHexBlob(const FString &Source, uint8 *DestBuffer, const uint32 DestSize)
 
int32 ParseIntoArrayLines(TArray< FString > &OutArray, bool InCullEmpty=true) const
 
FORCEINLINE bool FindLastChar(TCHAR InChar, int32 &Index) const
 
std::string ToString() const
Convert FString to std::string.
 
FString TrimQuotes(bool *bQuotesRemoved=nullptr) const
 
FORCEINLINE FString & operator+=(const TCHAR *Str)
 
void AppendInt(int32 InNum)
 
FORCEINLINE const TCHAR * operator*() const
 
FORCEINLINE friend FString operator/(FString &&Lhs, const TCHAR *Rhs)
 
FORCEINLINE friend FString operator/(FString &&Lhs, const FString &Rhs)
 
FString RightPad(int32 ChCount) const
 
FORCEINLINE friend TEnableIf< TIsCharType< CharType >::Value, FString >::Type operator+(const FString &Lhs, CharType Rhs)
 
FORCEINLINE friend DataType::RangedForConstIteratorType end(const FString &Str)
 
void PathAppend(const TCHAR *Str, int32 StrLength)
 
FORCEINLINE bool Contains(const FString &SubStr, ESearchCase::Type SearchCase=ESearchCase::IgnoreCase, ESearchDir::Type SearchDir=ESearchDir::FromStart) const
 
FORCEINLINE FString(const CharType *Src, typename TEnableIf< TIsCharType< CharType >::Value >::Type *Dummy=nullptr)
 
FORCEINLINE FString RightChop(int32 Count) const
 
bool EndsWith(const FString &InSuffix, ESearchCase::Type SearchCase=ESearchCase::IgnoreCase) const
 
static FString ChrN(int32 NumCharacters, TCHAR Char)
 
static FORCEINLINE FString ConcatFStringToTCHARs(typename TIdentity< LhsType >::Type Lhs, const TCHAR *Rhs)
 
FORCEINLINE friend FString operator+(const TCHAR *Lhs, FString &&Rhs)
 
FORCEINLINE TConstIterator CreateConstIterator() const
 
bool StartsWith(const FString &InPrefix, ESearchCase::Type SearchCase=ESearchCase::IgnoreCase) const
 
FString ToUpper() const &
 
FString(const FString &)=default
 
static FString FormatAsNumber(int32 InNumber)
 
FORCEINLINE bool Equals(const FString &Other, ESearchCase::Type SearchCase=ESearchCase::CaseSensitive) const
 
FORCEINLINE bool IsValidIndex(int32 Index) const
 
FORCEINLINE friend FString operator/(const FString &Lhs, const TCHAR *Rhs)
 
void TrimStartAndEndInline()
 
int32 ParseIntoArray(TArray< FString > &OutArray, const TCHAR *pchDelim, bool InCullEmpty=true) const
 
bool EndsWith(const TCHAR *InSuffix, ESearchCase::Type SearchCase=ESearchCase::IgnoreCase) const
 
FORCEINLINE FString(int32 InCount, const TCHAR *InSrc)
 
FORCEINLINE friend DataType::RangedForConstIteratorType begin(const FString &Str)
 
FORCEINLINE friend bool operator>(const FString &Lhs, const CharType *Rhs)
 
FString ReplaceCharWithEscapedChar(const TArray< TCHAR > *Chars=nullptr) const
 
static bool ToBlob(const FString &Source, uint8 *DestBuffer, const uint32 DestSize)
 
FORCEINLINE TCHAR & operator[](int32 Index)
 
FORCEINLINE void InsertAt(int32 Index, TCHAR Character)
 
FORCEINLINE friend bool operator>=(const CharType *Lhs, const FString &Rhs)
 
FORCEINLINE friend FString operator/(const TCHAR *Lhs, const FString &Rhs)
 
FORCEINLINE void AppendChars(const TCHAR *Array, int32 Count)
 
FORCEINLINE friend TEnableIf< TIsCharType< CharType >::Value, FString >::Type operator+(FString &&Lhs, CharType Rhs)
 
FORCEINLINE void Shrink()
 
FORCEINLINE friend bool operator>(const CharType *Lhs, const FString &Rhs)
 
FORCEINLINE bool IsEmpty() const
 
FORCEINLINE FString Right(int32 Count) const
 
FORCEINLINE void InsertAt(int32 Index, const FString &Characters)
 
FORCEINLINE bool Contains(const TCHAR *SubStr, ESearchCase::Type SearchCase=ESearchCase::IgnoreCase, ESearchDir::Type SearchDir=ESearchDir::FromStart) const
 
FORCEINLINE friend bool operator>(const FString &Lhs, const FString &Rhs)
 
FORCEINLINE friend bool operator==(const CharType *Lhs, const FString &Rhs)
 
FORCEINLINE friend bool operator<(const FString &Lhs, const CharType *Rhs)
 
static FString Join(const TArray< T, Allocator > &Array, const TCHAR *Separator)
 
bool RemoveFromEnd(const FString &InSuffix, ESearchCase::Type SearchCase=ESearchCase::IgnoreCase)
 
FORCEINLINE TEnableIf< TIsCharType< CharType >::Value, FString & >::Type operator+=(CharType InChar)
 
FORCEINLINE const TCHAR & operator[](int32 Index) const
 
FORCEINLINE friend bool operator<(const FString &Lhs, const FString &Rhs)
 
FORCEINLINE friend bool operator>=(const FString &Lhs, const FString &Rhs)
 
FString ToLower() const &
 
int32 ParseIntoArrayWS(TArray< FString > &OutArray, const TCHAR *pchExtraDelim=nullptr, bool InCullEmpty=true) const
 
bool Split(const FString &InS, FString *LeftS, FString *RightS, ESearchCase::Type SearchCase=ESearchCase::IgnoreCase, ESearchDir::Type SearchDir=ESearchDir::FromStart) const
 
static FString Format(const T *format, Args &&... args)
Formats text using fmt::format.
 
FString LeftPad(int32 ChCount) const
 
FORCEINLINE int32 FindLastCharByPredicate(Predicate Pred) const
 
FORCEINLINE void Reset(int32 NewReservedSize=0)
 
FORCEINLINE void Empty(int32 Slack=0)
 
FORCEINLINE int32 Len() const
 
FORCEINLINE int32 FindLastCharByPredicate(Predicate Pred, int32 Count) const
 
void TrimToNullTerminator()
 
bool RemoveFromStart(const FString &InPrefix, ESearchCase::Type SearchCase=ESearchCase::IgnoreCase)
 
FORCEINLINE FString & AppendChar(const TCHAR InChar)
 
FORCEINLINE friend bool operator>=(const FString &Lhs, const CharType *Rhs)
 
FORCEINLINE friend bool operator<=(const FString &Lhs, const FString &Rhs)
 
FORCEINLINE void CheckInvariants() const
 
FORCEINLINE friend FString operator+(FString &&Lhs, const TCHAR *Rhs)
 
FString ReplaceEscapedCharWithChar(const TArray< TCHAR > *Chars=nullptr) const
 
FORCEINLINE FString(const FString &Other, int32 ExtraSlack)
 
FORCEINLINE FString & operator/=(const TCHAR *Str)
 
FString & operator=(const FString &)=default
 
FString TrimStartAndEnd() const &
 
FieldArray & operator=(const T &other)=delete
 
std::shared_ptr< spdlog::logger > logger_
 
Log & operator=(Log &&)=delete
 
static std::shared_ptr< spdlog::logger > & GetLog()
 
Log & operator=(const Log &)=delete
 
FORCEINLINE int32 CalculateSlackReserve(int32 NumElements, int32 NumBytesPerElement) const
 
ForAnyElementType(const ForAnyElementType &)
 
SIZE_T GetAllocatedSize(int32 NumAllocatedElements, SIZE_T NumBytesPerElement) const
 
FORCEINLINE int32 CalculateSlackShrink(int32 NumElements, int32 NumAllocatedElements, int32 NumBytesPerElement) const
 
FScriptContainerElement * Data
 
FORCEINLINE ~ForAnyElementType()
 
FORCEINLINE void MoveToEmpty(ForAnyElementType &Other)
 
void ResizeAllocation(int32 PreviousNumElements, int32 NumElements, SIZE_T NumBytesPerElement)
 
FORCEINLINE FScriptContainerElement * GetAllocation() const
 
ForAnyElementType & operator=(const ForAnyElementType &)
 
FORCEINLINE int32 CalculateSlackGrow(int32 NumElements, int32 NumAllocatedElements, int32 NumBytesPerElement) const
 
FORCEINLINE ElementType * GetAllocation() const
 
FORCEINLINE bool Find(const ElementType &Item, int32 &Index) const
 
void RemoveAtImpl(int32 Index, int32 Count, bool bAllowShrinking)
 
TArray & operator=(TArray &&Other)
 
TCheckedPointerIterator< const ElementType > RangedForConstIteratorType
 
int32 AddUniqueImpl(ArgsType &&Args)
 
TArray & operator=(std::initializer_list< InElementType > InitList)
 
void SetNumUninitialized(int32 NewNum, bool bAllowShrinking=true)
 
FORCEINLINE int32 Num() const
 
int32 FindLastByPredicate(Predicate Pred, int32 Count) const
 
TIterator CreateIterator()
 
int32 AddZeroed(int32 Count=1)
 
FORCEINLINE int32 Emplace(ArgsType &&... Args)
 
FORCEINLINE int32 Max() const
 
ElementAllocatorType AllocatorInstance
 
FORCENOINLINE void ResizeTo(int32 NewMax)
 
InElementType ElementType
 
int32 RemoveAll(const PREDICATE_CLASS &Predicate)
 
void SetNumZeroed(int32 NewNum, bool bAllowShrinking=true)
 
void InsertZeroed(int32 Index, int32 Count=1)
 
static FORCEINLINE TEnableIf<!UE4Array_Private::TCanMoveTArrayPointersBetweenArrayTypes< FromArrayType, ToArrayType >::Value >::Type MoveOrCopy(ToArrayType &ToArray, FromArrayType &FromArray, int32 PrevMax)
 
FORCEINLINE const ElementType & Last(int32 IndexFromTheEnd=0) const
 
TIndexedContainerIterator< TArray, ElementType, int32 > TIterator
 
FORCEINLINE bool operator!=(const TArray &OtherArray) const
 
TCheckedPointerIterator< ElementType > RangedForIteratorType
 
TArray & operator+=(TArray &&Other)
 
static FORCEINLINE TEnableIf< UE4Array_Private::TCanMoveTArrayPointersBetweenArrayTypes< FromArrayType, ToArrayType >::Value >::Type MoveOrCopy(ToArrayType &ToArray, FromArrayType &FromArray, int32 PrevMax)
 
void Init(const ElementType &Element, int32 Number)
 
FORCEINLINE friend RangedForIteratorType end(TArray &Array)
 
FORCEINLINE bool ContainsByPredicate(Predicate Pred) const
 
FORCEINLINE void CheckAddress(const ElementType *Addr) const
 
TIndexedContainerIterator< const TArray, const ElementType, int32 > TConstIterator
 
FORCEINLINE void CheckInvariants() const
 
FORCEINLINE TArray(const TArray &Other, int32 ExtraSlack)
 
FORCEINLINE void RemoveAt(int32 Index, CountType Count, bool bAllowShrinking=true)
 
void StableSort(const PREDICATE_CLASS &Predicate)
 
FORCEINLINE void Append(std::initializer_list< ElementType > InitList)
 
TArray & operator+=(const TArray &Other)
 
FORCEINLINE int32 Add(const ElementType &Item)
 
FORCEINLINE ElementType & Last(int32 IndexFromTheEnd=0)
 
FORCENOINLINE void ResizeGrow(int32 OldNum)
 
FORCEINLINE void EmplaceAt(int32 Index, ArgsType &&... Args)
 
FORCEINLINE const ElementType & operator[](int32 Index) const
 
TArray< ElementType > FilterByPredicate(Predicate Pred) const
 
FORCEINLINE friend RangedForIteratorType begin(TArray &Array)
 
void Append(TArray< OtherElementType, OtherAllocator > &&Source)
 
FORCENOINLINE void ResizeForCopy(int32 NewMax, int32 PrevMax)
 
FORCEINLINE void RemoveAtSwap(int32 Index)
 
int32 Insert(const ElementType *Ptr, int32 Count, int32 Index)
 
FORCEINLINE int32 GetSlack() const
 
FORCEINLINE int32 AddUnique(const ElementType &Item)
 
int32 Find(const ElementType &Item) const
 
void CopyToEmpty(const OtherElementType *OtherData, int32 OtherNum, int32 PrevMax, int32 ExtraSlack)
 
FORCEINLINE void Shrink()
 
void SetNumUnsafeInternal(int32 NewNum)
 
FORCEINLINE const ElementType & Top() const
 
static FORCEINLINE TEnableIf< UE4Array_Private::TCanMoveTArrayPointersBetweenArrayTypes< FromArrayType, ToArrayType >::Value >::Type MoveOrCopyWithSlack(ToArrayType &ToArray, FromArrayType &FromArray, int32 PrevMax, int32 ExtraSlack)
 
int32 RemoveSwap(const ElementType &Item)
 
int32 IndexOfByKey(const KeyType &Key) const
 
void Append(const TArray< OtherElementType, OtherAllocator > &Source)
 
FORCEINLINE TArray(const TArray &Other)
 
FORCEINLINE ElementType & Top()
 
FORCEINLINE friend RangedForConstIteratorType end(const TArray &Array)
 
TArray(std::initializer_list< InElementType > InitList)
 
FORCEINLINE bool FindLast(const ElementType &Item, int32 &Index) const
 
FORCEINLINE int32 AddUnique(ElementType &&Item)
 
FORCEINLINE friend RangedForConstIteratorType begin(const TArray &Array)
 
int32 Insert(const ElementType &Item, int32 Index)
 
FORCEINLINE uint32 GetTypeSize() const
 
TArray & operator+=(std::initializer_list< ElementType > InitList)
 
void Append(const ElementType *Ptr, int32 Count)
 
static FORCEINLINE TEnableIf<!UE4Array_Private::TCanMoveTArrayPointersBetweenArrayTypes< FromArrayType, ToArrayType >::Value >::Type MoveOrCopyWithSlack(ToArrayType &ToArray, FromArrayType &FromArray, int32 PrevMax, int32 ExtraSlack)
 
int32 Insert(ElementType &&Item, int32 Index)
 
FORCEINLINE TArray(TArray &&Other)
 
FORCENOINLINE void ResizeShrink()
 
FORCEINLINE void RangeCheck(int32 Index) const
 
void Reset(int32 NewSize=0)
 
bool Contains(const ComparisonType &Item) const
 
TArray(TArray< OtherElementType, Allocator > &&Other, int32 ExtraSlack)
 
FORCEINLINE void RemoveAt(int32 Index)
 
int32 RemoveSingle(const ElementType &Item)
 
int32 FindLast(const ElementType &Item) const
 
void RemoveAllSwap(const PREDICATE_CLASS &Predicate, bool bAllowShrinking=true)
 
FORCEINLINE ElementType & operator[](int32 Index)
 
TArray & operator=(const TArray &Other)
 
int32 Remove(const ElementType &Item)
 
bool operator==(const TArray &OtherArray) const
 
FORCEINLINE const ElementType * FindByPredicate(Predicate Pred) const
 
FORCEINLINE TArray(const ElementType *Ptr, int32 Count)
 
FORCEINLINE ElementType Pop(bool bAllowShrinking=true)
 
FORCEINLINE int32 FindLastByPredicate(Predicate Pred) const
 
void Empty(int32 Slack=0)
 
TChooseClass< Allocator::NeedsElementType, typenameAllocator::templateForElementType< ElementType >, typenameAllocator::ForAnyElementType >::Result ElementAllocatorType
 
void SetNum(int32 NewNum, bool bAllowShrinking=true)
 
FORCEINLINE const ElementType * FindByKey(const KeyType &Key) const
 
FORCEINLINE void Push(const ElementType &Item)
 
TConstIterator CreateConstIterator() const
 
FORCEINLINE void Reserve(int32 Number)
 
void InsertDefaulted(int32 Index, int32 Count=1)
 
FORCEINLINE int32 AddUninitialized(int32 Count=1)
 
int32 RemoveSingleSwap(const ElementType &Item, bool bAllowShrinking=true)
 
FORCEINLINE TArray(TArray< OtherElementType, OtherAllocator > &&Other)
 
FORCEINLINE ElementType * GetData() const
 
FORCEINLINE bool IsValidIndex(int32 Index) const
 
int32 Insert(std::initializer_list< ElementType > InitList, const int32 InIndex)
 
FORCEINLINE uint32 GetAllocatedSize(void) const
 
int32 Insert(const TArray< ElementType > &Items, const int32 InIndex)
 
FORCEINLINE int32 Add(ElementType &&Item)
 
FORCEINLINE void RemoveAtSwap(int32 Index, CountType Count, bool bAllowShrinking=true)
 
TArray & operator=(const TArray< ElementType, OtherAllocator > &Other)
 
ElementType * FindByPredicate(Predicate Pred)
 
FORCEINLINE TArray(const TArray< OtherElementType, OtherAllocator > &Other)
 
void InsertUninitialized(int32 Index, int32 Count=1)
 
ElementType * FindByKey(const KeyType &Key)
 
void Sort(const PREDICATE_CLASS &Predicate)
 
int32 AddDefaulted(int32 Count=1)
 
void RemoveAtSwapImpl(int32 Index, int32 Count=1, bool bAllowShrinking=true)
 
FORCEINLINE void Push(ElementType &&Item)
 
int32 IndexOfByPredicate(Predicate Pred) const
 
ForElementType & operator=(const ForElementType &)
 
TTypeCompatibleBytes< ElementType > InlineData[NumInlineElements]
 
FORCEINLINE ElementType * GetAllocation() const
 
FORCEINLINE void MoveToEmpty(ForElementType &Other)
 
FORCEINLINE int32 CalculateSlackReserve(int32 NumElements, SIZE_T NumBytesPerElement) const
 
ElementType * GetInlineElements() const
 
SIZE_T GetAllocatedSize(int32 NumAllocatedElements, SIZE_T NumBytesPerElement) const
 
void ResizeAllocation(int32 PreviousNumElements, int32 NumElements, SIZE_T NumBytesPerElement)
 
FORCEINLINE int32 CalculateSlackGrow(int32 NumElements, int32 NumAllocatedElements, int32 NumBytesPerElement) const
 
ForElementType(const ForElementType &)
 
FORCEINLINE int32 CalculateSlackShrink(int32 NumElements, int32 NumAllocatedElements, int32 NumBytesPerElement) const
 
FORCEINLINE friend bool operator!=(const TIndexedContainerIterator &Lhs, const TIndexedContainerIterator &Rhs)
 
ElementType * operator->() const
 
FORCEINLINE friend bool operator==(const TIndexedContainerIterator &Lhs, const TIndexedContainerIterator &Rhs)
 
IndexType GetIndex() const
 
TIndexedContainerIterator operator+(int32 Offset) const
 
TIndexedContainerIterator operator++(int)
 
TIndexedContainerIterator & operator--()
 
TIndexedContainerIterator & operator-=(int32 Offset)
 
FORCEINLINE operator bool() const
 
TIndexedContainerIterator(ContainerType &InContainer, IndexType StartIndex=0)
 
ContainerType & Container
 
TIndexedContainerIterator & operator++()
 
TIndexedContainerIterator & operator+=(int32 Offset)
 
TIndexedContainerIterator operator--(int)
 
TIndexedContainerIterator operator-(int32 Offset) const
 
ElementType & operator*() const
 
FORCEINLINE int32 CalculateSlackReserve(int32 NumElements, SIZE_T NumBytesPerElement) const
 
FORCEINLINE int32 CalculateSlackShrink(int32 NumElements, int32 NumAllocatedElements, int32 NumBytesPerElement) const
 
FORCEINLINE ElementType * GetAllocation() const
 
TTypeCompatibleBytes< ElementType > InlineData[NumInlineElements]
 
ForElementType(const ForElementType &)
 
FORCEINLINE void MoveToEmpty(ForElementType &Other)
 
void ResizeAllocation(int32 PreviousNumElements, int32 NumElements, SIZE_T NumBytesPerElement)
 
ForElementType & operator=(const ForElementType &)
 
SIZE_T GetAllocatedSize(int32 NumAllocatedElements, SIZE_T NumBytesPerElement) const
 
FORCEINLINE int32 CalculateSlackGrow(int32 NumElements, int32 NumAllocatedElements, int32 NumBytesPerElement) const
 
SecondaryAllocator::template ForElementType< ElementType > SecondaryData
 
ElementType * GetInlineElements() const
 
TInlineSparseArrayAllocator< NumInlineElements, typename SecondaryAllocator::SparseArrayAllocator > SparseArrayAllocator
 
static FORCEINLINE uint32 GetNumberOfHashBuckets(uint32 NumHashedElements)
 
TInlineAllocator< NumInlineHashBuckets, typename SecondaryAllocator::HashAllocator > HashAllocator
 
TInlineAllocator< NumInlineElements, typename SecondaryAllocator::ElementAllocator > ElementAllocator
 
TInlineAllocator< InlineBitArrayDWORDs, typename SecondaryAllocator::BitArrayAllocator > BitArrayAllocator
 
static void Rotate(T *First, const int32 From, const int32 To, const int32 Amount)
 
static void Sort(T *First, const int32 Num, const PREDICATE_CLASS &Predicate)
 
static void Merge(T *First, const int32 Mid, const int32 Num, const PREDICATE_CLASS &Predicate)
 
static FORCEINLINE uint32 GetNumberOfHashBuckets(uint32 NumHashedElements)
 
InHashAllocator HashAllocator
 
InSparseArrayAllocator SparseArrayAllocator
 
FORCEINLINE ObjectType * Get() const
 
InBitArrayAllocator BitArrayAllocator
 
InElementAllocator ElementAllocator
 
ArgList(ULongLong types, const internal::Value *values)
 
internal::Arg::Type type(unsigned index) const
 
friend class internal::ArgMap
 
internal::Arg operator[](unsigned index) const
 
static internal::Arg::Type type(uint64_t types, unsigned index)
 
ArgList(ULongLong types, const internal::Arg *args)
 
void report_unhandled_arg()
 
Result visit_custom(Arg::CustomValue)
 
Result visit(const Arg &arg)
 
Result visit_double(double value)
 
Result visit_uint(unsigned value)
 
Result visit_cstring(const char *)
 
Result visit_pointer(const void *)
 
Result visit_unhandled_arg()
 
Result visit_any_double(T)
 
Result visit_long_double(long double value)
 
Result visit_long_long(LongLong value)
 
Result visit_wstring(Arg::StringValue< wchar_t >)
 
Result visit_string(Arg::StringValue< char >)
 
Result visit_ulong_long(ULongLong value)
 
Result visit_int(int value)
 
Result visit_bool(bool value)
 
Result visit_char(int value)
 
BasicArrayWriter(Char *array, std::size_t size)
 
internal::FixedBuffer< Char > buffer_
 
BasicArrayWriter(Char(&array)[SIZE])
 
const Char * c_str() const
 
BasicCStringRef(const Char *s)
 
BasicStringRef(const Char *s)
 
friend bool operator!=(BasicStringRef lhs, BasicStringRef rhs)
 
friend bool operator<(BasicStringRef lhs, BasicStringRef rhs)
 
const Char * data() const
 
friend bool operator<=(BasicStringRef lhs, BasicStringRef rhs)
 
friend bool operator>(BasicStringRef lhs, BasicStringRef rhs)
 
std::basic_string< Char > to_string() const
 
friend bool operator>=(BasicStringRef lhs, BasicStringRef rhs)
 
BasicStringRef(const Char *s, std::size_t size)
 
friend bool operator==(BasicStringRef lhs, BasicStringRef rhs)
 
int compare(BasicStringRef other) const
 
static CharPtr fill_padding(CharPtr buffer, unsigned total_size, std::size_t content_size, wchar_t fill)
 
void write_decimal(Int value)
 
void append_float_length(Char *&, T)
 
void write_int(T value, Spec spec)
 
static Char * get(Char *p)
 
friend class BasicPrintfArgFormatter
 
BasicWriter(Buffer< Char > &b)
 
CharPtr prepare_int_buffer(unsigned num_digits, const Spec &spec, const char *prefix, unsigned prefix_size)
 
Char * write_unsigned_decimal(UInt value, unsigned prefix_size=0)
 
void append_float_length(Char *&format_ptr, long double)
 
void operator<<(typename internal::WCharHelper< const wchar_t *, Char >::Unsupported)
 
CharPtr grow_buffer(std::size_t n)
 
void write_str(const internal::Arg::StringValue< StrChar > &str, const Spec &spec)
 
const Char * data() const FMT_NOEXCEPT
 
std::basic_string< Char > str() const
 
void clear() FMT_NOEXCEPT
 
CharPtr write_str(const StrChar *s, std::size_t size, const AlignSpec &spec)
 
void write(BasicCStringRef< Char > format, ArgList args)
 
Buffer< Char > & buffer() FMT_NOEXCEPT
 
CharPtr prepare_int_buffer(unsigned num_digits, const EmptySpec &, const char *prefix, unsigned prefix_size)
 
void operator<<(typename internal::WCharHelper< wchar_t, Char >::Unsupported)
 
internal::CharTraits< Char >::CharPtr CharPtr
 
void write_double(T value, const Spec &spec)
 
const Char * c_str() const
 
void resize(std::size_t new_size)
 
void push_back(const T &value)
 
void clear() FMT_NOEXCEPT
 
void append(const U *begin, const U *end)
 
void reserve(std::size_t capacity)
 
virtual void grow(std::size_t size)=0
 
Buffer(T *ptr=FMT_NULL, std::size_t capacity=0)
 
T & operator[](std::size_t index)
 
std::size_t capacity() const
 
const T & operator[](std::size_t index) const
 
SystemError(int error_code, CStringRef message)
 
FMT_API ~SystemError() FMT_DTOR_NOEXCEPT FMT_OVERRIDE
 
FMT_API void init(int err_code, CStringRef format_str, ArgList args)
 
void init(const ArgList &args)
 
static Char cast(int value)
 
static char convert(char value)
 
static char convert(wchar_t)
 
static wchar_t convert(char value)
 
static wchar_t convert(wchar_t value)
 
MakeValue(unsigned long value)
 
MakeValue(typename WCharHelper< wchar_t, Char >::Unsupported)
 
MakeValue(typename WCharHelper< WStringRef, Char >::Unsupported)
 
static uint64_t type(long)
 
MakeValue(typename WCharHelper< const wchar_t *, Char >::Unsupported)
 
MakeValue(typename WCharHelper< wchar_t *, Char >::Unsupported)
 
void set_string(WStringRef str)
 
static uint64_t type(unsigned long)
 
void set_string(StringRef str)
 
MakeValue(const T *value)
 
static void format_custom_arg(void *formatter, const void *arg, void *format_str_ptr)
 
RuntimeError(const RuntimeError &rerr)
 
FMT_API ~RuntimeError() FMT_DTOR_NOEXCEPT FMT_OVERRIDE
 
ThousandsSep(fmt::StringRef sep)
 
void operator()(Char *&buffer)
 
void _set_formatter(spdlog::formatter_ptr msg_formatter) override
 
void format(details::log_msg &msg) override
 
std::unique_ptr< details::async_log_helper > _async_log_helper
 
pattern_formatter(const pattern_formatter &)=delete
 
void _sink_it(details::log_msg &msg) override
 
std::tm get_time(details::log_msg &msg)
 
pattern_formatter & operator=(const pattern_formatter &)=delete
 
void handle_flag(char flag)
 
const std::string _pattern
 
const pattern_time_type _pattern_time
 
virtual log_err_handler error_handler() override
 
std::vector< std::unique_ptr< details::flag_formatter > > _formatters
 
const std::chrono::seconds cache_refresh
 
log_clock::time_point _last_update
 
void format(details::log_msg &msg, const std::tm &tm_time) override
 
z_formatter & operator=(const z_formatter &)=delete
 
int get_cached_offset(const log_msg &msg, const std::tm &tm_time)
 
void format(details::log_msg &msg, const std::tm &) override
 
z_formatter(const z_formatter &)=delete
 
static void sleep_or_yield(const spdlog::log_clock::time_point &now, const log_clock::time_point &last_op_time)
 
void log(const details::log_msg &msg)
 
const std::function< void()> _worker_teardown_cb
 
void push_msg(async_msg &&new_msg)
 
void flush(bool wait_for_q)
 
void handle_flush_interval(log_clock::time_point &now, log_clock::time_point &last_flush)
 
async_log_helper(formatter_ptr formatter, const std::vector< sink_ptr > &sinks, size_t queue_size, const log_err_handler err_handler, const async_overflow_policy overflow_policy=async_overflow_policy::block_retry, const std::function< void()> &worker_warmup_cb=nullptr, const std::chrono::milliseconds &flush_interval_ms=std::chrono::milliseconds::zero(), const std::function< void()> &worker_teardown_cb=nullptr)
 
const async_overflow_policy _overflow_policy
 
std::vector< std::shared_ptr< sinks::sink > > _sinks
 
bool _terminate_requested
 
std::thread _worker_thread
 
const std::function< void()> _worker_warmup_cb
 
bool process_next_msg(log_clock::time_point &last_pop, log_clock::time_point &last_flush)
 
const std::chrono::milliseconds _flush_interval_ms
 
log_err_handler _err_handler
 
void set_formatter(formatter_ptr)
 
void set_error_handler(spdlog::log_err_handler err_handler)
 
void reopen(bool truncate)
 
const filename_t & filename() const
 
file_helper(const file_helper &)=delete
 
void write(const log_msg &msg)
 
file_helper & operator=(const file_helper &)=delete
 
std::atomic< size_t > dequeue_pos_
 
char cacheline_pad_t[cacheline_size]
 
mpmc_bounded_queue(mpmc_bounded_queue const &)=delete
 
void operator=(mpmc_bounded_queue const &)=delete
 
std::atomic< size_t > enqueue_pos_
 
size_t const buffer_mask_
 
static size_t const cacheline_size
 
mpmc_bounded_queue(size_t buffer_size)
 
void set_async_mode(size_t q_size, const async_overflow_policy overflow_policy, const std::function< void()> &worker_warmup_cb, const std::chrono::milliseconds &flush_interval_ms, const std::function< void()> &worker_teardown_cb)
 
std::function< void()> _worker_warmup_cb
 
std::function< void()> _worker_teardown_cb
 
void formatter(formatter_ptr f)
 
std::shared_ptr< async_logger > create_async(const std::string &logger_name, size_t queue_size, const async_overflow_policy overflow_policy, const std::function< void()> &worker_warmup_cb, const std::chrono::milliseconds &flush_interval_ms, const std::function< void()> &worker_teardown_cb, const It &sinks_begin, const It &sinks_end)
 
void throw_if_exists(const std::string &logger_name)
 
void drop(const std::string &logger_name)
 
std::shared_ptr< logger > create(const std::string &logger_name, sink_ptr sink)
 
std::chrono::milliseconds _flush_interval_ms
 
void apply_all(std::function< void(std::shared_ptr< logger >)> fun)
 
std::shared_ptr< async_logger > create_async(const std::string &logger_name, size_t queue_size, const async_overflow_policy overflow_policy, const std::function< void()> &worker_warmup_cb, const std::chrono::milliseconds &flush_interval_ms, const std::function< void()> &worker_teardown_cb, sinks_init_list sinks)
 
void register_logger(std::shared_ptr< logger > logger)
 
log_err_handler _err_handler
 
void set_error_handler(log_err_handler handler)
 
std::shared_ptr< logger > create(const std::string &logger_name, sinks_init_list sinks)
 
void set_pattern(const std::string &pattern)
 
registry_t< Mutex > & operator=(const registry_t< Mutex > &)=delete
 
void set_level(level::level_enum log_level)
 
std::shared_ptr< logger > get(const std::string &logger_name)
 
std::shared_ptr< logger > create(const std::string &logger_name, const It &sinks_begin, const It &sinks_end)
 
std::shared_ptr< async_logger > create_async(const std::string &logger_name, size_t queue_size, const async_overflow_policy overflow_policy, const std::function< void()> &worker_warmup_cb, const std::chrono::milliseconds &flush_interval_ms, const std::function< void()> &worker_teardown_cb, sink_ptr sink)
 
async_overflow_policy _overflow_policy
 
static registry_t< Mutex > & instance()
 
const std::vector< sink_ptr > & sinks() const
 
std::atomic< time_t > _last_err_time
 
void log(level::level_enum lvl, const T &)
 
void log(level::level_enum lvl, const char *fmt, const Args &... args)
 
log_err_handler _err_handler
 
void debug(const char *fmt, const Arg1 &, const Args &... args)
 
void trace(const char *fmt, const Arg1 &, const Args &... args)
 
bool should_log(level::level_enum) const
 
void log(level::level_enum lvl, const char *msg)
 
void flush_on(level::level_enum log_level)
 
virtual log_err_handler error_handler()
 
spdlog::level_t _flush_level
 
void set_formatter(formatter_ptr)
 
void warn(const char *fmt, const Arg1 &, const Args &... args)
 
void info(const char *fmt, const Arg1 &, const Args &... args)
 
void error(const char *fmt, const Arg1 &, const Args &... args)
 
logger & operator=(const logger &)=delete
 
std::vector< sink_ptr > _sinks
 
logger(const logger &)=delete
 
std::atomic< size_t > _msg_counter
 
bool _should_flush_on(const details::log_msg &)
 
const std::string & name() const
 
virtual void _sink_it(details::log_msg &)
 
void critical(const char *fmt, const Arg1 &, const Args &... args)
 
virtual void _set_formatter(formatter_ptr)
 
void _incr_msg_counter(details::log_msg &msg)
 
void set_level(level::level_enum)
 
daily_file_sink(const filename_t &base_filename, int rotation_hour, int rotation_minute)
 
details::file_helper _file_helper
 
void _sink_it(const details::log_msg &msg) override
 
void set_force_flush(bool force_flush)
 
static std::shared_ptr< MyType > instance()
 
simple_file_sink(const filename_t &filename, bool truncate=false)
 
std::chrono::system_clock::time_point _next_rotation_tp()
 
std::chrono::system_clock::time_point _rotation_tp
 
rotating_file_sink(const filename_t &base_filename, std::size_t max_size, std::size_t max_files)
 
std::size_t _current_size
 
static filename_t calc_filename(const filename_t &filename, std::size_t index)
 
filename_t _base_filename
 
virtual ~base_sink()=default
 
base_sink & operator=(const base_sink &)=delete
 
void log(const details::log_msg &msg) SPDLOG_FINAL override
 
void flush() SPDLOG_FINAL override
 
virtual void _sink_it(const details::log_msg &msg)=0
 
base_sink(const base_sink &)=delete
 
void set_level(level::level_enum log_level)
 
bool should_log(level::level_enum msg_level) const
 
virtual void log(const details::log_msg &msg)=0
 
const char * what() const SPDLOG_NOEXCEPT override
 
#define SPDLOG_LEVEL_NAMES
 
FORCEINLINE int32 LowerBoundBy(RangeType &Range, const ValueType &Value, ProjectionType Projection, SortPredicateType SortPredicate)
 
FORCEINLINE int32 LowerBoundBy(RangeType &Range, const ValueType &Value, ProjectionType Projection)
 
FORCEINLINE int32 UpperBoundBy(RangeType &Range, const ValueType &Value, ProjectionType Projection)
 
FORCEINLINE int32 UpperBound(RangeType &Range, const ValueType &Value)
 
FORCEINLINE int32 BinarySearchBy(RangeType &Range, const ValueType &Value, ProjectionType Projection)
 
FORCEINLINE int32 BinarySearchBy(RangeType &Range, const ValueType &Value, ProjectionType Projection, SortPredicateType SortPredicate)
 
FORCEINLINE int32 UpperBoundBy(RangeType &Range, const ValueType &Value, ProjectionType Projection, SortPredicateType SortPredicate)
 
FORCEINLINE int32 BinarySearch(RangeType &Range, const ValueType &Value, SortPredicateType SortPredicate)
 
FORCEINLINE int32 BinarySearch(RangeType &Range, const ValueType &Value)
 
FORCEINLINE int32 UpperBound(RangeType &Range, const ValueType &Value, SortPredicateType SortPredicate)
 
FORCEINLINE int32 LowerBound(RangeType &Range, const ValueType &Value, SortPredicateType SortPredicate)
 
FORCEINLINE int32 LowerBound(RangeType &Range, const ValueType &Value)
 
FORCEINLINE SIZE_T UpperBoundInternal(RangeValueType *First, const SIZE_T Num, const PredicateValueType &Value, ProjectionType Projection, SortPredicateType SortPredicate)
 
FORCEINLINE SIZE_T LowerBoundInternal(RangeValueType *First, const SIZE_T Num, const PredicateValueType &Value, ProjectionType Projection, SortPredicateType SortPredicate)
 
IApiUtils & GetApiUtils()
 
void FromString(float &OutValue, const TCHAR *Buffer)
 
void FromString(int8 &OutValue, const TCHAR *Buffer)
 
void FromString(uint8 &OutValue, const TCHAR *Buffer)
 
void FromString(uint32 &OutValue, const TCHAR *Buffer)
 
TEnableIf< TIsCharType< CharType >::Value, FString >::Type ToString(const CharType *Ptr)
 
void FromString(int32 &OutValue, const TCHAR *Buffer)
 
void FromString(uint64 &OutValue, const TCHAR *Buffer)
 
FString ToSanitizedString(const T &Value)
 
void FromString(FString &OutValue, const TCHAR *Buffer)
 
void FromString(double &OutValue, const TCHAR *Buffer)
 
void FromString(uint16 &OutValue, const TCHAR *Buffer)
 
static TEnableIf< TIsArithmetic< T >::Value, bool >::Type TryParseString(T &OutValue, const TCHAR *Buffer)
 
void FromString(int16 &OutValue, const TCHAR *Buffer)
 
FString ToString(bool Value)
 
FORCEINLINE FString ToString(FString &&Str)
 
FORCEINLINE FString ToString(const FString &Str)
 
void FromString(int64 &OutValue, const TCHAR *Buffer)
 
FORCEINLINE auto DereferenceIfNecessary(CallableType &&Callable) -> typename TEnableIf< TPointerIsConvertibleFromTo< typename TDecay< CallableType >::Type, typename TDecay< BaseType >::Type >::Value, decltype((CallableType &&) Callable)>::Type
 
bool MatchesWildcardRecursive(const TCHAR *Target, int32 TargetLength, const TCHAR *Wildcard, int32 WildcardLength)
 
unsigned parse_nonnegative_int(const Char *&s)
 
T * make_ptr(T *ptr, std::size_t)
 
bool is_name_start(Char c)
 
Yes & convert(fmt::ULongLong)
 
bool is_negative(T value)
 
fmt::StringRef thousands_sep(...)
 
void require_numeric_argument(const Arg &arg, char spec)
 
MakeUnsigned< Int >::Type to_unsigned(Int value)
 
void format_decimal(Char *buffer, UInt value, unsigned num_digits)
 
void check_sign(const Char *&s, const Arg &arg)
 
StringRef thousands_sep(LConv *lc, LConvCheck< char *LConv::*, &LConv::thousands_sep >=0)
 
uint64_t make_type(const T &arg)
 
void format_arg(Formatter &,...)
 
void format_decimal(Char *buffer, UInt value, unsigned num_digits, ThousandsSep thousands_sep)
 
ArgJoin< wchar_t, It > join(It first, It last, const BasicCStringRef< wchar_t > &sep)
 
void format_decimal(char *&buffer, T value)
 
FMT_API void print(CStringRef format_str, ArgList args)
 
FMT_API void print_colored(Color c, CStringRef format, ArgList args)
 
ArgJoin< char, It > join(It first, It last, const BasicCStringRef< char > &sep)
 
IntFormatSpec< int, TypeSpec< 'o'> > oct(int value)
 
BasicWriter< char > Writer
 
StrFormatSpec< wchar_t > pad(const wchar_t *str, unsigned width, char fill=' ')
 
BasicArrayWriter< wchar_t > WArrayWriter
 
std::string format(CStringRef format_str, ArgList args)
 
BasicArrayWriter< char > ArrayWriter
 
IntFormatSpec< int, TypeSpec< 'b'> > bin(int value)
 
BasicMemoryWriter< wchar_t > WMemoryWriter
 
IntFormatSpec< int, TypeSpec< 'x'> > hex(int value)
 
BasicStringRef< wchar_t > WStringRef
 
BasicMemoryWriter< char > MemoryWriter
 
void arg(WStringRef, const internal::NamedArg< Char > &) FMT_DELETED_OR_UNDEFINED
 
FMT_API void report_system_error(int error_code, StringRef message) FMT_NOEXCEPT
 
void format_arg(fmt::BasicFormatter< Char, ArgFormatter > &f, const Char *&format_str, const ArgJoin< Char, It > &e)
 
std::wstring format(WCStringRef format_str, ArgList args)
 
FMT_API void print(std::FILE *f, CStringRef format_str, ArgList args)
 
internal::NamedArgWithType< char, T > arg(StringRef name, const T &arg)
 
IntFormatSpec< int, AlignTypeSpec< TYPE_CODE >, Char > pad(int value, unsigned width, Char fill=' ')
 
FMT_API void format_system_error(fmt::Writer &out, int error_code, fmt::StringRef message) FMT_NOEXCEPT
 
void arg(StringRef, const internal::NamedArg< Char > &) FMT_DELETED_OR_UNDEFINED
 
internal::NamedArgWithType< wchar_t, T > arg(WStringRef name, const T &arg)
 
IntFormatSpec< int, TypeSpec< 'X'> > hexu(int value)
 
BasicStringRef< char > StringRef
 
StrFormatSpec< Char > pad(const Char *str, unsigned width, Char fill=' ')
 
BasicCStringRef< wchar_t > WCStringRef
 
FMT_GCC_EXTENSION typedef long long LongLong
 
BasicCStringRef< char > CStringRef
 
FMT_GCC_EXTENSION typedef unsigned long long ULongLong
 
BasicWriter< wchar_t > WWriter
 
bool operator!=(const std::tm &tm1, const std::tm &tm2)
 
std::string errno_to_string(char[256], char *res)
 
bool in_terminal(FILE *file)
 
std::string errno_to_string(char buf[256], int res)
 
void prevent_child_fd(FILE *f)
 
int utc_minutes_offset(const std::tm &tm=details::os::localtime())
 
std::tm gmtime(const std::time_t &time_tt)
 
static SPDLOG_CONSTEXPR int eol_size
 
std::tm localtime(const std::time_t &time_tt)
 
spdlog::log_clock::time_point now()
 
std::string errno_str(int err_num)
 
static SPDLOG_CONSTEXPR const char * eol
 
bool operator==(const std::tm &tm1, const std::tm &tm2)
 
registry_t< std::mutex > registry
 
static fmt::MemoryWriter & pad_n_join(fmt::MemoryWriter &w, int v1, int v2, int v3, char sep)
 
static const char * ampm(const tm &t)
 
static int to12h(const tm &t)
 
static fmt::MemoryWriter & pad_n_join(fmt::MemoryWriter &w, int v1, int v2, char sep)
 
const char * to_short_str(spdlog::level::level_enum l)
 
const char * to_str(spdlog::level::level_enum l)
 
static const char * short_level_names[]
 
stderr_sink< details::null_mutex > stderr_sink_st
 
rotating_file_sink< std::mutex > rotating_file_sink_mt
 
daily_file_sink< std::mutex > daily_file_sink_mt
 
stderr_sink< std::mutex > stderr_sink_mt
 
wincolor_stderr_sink< std::mutex > wincolor_stderr_sink_mt
 
simple_file_sink< std::mutex > simple_file_sink_mt
 
simple_file_sink< details::null_mutex > simple_file_sink_st
 
wincolor_stdout_sink< details::null_mutex > wincolor_stdout_sink_st
 
stdout_sink< std::mutex > stdout_sink_mt
 
rotating_file_sink< details::null_mutex > rotating_file_sink_st
 
wincolor_stderr_sink< details::null_mutex > wincolor_stderr_sink_st
 
stdout_sink< details::null_mutex > stdout_sink_st
 
daily_file_sink< details::null_mutex > daily_file_sink_st
 
wincolor_stdout_sink< std::mutex > wincolor_stdout_sink_mt
 
void set_formatter(formatter_ptr f)
 
std::shared_ptr< logger > stdout_logger_st(const std::string &logger_name)
 
std::shared_ptr< logger > create_async(const std::string &logger_name, const sink_ptr &sink, size_t queue_size, const async_overflow_policy overflow_policy=async_overflow_policy::block_retry, const std::function< void()> &worker_warmup_cb=nullptr, const std::chrono::milliseconds &flush_interval_ms=std::chrono::milliseconds::zero(), const std::function< void()> &worker_teardown_cb=nullptr)
 
void register_logger(std::shared_ptr< logger > logger)
 
std::shared_ptr< logger > rotating_logger_st(const std::string &logger_name, const filename_t &filename, size_t max_file_size, size_t max_files)
 
std::shared_ptr< logger > rotating_logger_mt(const std::string &logger_name, const filename_t &filename, size_t max_file_size, size_t max_files)
 
void set_error_handler(log_err_handler)
 
std::shared_ptr< logger > create_async(const std::string &logger_name, sinks_init_list sinks, size_t queue_size, const async_overflow_policy overflow_policy=async_overflow_policy::block_retry, const std::function< void()> &worker_warmup_cb=nullptr, const std::chrono::milliseconds &flush_interval_ms=std::chrono::milliseconds::zero(), const std::function< void()> &worker_teardown_cb=nullptr)
 
std::shared_ptr< logger > stdout_color_mt(const std::string &logger_name)
 
std::shared_ptr< logger > get(const std::string &name)
 
std::shared_ptr< logger > create(const std::string &logger_name, sinks_init_list sinks)
 
std::shared_ptr< logger > create_async(const std::string &logger_name, const It &sinks_begin, const It &sinks_end, size_t queue_size, const async_overflow_policy overflow_policy=async_overflow_policy::block_retry, const std::function< void()> &worker_warmup_cb=nullptr, const std::chrono::milliseconds &flush_interval_ms=std::chrono::milliseconds::zero(), const std::function< void()> &worker_teardown_cb=nullptr)
 
void apply_all(std::function< void(std::shared_ptr< logger >)> fun)
 
std::shared_ptr< logger > create(const std::string &logger_name, const It &sinks_begin, const It &sinks_end)
 
std::shared_ptr< logger > daily_logger_mt(const std::string &logger_name, const filename_t &filename, int hour=0, int minute=0)
 
std::shared_ptr< logger > stdout_logger_mt(const std::string &logger_name)
 
std::shared_ptr< logger > stdout_color_st(const std::string &logger_name)
 
std::shared_ptr< logger > daily_logger_st(const std::string &logger_name, const filename_t &filename, int hour=0, int minute=0)
 
std::shared_ptr< logger > stderr_color_st(const std::string &logger_name)
 
std::shared_ptr< logger > basic_logger_mt(const std::string &logger_name, const filename_t &filename, bool truncate=false)
 
void set_level(level::level_enum log_level)
 
void set_async_mode(size_t queue_size, const async_overflow_policy overflow_policy=async_overflow_policy::block_retry, const std::function< void()> &worker_warmup_cb=nullptr, const std::chrono::milliseconds &flush_interval_ms=std::chrono::milliseconds::zero(), const std::function< void()> &worker_teardown_cb=nullptr)
 
std::shared_ptr< logger > stderr_logger_mt(const std::string &logger_name)
 
std::shared_ptr< spdlog::logger > create(const std::string &logger_name, Args...)
 
std::shared_ptr< logger > create(const std::string &logger_name, const sink_ptr &sink)
 
std::shared_ptr< logger > stderr_logger_st(const std::string &logger_name)
 
void set_pattern(const std::string &format_string)
 
std::shared_ptr< logger > stderr_color_mt(const std::string &logger_name)
 
void drop(const std::string &name)
 
std::shared_ptr< logger > basic_logger_st(const std::string &logger_name, const filename_t &filename, bool truncate=false)
 
#define SPDLOG_FILENAME_T(s)
 
FVector & DefaultActorLocationField()
 
int & TargetingTeamField()
 
USceneComponent * RootComponentField()
 
APlayerState * PlayerStateField()
 
UCheatManager * CheatManagerField()
 
FString * GetPlayerNetworkAddress(FString *result)
 
FUniqueNetIdRepl & UniqueIdField()
 
FString & PlayerNameField()
 
bool TeleportTo(FVector *DestLocation, FRotator *DestRotation, bool bIsATest, bool bNoCheck)
 
UPrimalInventoryComponent * MyInventoryComponentField()
 
void DoNeuter_Implementation()
 
static UClass * GetPrivateStaticClass()
 
void TameDino(AShooterPlayerController *ForPC, bool bIgnoreMaxTameLimit, int OverrideTamingTeamID)
 
int & TamingTeamIDField()
 
FString & TamerStringField()
 
int & AbsoluteBaseLevelField()
 
UPrimalPlayerData * GetPlayerData()
 
APrimalDinoCharacter * GetRidingDino()
 
unsigned __int64 GetSteamIDForPlayerID(int playerDataID)
 
void AddPlayerID(int playerDataID, unsigned __int64 netUniqueID)
 
__int64 & LinkedPlayerIDField()
 
void SetPlayerPos(float X, float Y, float Z)
 
AActor * SpawnActor(FString *blueprintPath, float spawnDistance, float spawnYOffset, float ZOffset, bool bDoDeferBeginPlay)
 
AShooterCharacter * GetPlayerCharacter()
 
FString * GetPlayerName(FString *result)
 
void SetTribeTamingDinoSettings(APrimalDinoCharacter *aDinoChar)
 
static uint32 MemCrc32(const void *Data, int32 Lenght)
 
FORCEINLINE T && operator()(T &&Val) const
 
FIntVector(FVector InVector)
 
static float UnwindRadians(float A)
 
static T InterpCircularOut(const T &A, const T &B, float Alpha)
 
static T InterpEaseInOut(const T &A, const T &B, float Alpha, float Exp)
 
static T InterpExpoInOut(const T &A, const T &B, float Alpha)
 
static FORCEINLINE double RoundToNegativeInfinity(double F)
 
static FORCEINLINE int32 RandRange(int32 Min, int32 Max)
 
static T BiLerp(const T &P00, const T &P10, const T &P01, const T &P11, const U &FracX, const U &FracY)
 
static T LerpStable(const T &A, const T &B, double Alpha)
 
static FORCEINLINE float RandRange(float InMin, float InMax)
 
static float UnwindDegrees(float A)
 
static FORCEINLINE float FastAsin(float Value)
 
static FORCEINLINE float RoundToNegativeInfinity(float F)
 
static float FindDeltaAngleRadians(float A1, float A2)
 
static U CubicCRSplineInterp(const U &P0, const U &P1, const U &P2, const U &P3, const float T0, const float T1, const float T2, const float T3, const float T)
 
static T InterpCircularInOut(const T &A, const T &B, float Alpha)
 
static float SmoothStep(float A, float B, float X)
 
static FORCEINLINE T Clamp(const T X, const T Min, const T Max)
 
static FORCEINLINE float RoundFromZero(float F)
 
static T CubicInterpSecondDerivative(const T &P0, const T &T0, const T &P1, const T &T1, const U &A)
 
static int32 LeastCommonMultiplier(int32 a, int32 b)
 
static FORCEINLINE T Square(const T A)
 
static T Lerp(const T &A, const T &B, const U &Alpha)
 
static FORCEINLINE T Max3(const T A, const T B, const T C)
 
static T InterpEaseOut(const T &A, const T &B, float Alpha, float Exp)
 
static FORCEINLINE T DivideAndRoundDown(T Dividend, T Divisor)
 
static FORCEINLINE float RoundToZero(float F)
 
static FORCEINLINE int32 RandHelper(int32 A)
 
static int32 GreatestCommonDivisor(int32 a, int32 b)
 
static T InterpSinOut(const T &A, const T &B, float Alpha)
 
static T InterpEaseIn(const T &A, const T &B, float Alpha, float Exp)
 
static FORCEINLINE float RoundToPositiveInfinity(float F)
 
static FORCEINLINE void PolarToCartesian(const float Rad, const float Ang, float &OutX, float &OutY)
 
static FORCEINLINE float FRandRange(float InMin, float InMax)
 
static float FindDeltaAngleDegrees(float A1, float A2)
 
static FORCEINLINE bool IsPowerOfTwo(T Value)
 
static FORCEINLINE auto RadiansToDegrees(T const &RadVal) -> decltype(RadVal *(180.f/PI))
 
static T InterpCircularIn(const T &A, const T &B, float Alpha)
 
static T InterpStep(const T &A, const T &B, float Alpha, int32 Steps)
 
static FORCEINLINE T DivideAndRoundUp(T Dividend, T Divisor)
 
static T InterpExpoOut(const T &A, const T &B, float Alpha)
 
static T CubicInterpDerivative(const T &P0, const T &T0, const T &P1, const T &T1, const U &A)
 
static T CubicInterp(const T &P0, const T &T0, const T &P1, const T &T1, const U &A)
 
static FORCEINLINE double RoundToPositiveInfinity(double F)
 
static FORCEINLINE void SinCos(float *ScalarSin, float *ScalarCos, float Value)
 
static FORCEINLINE T Min3(const T A, const T B, const T C)
 
static FORCEINLINE auto DegreesToRadians(T const &DegVal) -> decltype(DegVal *(PI/180.f))
 
static T LerpStable(const T &A, const T &B, float Alpha)
 
static T InterpExpoIn(const T &A, const T &B, float Alpha)
 
static FORCEINLINE double RoundToZero(double F)
 
static T InterpSinIn(const T &A, const T &B, float Alpha)
 
static FORCEINLINE double RoundFromZero(double F)
 
static T InterpSinInOut(const T &A, const T &B, float Alpha)
 
static FORCEINLINE bool RandBool()
 
static FORCEINLINE void * Memzero(void *Dest, SIZE_T Count)
 
static FORCEINLINE void Memzero(T &Src)
 
static FORCEINLINE void * SystemMalloc(SIZE_T Size)
 
static void Free(void *Original)
 
static FORCEINLINE void * Memset(void *Dest, uint8 Char, SIZE_T Count)
 
static void * Malloc(SIZE_T Count, uint32 Alignment=DEFAULT_ALIGNMENT)
 
static FORCEINLINE void * Memmove(void *Dest, const void *Src, SIZE_T Count)
 
static FORCEINLINE int32 Memcmp(const void *Buf1, const void *Buf2, SIZE_T Count)
 
static FORCEINLINE void Memswap(void *Ptr1, void *Ptr2, SIZE_T Size)
 
static FORCEINLINE void * StreamingMemcpy(void *Dest, const void *Src, SIZE_T Count)
 
static FORCEINLINE void Memcpy(T &Dest, const T &Src)
 
static FORCEINLINE void Memset(T &Src, uint8 ValueToSet)
 
static void * Realloc(void *Ptr, SIZE_T Size, uint32 Alignment=DEFAULT_ALIGNMENT)
 
static FORCEINLINE void SystemFree(void *Ptr)
 
static SIZE_T QuantizeSize(SIZE_T Count, uint32 Alignment=DEFAULT_ALIGNMENT)
 
static FORCEINLINE void * BigBlockMemcpy(void *Dest, const void *Src, SIZE_T Count)
 
static FORCEINLINE void * Memcpy(void *Dest, const void *Src, SIZE_T Count)
 
unsigned __int64 & PlayerDataIDField()
 
FORCEINLINE FRotator(float InPitch, float InYaw, float InRoll)
 
TSharedPtr< FUniqueNetId > UniqueNetId
 
FORCEINLINE FVector operator+(float Bias) const
 
FORCEINLINE FVector operator*=(float Scale)
 
bool operator!=(const FVector &V) const
 
static float Triple(const FVector &X, const FVector &Y, const FVector &Z)
 
static bool Orthogonal(const FVector &Normal1, const FVector &Normal2, float OrthogonalCosineThreshold=THRESH_NORMALS_ARE_ORTHOGONAL)
 
static bool Parallel(const FVector &Normal1, const FVector &Normal2, float ParallelCosineThreshold=THRESH_NORMALS_ARE_PARALLEL)
 
FORCEINLINE FVector operator-(const FVector &V) const
 
FORCEINLINE FVector operator-=(const FVector &V)
 
FVector GetSafeNormal(float Tolerance=SMALL_NUMBER) const
 
static FVector VectorPlaneProject(const FVector &V, const FVector &PlaneNormal)
 
FVector operator/=(const FVector &V)
 
static bool PointsAreSame(const FVector &P, const FVector &Q)
 
FORCEINLINE FVector(float InF)
 
FORCEINLINE FVector operator+=(const FVector &V)
 
FORCEINLINE FVector operator-() const
 
FORCEINLINE FVector operator^(const FVector &V) const
 
bool IsUniform(float Tolerance=KINDA_SMALL_NUMBER) const
 
FORCEINLINE FVector operator-(float Bias) const
 
FRotator ToOrientationRotator() const
 
FVector(const FLinearColor &InColor)
 
FVector MirrorByVector(const FVector &MirrorNormal) const
 
FVector Reciprocal() const
 
static FORCEINLINE float DistSquaredXY(const FVector &V1, const FVector &V2)
 
static bool PointsAreNear(const FVector &Point1, const FVector &Point2, float Dist)
 
bool InitFromString(const FString &InSourceString)
 
static FORCEINLINE float DotProduct(const FVector &A, const FVector &B)
 
FVector ComponentMax(const FVector &Other) const
 
void ToDirectionAndLength(FVector &OutDir, float &OutLength) const
 
FORCEINLINE float operator|(const FVector &V) const
 
FRotator Rotation() const
 
FORCEINLINE FVector GetUnsafeNormal() const
 
FVector GetClampedToMaxSize(float MaxSize) const
 
FORCEINLINE FVector operator*(const FVector &V) const
 
void FindBestAxisVectors(FVector &Axis1, FVector &Axis2) const
 
FVector(FIntVector InVector)
 
static const FVector ZeroVector
 
float SizeSquared2D() const
 
FVector GetSafeNormal2D(float Tolerance=SMALL_NUMBER) const
 
float & Component(int32 Index)
 
static FORCEINLINE float BoxPushOut(const FVector &Normal, const FVector &Size)
 
FVector operator/(float Scale) const
 
static FVector RadiansToDegrees(const FVector &RadVector)
 
FVector2D UnitCartesianToSpherical() const
 
static float PointPlaneDist(const FVector &Point, const FVector &PlaneBase, const FVector &PlaneNormal)
 
FVector BoundToCube(float Radius) const
 
static FORCEINLINE float DistSquared(const FVector &V1, const FVector &V2)
 
FORCEINLINE FVector GetSignVector() const
 
FORCEINLINE FVector operator/(const FVector &V) const
 
static FORCEINLINE float Dist2D(const FVector &V1, const FVector &V2)
 
FVector ComponentMin(const FVector &Other) const
 
float & operator[](int32 Index)
 
static FORCEINLINE float Dist(const FVector &V1, const FVector &V2)
 
FVector GridSnap(const float &GridSz) const
 
static bool Coincident(const FVector &Normal1, const FVector &Normal2, float ParallelCosineThreshold=THRESH_NORMALS_ARE_PARALLEL)
 
FVector Projection() const
 
static bool Coplanar(const FVector &Base1, const FVector &Normal1, const FVector &Base2, const FVector &Normal2, float ParallelCosineThreshold=THRESH_NORMALS_ARE_PARALLEL)
 
FORCEINLINE FVector ProjectOnTo(const FVector &A) const
 
static FVector PointPlaneProject(const FVector &Point, const FVector &PlaneBase, const FVector &PlaneNormal)
 
bool IsNormalized() const
 
FORCEINLINE FVector ProjectOnToNormal(const FVector &Normal) const
 
static FVector PointPlaneProject(const FVector &Point, const FVector &A, const FVector &B, const FVector &C)
 
bool Equals(const FVector &V, float Tolerance=KINDA_SMALL_NUMBER) const
 
FQuat ToOrientationQuat() const
 
bool operator==(const FVector &V) const
 
FVector GetClampedToSize2D(float Min, float Max) const
 
float SizeSquared() const
 
float operator[](int32 Index) const
 
FVector GetClampedToSize(float Min, float Max) const
 
static FORCEINLINE float DistSquared2D(const FVector &V1, const FVector &V2)
 
FVector operator/=(float V)
 
static FORCEINLINE FVector CrossProduct(const FVector &A, const FVector &B)
 
FVector operator*=(const FVector &V)
 
void Set(float InX, float InY, float InZ)
 
FORCEINLINE FVector operator+(const FVector &V) const
 
FORCEINLINE FVector operator*(float Scale) const
 
static FVector DegreesToRadians(const FVector &DegVector)
 
FORCEINLINE CONSTEXPR FVector(float InX, float InY, float InZ)
 
FORCEINLINE float CosineAngle2D(FVector B) const
 
bool AllComponentsEqual(float Tolerance=KINDA_SMALL_NUMBER) const
 
FVector GetClampedToMaxSize2D(float MaxSize) const
 
static FORCEINLINE float DistXY(const FVector &V1, const FVector &V2)
 
static void CreateOrthonormalBasis(FVector &XAxis, FVector &YAxis, FVector &ZAxis)
 
FORCEINLINE bool IsUnit(float LengthSquaredTolerance=KINDA_SMALL_NUMBER) const
 
FVector RotateAngleAxis(const float AngleDeg, const FVector &Axis) const
 
float HeadingAngle() const
 
static float EvaluateBezier(const FVector *ControlPoints, int32 NumPoints, TArray< FVector > &OutPoints)
 
float Component(int32 Index) const
 
FORCEINLINE FVector(const FVector2D V, float InZ)
 
bool IsNearlyZero(float Tolerance=KINDA_SMALL_NUMBER) const
 
FORCEINLINE FVector(EForceInit)
 
static FORCEINLINE float Distance(const FVector &V1, const FVector &V2)
 
bool Normalize(float Tolerance=SMALL_NUMBER)
 
virtual ~FVirtualDestructor()
 
TArrayRange(T *InPtr, int32 InSize)
 
static FORCEINLINE uint64 Strtoui64(const CharType *Start, CharType **End, int32 Base)
 
static CharType * Stristr(CharType *Str, const CharType *Find)
 
static FORCEINLINE CharType * Strstr(CharType *String, const CharType *Find)
 
static FORCEINLINE const CharType * Strstr(const CharType *String, const CharType *Find)
 
static FORCEINLINE double Atod(const CharType *String)
 
static FORCEINLINE int32 Stricmp(const CharType *String1, const CharType *String2)
 
static FORCEINLINE int32 Strnicmp(const CharType *String1, const CharType *String2, SIZE_T Count)
 
static FORCEINLINE float Atof(const CharType *String)
 
static FORCEINLINE int32 Strlen(const CharType *String)
 
static FORCEINLINE int32 Atoi(const CharType *String)
 
static FORCEINLINE int32 Strncmp(const CharType *String1, const CharType *String2, SIZE_T Count)
 
static FORCEINLINE int32 Strtoi(const CharType *Start, CharType **End, int32 Base)
 
static const CharType * Stristr(const CharType *Str, const CharType *Find)
 
static FORCEINLINE int64 Atoi64(const CharType *String)
 
static FORCEINLINE int32 Strcmp(const CharType *String1, const CharType *String2)
 
const ArrayType & ConstReference
 
const T *const ConstPointerType
 
const T *const ConstPointerType
 
const ArrayType & ConstReference
 
TCallTraitsParamTypeHelper< T, PassByValue >::ConstParamType ConstPointerType
 
TCallTraitsParamTypeHelper< T, PassByValue >::ParamType ParamType
 
static CharType ToLower(CharType Char)
 
static bool IsWhitespace(CharType Char)
 
static CharType ToUpper(CharType Char)
 
FORCEINLINE friend bool operator!=(const TCheckedPointerIterator &Lhs, const TCheckedPointerIterator &Rhs)
 
TCheckedPointerIterator(const int32 &InNum, ElementType *InPtr)
 
FORCEINLINE TCheckedPointerIterator & operator++()
 
FORCEINLINE ElementType & operator*() const
 
FORCEINLINE TCheckedPointerIterator & operator--()
 
UE4Decay_Private::TDecayNonReference< typenameTRemoveReference< T >::Type >::Type Type
 
TDereferenceWrapper(const PREDICATE_CLASS &InPredicate)
 
const PREDICATE_CLASS & Predicate
 
FORCEINLINE bool operator()(T *A, T *B) const
 
TDereferenceWrapper(const PREDICATE_CLASS &InPredicate)
 
const PREDICATE_CLASS & Predicate
 
FORCEINLINE bool operator()(T &A, T &B)
 
FORCEINLINE bool operator()(const T &A, const T &B) const
 
FORCEINLINE TDereferencingIterator & operator++()
 
FORCEINLINE ElementType & operator*() const
 
FORCEINLINE friend bool operator!=(const TDereferencingIterator &Lhs, const TDereferencingIterator &Rhs)
 
TDereferencingIterator(IteratorType InIter)
 
FORCEINLINE const Type & operator*() const
 
TGuardValue(Type &ReferenceValue, const Type &NewValue)
 
FORCEINLINE bool operator()(const TKeyValuePair &A, const TKeyValuePair &B) const
 
bool operator!=(const TKeyValuePair &Other) const
 
TKeyValuePair(const KeyType &InKey, const ValueType &InValue)
 
bool operator==(const TKeyValuePair &Other) const
 
TKeyValuePair(const KeyType &InKey)
 
bool operator<(const TKeyValuePair &Other) const
 
FORCEINLINE bool operator()(const T &A, const T &B) const
 
FORCEINLINE bool operator()(const T &A, const T &B) const
 
static FORCEINLINE TCHAR const * GetName()
 
TScopeCounter(Type &ReferenceValue)
 
static void FromString(T &Value, const TCHAR *Buffer)
 
static FString ToSanitizedString(const T &Value)
 
static FString ToString(const T &Value)
 
TCallTraits< T >::ParamType ConstInitType
 
TCallTraits< T >::ConstPointerType ConstPointerType
 
T * Get(bool bEvenIfPendingKill=false)
 
FORCEINLINE T * operator->()
 
UObject * GetDefaultObject(bool bCreateIfNeeded)
 
FromArrayType::Allocator FromAllocatorType
 
FromArrayType::ElementType FromElementType
 
ToArrayType::Allocator ToAllocatorType
 
ToArrayType::ElementType ToElementType
 
TRemoveCV< T >::Type Type
 
static FORCEINLINE bool Compare(TCHAR Lhs, TCHAR Rhs)
 
static FORCEINLINE bool Compare(TCHAR Lhs, TCHAR Rhs)
 
FString * GetFullName(FString *result, UObject *StopOuter)
 
bool IsA(UClass *SomeBase)
 
UPrimalGameData * PrimalGameDataOverrideField()
 
UPrimalGameData * PrimalGameDataField()
 
FPrimalPlayerDataStruct * MyDataField()
 
FVector * GetWorldLocation(FVector *result)
 
static TArray< AActor * > * ServerOctreeOverlapActors(TArray< AActor * > *result, UWorld *theWorld, FVector AtLoc, float Radius, EServerOctreeGroup::Type OctreeType, bool bForceActorLocationDistanceCheck)
 
TArray< TAutoWeakObjectPtr< APlayerController > > & PlayerControllerListField()
 
APlayerController * GetFirstPlayerController()
 
AGameState * GameStateField()
 
AlignSpec(unsigned width, wchar_t fill, Alignment align=ALIGN_DEFAULT)
 
bool flag(unsigned) const
 
AlignTypeSpec(unsigned width, wchar_t fill)
 
BasicCStringRef< Char > sep
 
ArgJoin(It first, It last, const BasicCStringRef< Char > &sep)
 
bool flag(unsigned) const
 
WidthSpec(unsigned width, wchar_t fill)
 
static Arg make(const T &value)
 
Value Type[N > 0 ? N :+1]
 
static Value make(const T &value)
 
static const uint32_t POWERS_OF_10_32[]
 
static const char DIGITS[]
 
static const uint64_t POWERS_OF_10_64[]
 
NamedArg(BasicStringRef< Char > argname, const T &value)
 
BasicStringRef< Char > name
 
NamedArgWithType(BasicStringRef< Char > argname, const T &value)
 
static bool is_negative(T)
 
static bool is_negative(T value)
 
void(* FormatFunc)(void *formatter, const void *arg, void *format_str_ptr)
 
StringValue< wchar_t > wstring
 
StringValue< signed char > sstring
 
ULongLong ulong_long_value
 
long double long_double_value
 
StringValue< char > string
 
StringValue< unsigned char > ustring
 
async_msg(const async_msg &)=delete
 
log_clock::time_point time
 
async_msg & operator=(const async_msg &other)=delete
 
void fill_log_msg(log_msg &msg)
 
async_msg(const details::log_msg &m)
 
async_msg & operator=(async_msg &&other) SPDLOG_NOEXCEPT
 
async_msg(async_msg_type m_type)
 
async_msg(async_msg &&other) SPDLOG_NOEXCEPT
 
const std::string * logger_name
 
fmt::MemoryWriter formatted
 
log_clock::time_point time
 
log_msg(const log_msg &other)=delete
 
log_msg & operator=(log_msg &&other)=delete
 
log_msg(log_msg &&other)=delete
 
std::atomic< size_t > sequence_
 
int load(std::memory_order) const
 
null_atomic_int()=default
 
static filename_t calc_filename(const filename_t &filename)
 
static filename_t calc_filename(const filename_t &filename)