7#include "Containers/TArray.h"
8#include "Containers/FString.h"
9#include "Containers/EnumAsByte.h"
10#include "Templates/SharedPointer.h"
11#include "API/Fields.h"
13#include "API/UE/Math/Color.h"
14#include "Misc/GlobalObjectsArray.h"
37 FName(
const char* Name, EFindName FindType)
42 bool operator==(
const wchar_t* Other) {
return NativeCall<
bool,
const wchar_t*>(
this,
"FName.operator==", Other); }
55 static bool SplitNameWithCheck(
const wchar_t* OldName,
wchar_t* NewName,
int NewNameLen,
int* NewNumber) {
return NativeCall<
bool,
const wchar_t*,
wchar_t*,
int,
int*>(
nullptr,
"FName.SplitNameWithCheck", OldName, NewName, NewNameLen, NewNumber); }
57 void Init(
const char* InName,
int InNumber, EFindName FindType,
bool bSplitName,
int HardcodeIndex) { NativeCall<
void,
const char*,
int, EFindName,
bool,
int>(
this,
"FName.Init", InName, InNumber, FindType, bSplitName, HardcodeIndex); }
91template <
typename ObjectType>
107struct __declspec(align(8)) FTextHistory
121 int CompareTo(
FText* Other, ETextComparisonLevel::Type ComparisonLevel) {
return NativeCall<
int,
FText*, ETextComparisonLevel::Type>(
this,
"FText.CompareTo", Other, ComparisonLevel); }
122 FText() { NativeCall<
void>(
this,
"FText.FText"); }
126 FText(
FString InSourceString,
FString InNamespace,
FString InKey,
int InFlags) { NativeCall<
void,
FString,
FString,
FString,
int>(
this,
"FText.FText", InSourceString, InNamespace, InKey, InFlags); }
131 static FText*
Format(
FText* result,
FText* Fmt,
FText* v1,
FText* v2) {
return NativeCall<
FText*,
FText*,
FText*,
FText*,
FText*>(
nullptr,
"FText.Format", result, Fmt, v1, v2); }
132 static FText*
Format(
FText* result,
FText* Fmt,
FText* v1,
FText* v2,
FText* v3) {
return NativeCall<
FText*,
FText*,
FText*,
FText*,
FText*,
FText*>(
nullptr,
"FText.Format", result, Fmt, v1, v2, v3); }
133 static bool FindText(
FString* Namespace,
FString* Key,
FText* OutText,
FString*
const SourceString) {
return NativeCall<
bool,
FString*,
FString*,
FText*,
FString*
const>(
nullptr,
"FText.FindText", Namespace, Key, OutText, SourceString); }
140 static void GetEmpty() { NativeCall<
void>(
nullptr,
"FText.GetEmpty"); }
152 void operator=(
UObject const* __that) {
return NativeCall<
void,
UObject const*>(
this,
"FWeakObjectPtr.operator=", __that); }
153 bool IsValid() {
return NativeCall<
bool>(
this,
"FWeakObjectPtr.IsValid"); }
172 T*
Get(
bool bEvenIfPendingKill =
false)
174 return NativeCall<T*,
bool>(
this,
"FWeakObjectPtr.Get", bEvenIfPendingKill);
179 return Get() !=
nullptr;
205 FWeakObjectPtr tempWeak;
206 tempWeak.operator=(object);
207 TWeakObjectPtr<T> tempTWeak(tempWeak.ObjectIndex, tempWeak.ObjectSerialNumber);
241 unsigned __int64&
UniqueNetIdField() {
return *GetNativePointerField<
unsigned __int64*>(
this,
"FUniqueNetIdUInt64.UniqueNetId"); }
248 FUniqueNetIdUInt64(uint64 InUniqueNetId) { NativeCall<
void, uint64>(
this,
"FUniqueNetIdUInt64.FUniqueNetIdUInt64", InUniqueNetId); }
250 bool IsValid() {
return NativeCall<
bool>(
this,
"FUniqueNetIdUInt64.IsValid"); }
252 unsigned int GetHash() {
return NativeCall<
int>(
this,
"FUniqueNetIdUInt64.GetHash"); }
262 int GetSize() {
return NativeCall<
int>(
this,
"FUniqueNetIdSteam.GetSize"); }
264 bool IsValid() {
return NativeCall<
bool>(
this,
"FUniqueNetIdSteam.IsValid"); }
275 EObjectFlags&
ObjectFlagsField() {
return *GetNativePointerField<EObjectFlags*>(
this,
"UObjectBase.ObjectFlags"); }
276 int&
InternalIndexField() {
return *GetNativePointerField<
int*>(
this,
"UObjectBase.InternalIndex"); }
283 void DeferredRegister(
UClass* UClassStaticClass,
const wchar_t* PackageName,
const wchar_t* InName) { NativeCall<
void,
UClass*,
const wchar_t*,
const wchar_t*>(
this,
"UObjectBase.DeferredRegister", UClassStaticClass, PackageName, InName); }
284 bool IsValidLowLevel() {
return NativeCall<
bool>(
this,
"UObjectBase.IsValidLowLevel"); }
285 bool IsValidLowLevelFast(
bool bRecursive) {
return NativeCall<
bool,
bool>(
this,
"UObjectBase.IsValidLowLevelFast", bRecursive); }
287 void Register(
const wchar_t* PackageName,
const wchar_t* InName) { NativeCall<
void,
const wchar_t*,
const wchar_t*>(
this,
"UObjectBase.Register", PackageName, InName); }
298 bool IsIn(
UObject* SomeOuter) {
return NativeCall<
bool,
UObject*>(
this,
"UObjectBaseUtility.IsIn", SomeOuter); }
299 bool IsA(
UClass* SomeBase) {
return NativeCall<
bool,
UClass*>(
this,
"UObjectBaseUtility.IsA", SomeBase); }
301 bool IsDefaultSubobject() {
return NativeCall<
bool>(
this,
"UObjectBaseUtility.IsDefaultSubobject"); }
302 int GetLinkerIndex() {
return NativeCall<
int>(
this,
"UObjectBaseUtility.GetLinkerIndex"); }
309 void ExecuteUbergraph(
int EntryPoint) { NativeCall<
void,
int>(
this,
"UObject.ExecuteUbergraph", EntryPoint); }
315 bool IsInBlueprint() {
return NativeCall<
bool>(
this,
"UObject.IsInBlueprint"); }
316 bool Rename(
const wchar_t* InName,
UObject* NewOuter,
unsigned int Flags) {
return NativeCall<
bool,
const wchar_t*,
UObject*,
unsigned int>(
this,
"UObject.Rename", InName, NewOuter, Flags); }
317 void LoadLocalized(
UObject* LocBase,
bool bLoadHierachecally) { NativeCall<
void,
UObject*,
bool>(
this,
"UObject.LoadLocalized", LocBase, bLoadHierachecally); }
318 void LocalizeProperty(
UObject* LocBase,
TArray<
FString>* PropertyTagChain,
UProperty*
const BaseProperty,
UProperty*
const Property,
void*
const ValueAddress) { NativeCall<
void,
UObject*,
TArray<
FString>*,
UProperty*
const,
UProperty*
const,
void*
const>(
this,
"UObject.LocalizeProperty", LocBase, PropertyTagChain, BaseProperty, Property, ValueAddress); }
319 void BeginDestroy() { NativeCall<
void>(
this,
"UObject.BeginDestroy"); }
325 bool Modify(
bool bAlwaysMarkDirty) {
return NativeCall<
bool,
bool>(
this,
"UObject.Modify", bAlwaysMarkDirty); }
326 bool IsSelected() {
return NativeCall<
bool>(
this,
"UObject.IsSelected"); }
329 bool IsAsset() {
return NativeCall<
bool>(
this,
"UObject.IsAsset"); }
331 void LoadConfig(
UClass* ConfigClass,
const wchar_t* InFilename,
unsigned int PropagationFlags,
UProperty* PropertyToLoad) { NativeCall<
void,
UClass*,
const wchar_t*,
unsigned int,
UProperty*>(
this,
"UObject.LoadConfig", ConfigClass, InFilename, PropagationFlags, PropertyToLoad); }
338 static UObject*
GetArchetypeFromRequiredInfo(
UClass* Class,
UObject* Outer,
FName Name,
bool bIsCDO) {
return NativeCall<
UObject*,
UClass*,
UObject*,
FName,
bool>(
nullptr,
"UObject.GetArchetypeFromRequiredInfo", Class, Outer, Name, bIsCDO); }
350 void PostLoad() { NativeCall<
void>(
this,
"UField.PostLoad"); }
372 const wchar_t*
GetPrefixCPP() {
return NativeCall<
const wchar_t*>(
this,
"UStruct.GetPrefixCPP"); }
374 void StaticLink(
bool bRelinkExistingProperties) { NativeCall<
void,
bool>(
this,
"UStruct.StaticLink", bRelinkExistingProperties); }
377 void TagSubobjects(EObjectFlags NewFlags) { NativeCall<
void, EObjectFlags>(
this,
"UStruct.TagSubobjects", NewFlags); }
400 unsigned int&
ClassFlagsField() {
return *GetNativePointerField<
unsigned int*>(
this,
"UClass.ClassFlags"); }
401 unsigned __int64&
ClassCastFlagsField() {
return *GetNativePointerField<
unsigned __int64*>(
this,
"UClass.ClassCastFlags"); }
402 int&
ClassUniqueField() {
return *GetNativePointerField<
int*>(
this,
"UClass.ClassUnique"); }
405 bool&
bIsGameClassField() {
return *GetNativePointerField<
bool*>(
this,
"UClass.bIsGameClass"); }
409 bool&
bCookedField() {
return *GetNativePointerField<
bool*>(
this,
"UClass.bCooked"); }
422 void DeferredRegister(
UClass* UClassStaticClass,
const wchar_t* PackageName,
const wchar_t* Name) { NativeCall<
void,
UClass*,
const wchar_t*,
const wchar_t*>(
this,
"UClass.DeferredRegister", UClassStaticClass, PackageName, Name); }
423 bool Rename(
const wchar_t* InName,
UObject* NewOuter,
unsigned int Flags) {
return NativeCall<
bool,
const wchar_t*,
UObject*,
unsigned int>(
this,
"UClass.Rename", InName, NewOuter, Flags); }
424 void TagSubobjects(EObjectFlags NewFlags) { NativeCall<
void, EObjectFlags>(
this,
"UClass.TagSubobjects", NewFlags); }
425 void Bind() { NativeCall<
void>(
this,
"UClass.Bind"); }
426 const wchar_t*
GetPrefixCPP() {
return NativeCall<
const wchar_t*>(
this,
"UClass.GetPrefixCPP"); }
429 void PostLoad() { NativeCall<
void>(
this,
"UClass.PostLoad"); }
432 void PurgeClass(
bool bRecompilingOnLoad) { NativeCall<
void,
bool>(
this,
"UClass.PurgeClass", bRecompilingOnLoad); }
436 unsigned int EmitStructArrayBegin(
int Offset,
FName* DebugName,
int Stride) {
return NativeCall<
unsigned int,
int,
FName*,
int>(
this,
"UClass.EmitStructArrayBegin", Offset, DebugName, Stride); }
466 void TagSubobjects(EObjectFlags NewFlags) { NativeCall<
void, EObjectFlags>(
this,
"UBlueprint.TagSubobjects", NewFlags); }
471 int&
ArrayDimField() {
return *GetNativePointerField<
int*>(
this,
"UProperty.ArrayDim"); }
472 int&
ElementSizeField() {
return *GetNativePointerField<
int*>(
this,
"UProperty.ElementSize"); }
473 unsigned __int64&
PropertyFlagsField() {
return *GetNativePointerField<
unsigned __int64*>(
this,
"UProperty.PropertyFlags"); }
474 unsigned __int16&
RepIndexField() {
return *GetNativePointerField<
unsigned __int16*>(
this,
"UProperty.RepIndex"); }
484 bool Identical(
const void* A,
const void* B,
unsigned int PortFlags) {
return NativeCall<
bool,
const void*,
const void*,
unsigned int>(
this,
"UProperty.Identical", A, B, PortFlags); }
485 void ExportTextItem(
FString* ValueStr,
const void* PropertyValue,
const void* DefaultValue,
UObject* Parent,
int PortFlags,
UObject* ExportRootScope) { NativeCall<
void,
FString*,
const void*,
const void*,
UObject*,
int,
UObject*>(
this,
"UProperty.ExportTextItem", ValueStr, PropertyValue, DefaultValue, Parent, PortFlags, ExportRootScope); }
486 void CopySingleValueFromScriptVM(
void* Dest,
const void* Src) { NativeCall<
void,
void*,
const void*>(
this,
"UProperty.CopySingleValueFromScriptVM", Dest, Src); }
487 void CopyCompleteValueFromScriptVM(
void* Dest,
const void* Src) { NativeCall<
void,
void*,
const void*>(
this,
"UProperty.CopyCompleteValueFromScriptVM", Dest, Src); }
489 bool Identical_InContainer(
const void* A,
const void* B,
int ArrayIndex,
unsigned int PortFlags) {
return NativeCall<
bool,
const void*,
const void*,
int,
unsigned int>(
this,
"UProperty.Identical_InContainer", A, B, ArrayIndex, PortFlags); }
492 bool ExportText_Direct(
FString* ValueStr,
const void* Data,
const void* Delta,
UObject* Parent,
int PortFlags,
UObject* ExportRootScope) {
return NativeCall<
bool,
FString*,
const void*,
const void*,
UObject*,
int,
UObject*>(
this,
"UProperty.ExportText_Direct", ValueStr, Data, Delta, Parent, PortFlags, ExportRootScope); }
493 bool IsLocalized() {
return NativeCall<
bool>(
this,
"UProperty.IsLocalized"); }
494 bool ShouldPort(
unsigned int PortFlags) {
return NativeCall<
bool,
unsigned int>(
this,
"UProperty.ShouldPort", PortFlags); }
531 const void* PropertyValue,
532 const void* DefaultValue,
537 NativeCall<
void,
FString*,
const void*,
const void*,
UObject*,
int,
UObject*>(
this,
"UStructProperty.ExportTextItem", ValueStr, PropertyValue, DefaultValue, Parent, PortFlags, ExportRootScope);
542template<
typename InTCppType,
class TInPropertyBaseClass>
547 void ExportTextItem(
FString* ValueStr,
const void* PropertyValue,
const void* DefaultValue,
UObject* Parent,
int PortFlags,
UObject* ExportRootScope) { NativeCall<
void,
FString*,
const void*,
const void*,
UObject*,
int,
UObject*>(
this,
"UObjectProperty.ExportTextItem", ValueStr, PropertyValue, DefaultValue, Parent, PortFlags, ExportRootScope); }
550 void ExportTextItem(
FString* ValueStr,
const void* PropertyValue,
const void* DefaultValue,
UObject* Parent,
int PortFlags,
UObject* ExportRootScope) { NativeCall<
void,
FString*,
const void*,
const void*,
UObject*,
int,
UObject*>(
this,
"UClassProperty.ExportTextItem", ValueStr, PropertyValue, DefaultValue, Parent, PortFlags, ExportRootScope); }
554 void ExportTextItem(
FString* ValueStr,
const void* PropertyValue,
const void* DefaultValue,
UObject* Parent,
int PortFlags,
UObject* ExportRootScope) { NativeCall<
void,
FString*,
const void*,
const void*,
UObject*,
int,
UObject*>(
this,
"UTextProperty.ExportTextItem", ValueStr, PropertyValue, DefaultValue, Parent, PortFlags, ExportRootScope); }
558 void ExportTextItem(
FString* ValueStr,
const void* PropertyValue,
const void* DefaultValue,
UObject* Parent,
int PortFlags,
UObject* ExportRootScope) { NativeCall<
void,
FString*,
const void*,
const void*,
UObject*,
int,
UObject*>(
this,
"UDelegateProperty.ExportTextItem", ValueStr, PropertyValue, DefaultValue, Parent, PortFlags, ExportRootScope); }
562 void ExportTextItem(
FString* ValueStr,
const void* PropertyValue,
const void* DefaultValue,
UObject* Parent,
int PortFlags,
UObject* ExportRootScope) { NativeCall<
void,
FString*,
const void*,
const void*,
UObject*,
int,
UObject*>(
this,
"UMulticastDelegateProperty.ExportTextItem", ValueStr, PropertyValue, DefaultValue, Parent, PortFlags, ExportRootScope); }
566 void ExportTextItem(
FString* ValueStr,
const void* PropertyValue,
const void* DefaultValue,
UObject* Parent,
int PortFlags,
UObject* ExportRootScope) { NativeCall<
void,
FString*,
const void*,
const void*,
UObject*,
int,
UObject*>(
this,
"UWeakObjectProperty.ExportTextItem", ValueStr, PropertyValue, DefaultValue, Parent, PortFlags, ExportRootScope); }
570 void ExportTextItem(
FString* ValueStr,
const void* PropertyValue,
const void* DefaultValue,
UObject* Parent,
int PortFlags,
UObject* ExportRootScope) { NativeCall<
void,
FString*,
const void*,
const void*,
UObject*,
int,
UObject*>(
this,
"UInterfaceProperty.ExportTextItem", ValueStr, PropertyValue, DefaultValue, Parent, PortFlags, ExportRootScope); }
576 const void* PropertyValue,
577 const void* DefaultValue,
581 ) { NativeCall<
void,
FString*,
const void*,
const void*,
UObject*,
int,
UObject*>(
this,
"UArrayProperty.ExportTextItem", ValueStr, PropertyValue, DefaultValue, Parent, PortFlags, ExportRootScope); }
586 __int64 GetSignedIntPropertyValue(
void const* Data) {
return NativeCall<
__int64,
void const*>(
this,
"UNumericProperty.GetSignedIntPropertyValue", Data); }
587 double GetFloatingPointPropertyValue(
void const* Data) {
return NativeCall<
double,
void const*>(
this,
"UNumericProperty.GetFloatingPointPropertyValue", Data); }
588 unsigned __int64 GetUnsignedIntPropertyValue(
void const* Data) {
return NativeCall<
unsigned __int64,
void const*>(
this,
"UNumericProperty.GetUnsignedIntPropertyValue", Data); }
593 char&
FieldSizeField() {
return *GetNativePointerField<
char*>(
this,
"UBoolProperty.FieldSize"); }
594 char&
ByteOffsetField() {
return *GetNativePointerField<
char*>(
this,
"UBoolProperty.ByteOffset"); }
595 char&
ByteMaskField() {
return *GetNativePointerField<
char*>(
this,
"UBoolProperty.ByteMask"); }
596 char&
FieldMaskField() {
return *GetNativePointerField<
char*>(
this,
"UBoolProperty.FieldMask"); }
600 static void*
operator new(
const unsigned __int64 InSize,
UObject* InOuter,
FName InName, EObjectFlags InSetFlags) {
return NativeCall<
void*,
const unsigned __int64,
UObject*,
FName, EObjectFlags>(
nullptr,
"UBoolProperty.operator new", InSize, InOuter, InName, InSetFlags); }
601 void SetBoolSize(
const unsigned int InSize,
const bool bIsNativeBool,
const unsigned int InBitMask) { NativeCall<
void,
const unsigned int,
const bool,
const unsigned int>(
this,
"UBoolProperty.SetBoolSize", InSize, bIsNativeBool, InBitMask); }
602 int GetMinAlignment() {
return NativeCall<
int>(
this,
"UBoolProperty.GetMinAlignment"); }
605 void ExportTextItem(
FString* ValueStr,
const void* PropertyValue,
const void* DefaultValue,
UObject* Parent,
int PortFlags,
UObject* ExportRootScope) { NativeCall<
void,
FString*,
const void*,
const void*,
UObject*,
int,
UObject*>(
this,
"UBoolProperty.ExportTextItem", ValueStr, PropertyValue, DefaultValue, Parent, PortFlags, ExportRootScope); }
606 bool Identical(
const void* A,
const void* B,
unsigned int PortFlags) {
return NativeCall<
bool,
const void*,
const void*,
unsigned int>(
this,
"UBoolProperty.Identical", A, B, PortFlags); }
607 void CopyValuesInternal(
void* Dest,
const void* Src,
int Count) { NativeCall<
void,
void*,
const void*,
int>(
this,
"UBoolProperty.CopyValuesInternal", Dest, Src, Count); }
608 void ClearValueInternal(
void* Data) { NativeCall<
void,
void*>(
this,
"UBoolProperty.ClearValueInternal", Data); }
615
616
617
618
619
628 nullptr,
"Global.GetObjectsOfClass", ClassToLookFor, Results, bIncludeDerivedClasses, ExclusionFlags);
632 unsigned int LoadFlags, DWORD64 Sandbox,
bool bAllowObjectReconciliation)
634 return NativeCall<
UObject*,
UClass*,
UObject*,
const wchar_t*,
const wchar_t*,
unsigned int, DWORD64,
bool>(
635 nullptr,
"Global.StaticLoadObject", ObjectClass, InOuter, InName, Filename, LoadFlags, Sandbox,
636 bAllowObjectReconciliation);
641 UObject* InTemplate,
bool bCopyTransientsFromClassDefaults,
645 nullptr,
"Global.StaticConstructObject", InClass, InOuter, InName, InFlags, InTemplate,
646 bCopyTransientsFromClassDefaults, InInstanceGraph);
650 template <
typename T>
652 void(
__cdecl* RegisterNativeFunc)());
655
656
657
666 const auto flags_value =
static_cast<std::underlying_type<ClassCastFlags>::type>(flags);
667 return object !=
nullptr && (object->ClassField()->ClassCastFlagsField() & flags_value) == flags_value;
672 const auto flags_value =
static_cast<std::underlying_type<ClassCastFlags>::type>(flags);
673 return _class !=
nullptr && (_class->ClassCastFlagsField() & flags_value) == flags_value;
680 static FORCEINLINE
UClass* FindClass(
const std::string& name)
682 for (
auto i = 0; i < Globals::GUObjectArray()().ObjObjects.NumElements; i++)
684 auto obj = Globals::GUObjectArray()().ObjObjects.GetObjectPtr(i)->Object;
688 obj->GetFullName(&full_name,
nullptr);
689 if (name == full_name.ToString())
701 UClass** ReturnClass,
void(
__cdecl* RegisterNativeFunc)())
703 return NativeCall<
void,
const wchar_t*,
const wchar_t*,
UClass**,
void(
__cdecl*)()>(
704 nullptr,
"Global.GetPrivateStaticClassBody<UClass>", PackageName, Name, ReturnClass, RegisterNativeFunc);
720 bool IsUAsset() {
return NativeCall<
bool>(
this,
"FAssetData.IsUAsset"); }
741 void FindModules(
const wchar_t* WildcardWithoutExtension,
TArray<
FName>* OutModules) { NativeCall<
void,
const wchar_t*,
TArray<
FName>*>(
this,
"FModuleManager.FindModules", WildcardWithoutExtension, OutModules); }
744 void AddModule(
FName InModuleName) { NativeCall<
void,
FName>(
this,
"FModuleManager.AddModule", InModuleName); }
746 bool UnloadModule(
FName InModuleName,
bool bIsShutdown) {
return NativeCall<
bool,
FName,
bool>(
this,
"FModuleManager.UnloadModule", InModuleName, bIsShutdown); }
751 void AddBinariesDirectory(
const wchar_t* InDirectory,
bool bIsGameDirectory) { NativeCall<
void,
const wchar_t*,
bool>(
this,
"FModuleManager.AddBinariesDirectory", InDirectory, bIsGameDirectory); }
752 void FModuleInfo() { NativeCall<
void>(
this,
"FModuleManager.FModuleInfo"); }
758 void SearchAllAssets(
bool bSynchronousSearch) { NativeCall<
void,
bool>(
this,
"FAssetRegistry.SearchAllAssets", bSynchronousSearch); }
772 float GetAssetAvailabilityProgress(
FAssetData* AssetData, EAssetAvailabilityProgressReportingType::Type ReportType) {
return NativeCall<
float,
FAssetData*, EAssetAvailabilityProgressReportingType::Type>(
this,
"FAssetRegistry.GetAssetAvailabilityProgress", AssetData, ReportType); }
773 bool GetAssetAvailabilityProgressTypeSupported(EAssetAvailabilityProgressReportingType::Type ReportType) {
return NativeCall<
bool, EAssetAvailabilityProgressReportingType::Type>(
this,
"FAssetRegistry.GetAssetAvailabilityProgressTypeSupported", ReportType); }
782 bool IsLoadingAssets() {
return NativeCall<
bool>(
this,
"FAssetRegistry.IsLoadingAssets"); }
783 void Tick(
float DeltaTime) { NativeCall<
void,
float>(
this,
"FAssetRegistry.Tick", DeltaTime); }
784 static bool IsUsingWorldAssets() {
return NativeCall<
bool>(
nullptr,
"FAssetRegistry.IsUsingWorldAssets"); }
788 bool RemoveAssetPath(
FString* PathToRemove,
bool bEvenIfAssetsStillExist) {
return NativeCall<
bool,
FString*,
bool>(
this,
"FAssetRegistry.RemoveAssetPath", PathToRemove, bEvenIfAssetsStillExist); }
824 void GetMipData(
int FirstMipToLoad,
void** OutMipData) {
return NativeCall<
void,
int,
void**>(
this,
"UTexture2D.GetMipData", FirstMipToLoad, OutMipData); }
825 void UpdateResourceW() {
return NativeCall<
void>(
this,
"UTexture2D.UpdateResourceW"); }
828 float GetSurfaceHeight() {
return NativeCall<
float>(
this,
"UTexture2D.GetSurfaceHeight"); }
829 int&
SizeX_DEPRECATED() {
return *GetNativePointerField<
int*>(
this,
"UTexture2D.SizeX_DEPRECATED"); }
830 int&
SizeY_DEPRECATED() {
return *GetNativePointerField<
int*>(
this,
"UTexture2D.SizeY_DEPRECATED"); }
838struct __declspec(align(8)) UNavArea :
UObject
841 float FixedAreaEnteringCost;
847struct __declspec(align(8)) FNavigationFilterArea
850 float TravelCostOverride;
851 float EnteringCostOverride;
852 uint32_t bIsExcluded : 1;
853 uint32_t bOverrideTravelCost : 1;
854 uint32_t bOverrideEnteringCost : 1;
904 int&
AsyncBytesReadField() {
return *GetNativePointerField<
int*>(
this,
"FHttpResponseWinInet.AsyncBytesRead"); }
905 int&
TotalBytesReadField() {
return *GetNativePointerField<
int*>(
this,
"FHttpResponseWinInet.TotalBytesRead"); }
906 TMap<
FString,
FString,
FDefaultSetAllocator,
TDefaultMapKeyFuncs<
FString,
FString, 0> >&
ResponseHeadersField() {
return *GetNativePointerField<
TMap<
FString,
FString,
FDefaultSetAllocator,
TDefaultMapKeyFuncs<
FString,
FString, 0> >*>(
this,
"FHttpResponseWinInet.ResponseHeaders"); }
907 int&
ResponseCodeField() {
return *GetNativePointerField<
int*>(
this,
"FHttpResponseWinInet.ResponseCode"); }
908 int&
ContentLengthField() {
return *GetNativePointerField<
int*>(
this,
"FHttpResponseWinInet.ContentLength"); }
910 volatile int&
bIsReadyField() {
return *GetNativePointerField<
volatile int*>(
this,
"FHttpResponseWinInet.bIsReady"); }
911 volatile int&
bResponseSucceededField() {
return *GetNativePointerField<
volatile int*>(
this,
"FHttpResponseWinInet.bResponseSucceeded"); }
923 int GetContentLength() {
return NativeCall<
int>(
this,
"FHttpResponseWinInet.GetContentLength"); }
924 TArray<
unsigned char>*
GetContent() {
return NativeCall<
TArray<
unsigned char>*>(
this,
"FHttpResponseWinInet.GetContent"); }
925 int GetResponseCode() {
return NativeCall<
int>(
this,
"FHttpResponseWinInet.GetResponseCode"); }
926 void ProcessResponse() { NativeCall<
void>(
this,
"FHttpResponseWinInet.ProcessResponse"); }
929 int QueryContentLength() {
return NativeCall<
int>(
this,
"FHttpResponseWinInet.QueryContentLength"); }
939 TMap<
FString,
FString,
FDefaultSetAllocator,
TDefaultMapKeyFuncs<
FString,
FString, 0> >&
RequestHeadersField() {
return *GetNativePointerField<
TMap<
FString,
FString,
FDefaultSetAllocator,
TDefaultMapKeyFuncs<
FString,
FString, 0> >*>(
this,
"FHttpRequestWinInet.RequestHeaders"); }
942 EHttpRequestStatus::Type&
CompletionStatusField() {
return *GetNativePointerField<EHttpRequestStatus::Type*>(
this,
"FHttpRequestWinInet.CompletionStatus"); }
943 void*
ConnectionHandleField() {
return *GetNativePointerField<
void**>(
this,
"FHttpRequestWinInet.ConnectionHandle"); }
944 void*
RequestHandleField() {
return *GetNativePointerField<
void**>(
this,
"FHttpRequestWinInet.RequestHandle"); }
947 long double&
StartRequestTimeField() {
return *GetNativePointerField<
long double*>(
this,
"FHttpRequestWinInet.StartRequestTime"); }
948 bool&
bDebugVerboseField() {
return *GetNativePointerField<
bool*>(
this,
"FHttpRequestWinInet.bDebugVerbose"); }
958 int GetContentLength() {
return NativeCall<
int>(
this,
"FHttpRequestWinInet.GetContentLength"); }
962 void SetContent(
TArray<
unsigned char>* ContentPayload) { NativeCall<
void,
TArray<
unsigned char>*>(
this,
"FHttpRequestWinInet.SetContent", ContentPayload); }
965 bool ProcessRequest() {
return NativeCall<
bool>(
this,
"FHttpRequestWinInet.ProcessRequest"); }
966 bool StartRequest() {
return NativeCall<
bool>(
this,
"FHttpRequestWinInet.StartRequest"); }
967 void FinishedRequest() { NativeCall<
void>(
this,
"FHttpRequestWinInet.FinishedRequest"); }
969 void CancelRequest() { NativeCall<
void>(
this,
"FHttpRequestWinInet.CancelRequest"); }
970 EHttpRequestStatus::Type
GetStatus() {
return NativeCall<EHttpRequestStatus::Type>(
this,
"FHttpRequestWinInet.GetStatus"); }
972 void Tick(
float DeltaSeconds) { NativeCall<
void,
float>(
this,
"FHttpRequestWinInet.Tick", DeltaSeconds); }
982 float&
HttpTimeoutField() {
return *GetNativePointerField<
float*>(
this,
"FHttpModule.HttpTimeout"); }
988 bool&
bEnableHttpField() {
return *GetNativePointerField<
bool*>(
this,
"FHttpModule.bEnableHttp"); }
992 void StartupModule() { NativeCall<
void>(
this,
"FHttpModule.StartupModule"); }
999
1000
1001
1002
1003
1004template <
typename T>
1008 UClass* objClass = T::StaticClass();
1011 return objClass->PropertiesSizeField();
1018
1019
1020
1021
1022
1023template <
typename T>
1028 UScriptStruct* staticStruct = T::StaticStruct();
1031 return staticStruct->PropertiesSizeField();
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.
static FORCEINLINE int32 BYTESWAP_ORDER32(int32 val)
static FORCEINLINE uint16 BYTESWAP_ORDER16(uint16 val)
static FORCEINLINE void BYTESWAP_ORDER_TCHARARRAY(TCHAR *str)
static FORCEINLINE uint32 BYTESWAP_ORDER32(uint32 val)
#define BYTESWAP_ORDER16_unsigned(x)
static FORCEINLINE float BYTESWAP_ORDERF(float val)
static FORCEINLINE int16 BYTESWAP_ORDER16(int16 val)
static FORCEINLINE uint64 BYTESWAP_ORDER64(uint64 Value)
static FORCEINLINE int64 BYTESWAP_ORDER64(int64 Value)
#define BYTESWAP_ORDER32_unsigned(x)
TCString< ANSICHAR > FCStringAnsi
TCString< WIDECHAR > FCStringWide
TCString< TCHAR > FCString
TChar< WIDECHAR > FCharWide
#define LITERAL(CharType, StringLiteral)
TChar< ANSICHAR > FCharAnsi
static const float OneOver255
FORCEINLINE FLinearColor operator*(float Scalar, const FLinearColor &Color)
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
FORCEINLINE FRotator operator*(float Scale, const FRotator &R)
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)
FORCEINLINE uint32 GetTypeHash(const FName &name)
TWeakObjectPtr< T > GetWeakReference(T *object)
#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 FVector2D operator*(float Scale, const FVector2D &V)
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)
static const FColor MediumSlateBlue
static const FColor Orange
static const FColor DarkGreenCopper
static const FColor BronzeII
static const FColor Yellow
static const FColor Magenta
static const FColor IndianRed
static const FColor SummerSky
static const FColor SpringGreen
static const FColor CornFlowerBlue
static const FColor GreenCopper
static const FColor MediumGoldenrod
static const FColor LimeGreen
static const FColor LightSteelBlue
static const FColor DarkOliveGreen
static const FColor Quartz
static const FColor SteelBlue
static const FColor DarkPurple
static const FColor Turquoise
static const FColor Black
static const FColor Maroon
static const FColor MediumOrchid
static const FColor NewTan
static const FColor NeonBlue
static const FColor MediumWood
static const FColor DarkSlateBlue
static const FColor White
static const FColor MandarianOrange
static const FColor Scarlet
static const FColor SeaGreen
static const FColor Aquamarine
static const FColor Wheat
static const FColor VeryDarkBrown
static const FColor Thistle
static const FColor BlueViolet
static const FColor Violet
static const FColor MediumSpringGreen
static const FColor NavyBlue
static const FColor CoolCopper
static const FColor DarkTan
static const FColor Firebrick
static const FColor GreenYellow
static const FColor DarkOrchid
static const FColor SemiSweetChocolate
static const FColor SpicyPink
static const FColor OldGold
static const FColor DarkTurquoise
static const FColor PaleGreen
static const FColor BrightGold
static const FColor CadetBlue
static const FColor BakerChocolate
static const FColor DarkGreen
static const FColor Coral
static const FColor OrangeRed
static const FColor HunterGreen
static const FColor VeryLightGrey
static const FColor MediumVioletRed
static const FColor Silver
static const FColor MediumSeaGreen
static const FColor DarkSlateGrey
static const FColor Khaki
static const FColor DustyRose
static const FColor Bronze
static const FColor MediumBlue
static const FColor Goldenrod
static const FColor Feldspar
static const FColor LightBlue
static const FColor DimGrey
static const FColor Brown
static const FColor VioletRed
static const FColor Orchid
static const FColor LightWood
static const FColor SlateBlue
static const FColor DarkWood
static const FColor NeonPink
static const FColor MediumTurquoise
static const FColor MediumForestGreen
static const FColor Salmon
static const FColor Brass
static const FColor ForestGreen
static const FColor Sienna
static const FColor MediumAquamarine
static const FColor YellowGreen
static const FColor Green
static const FColor RichBlue
static const FColor MidnightBlue
static const FColor LightGrey
static const FColor SkyBlue
static const FColor NewMidnightBlue
static const FColor DarkBrown
static const FColor Copper
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)
FORCEINLINE bool operator()(T &&A, T &&B) const
TReversePredicate(const PredicateType &InPredicate)
const PredicateType & 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 void Sort(RangeType &Range)
FORCEINLINE int32 LowerBoundBy(RangeType &Range, const ValueType &Value, ProjectionType Projection, SortPredicateType SortPredicate)
FORCEINLINE int32 LowerBoundBy(RangeType &Range, const ValueType &Value, ProjectionType Projection)
FORCEINLINE void SortBy(RangeType &Range, ProjectionType Proj)
FORCEINLINE int32 UpperBoundBy(RangeType &Range, const ValueType &Value, ProjectionType Projection)
FORCEINLINE int32 UpperBound(RangeType &Range, const ValueType &Value)
FORCEINLINE void Sort(RangeType &Range, PredicateType Pred)
FORCEINLINE void IntroSort(RangeType &Range)
FORCEINLINE int32 BinarySearchBy(RangeType &Range, const ValueType &Value, ProjectionType Projection)
FORCEINLINE void IntroSortBy(RangeType &Range, ProjectionType Projection, PredicateType Predicate)
FORCEINLINE void IntroSort(RangeType &Range, PredicateType Predicate)
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 void IntroSortBy(RangeType &Range, ProjectionType Projection)
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 void SortBy(RangeType &Range, ProjectionType Proj, PredicateType Pred)
FORCEINLINE int32 LowerBound(RangeType &Range, const ValueType &Value, SortPredicateType SortPredicate)
FORCEINLINE int32 LowerBound(RangeType &Range, const ValueType &Value)
FORCEINLINE bool HeapIsLeaf(int32 Index, int32 Count)
FORCEINLINE int32 HeapGetParentIndex(int32 Index)
void IntroSortInternal(T *First, SIZE_T Num, ProjectionType Projection, PredicateType Predicate)
FORCEINLINE int32 HeapGetLeftChildIndex(int32 Index)
FORCEINLINE int32 HeapSiftUp(RangeValueType *Heap, int32 RootIndex, int32 NodeIndex, const ProjectionType &Projection, const PredicateType &Predicate)
FORCEINLINE void HeapSiftDown(RangeValueType *Heap, int32 Index, const int32 Count, const ProjectionType &Projection, const PredicateType &Predicate)
FORCEINLINE void HeapifyInternal(RangeValueType *First, SIZE_T Num, ProjectionType Projection, PredicateType Predicate)
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)
void HeapSortInternal(RangeValueType *First, SIZE_T Num, ProjectionType Projection, PredicateType Predicate)
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)
void PrioritizeAssetInstall(FAssetData *AssetData)
EAssetAvailability::Type GetAssetAvailability(FAssetData *AssetData)
bool GetDependencies(FName PackageName, TArray< FName > *OutDependencies)
float GetAssetAvailabilityProgress(FAssetData *AssetData, EAssetAvailabilityProgressReportingType::Type ReportType)
bool GetAssetsByPackageName(FName PackageName, TArray< FAssetData > *OutAssetData)
void AssetRenamed(UObject *RenamedAsset, FString *OldObjectPath)
void GetSubPaths(FString *InBasePath, TArray< FString > *OutPathList, bool bInRecurse)
void AddAssetData(FAssetData *AssetData)
void PrioritizeSearchPath(FString *PathToPrioritize)
bool GetAssetsByClass(FName ClassName, TArray< FAssetData > *OutAssetData, bool bSearchSubClasses)
bool GetAllAssets(TArray< FAssetData > *OutAssetData)
void SearchAllAssets(bool bSynchronousSearch)
void ScanPathsSynchronous_Internal(TArray< FString > *InPaths, bool bForceRescan, bool bUseCache)
void OnContentPathMounted(FString *InAssetPath, FString *FileSystemPath)
bool RemoveAssetData(FAssetData *AssetData)
FAssetData * GetAssetByObjectPath(FAssetData *result, FName ObjectPath)
void AssetDeleted(UObject *DeletedAsset)