Ark Server API (ASE) - Wiki
Loading...
Searching...
No Matches
UE.h
Go to the documentation of this file.
1#pragma once
2
3#include <comdef.h>
4#include <xmmintrin.h>
5
6#include "Crc.h"
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"
12#include "API/Enums.h"
13#include "API/UE/Math/Color.h"
14#include "Misc/GlobalObjectsArray.h"
15
16// Base types
17
18struct FText;
19
20struct FName
21{
23 unsigned int Number;
24
25 // Functions
26
28 {
29 }
30
32 {
33 }
34
35 static FString* NameToDisplayString(FString* result, FString* InDisplayName, const bool bIsBool) { return NativeCall<FString*, FString*, FString*, const bool>(nullptr, "FName.NameToDisplayString", result, InDisplayName, bIsBool); }
36
37 FName(const char* Name, EFindName FindType)
38 {
39 Init(Name, 0, FindType, true, -1);
40 }
41
42 bool operator==(const wchar_t* Other) { return NativeCall<bool, const wchar_t*>(this, "FName.operator==", Other); }
43 int Compare(FName* Other) { return NativeCall<int, FName*>(this, "FName.Compare", Other); }
44 void ToString(FString* Out) { NativeCall<void, FString*>(this, "FName.ToString", Out); }
46 {
47 FString out;
48 FName tmp = *this;
49
50 tmp.ToString(&out);
51
52 return out;
53 }
54 void AppendString(FString* Out) { NativeCall<void, FString*>(this, "FName.AppendString", Out); }
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); }
56 bool IsValidXName(FString InvalidChars, FText* Reason) { return NativeCall<bool, FString, FText*>(this, "FName.IsValidXName", InvalidChars, Reason); }
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); }
58 FString* GetPlainNameString(FString* result) { return NativeCall<FString*, FString*>(this, "FName.GetPlainNameString", result); }
59
60 bool operator==(const FName& Other) const { return Other.ToString() == this->ToString(); }
61};
62
63FORCEINLINE uint32 GetTypeHash(const FName& name)
64{
65 return FCrc::MemCrc32(&name, sizeof(FName));
66}
67
69{
70 __m128 Rotation;
72 __m128 Scale3D;
73};
74
76{
77};
78
79struct FGuid
80{
81 uint32_t A;
82 uint32_t B;
83 uint32_t C;
84 uint32_t D;
85};
86
87struct FBox
88{
89};
90
91template <typename ObjectType>
93{
94 ObjectType* Object;
95
96 FORCEINLINE ObjectType& operator*() const
97 {
98 return *Object;
99 }
100
101 FORCEINLINE ObjectType* operator->() const
102 {
103 return Object;
104 }
105};
106
107struct __declspec(align(8)) FTextHistory
108{
109 void* vfptr;
110 int Revision;
111};
112
113struct FText
114{
115 TSharedPtr<FTextHistory> History;
116 int Flags;
118
119 // Functions
120
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"); }
123 FText(FText* Source) { NativeCall<void, FText*>(this, "FText.FText", Source); }
124 FText* operator=(FText* Source) { return NativeCall<FText*, FText*>(this, "FText.operator=", Source); }
125 FText(FString InSourceString) { NativeCall<void, FString>(this, "FText.FText", InSourceString); }
126 FText(FString InSourceString, FString InNamespace, FString InKey, int InFlags) { NativeCall<void, FString, FString, FString, int>(this, "FText.FText", InSourceString, InNamespace, InKey, InFlags); }
127 static FText* TrimPreceding(FText* result, FText* InText) { return NativeCall<FText*, FText*, FText*>(nullptr, "FText.TrimPreceding", result, InText); }
128 static FText* TrimTrailing(FText* result, FText* InText) { return NativeCall<FText*, FText*, FText*>(nullptr, "FText.TrimTrailing", result, InText); }
129 static FText* TrimPrecedingAndTrailing(FText* result, FText* InText) { return NativeCall<FText*, FText*, FText*>(nullptr, "FText.TrimPrecedingAndTrailing", result, InText); }
130 static FText* Format(FText* result, FText* Fmt, FText* v1) { return NativeCall<FText*, FText*, FText*, FText*>(nullptr, "FText.Format", result, Fmt, v1); }
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); }
134 static FText* CreateChronologicalText(FText* result, FString InSourceString) { return NativeCall<FText*, FText*, FString>(nullptr, "FText.CreateChronologicalText", result, InSourceString); }
135 static FText* FromName(FText* result, FName* Val) { return NativeCall<FText*, FText*, FName*>(nullptr, "FText.FromName", result, Val); }
136 static FText* FromString(FText* result, FString String) { return NativeCall<FText*, FText*, FString>(nullptr, "FText.FromString", result, String); }
137 FString* ToString() { return NativeCall<FString*>(this, "FText.ToString"); }
138 bool ShouldGatherForLocalization() { return NativeCall<bool>(this, "FText.ShouldGatherForLocalization"); }
139 TSharedPtr<FString>* GetSourceString(TSharedPtr<FString>* result) { return NativeCall<TSharedPtr<FString>*, TSharedPtr<FString>*>(this, "FText.GetSourceString", result); }
140 static void GetEmpty() { NativeCall<void>(nullptr, "FText.GetEmpty"); }
141};
142
144{
145};
146
148{
151
152 void operator=(UObject const* __that) { return NativeCall<void, UObject const*>(this, "FWeakObjectPtr.operator=", __that); }
153 bool IsValid() { return NativeCall<bool>(this, "FWeakObjectPtr.IsValid"); }
154};
155
156template <typename T>
158{
161
162 FORCEINLINE T& operator*()
163 {
164 return *Get();
165 }
166
167 FORCEINLINE T* operator->()
168 {
169 return Get();
170 }
171
172 T* Get(bool bEvenIfPendingKill = false)
173 {
174 return NativeCall<T*, bool>(this, "FWeakObjectPtr.Get", bEvenIfPendingKill);
175 }
176
177 FORCEINLINE operator bool()
178 {
179 return Get() != nullptr;
180 }
181
182 FORCEINLINE operator T* ()
183 {
184 return Get();
185 }
186
187 FORCEINLINE bool operator==(const TWeakObjectPtr<T>& __that) const
188 {
189 return this->ObjectIndex == __that.ObjectIndex
191 }
192
194 {}
195
196 TWeakObjectPtr(int index, int serialnumber)
199 {}
200};
201
202template <typename T>
204{
205 FWeakObjectPtr tempWeak;
206 tempWeak.operator=(object);
207 TWeakObjectPtr<T> tempTWeak(tempWeak.ObjectIndex, tempWeak.ObjectSerialNumber);
208 return tempTWeak;
209}
210template <typename T>
211using TAutoWeakObjectPtr = TWeakObjectPtr<T>;
212
213template <typename T>
215{
217 : uClass(nullptr)
218 {
219 }
220
222 : uClass(uClass)
223 {
224 }
225
227};
228
230{
231 void* vfptr;
232 FString* ToHumanReadableString(FString* result) { return NativeCall<FString*, FString*>(this, "IOnlinePlatformData.ToHumanReadableString", result); }
233};
234
236{
237};
238
240{
241 unsigned __int64& UniqueNetIdField() { return *GetNativePointerField<unsigned __int64*>(this, "FUniqueNetIdUInt64.UniqueNetId"); }
242
243 // Functions
244
245 FUniqueNetIdUInt64(FString* Str) { NativeCall<void, FString*>(this, "FUniqueNetIdUInt64.FUniqueNetIdUInt64", Str); }
246 FUniqueNetIdUInt64(FUniqueNetIdUInt64* Src) { NativeCall<void, FUniqueNetIdUInt64*>(this, "FUniqueNetIdUInt64.FUniqueNetIdUInt64", Src); }
247 FUniqueNetIdUInt64(FUniqueNetId* InUniqueNetId) { NativeCall<void, FUniqueNetId*>(this, "FUniqueNetIdUInt64.FUniqueNetIdUInt64", InUniqueNetId); }
248 FUniqueNetIdUInt64(uint64 InUniqueNetId) { NativeCall<void, uint64>(this, "FUniqueNetIdUInt64.FUniqueNetIdUInt64", InUniqueNetId); }
249
250 bool IsValid() { return NativeCall<bool>(this, "FUniqueNetIdUInt64.IsValid"); }
251 FString* ToDebugString(FString* result) { return NativeCall<FString*, FString*>(this, "FUniqueNetIdUInt64.ToDebugString", result); }
252 unsigned int GetHash() { return NativeCall<int>(this, "FUniqueNetIdUInt64.GetHash"); }
253 FString* ToString(FString* result) { return NativeCall<FString*, FString*>(this, "FUniqueNetIdUInt64.ToString", result); }
254};
255
257{
258 unsigned __int64 UniqueNetId;
259
260 // Functions
261
262 int GetSize() { return NativeCall<int>(this, "FUniqueNetIdSteam.GetSize"); }
263 FString* ToString(FString* result) { return NativeCall<FString*, FString*>(this, "FUniqueNetIdSteam.ToString", result); }
264 bool IsValid() { return NativeCall<bool>(this, "FUniqueNetIdSteam.IsValid"); }
265 FString* ToDebugString(FString* result) { return NativeCall<FString*, FString*>(this, "FUniqueNetIdSteam.ToDebugString", result); }
266};
267
269{
271};
272
274{
275 EObjectFlags& ObjectFlagsField() { return *GetNativePointerField<EObjectFlags*>(this, "UObjectBase.ObjectFlags"); }
276 int& InternalIndexField() { return *GetNativePointerField<int*>(this, "UObjectBase.InternalIndex"); }
277 UClass* ClassField() { return *GetNativePointerField<UClass**>(this, "UObjectBase.Class"); }
278 FName& NameField() { return *GetNativePointerField<FName*>(this, "UObjectBase.Name"); }
279 UObject* OuterField() { return *GetNativePointerField<UObject**>(this, "UObjectBase.Outer"); }
280
281 // Functions
282
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); }
286 static void EmitBaseReferences(UClass* RootClass) { NativeCall<void, UClass*>(nullptr, "UObjectBase.EmitBaseReferences", RootClass); }
287 void Register(const wchar_t* PackageName, const wchar_t* InName) { NativeCall<void, const wchar_t*, const wchar_t*>(this, "UObjectBase.Register", PackageName, InName); }
288};
289
291{
292 int GetLinkerUE4Version() { return NativeCall<int>(this, "UObjectBaseUtility.GetLinkerUE4Version"); }
293 int GetLinkerLicenseeUE4Version() { return NativeCall<int>(this, "UObjectBaseUtility.GetLinkerLicenseeUE4Version"); }
294 FString* GetPathName(FString* result, UObject* StopOuter) { return NativeCall<FString*, FString*, UObject*>(this, "UObjectBaseUtility.GetPathName", result, StopOuter); }
295 void GetPathName(UObject* StopOuter, FString* ResultString) { NativeCall<void, UObject*, FString*>(this, "UObjectBaseUtility.GetPathName", StopOuter, ResultString); }
296 FString* GetFullName(FString* result, UObject* StopOuter) { return NativeCall<FString*, FString*, UObject*>(this, "UObjectBaseUtility.GetFullName", result, StopOuter); }
297 void MarkPackageDirty() { NativeCall<void>(this, "UObjectBaseUtility.MarkPackageDirty"); }
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); }
300 void* GetInterfaceAddress(UClass* InterfaceClass) { return NativeCall<void*, UClass*>(this, "UObjectBaseUtility.GetInterfaceAddress", InterfaceClass); }
301 bool IsDefaultSubobject() { return NativeCall<bool>(this, "UObjectBaseUtility.IsDefaultSubobject"); }
302 int GetLinkerIndex() { return NativeCall<int>(this, "UObjectBaseUtility.GetLinkerIndex"); }
303};
304
306{
307 static UClass* GetPrivateStaticClass() { return NativeCall<UClass*>(nullptr, "UObject.GetPrivateStaticClass"); }
308 static UClass* StaticClass() { return NativeCall<UClass*>(nullptr, "UObject.StaticClass"); }
309 void ExecuteUbergraph(int EntryPoint) { NativeCall<void, int>(this, "UObject.ExecuteUbergraph", EntryPoint); }
310 bool AreAllOuterObjectsValid() { return NativeCall<bool>(this, "UObject.AreAllOuterObjectsValid"); }
311 FName* GetExporterName(FName* result) { return NativeCall<FName*, FName*>(this, "UObject.GetExporterName", result); }
312 FString* GetDetailedInfoInternal(FString* result) { return NativeCall<FString*, FString*>(this, "UObject.GetDetailedInfoInternal", result); }
313 UObject* GetArchetype() { return NativeCall<UObject*>(this, "UObject.GetArchetype"); }
314 bool IsBasedOnArchetype(UObject* const SomeObject) { return NativeCall<bool, UObject* const>(this, "UObject.IsBasedOnArchetype", SomeObject); }
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"); }
320 void FinishDestroy() { NativeCall<void>(this, "UObject.FinishDestroy"); }
321 FString* GetDetailedInfo(FString* result) { return NativeCall<FString*, FString*>(this, "UObject.GetDetailedInfo", result); }
322 bool ConditionalBeginDestroy() { return NativeCall<bool>(this, "UObject.ConditionalBeginDestroy"); }
323 bool ConditionalFinishDestroy() { return NativeCall<bool>(this, "UObject.ConditionalFinishDestroy"); }
324 void ConditionalPostLoad() { NativeCall<void>(this, "UObject.ConditionalPostLoad"); }
325 bool Modify(bool bAlwaysMarkDirty) { return NativeCall<bool, bool>(this, "UObject.Modify", bAlwaysMarkDirty); }
326 bool IsSelected() { return NativeCall<bool>(this, "UObject.IsSelected"); }
327 void CollectDefaultSubobjects(TArray<UObject*>* OutSubobjectArray, bool bIncludeNestedSubobjects) { NativeCall<void, TArray<UObject*>*, bool>(this, "UObject.CollectDefaultSubobjects", OutSubobjectArray, bIncludeNestedSubobjects); }
328 bool CheckDefaultSubobjectsInternal() { return NativeCall<bool>(this, "UObject.CheckDefaultSubobjectsInternal"); }
329 bool IsAsset() { return NativeCall<bool>(this, "UObject.IsAsset"); }
330 bool IsSafeForRootSet() { return NativeCall<bool>(this, "UObject.IsSafeForRootSet"); }
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); }
332 void ConditionalShutdownAfterError() { NativeCall<void>(this, "UObject.ConditionalShutdownAfterError"); }
333 bool IsNameStableForNetworking() { return NativeCall<bool>(this, "UObject.IsNameStableForNetworking"); }
334 bool IsFullNameStableForNetworking() { return NativeCall<bool>(this, "UObject.IsFullNameStableForNetworking"); }
335 bool IsSupportedForNetworking() { return NativeCall<bool>(this, "UObject.IsSupportedForNetworking"); }
336 UFunction* FindFunctionChecked(FName InName) { return NativeCall<UFunction*, FName>(this, "UObject.FindFunctionChecked", InName); }
337 void ProcessEvent(UFunction* Function, void* Parms) { NativeCall<void, UFunction*, void*>(this, "UObject.ProcessEvent", Function, Parms); }
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); }
339 __declspec(dllexport) UProperty* FindProperty(FName name);
340};
341
343{
344 UField* NextField() { return *GetNativePointerField<UField**>(this, "UField.Next"); }
345
346 // Functions
347
348 UClass* GetOwnerClass() { return NativeCall<UClass*>(this, "UField.GetOwnerClass"); }
349 UStruct* GetOwnerStruct() { return NativeCall<UStruct*>(this, "UField.GetOwnerStruct"); }
350 void PostLoad() { NativeCall<void>(this, "UField.PostLoad"); }
351 void AddCppProperty(UProperty* Property) { NativeCall<void, UProperty*>(this, "UField.AddCppProperty", Property); }
352};
353
355{
356 UStruct* SuperStructField() { return *GetNativePointerField<UStruct**>(this, "UStruct.SuperStruct"); }
357 UField* ChildrenField() { return *GetNativePointerField<UField**>(this, "UStruct.Children"); }
358 int& PropertiesSizeField() { return *GetNativePointerField<int*>(this, "UStruct.PropertiesSize"); }
359 TArray<unsigned char>& ScriptField() { return *GetNativePointerField<TArray<unsigned char>*>(this, "UStruct.Script"); }
360 int& MinAlignmentField() { return *GetNativePointerField<int*>(this, "UStruct.MinAlignment"); }
361 UProperty* PropertyLinkField() { return *GetNativePointerField<UProperty**>(this, "UStruct.PropertyLink"); }
362 UProperty* RefLinkField() { return *GetNativePointerField<UProperty**>(this, "UStruct.RefLink"); }
363 UProperty* DestructorLinkField() { return *GetNativePointerField<UProperty**>(this, "UStruct.DestructorLink"); }
364 UProperty* PostConstructLinkField() { return *GetNativePointerField<UProperty**>(this, "UStruct.PostConstructLink"); }
365 TArray<UObject*> ScriptObjectReferencesField() { return *GetNativePointerField<TArray<UObject*>*>(this, "UStruct.ScriptObjectReferences"); }
366
367 // Functions
368
369 bool IsChildOf(UStruct* SomeBase) { return NativeCall<bool, UStruct*>(this, "UStruct.IsChildOf", SomeBase); }
370 UField* StaticClass() { return NativeCall<UField*>(this, "UStruct.StaticClass"); }
371 void LinkChild(UProperty* Property) { NativeCall<void, UProperty*>(this, "UStruct.LinkChild", Property); }
372 const wchar_t* GetPrefixCPP() { return NativeCall<const wchar_t*>(this, "UStruct.GetPrefixCPP"); }
373 void RegisterDependencies() { NativeCall<void>(this, "UStruct.RegisterDependencies"); }
374 void StaticLink(bool bRelinkExistingProperties) { NativeCall<void, bool>(this, "UStruct.StaticLink", bRelinkExistingProperties); }
375 void FinishDestroy() { NativeCall<void>(this, "UStruct.FinishDestroy"); }
376 void SetSuperStruct(UStruct* NewSuperStruct) { NativeCall<void, UStruct*>(this, "UStruct.SetSuperStruct", NewSuperStruct); }
377 void TagSubobjects(EObjectFlags NewFlags) { NativeCall<void, EObjectFlags>(this, "UStruct.TagSubobjects", NewFlags); }
378};
379
381{
382 unsigned int FunctionFlags;
383 unsigned __int16 RepOffset;
385 unsigned __int16 ParmsSize;
386 unsigned __int16 ReturnValueOffset;
387 unsigned __int16 RPCId;
388 unsigned __int16 RPCResponseId;
390};
391
393{
395 void(__fastcall* Pointer)(UObject* _this, void*, void* const);
396};
397
399{
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"); }
403 UClass* ClassWithinField() { return *GetNativePointerField<UClass**>(this, "UClass.ClassWithin"); }
404 UObject* ClassGeneratedByField() { return *GetNativePointerField<UObject**>(this, "UClass.ClassGeneratedBy"); }
405 bool& bIsGameClassField() { return *GetNativePointerField<bool*>(this, "UClass.bIsGameClass"); }
406 FName& ClassConfigNameField() { return *GetNativePointerField<FName*>(this, "UClass.ClassConfigName"); }
407 TArray<UField*> NetFieldsField() { return *GetNativePointerField<TArray<UField*>*>(this, "UClass.NetFields"); }
408 UObject* ClassDefaultObjectField() { return *GetNativePointerField<UObject**>(this, "UClass.ClassDefaultObject"); }
409 bool& bCookedField() { return *GetNativePointerField<bool*>(this, "UClass.bCooked"); }
410 TMap<FName, UFunction*> FuncMapField() { return *GetNativePointerField<TMap<FName, UFunction*>*>(this, "UClass.FuncMap"); }
411 TArray<FNativeFunctionLookup>& NativeFunctionLookupTableField() { return *GetNativePointerField<TArray<FNativeFunctionLookup>*>(this, "UClass.NativeFunctionLookupTable"); }
412
413 // Functions
414
415 UObject* GetDefaultObject(bool bCreateIfNeeded) { return NativeCall<UObject*, bool>(this, "UClass.GetDefaultObject", bCreateIfNeeded); }
416 void AddFunctionToFunctionMap(UFunction* NewFunction) { NativeCall<void, UFunction*>(this, "UClass.AddFunctionToFunctionMap", NewFunction); }
417 void PostInitProperties() { NativeCall<void>(this, "UClass.PostInitProperties"); }
418 UObject* GetDefaultSubobjectByName(FName ToFind) { return NativeCall<UObject*, FName>(this, "UClass.GetDefaultSubobjectByName", ToFind); }
419 void GetDefaultObjectSubobjects(TArray<UObject*>* OutDefaultSubobjects) { NativeCall<void, TArray<UObject*>*>(this, "UClass.GetDefaultObjectSubobjects", OutDefaultSubobjects); }
420 UObject* CreateDefaultObject() { return NativeCall<UObject*>(this, "UClass.CreateDefaultObject"); }
421 FName* GetDefaultObjectName(FName* result) { return NativeCall<FName*, FName*>(this, "UClass.GetDefaultObjectName", result); }
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"); }
427 FString* GetDescription(FString* result) { return NativeCall<FString*, FString*>(this, "UClass.GetDescription", result); }
428 void FinishDestroy() { NativeCall<void>(this, "UClass.FinishDestroy"); }
429 void PostLoad() { NativeCall<void>(this, "UClass.PostLoad"); }
430 void SetSuperStruct(UStruct* NewSuperStruct) { NativeCall<void, UStruct*>(this, "UClass.SetSuperStruct", NewSuperStruct); }
431 bool ImplementsInterface(UClass* SomeInterface) { return NativeCall<bool, UClass*>(this, "UClass.ImplementsInterface", SomeInterface); }
432 void PurgeClass(bool bRecompilingOnLoad) { NativeCall<void, bool>(this, "UClass.PurgeClass", bRecompilingOnLoad); }
433 bool HasProperty(UProperty* InProperty) { return NativeCall<bool, UProperty*>(this, "UClass.HasProperty", InProperty); }
434 UFunction* FindFunctionByName(FName InName, EIncludeSuperFlag::Type IncludeSuper) { return NativeCall<UFunction*, FName, EIncludeSuperFlag::Type>(this, "UClass.FindFunctionByName", InName, IncludeSuper); }
435 FString* GetConfigName(FString* result) { return NativeCall<FString*, FString*>(this, "UClass.GetConfigName", result); }
436 unsigned int EmitStructArrayBegin(int Offset, FName* DebugName, int Stride) { return NativeCall<unsigned int, int, FName*, int>(this, "UClass.EmitStructArrayBegin", Offset, DebugName, Stride); }
437 void AssembleReferenceTokenStream() { NativeCall<void>(this, "UClass.AssembleReferenceTokenStream"); }
438};
439
441{
442 TSubclassOf<UObject>& SkeletonGeneratedClassField() { return *GetNativePointerField<TSubclassOf<UObject>*>(this, "UBlueprintCore.SkeletonGeneratedClass"); }
443 TSubclassOf<UObject>& GeneratedClassField() { return *GetNativePointerField<TSubclassOf<UObject>*>(this, "UBlueprintCore.GeneratedClass"); }
444 bool& bLegacyNeedToPurgeSkelRefsField() { return *GetNativePointerField<bool*>(this, "UBlueprintCore.bLegacyNeedToPurgeSkelRefs"); }
445 bool& bLegacyGeneratedClassIsAuthoritativeField() { return *GetNativePointerField<bool*>(this, "UBlueprintCore.bLegacyGeneratedClassIsAuthoritative"); }
446 FGuid& BlueprintGuidField() { return *GetNativePointerField<FGuid*>(this, "UBlueprintCore.BlueprintGuid"); }
447
448 // Functions
449
450 void GenerateDeterministicGuid() { NativeCall<void>(this, "UBlueprintCore.GenerateDeterministicGuid"); }
451};
452
454{
455 TSubclassOf<UObject>& ParentClassField() { return *GetNativePointerField<TSubclassOf<UObject>*>(this, "UBlueprint.ParentClass"); }
456 UObject* PRIVATE_InnermostPreviousCDOField() { return *GetNativePointerField<UObject**>(this, "UBlueprint.PRIVATE_InnermostPreviousCDO"); }
457 TArray<UActorComponent*> ComponentTemplatesField() { return *GetNativePointerField<TArray<UActorComponent*>*>(this, "UBlueprint.ComponentTemplates"); }
458 TEnumAsByte<enum EBlueprintType>& BlueprintTypeField() { return *GetNativePointerField<TEnumAsByte<enum EBlueprintType>*>(this, "UBlueprint.BlueprintType"); }
459 int& BlueprintSystemVersionField() { return *GetNativePointerField<int*>(this, "UBlueprint.BlueprintSystemVersion"); }
460
461 // Functions
462
463 FString* GetDesc(FString* result) { return NativeCall<FString*, FString*>(this, "UBlueprint.GetDesc", result); }
464 bool NeedsLoadForClient() { return NativeCall<bool>(this, "UBlueprint.NeedsLoadForClient"); }
465 bool NeedsLoadForServer() { return NativeCall<bool>(this, "UBlueprint.NeedsLoadForServer"); }
466 void TagSubobjects(EObjectFlags NewFlags) { NativeCall<void, EObjectFlags>(this, "UBlueprint.TagSubobjects", NewFlags); }
467};
468
470{
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"); }
475 FName& RepNotifyFuncField() { return *GetNativePointerField<FName*>(this, "UProperty.RepNotifyFunc"); }
476 int& Offset_InternalField() { return *GetNativePointerField<int*>(this, "UProperty.Offset_Internal"); }
477 UProperty* PropertyLinkNextField() { return *GetNativePointerField<UProperty**>(this, "UProperty.PropertyLinkNext"); }
478 UProperty* NextRefField() { return *GetNativePointerField<UProperty**>(this, "UProperty.NextRef"); }
479 UProperty* DestructorLinkNextField() { return *GetNativePointerField<UProperty**>(this, "UProperty.DestructorLinkNext"); }
480 UProperty* PostConstructLinkNextField() { return *GetNativePointerField<UProperty**>(this, "UProperty.PostConstructLinkNext"); }
481
482 // Functions
483
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); }
488 FString* GetCPPType(FString* result, FString* ExtendedTypeText, unsigned int CPPExportFlags) { return NativeCall<FString*, FString*, FString*, unsigned int>(this, "UProperty.GetCPPType", result, ExtendedTypeText, CPPExportFlags); }
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); }
490 bool ShouldDuplicateValue() { return NativeCall<bool>(this, "UProperty.ShouldDuplicateValue"); }
491 FString* GetCPPMacroType(FString* result, FString* ExtendedTypeText) { return NativeCall<FString*, FString*, FString*>(this, "UProperty.GetCPPMacroType", result, ExtendedTypeText); }
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); }
495 FName* GetID(FName* result) { return NativeCall<FName*, FName*>(this, "UProperty.GetID", result); }
496 bool SameType(UProperty* Other) { return NativeCall<bool, UProperty*>(this, "UProperty.SameType", Other); }
497
498 template<typename T>
499 T Get(UObject* object)
500 {
501 if (!object->StaticClass()->HasProperty(this))
502 throw std::invalid_argument("Object does not contain this property.");
503 if (sizeof(T) != this->ElementSizeField())
504 throw std::invalid_argument("Expected size does not match property size.");
505 return *((T*)(object + this->Offset_InternalField()));
506 }
507
508 template<typename T>
509 void Set(UObject* object, T value)
510 {
511 if (!object->StaticClass()->HasProperty(this))
512 throw std::invalid_argument("Object does not contain this property.");
513 if (sizeof(T) != this->ElementSizeField())
514 throw std::invalid_argument("Expected size does not match property size.");
515 *((T*)(object + this->Offset_InternalField())) = value;
516 }
517};
518
520
522{
523 UClass* PropertyClassField() { return *GetNativePointerField<UClass**>(this, "UObjectPropertyBase.PropertyClass"); }
524};
525
527{
528 UScriptStruct* StructField() { return *GetNativePointerField<UScriptStruct* *>(this, "UStructProperty.Struct"); }
530 FString* ValueStr,
531 const void* PropertyValue,
532 const void* DefaultValue,
533 UObject* Parent,
534 int PortFlags,
535 UObject* ExportRootScope
536 ) {
537 NativeCall<void, FString*, const void*, const void*, UObject*, int, UObject*>(this, "UStructProperty.ExportTextItem", ValueStr, PropertyValue, DefaultValue, Parent, PortFlags, ExportRootScope);
538 }
539};
540
541template<typename InTCppType> struct TPropertyTypeFundamentals {};
542template<typename InTCppType, class TInPropertyBaseClass>
543struct TProperty : public TInPropertyBaseClass, public TPropertyTypeFundamentals<InTCppType> {};
544template<typename InTCppType> struct TUObjectPropertyBase : public TProperty<InTCppType, UObjectPropertyBase> {};
545
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); }
548};
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); }
551};
552
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); }
555};
556
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); }
559};
560
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); }
563};
564
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); }
567};
568
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); }
571};
572
575 FString* ValueStr,
576 const void* PropertyValue,
577 const void* DefaultValue,
578 UObject* Parent,
579 int PortFlags,
580 UObject* ExportRootScope
581 ) { NativeCall<void, FString*, const void*, const void*, UObject*, int, UObject*>(this, "UArrayProperty.ExportTextItem", ValueStr, PropertyValue, DefaultValue, Parent, PortFlags, ExportRootScope); }
582};
583
585{
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); }
589};
590
592{
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"); }
597
598 // Functions
599
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"); }
603 FString* GetCPPType(FString* result, FString* ExtendedTypeText, unsigned int CPPExportFlags) { return NativeCall<FString*, FString*, FString*, unsigned int>(this, "UBoolProperty.GetCPPType", result, ExtendedTypeText, CPPExportFlags); }
604 FString* GetCPPMacroType(FString* result, FString* ExtendedTypeText) { return NativeCall<FString*, FString*, FString*>(this, "UBoolProperty.GetCPPMacroType", result, ExtendedTypeText); }
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); }
609};
610
611//not using this right now so leave empty
613{
614 /*UObject *SourceRoot;
615 UObject *DestinationRoot;
616 bool bCreatingArchetype;
617 bool bEnableSubobjectInstancing;
618 bool bLoadingObject;
619 TMap<UObject *, UObject *, FDefaultSetAllocator, TDefaultMapKeyFuncs<UObject *, UObject *, 0> > SourceToDestinationMap;*/
620};
621
623{
624 //void __fastcall GetObjectsOfClass(UClass *ClassToLookFor, TArray<UObject *,FDefaultAllocator> *Results, bool bIncludeDerivedClasses, EObjectFlags ExclusionFlags)
625 static void GetObjectsOfClass(UClass* ClassToLookFor, TArray<UObject*, FDefaultAllocator>* Results, bool bIncludeDerivedClasses, EObjectFlags ExclusionFlags)
626 {
627 NativeCall<void, UClass*, TArray<UObject*, FDefaultAllocator>*, bool, EObjectFlags >(
628 nullptr, "Global.GetObjectsOfClass", ClassToLookFor, Results, bIncludeDerivedClasses, ExclusionFlags);
629 }
630
631 static UObject* StaticLoadObject(UClass* ObjectClass, UObject* InOuter, const wchar_t* InName, const wchar_t* Filename,
632 unsigned int LoadFlags, DWORD64 Sandbox, bool bAllowObjectReconciliation)
633 {
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);
637 }
638
639 //UObject *__fastcall StaticConstructObject(UClass *InClass, UObject *InOuter, FName InName, EObjectFlags InFlags, UObject *InTemplate, bool bCopyTransientsFromClassDefaults, FObjectInstancingGraph *InInstanceGraph)
640 static UObject* StaticConstructObject(UClass* InClass, UObject* InOuter, FName InName, EObjectFlags InFlags,
641 UObject* InTemplate, bool bCopyTransientsFromClassDefaults,
642 FObjectInstancingGraph* InInstanceGraph)
643 {
644 return NativeCall<UObject*, UClass*, UObject*, FName, EObjectFlags, UObject*, bool, FObjectInstancingGraph*>(
645 nullptr, "Global.StaticConstructObject", InClass, InOuter, InName, InFlags, InTemplate,
646 bCopyTransientsFromClassDefaults, InInstanceGraph);
647 }
648
649 //UObject *__fastcall StaticFindObjectFastInternal(UClass *ObjectClass, UObject *ObjectPackage, FName ObjectName, bool bExactClass, bool bAnyPackage, EObjectFlags ExcludeFlags)
650 template <typename T>
651 static void GetPrivateStaticClassBody(const wchar_t* PackageName, const wchar_t* Name, T** ReturnClass,
652 void(__cdecl* RegisterNativeFunc)());
653
654 /*template <>
655 static void GetPrivateStaticClassBody<UClass>(const wchar_t *PackageName, const wchar_t *Name, UClass **ReturnClass, void(__cdecl *RegisterNativeFunc)()) {
656 return NativeCall<void, const wchar_t *, const wchar_t *, UClass **, void(__cdecl *)()>(nullptr, "Global.GetPrivateStaticClassBody<UClass>", PackageName, Name, ReturnClass, RegisterNativeFunc);
657 }*/
658
659 //void __fastcall GetPrivateStaticClassBody<UClass>(const wchar_t *PackageName, const wchar_t *Name, UClass **ReturnClass, void(__cdecl *RegisterNativeFunc)())
660
661 //static char RaycastSingle(UWorld *World, FHitResult *OutHit, FVector *Start, FVector *End, ECollisionChannel TraceChannel, FCollisionQueryParams *Params, FCollisionResponseParams *ResponseParams, FCollisionObjectQueryParams *ObjectParams) { return NativeCall<char, UWorld *, FHitResult *, FVector *, FVector *, ECollisionChannel, FCollisionQueryParams *, FCollisionResponseParams *, FCollisionObjectQueryParams *>(nullptr, "Global.RaycastSingle", World, OutHit, Start, End, TraceChannel, Params, ResponseParams, ObjectParams); }
662 //char RaycastSingle(UWorld *World, FHitResult *OutHit, FVector *Start, FVector *End, ECollisionChannel TraceChannel, FCollisionQueryParams *Params, FCollisionResponseParams *ResponseParams, FCollisionObjectQueryParams *ObjectParams)
663
664 static bool HasClassCastFlags(UObject* object, ClassCastFlags flags)
665 {
666 const auto flags_value = static_cast<std::underlying_type<ClassCastFlags>::type>(flags);
667 return object != nullptr && (object->ClassField()->ClassCastFlagsField() & flags_value) == flags_value;
668 }
669
670 static bool HasClassCastFlags(UClass* _class, ClassCastFlags flags)
671 {
672 const auto flags_value = static_cast<std::underlying_type<ClassCastFlags>::type>(flags);
673 return _class != nullptr && (_class->ClassCastFlagsField() & flags_value) == flags_value;
674 }
675
676 static DataValue<UEngine*> GEngine() { return { "Global.GEngine" }; }
677
678 static DataValue<FUObjectArray> GUObjectArray() { return { "Global.GUObjectArray" }; }
679
680 static FORCEINLINE UClass* FindClass(const std::string& name)
681 {
682 for (auto i = 0; i < Globals::GUObjectArray()().ObjObjects.NumElements; i++)
683 {
684 auto obj = Globals::GUObjectArray()().ObjObjects.GetObjectPtr(i)->Object;
685 if (obj != nullptr)
686 {
687 FString full_name;
688 obj->GetFullName(&full_name, nullptr);
689 if (name == full_name.ToString())
690 {
691 return (UClass*)obj;
692 }
693 }
694 }
695 return nullptr;
696 }
697};
698
699template <>
700inline void Globals::GetPrivateStaticClassBody<UClass>(const wchar_t* PackageName, const wchar_t* Name,
701 UClass** ReturnClass, void(__cdecl* RegisterNativeFunc)())
702{
703 return NativeCall<void, const wchar_t*, const wchar_t*, UClass**, void(__cdecl*)()>(
704 nullptr, "Global.GetPrivateStaticClassBody<UClass>", PackageName, Name, ReturnClass, RegisterNativeFunc);
705}
706
708{
715 char unk[80];// TMap<FName, FString<FName, FString> > TagsAndValues;
717
718 // Functions
719
720 bool IsUAsset() { return NativeCall<bool>(this, "FAssetData.IsUAsset"); }
721 void PrintAssetData() { NativeCall<void>(this, "FAssetData.PrintAssetData"); }
722 UObject* GetAsset() { return NativeCall<UObject*>(this, "FAssetData.GetAsset"); }
723};
724
726{
727};
728
730{
731};
732
734{
735 FAssetRegistry* Get() { return NativeCall<FAssetRegistry*>(this, "FAssetRegistryModule.Get"); }
736};
737
739{
740 static FModuleManager* Get() { return NativeCall<FModuleManager*>(nullptr, "FModuleManager.Get"); }
741 void FindModules(const wchar_t* WildcardWithoutExtension, TArray<FName>* OutModules) { NativeCall<void, const wchar_t*, TArray<FName>*>(this, "FModuleManager.FindModules", WildcardWithoutExtension, OutModules); }
742 bool IsModuleLoaded(FName InModuleName) { return NativeCall<bool, FName>(this, "FModuleManager.IsModuleLoaded", InModuleName); }
743 bool IsModuleUpToDate(FName InModuleName) { return NativeCall<bool, FName>(this, "FModuleManager.IsModuleUpToDate", InModuleName); }
744 void AddModule(FName InModuleName) { NativeCall<void, FName>(this, "FModuleManager.AddModule", InModuleName); }
745 TSharedPtr<IModuleInterface>* LoadModule(TSharedPtr<IModuleInterface>* result, FName InModuleName, const bool bWasReloaded) { return NativeCall<TSharedPtr<IModuleInterface>*, TSharedPtr<IModuleInterface>*, FName, const bool>(this, "FModuleManager.LoadModule", result, InModuleName, bWasReloaded); }
746 bool UnloadModule(FName InModuleName, bool bIsShutdown) { return NativeCall<bool, FName, bool>(this, "FModuleManager.UnloadModule", InModuleName, bIsShutdown); }
747 void UnloadModulesAtShutdown() { NativeCall<void>(this, "FModuleManager.UnloadModulesAtShutdown"); }
748 TSharedPtr<IModuleInterface>* GetModule(TSharedPtr<IModuleInterface>* result, FName InModuleName) { return NativeCall<TSharedPtr<IModuleInterface>*, TSharedPtr<IModuleInterface>*, FName>(this, "FModuleManager.GetModule", result, InModuleName); }
749 static FString* GetCleanModuleFilename(FString* result, FName ModuleName, bool bGameModule) { return NativeCall<FString*, FString*, FName, bool>(nullptr, "FModuleManager.GetCleanModuleFilename", result, ModuleName, bGameModule); }
750 static void GetModuleFilenameFormat(bool bGameModule, FString* OutPrefix, FString* OutSuffix) { NativeCall<void, bool, FString*, FString*>(nullptr, "FModuleManager.GetModuleFilenameFormat", bGameModule, OutPrefix, OutSuffix); }
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"); }
753};
754
756{
757 void CollectCodeGeneratorClasses() { NativeCall<void>(this, "FAssetRegistry.CollectCodeGeneratorClasses"); }
758 void SearchAllAssets(bool bSynchronousSearch) { NativeCall<void, bool>(this, "FAssetRegistry.SearchAllAssets", bSynchronousSearch); }
759 bool GetAssetsByPackageName(FName PackageName, TArray<FAssetData>* OutAssetData) { return NativeCall<bool, FName, TArray<FAssetData>*>(this, "FAssetRegistry.GetAssetsByPackageName", PackageName, OutAssetData); }
760 bool GetAssetsByPath(FName PackagePath, TArray<FAssetData>* OutAssetData, bool bRecursive) { return NativeCall<bool, FName, TArray<FAssetData>*, bool>(this, "FAssetRegistry.GetAssetsByPath", PackagePath, OutAssetData, bRecursive); }
761 bool GetAssetsByClass(FName ClassName, TArray<FAssetData>* OutAssetData, bool bSearchSubClasses) { return NativeCall<bool, FName, TArray<FAssetData>*, bool>(this, "FAssetRegistry.GetAssetsByClass", ClassName, OutAssetData, bSearchSubClasses); }
762 //bool GetAssetsByTagValues(TMultiMap<FName, FString, FDefaultSetAllocator, TDefaultMapKeyFuncs<FName, FString, 1> > * AssetTagsAndValues, TArray<FAssetData> * OutAssetData) { return NativeCall<bool, TMultiMap<FName, FString, FDefaultSetAllocator, TDefaultMapKeyFuncs<FName, FString, 1> > *, TArray<FAssetData> *>(this, "FAssetRegistry.GetAssetsByTagValues", AssetTagsAndValues, OutAssetData); }
763 //bool GetAssets(FARFilter * Filter, TArray<FAssetData> * OutAssetData) { return NativeCall<bool, FARFilter *, TArray<FAssetData> *>(this, "FAssetRegistry.GetAssets", Filter, OutAssetData); }
764 FAssetData* GetAssetByObjectPath(FAssetData* result, FName ObjectPath) { return NativeCall<FAssetData*, FAssetData*, FName>(this, "FAssetRegistry.GetAssetByObjectPath", result, ObjectPath); }
765 bool GetAllAssets(TArray<FAssetData>* OutAssetData) { return NativeCall<bool, TArray<FAssetData>*>(this, "FAssetRegistry.GetAllAssets", OutAssetData); }
766 bool GetDependencies(FName PackageName, TArray<FName>* OutDependencies) { return NativeCall<bool, FName, TArray<FName>*>(this, "FAssetRegistry.GetDependencies", PackageName, OutDependencies); }
767 bool GetReferencers(FName PackageName, TArray<FName>* OutReferencers) { return NativeCall<bool, FName, TArray<FName>*>(this, "FAssetRegistry.GetReferencers", PackageName, OutReferencers); }
768 bool GetAncestorClassNames(FName ClassName, TArray<FName>* OutAncestorClassNames) { return NativeCall<bool, FName, TArray<FName>*>(this, "FAssetRegistry.GetAncestorClassNames", ClassName, OutAncestorClassNames); }
769 void GetAllCachedPaths(TArray<FString>* OutPathList) { NativeCall<void, TArray<FString>*>(this, "FAssetRegistry.GetAllCachedPaths", OutPathList); }
770 void GetSubPaths(FString* InBasePath, TArray<FString>* OutPathList, bool bInRecurse) { NativeCall<void, FString*, TArray<FString>*, bool>(this, "FAssetRegistry.GetSubPaths", InBasePath, OutPathList, bInRecurse); }
771 EAssetAvailability::Type GetAssetAvailability(FAssetData* AssetData) { return NativeCall<EAssetAvailability::Type, FAssetData*>(this, "FAssetRegistry.GetAssetAvailability", AssetData); }
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); }
774 void PrioritizeAssetInstall(FAssetData* AssetData) { NativeCall<void, FAssetData*>(this, "FAssetRegistry.PrioritizeAssetInstall", AssetData); }
775 bool AddPath(FString* PathToAdd) { return NativeCall<bool, FString*>(this, "FAssetRegistry.AddPath", PathToAdd); }
776 bool RemovePath(FString* PathToRemove) { return NativeCall<bool, FString*>(this, "FAssetRegistry.RemovePath", PathToRemove); }
777 void ScanPathsSynchronous(TArray<FString>* InPaths, bool bForceRescan) { NativeCall<void, TArray<FString>*, bool>(this, "FAssetRegistry.ScanPathsSynchronous", InPaths, bForceRescan); }
778 void PrioritizeSearchPath(FString* PathToPrioritize) { NativeCall<void, FString*>(this, "FAssetRegistry.PrioritizeSearchPath", PathToPrioritize); }
779 void AssetCreated(UObject* NewAsset) { NativeCall<void, UObject*>(this, "FAssetRegistry.AssetCreated", NewAsset); }
780 void AssetDeleted(UObject* DeletedAsset) { NativeCall<void, UObject*>(this, "FAssetRegistry.AssetDeleted", DeletedAsset); }
781 void AssetRenamed(UObject* RenamedAsset, FString* OldObjectPath) { NativeCall<void, UObject*, FString*>(this, "FAssetRegistry.AssetRenamed", RenamedAsset, OldObjectPath); }
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"); }
785 void ScanPathsSynchronous_Internal(TArray<FString>* InPaths, bool bForceRescan, bool bUseCache) { NativeCall<void, TArray<FString>*, bool, bool>(this, "FAssetRegistry.ScanPathsSynchronous_Internal", InPaths, bForceRescan, bUseCache); }
786 void PathDataGathered(const long double TickStartTime, TArray<FString>* PathResults) { NativeCall<void, const long double, TArray<FString>*>(this, "FAssetRegistry.PathDataGathered", TickStartTime, PathResults); }
787 bool RemoveDependsNode(FName PackageName) { return NativeCall<bool, FName>(this, "FAssetRegistry.RemoveDependsNode", PackageName); }
788 bool RemoveAssetPath(FString* PathToRemove, bool bEvenIfAssetsStillExist) { return NativeCall<bool, FString*, bool>(this, "FAssetRegistry.RemoveAssetPath", PathToRemove, bEvenIfAssetsStillExist); }
789 FString* ExportTextPathToObjectName(FString* result, FString* InExportTextPath) { return NativeCall<FString*, FString*, FString*>(this, "FAssetRegistry.ExportTextPathToObjectName", result, InExportTextPath); }
790 void AddAssetData(FAssetData* AssetData) { NativeCall<void, FAssetData*>(this, "FAssetRegistry.AddAssetData", AssetData); }
791 bool RemoveAssetData(FAssetData* AssetData) { return NativeCall<bool, FAssetData*>(this, "FAssetRegistry.RemoveAssetData", AssetData); }
792 void OnContentPathMounted(FString* InAssetPath, FString* FileSystemPath) { NativeCall<void, FString*, FString*>(this, "FAssetRegistry.OnContentPathMounted", InAssetPath, FileSystemPath); }
793 void OnContentPathDismounted(FString* InAssetPath, FString* FileSystemPath) { NativeCall<void, FString*, FString*>(this, "FAssetRegistry.OnContentPathDismounted", InAssetPath, FileSystemPath); }
794 //static void GetAssets(FAssetData ** First, const int Num, TDereferenceWrapper<FAssetData *, `FAssetRegistry::GetAssets'::`124'::FCompareFAssetData> * Predicate) { NativeCall<void, FAssetData **, const int, TDereferenceWrapper<FAssetData *, `FAssetRegistry::GetAssets'::`124'::FCompareFAssetData> *>(nullptr, "FAssetRegistry.GetAssets", First, Num, Predicate); }
795};
796
798{
801 Open = 0x2,
802};
803
805{
806};
807
809{
810};
811
813{
814};
815
817{
818 static UClass* StaticClass() { return NativeCall<UClass*>(nullptr, "UTexture.StaticClass"); }
819};
820
822{
823 static UClass* StaticClass() { return NativeCall<UClass*>(nullptr, "UTexture2D.StaticClass"); }
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"); }
826 FTextureResource* CreateResource() { return NativeCall<FTextureResource*>(this, "UTexture2D.CreateResource"); }
827 __int64 GetResourceSize(EResourceSizeMode type) { return NativeCall<__int64, EResourceSizeMode>(this, "UTexture2D.GetResourceSize", type); }
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"); }
831};
832
834{
835 uint32_t Flags;
836};
837
838struct __declspec(align(8)) UNavArea : UObject
839{
840 float DefaultCost;
841 float FixedAreaEnteringCost;
842 FColor DrawColor;
843 uint32_t unk;
844 uint16_t AreaFlags;
845};
846
847struct __declspec(align(8)) FNavigationFilterArea
848{
849 TSubclassOf<UNavArea> AreaClass;
850 float TravelCostOverride;
851 float EnteringCostOverride;
852 uint32_t bIsExcluded : 1;
853 uint32_t bOverrideTravelCost : 1;
854 uint32_t bOverrideEnteringCost : 1;
855};
856
858{
859 //TArray<FNavigationFilterArea, FDefaultAllocator> Areas;
860 TArray<FNavigationFilterArea> Areas;
863};
864
866{
874 TArray<unsigned int> IgnoreActors;
875};
876
878{
879 char unk[32];
880};
881
883{
885};
886
888{
890
892 {
896 };
897};
898
900
902{
903 FHttpRequestWinInet* RequestField() { return *GetNativePointerField<FHttpRequestWinInet**>(this, "FHttpResponseWinInet.Request"); }
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"); }
909 TArray<unsigned char>& ResponsePayloadField() { return *GetNativePointerField<TArray<unsigned char>*>(this, "FHttpResponseWinInet.ResponsePayload"); }
910 volatile int& bIsReadyField() { return *GetNativePointerField<volatile int*>(this, "FHttpResponseWinInet.bIsReady"); }
911 volatile int& bResponseSucceededField() { return *GetNativePointerField<volatile int*>(this, "FHttpResponseWinInet.bResponseSucceeded"); }
912 int& MaxReadBufferSizeField() { return *GetNativePointerField<int*>(this, "FHttpResponseWinInet.MaxReadBufferSize"); }
913
914 // Functions
915
916 ~FHttpResponseWinInet() { NativeCall<void>(this, "FHttpResponseWinInet.~FHttpResponseWinInet"); }
917 FString* GetURL(FString* result) { return NativeCall<FString*, FString*>(this, "FHttpResponseWinInet.GetURL", result); }
918 FString* GetContentAsString(FString* result) { return NativeCall<FString*, FString*>(this, "FHttpResponseWinInet.GetContentAsString", result); }
919 FString* GetURLParameter(FString* result, FString* ParameterName) { return NativeCall<FString*, FString*, FString*>(this, "FHttpResponseWinInet.GetURLParameter", result, ParameterName); }
920 FString* GetHeader(FString* result, FString* HeaderName) { return NativeCall<FString*, FString*, FString*>(this, "FHttpResponseWinInet.GetHeader", result, HeaderName); }
921 TArray<FString>* GetAllHeaders(TArray<FString>* result) { return NativeCall<TArray<FString>*, TArray<FString>*>(this, "FHttpResponseWinInet.GetAllHeaders", result); }
922 FString* GetContentType(FString* result) { return NativeCall<FString*, FString*>(this, "FHttpResponseWinInet.GetContentType", result); }
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"); }
927 void ProcessResponseHeaders() { NativeCall<void>(this, "FHttpResponseWinInet.ProcessResponseHeaders"); }
928 FString* QueryHeaderString(FString* result, unsigned int HttpQueryInfoLevel, FString* HeaderName) { return NativeCall<FString*, FString*, unsigned int, FString*>(this, "FHttpResponseWinInet.QueryHeaderString", result, HttpQueryInfoLevel, HeaderName); }
929 int QueryContentLength() { return NativeCall<int>(this, "FHttpResponseWinInet.QueryContentLength"); }
930};
931
933{
934};
935
937{
938 FString& RequestVerbField() { return *GetNativePointerField<FString*>(this, "FHttpRequestWinInet.RequestVerb"); }
939 TMap<FString, FString, FDefaultSetAllocator, TDefaultMapKeyFuncs<FString, FString, 0> >& RequestHeadersField() { return *GetNativePointerField<TMap<FString, FString, FDefaultSetAllocator, TDefaultMapKeyFuncs<FString, FString, 0> >*>(this, "FHttpRequestWinInet.RequestHeaders"); }
940 TArray<unsigned char>& RequestPayloadField() { return *GetNativePointerField<TArray<unsigned char>*>(this, "FHttpRequestWinInet.RequestPayload"); }
941 TSharedPtr<FHttpResponseWinInet, 1>& ResponseField() { return *GetNativePointerField<TSharedPtr<FHttpResponseWinInet, 1>*>(this, "FHttpRequestWinInet.Response"); }
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"); }
945 volatile int& ElapsedTimeSinceLastServerResponseField() { return *GetNativePointerField<volatile int*>(this, "FHttpRequestWinInet.ElapsedTimeSinceLastServerResponse"); }
946 int& ProgressBytesSentField() { return *GetNativePointerField<int*>(this, "FHttpRequestWinInet.ProgressBytesSent"); }
947 long double& StartRequestTimeField() { return *GetNativePointerField<long double*>(this, "FHttpRequestWinInet.StartRequestTime"); }
948 bool& bDebugVerboseField() { return *GetNativePointerField<bool*>(this, "FHttpRequestWinInet.bDebugVerbose"); }
949
950 // Functions
951
952 ~FHttpRequestWinInet() { NativeCall<void>(this, "FHttpRequestWinInet.~FHttpRequestWinInet"); }
953 FString* GetURL(FString* result) { return NativeCall<FString*, FString*>(this, "FHttpRequestWinInet.GetURL", result); }
954 FString* GetURLParameter(FString* result, FString* ParameterName) { return NativeCall<FString*, FString*, FString*>(this, "FHttpRequestWinInet.GetURLParameter", result, ParameterName); }
955 FString* GetHeader(FString* result, FString* HeaderName) { return NativeCall<FString*, FString*, FString*>(this, "FHttpRequestWinInet.GetHeader", result, HeaderName); }
956 TArray<FString>* GetAllHeaders(TArray<FString>* result) { return NativeCall<TArray<FString>*, TArray<FString>*>(this, "FHttpRequestWinInet.GetAllHeaders", result); }
957 FString* GetContentType(FString* result) { return NativeCall<FString*, FString*>(this, "FHttpRequestWinInet.GetContentType", result); }
958 int GetContentLength() { return NativeCall<int>(this, "FHttpRequestWinInet.GetContentLength"); }
959 FString* GetVerb(FString* result) { return NativeCall<FString*, FString*>(this, "FHttpRequestWinInet.GetVerb", result); }
960 void SetVerb(FString* Verb) { NativeCall<void, FString*>(this, "FHttpRequestWinInet.SetVerb", Verb); }
961 void SetURL(FString* URL) { NativeCall<void, FString*>(this, "FHttpRequestWinInet.SetURL", URL); }
962 void SetContent(TArray<unsigned char>* ContentPayload) { NativeCall<void, TArray<unsigned char>*>(this, "FHttpRequestWinInet.SetContent", ContentPayload); }
963 void SetContentAsString(FString* ContentString) { NativeCall<void, FString*>(this, "FHttpRequestWinInet.SetContentAsString", ContentString); }
964 void SetHeader(FString* HeaderName, FString* HeaderValue) { NativeCall<void, FString*, FString*>(this, "FHttpRequestWinInet.SetHeader", HeaderName, HeaderValue); }
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"); }
968 FString* GenerateHeaderBuffer(FString* result, unsigned int ContentLength) { return NativeCall<FString*, FString*, unsigned int>(this, "FHttpRequestWinInet.GenerateHeaderBuffer", result, ContentLength); }
969 void CancelRequest() { NativeCall<void>(this, "FHttpRequestWinInet.CancelRequest"); }
970 EHttpRequestStatus::Type GetStatus() { return NativeCall<EHttpRequestStatus::Type>(this, "FHttpRequestWinInet.GetStatus"); }
971 TSharedPtr<IHttpResponse, 1>* GetResponse(TSharedPtr<IHttpResponse, 1>* result) { return NativeCall<TSharedPtr<IHttpResponse, 1>*, TSharedPtr<IHttpResponse, 1>*>(this, "FHttpRequestWinInet.GetResponse", result); }
972 void Tick(float DeltaSeconds) { NativeCall<void, float>(this, "FHttpRequestWinInet.Tick", DeltaSeconds); }
973};
974
976{
977};
978
980{
981 //FHttpManager * HttpManagerField() { return *GetNativePointerField<FHttpManager **>(this, "FHttpModule.HttpManager"); }
982 float& HttpTimeoutField() { return *GetNativePointerField<float*>(this, "FHttpModule.HttpTimeout"); }
983 float& HttpConnectionTimeoutField() { return *GetNativePointerField<float*>(this, "FHttpModule.HttpConnectionTimeout"); }
984 float& HttpReceiveTimeoutField() { return *GetNativePointerField<float*>(this, "FHttpModule.HttpReceiveTimeout"); }
985 float& HttpSendTimeoutField() { return *GetNativePointerField<float*>(this, "FHttpModule.HttpSendTimeout"); }
986 int& HttpMaxConnectionsPerServerField() { return *GetNativePointerField<int*>(this, "FHttpModule.HttpMaxConnectionsPerServer"); }
987 int& MaxReadBufferSizeField() { return *GetNativePointerField<int*>(this, "FHttpModule.MaxReadBufferSize"); }
988 bool& bEnableHttpField() { return *GetNativePointerField<bool*>(this, "FHttpModule.bEnableHttp"); }
989
990 // Functions
991
992 void StartupModule() { NativeCall<void>(this, "FHttpModule.StartupModule"); }
993 void ShutdownModule() { NativeCall<void>(this, "FHttpModule.ShutdownModule"); }
994 static FHttpModule* Get() { return NativeCall<FHttpModule*>(nullptr, "FHttpModule.Get"); }
995 TSharedRef<IHttpRequest, 0>* CreateRequest(TSharedRef<IHttpRequest, 0>* result) { return NativeCall<TSharedRef<IHttpRequest, 0>*, TSharedRef<IHttpRequest, 0>*>(this, "FHttpModule.CreateRequest", result); }
996};
997
998/*
999* \brief Gets the size in bytes of an Object class. Example: GetObjectClassSize<AActor>()
1000*
1001* tparam T - Object class
1002* \return The size of the class in bytes
1003*/
1004template <typename T>
1006{
1007 // Credits to Substitute#0001 for the idea
1008 UClass* objClass = T::StaticClass();
1009 if (objClass)
1010 {
1011 return objClass->PropertiesSizeField();
1012 }
1013
1014 return 0;
1015}
1016
1017/*
1018* \brief Gets the size in bytes of an struct class. Example: GetObjectClassSize<FTribeData>()
1019*
1020* \tparam T - Struct class
1021* \return The size in bytes
1022*/
1023template <typename T>
1025{
1026 // Credits to Substitute#0001 for the idea
1027 int size = 0;
1028 UScriptStruct* staticStruct = T::StaticStruct();
1029 if (staticStruct)
1030 {
1031 return staticStruct->PropertiesSizeField();
1032 }
1033 return 0;
1034}
EBlueprintType
Definition Enums.h:3920
static unsigned int GetBuildUniqueId()
Definition Atlas.h:30
ARK_API LPVOID GetDataAddress(const std::string &name)
Definition Base.cpp:15
ARK_API BitField GetBitField(LPVOID base, const std::string &name)
Definition Base.cpp:25
ARK_API BitField GetBitField(const void *base, const std::string &name)
Definition Base.cpp:20
#define ARK_API
Definition Base.h:9
ARK_API DWORD64 GetAddress(const void *base, const std::string &name)
Definition Base.cpp:5
ARK_API LPVOID GetAddress(const std::string &name)
Definition Base.cpp:10
FPlatformTypes::CHAR16 UCS2CHAR
A 16-bit character containing a UCS2 (Unicode, 16-bit, fixed-width) code unit, used for compatibility...
Definition BasicTypes.h:124
#define checkSlow(expr)
Definition BasicTypes.h:15
@ INDEX_NONE
Definition BasicTypes.h:144
FWindowsPlatformTypes FPlatformTypes
Definition BasicTypes.h:94
#define PLATFORM_LITTLE_ENDIAN
Definition BasicTypes.h:12
FPlatformTypes::CHAR8 UTF8CHAR
An 8-bit character containing a UTF8 (Unicode, 8-bit, variable-width) code unit.
Definition BasicTypes.h:122
ENoInit
Definition BasicTypes.h:151
@ NoInit
Definition BasicTypes.h:151
#define check(expr)
Definition BasicTypes.h:14
#define FORCENOINLINE
Definition BasicTypes.h:6
#define MS_ALIGN(n)
Definition BasicTypes.h:21
#define GCC_ALIGN(n)
Definition BasicTypes.h:22
#define checkf(...)
Definition BasicTypes.h:16
#define ensureMsgf(Expr, Expr2)
Definition BasicTypes.h:19
#define RESTRICT
Definition BasicTypes.h:5
FPlatformTypes::CHAR16 UTF16CHAR
A 16-bit character containing a UTF16 (Unicode, 16-bit, variable-width) code unit.
Definition BasicTypes.h:126
#define CONSTEXPR
Definition BasicTypes.h:7
EForceInit
Definition BasicTypes.h:147
@ ForceInitToZero
Definition BasicTypes.h:149
@ ForceInit
Definition BasicTypes.h:148
FPlatformTypes::CHAR32 UTF32CHAR
A 32-bit character containing a UTF32 (Unicode, 32-bit, fixed-width) code unit.
Definition BasicTypes.h:128
static FORCEINLINE int32 BYTESWAP_ORDER32(int32 val)
Definition ByteSwap.h:30
static FORCEINLINE uint16 BYTESWAP_ORDER16(uint16 val)
Definition ByteSwap.h:12
static FORCEINLINE void BYTESWAP_ORDER_TCHARARRAY(TCHAR *str)
Definition ByteSwap.h:72
static FORCEINLINE uint32 BYTESWAP_ORDER32(uint32 val)
Definition ByteSwap.h:25
#define BYTESWAP_ORDER16_unsigned(x)
Definition ByteSwap.h:8
static FORCEINLINE float BYTESWAP_ORDERF(float val)
Definition ByteSwap.h:38
static FORCEINLINE int16 BYTESWAP_ORDER16(int16 val)
Definition ByteSwap.h:17
static FORCEINLINE uint64 BYTESWAP_ORDER64(uint64 Value)
Definition ByteSwap.h:46
static FORCEINLINE int64 BYTESWAP_ORDER64(int64 Value)
Definition ByteSwap.h:58
#define BYTESWAP_ORDER32_unsigned(x)
Definition ByteSwap.h:9
TCString< ANSICHAR > FCStringAnsi
Definition CString.h:336
TCString< WIDECHAR > FCStringWide
Definition CString.h:337
TCString< TCHAR > FCString
Definition CString.h:335
TChar< WIDECHAR > FCharWide
Definition Char.h:143
#define LITERAL(CharType, StringLiteral)
Definition Char.h:30
TChar< ANSICHAR > FCharAnsi
Definition Char.h:144
TChar< TCHAR > FChar
Definition Char.h:142
static const float OneOver255
Definition Color.h:527
EGammaSpace
Definition Color.h:20
FORCEINLINE FLinearColor operator*(float Scalar, const FLinearColor &Color)
Definition Color.h:364
FORCEINLINE int32 DefaultCalculateSlackShrink(int32 NumElements, int32 NumAllocatedElements, SIZE_T BytesPerElement, bool bAllowQuantize, uint32 Alignment=DEFAULT_ALIGNMENT)
#define NumBitsPerDWORD
#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)
ClassCastFlags
Definition Enums.h:873
int32 FindMatchingClosingParenthesis(const FString &TargetString, const int32 StartSearch)
Definition FString.h:3011
int32 HexToBytes(const FString &HexString, uint8 *OutBytes)
Definition FString.h:1803
const TCHAR * GetData(const FString &String)
Definition FString.h:1672
const uint8 TCharToNibble(const TCHAR Char)
Definition FString.h:1783
const bool CheckTCharIsHex(const TCHAR Char)
Definition FString.h:1773
FORCEINLINE uint32 GetTypeHash(const FString &Thing)
Definition FString.h:1646
TCHAR * GetData(FString &String)
Definition FString.h:1667
SIZE_T GetNum(const FString &String)
Definition FString.h:1677
void ByteToHex(uint8 In, FString &Result)
Definition FString.h:1743
static const uint32 MaxSupportedEscapeChars
Definition FString.h:2924
FString BytesToHex(const uint8 *In, int32 Count)
Definition FString.h:1755
int32 StringToBytes(const FString &String, uint8 *OutBytes, int32 MaxBufferSize)
Definition FString.h:1714
static const TCHAR * CharToEscapeSeqMap[][2]
Definition FString.h:2913
TCHAR NibbleToTChar(uint8 Num)
Definition FString.h:1729
FString BytesToString(const uint8 *In, int32 Count)
Definition FString.h:1688
FORCEINLINE auto Invoke(ReturnType ObjType::*pdm, CallableType &&Callable) -> decltype(UE4Invoke_Private::DereferenceIfNecessary< ObjType >(Forward< CallableType >(Callable)).*pdm)
Definition Invoke.h:48
FORCEINLINE auto Invoke(FuncType &&Func, ArgTypes &&... Args) -> decltype(Forward< FuncType >(Func)(Forward< ArgTypes >(Args)...))
Definition Invoke.h:41
FORCEINLINE auto Invoke(ReturnType(ObjType::*PtrMemFun)(PMFArgTypes...), CallableType &&Callable, ArgTypes &&... Args) -> decltype((UE4Invoke_Private::DereferenceIfNecessary< ObjType >(Forward< CallableType >(Callable)).*PtrMemFun)(Forward< ArgTypes >(Args)...))
Definition Invoke.h:55
ARK_API std::vector< spdlog::sink_ptr > &APIENTRY GetLogSinks()
Definition Logger.cpp:31
FORCEINLINE TEnableIf<!TIsTriviallyCopyAssignable< ElementType >::Value >::Type CopyAssignItems(ElementType *Dest, const ElementType *Source, int32 Count)
Definition MemoryOps.h:149
FORCEINLINE TEnableIf< UE4MemoryOps_Private::TCanBitwiseRelocate< DestinationElementType, SourceElementType >::Value >::Type RelocateConstructItems(void *Dest, const SourceElementType *Source, int32 Count)
Definition MemoryOps.h:192
FORCEINLINE TEnableIf< TIsZeroConstructType< ElementType >::Value >::Type DefaultConstructItems(void *Elements, int32 Count)
Definition MemoryOps.h:56
FORCEINLINE TEnableIf<!TIsTriviallyCopyConstructible< ElementType >::Value >::Type MoveConstructItems(void *Dest, const ElementType *Source, int32 Count)
Definition MemoryOps.h:213
FORCEINLINE TEnableIf< TIsTriviallyCopyConstructible< ElementType >::Value >::Type MoveConstructItems(void *Dest, const ElementType *Source, int32 Count)
Definition MemoryOps.h:225
FORCEINLINE TEnableIf<!TIsZeroConstructType< ElementType >::Value >::Type DefaultConstructItems(void *Address, int32 Count)
Definition MemoryOps.h:43
FORCEINLINE TEnableIf<!TIsTriviallyDestructible< ElementType >::Value >::Type DestructItem(ElementType *Element)
Definition MemoryOps.h:70
FORCEINLINE TEnableIf< TTypeTraits< ElementType >::IsBytewiseComparable, bool >::Type CompareItems(const ElementType *A, const ElementType *B, int32 Count)
Definition MemoryOps.h:256
FORCEINLINE TEnableIf< TIsTriviallyCopyAssignable< ElementType >::Value >::Type MoveAssignItems(ElementType *Dest, const ElementType *Source, int32 Count)
Definition MemoryOps.h:250
FORCEINLINE TEnableIf< TIsTriviallyDestructible< ElementType >::Value >::Type DestructItem(ElementType *Element)
Definition MemoryOps.h:80
FORCEINLINE TEnableIf<!TIsTriviallyDestructible< ElementType >::Value >::Type DestructItems(ElementType *Element, int32 Count)
Definition MemoryOps.h:94
FORCEINLINE TEnableIf<!TIsTriviallyCopyAssignable< ElementType >::Value >::Type MoveAssignItems(ElementType *Dest, const ElementType *Source, int32 Count)
Definition MemoryOps.h:238
FORCEINLINE TEnableIf<!TTypeTraits< ElementType >::IsBytewiseComparable, bool >::Type CompareItems(const ElementType *A, const ElementType *B, int32 Count)
Definition MemoryOps.h:263
FORCEINLINE TEnableIf<!TIsBitwiseConstructible< DestinationElementType, SourceElementType >::Value >::Type ConstructItems(void *Dest, const SourceElementType *Source, int32 Count)
Definition MemoryOps.h:122
FORCEINLINE TEnableIf<!UE4MemoryOps_Private::TCanBitwiseRelocate< DestinationElementType, SourceElementType >::Value >::Type RelocateConstructItems(void *Dest, const SourceElementType *Source, int32 Count)
Definition MemoryOps.h:177
FORCEINLINE TEnableIf< TIsTriviallyDestructible< ElementType >::Value >::Type DestructItems(ElementType *Elements, int32 Count)
Definition MemoryOps.h:109
FORCEINLINE TEnableIf< TIsTriviallyCopyAssignable< ElementType >::Value >::Type CopyAssignItems(ElementType *Dest, const ElementType *Source, int32 Count)
Definition MemoryOps.h:162
FORCEINLINE TEnableIf< TIsBitwiseConstructible< DestinationElementType, SourceElementType >::Value >::Type ConstructItems(void *Dest, const SourceElementType *Source, int32 Count)
Definition MemoryOps.h:135
FMicrosoftPlatformString FPlatformString
#define WIN32_LEAN_AND_MEAN
Definition Requests.cpp:2
FORCEINLINE FRotator operator*(float Scale, const FRotator &R)
Definition Rotator.h:363
void StableSort(T **First, const int32 Num, const PREDICATE_CLASS &Predicate)
Definition Sorting.h:385
void StableSort(T *First, const int32 Num, const PREDICATE_CLASS &Predicate)
Definition Sorting.h:371
void StableSortInternal(T *First, const int32 Num, const PREDICATE_CLASS &Predicate)
Definition Sorting.h:356
void Sort(T **First, const int32 Num)
Definition Sorting.h:117
void StableSort(T *First, const int32 Num)
Definition Sorting.h:400
void StableSort(T **First, const int32 Num)
Definition Sorting.h:413
void Merge(T *Out, T *In, const int32 Mid, const int32 Num, const PREDICATE_CLASS &Predicate)
Definition Sorting.h:134
void Sort(T **First, const int32 Num, const PREDICATE_CLASS &Predicate)
Definition Sorting.h:90
void Sort(T *First, const int32 Num, const PREDICATE_CLASS &Predicate)
Definition Sorting.h:76
void Sort(T *First, const int32 Num)
Definition Sorting.h:104
#define TARRAY_RANGED_FOR_CHECKS
Definition TArray.h:15
FORCEINLINE TIndexedContainerIterator< ContainerType, ElementType, IndexType > operator+(int32 Offset, TIndexedContainerIterator< ContainerType, ElementType, IndexType > RHS)
Definition TArray.h:141
void * operator new(size_t Size, TArray< T, Allocator > &Array, int32 Index)
Definition TArray.h:2152
void * operator new(size_t Size, TArray< T, Allocator > &Array)
Definition TArray.h:2146
#define IMPLEMENT_ALIGNED_STORAGE(Align)
int GetStructSize()
Definition UE.h:1024
EResourceSizeMode
Definition UE.h:798
@ Exclusive
Definition UE.h:799
@ Open
Definition UE.h:801
@ Inclusive
Definition UE.h:800
int GetObjectClassSize()
Definition UE.h:1005
FORCEINLINE uint32 GetTypeHash(const FName &name)
Definition UE.h:63
TWeakObjectPtr< T > GetWeakReference(T *object)
Definition UE.h:203
#define THRESH_VECTOR_NORMALIZED
#define THRESH_NORMALS_ARE_PARALLEL
#define THRESH_POINTS_ARE_SAME
#define DELTA
#define SMALL_NUMBER
#define THRESH_POINT_ON_PLANE
#define PI
#define THRESH_NORMALS_ARE_ORTHOGONAL
#define KINDA_SMALL_NUMBER
#define BIG_NUMBER
#define FASTASIN_HALF_PI
#define HALF_PI
#define INV_PI
@ MIN_ALIGNMENT
@ DEFAULT_ALIGNMENT
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)
T && DeclVal()
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)
bool XOR(bool A, bool 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)
Definition Vector2D.h:467
FORCEINLINE float ComputeSquaredDistanceFromBoxToPoint(const FVector &Mins, const FVector &Maxs, const FVector &Point)
Definition Vector.h:893
FORCEINLINE FVector ClampVector(const FVector &V, const FVector &Min, const FVector &Max)
Definition Vector.h:1646
FORCEINLINE FVector operator*(float Scale, const FVector &V)
Definition Vector.h:870
ApiUtils & operator=(ApiUtils &&)=delete
ApiUtils()=default
void SetCheatManager(UShooterCheatManager *cheatmanager)
Definition ApiUtils.cpp:44
void SetWorld(UWorld *uworld)
Definition ApiUtils.cpp:9
ApiUtils & operator=(const ApiUtils &)=delete
void SetShooterGameMode(AShooterGameMode *shooter_game_mode)
Definition ApiUtils.cpp:21
std::unordered_map< uint64, AShooterPlayerController * > steam_id_map_
Definition ApiUtils.h:38
UShooterCheatManager * GetCheatManager() const override
Returns a point to URCON CheatManager.
Definition ApiUtils.cpp:93
UWorld * u_world_
Definition ApiUtils.h:34
ApiUtils(ApiUtils &&)=delete
AShooterGameMode * shooter_game_mode_
Definition ApiUtils.h:35
AShooterGameMode * GetShooterGameMode() const override
Returns a pointer to AShooterGameMode.
Definition ApiUtils.cpp:26
void RemovePlayerController(AShooterPlayerController *player_controller)
Definition ApiUtils.cpp:62
UShooterCheatManager * cheatmanager_
Definition ApiUtils.h:37
void SetPlayerController(AShooterPlayerController *player_controller)
Definition ApiUtils.cpp:49
ServerStatus GetStatus() const override
Returns the current server status.
Definition ApiUtils.cpp:38
ServerStatus status_
Definition ApiUtils.h:36
AShooterPlayerController * FindPlayerFromSteamId_Internal(uint64 steam_id) const override
Definition ApiUtils.cpp:75
~ApiUtils() override=default
void SetStatus(ServerStatus status)
Definition ApiUtils.cpp:33
UWorld * GetWorld() const override
Returns a pointer to UWorld.
Definition ApiUtils.cpp:14
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.
void Set(RT other)
Definition Fields.h:144
BitFieldValue & operator=(RT other)
Definition Fields.h:133
void * parent_
Definition Fields.h:150
std::string field_name_
Definition Fields.h:151
RT operator()() const
Definition Fields.h:128
RT Get() const
Definition Fields.h:139
T * value_
Definition Fields.h:116
void Set(const T &other)
Definition Fields.h:110
T & Get() const
Definition Fields.h:105
DataValue & operator=(const T &other)
Definition Fields.h:99
T & operator()() const
Definition Fields.h:94
static const FColor MediumSlateBlue
Definition ColorList.h:69
static const FColor Orange
Definition ColorList.h:81
static const FColor DarkGreenCopper
Definition ColorList.h:34
static const FColor BronzeII
Definition ColorList.h:26
static const FColor Yellow
Definition ColorList.h:17
static const FColor Magenta
Definition ColorList.h:15
static const FColor IndianRed
Definition ColorList.h:54
static const FColor SummerSky
Definition ColorList.h:100
static const FColor SpringGreen
Definition ColorList.h:98
static const FColor Grey
Definition ColorList.h:50
static const FColor CornFlowerBlue
Definition ColorList.h:31
static const FColor Cyan
Definition ColorList.h:16
static const FColor Blue
Definition ColorList.h:14
static const FColor GreenCopper
Definition ColorList.h:51
static const FColor MediumGoldenrod
Definition ColorList.h:66
static const FColor LimeGreen
Definition ColorList.h:60
static const FColor LightSteelBlue
Definition ColorList.h:58
static const FColor DarkOliveGreen
Definition ColorList.h:35
static const FColor Quartz
Definition ColorList.h:87
static const FColor SteelBlue
Definition ColorList.h:99
static const FColor DarkPurple
Definition ColorList.h:37
static const FColor Turquoise
Definition ColorList.h:103
static const FColor Black
Definition ColorList.h:18
static const FColor Maroon
Definition ColorList.h:62
static const FColor MediumOrchid
Definition ColorList.h:67
static const FColor NewTan
Definition ColorList.h:79
static const FColor NeonBlue
Definition ColorList.h:76
static const FColor MediumWood
Definition ColorList.h:73
static const FColor DarkSlateBlue
Definition ColorList.h:38
static const FColor White
Definition ColorList.h:11
static const FColor MandarianOrange
Definition ColorList.h:61
static const FColor Tan
Definition ColorList.h:101
static const FColor Scarlet
Definition ColorList.h:90
static const FColor SeaGreen
Definition ColorList.h:91
static const FColor Aquamarine
Definition ColorList.h:19
static const FColor Wheat
Definition ColorList.h:108
static const FColor VeryDarkBrown
Definition ColorList.h:104
static const FColor Thistle
Definition ColorList.h:102
static const FColor BlueViolet
Definition ColorList.h:21
static const FColor Violet
Definition ColorList.h:106
static const FColor MediumSpringGreen
Definition ColorList.h:70
static const FColor NavyBlue
Definition ColorList.h:75
static const FColor CoolCopper
Definition ColorList.h:28
static const FColor DarkTan
Definition ColorList.h:40
static const FColor Firebrick
Definition ColorList.h:46
static const FColor GreenYellow
Definition ColorList.h:52
static const FColor DarkOrchid
Definition ColorList.h:36
static const FColor Plum
Definition ColorList.h:86
static const FColor SemiSweetChocolate
Definition ColorList.h:92
static const FColor SpicyPink
Definition ColorList.h:97
static const FColor OldGold
Definition ColorList.h:80
static const FColor DarkTurquoise
Definition ColorList.h:41
static const FColor PaleGreen
Definition ColorList.h:84
static const FColor BrightGold
Definition ColorList.h:23
static const FColor CadetBlue
Definition ColorList.h:27
static const FColor BakerChocolate
Definition ColorList.h:20
static const FColor DarkGreen
Definition ColorList.h:33
static const FColor Coral
Definition ColorList.h:30
static const FColor OrangeRed
Definition ColorList.h:82
static const FColor HunterGreen
Definition ColorList.h:53
static const FColor VeryLightGrey
Definition ColorList.h:105
static const FColor MediumVioletRed
Definition ColorList.h:72
static const FColor Silver
Definition ColorList.h:94
static const FColor MediumSeaGreen
Definition ColorList.h:68
static const FColor DarkSlateGrey
Definition ColorList.h:39
static const FColor Khaki
Definition ColorList.h:55
static const FColor DustyRose
Definition ColorList.h:44
static const FColor Red
Definition ColorList.h:12
static const FColor Bronze
Definition ColorList.h:25
static const FColor MediumBlue
Definition ColorList.h:64
static const FColor Goldenrod
Definition ColorList.h:49
static const FColor Feldspar
Definition ColorList.h:45
static const FColor LightBlue
Definition ColorList.h:56
static const FColor Pink
Definition ColorList.h:85
static const FColor DimGrey
Definition ColorList.h:43
static const FColor Brown
Definition ColorList.h:24
static const FColor VioletRed
Definition ColorList.h:107
static const FColor Orchid
Definition ColorList.h:83
static const FColor LightWood
Definition ColorList.h:59
static const FColor SlateBlue
Definition ColorList.h:96
static const FColor DarkWood
Definition ColorList.h:42
static const FColor NeonPink
Definition ColorList.h:77
static const FColor MediumTurquoise
Definition ColorList.h:71
static const FColor MediumForestGreen
Definition ColorList.h:65
static const FColor Salmon
Definition ColorList.h:89
static const FColor Brass
Definition ColorList.h:22
static const FColor ForestGreen
Definition ColorList.h:47
static const FColor Sienna
Definition ColorList.h:93
static const FColor MediumAquamarine
Definition ColorList.h:63
static const FColor YellowGreen
Definition ColorList.h:109
static const FColor Green
Definition ColorList.h:13
static const FColor RichBlue
Definition ColorList.h:88
static const FColor MidnightBlue
Definition ColorList.h:74
static const FColor LightGrey
Definition ColorList.h:57
static const FColor SkyBlue
Definition ColorList.h:95
static const FColor NewMidnightBlue
Definition ColorList.h:78
static const FColor DarkBrown
Definition ColorList.h:32
static const FColor Gold
Definition ColorList.h:48
static const FColor Copper
Definition ColorList.h:29
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)
ForElementType< FScriptContainerElement > ForAnyElementType
static int32 GCD(int32 A, int32 B)
Definition Sorting.h:171
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
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 void MoveToEmpty(ForAnyElementType &Other)
FORCEINLINE ElementType * GetAllocation() const
FNoncopyable(const FNoncopyable &)
FNoncopyable & operator=(const FNoncopyable &)
FORCEINLINE const DataType & GetCharArray() const
Definition FString.h:299
FORCEINLINE friend bool operator<=(const FString &Lhs, const CharType *Rhs)
Definition FString.h:844
FORCEINLINE void RemoveAt(int32 Index, int32 Count=1, bool bAllowShrinking=true)
Definition FString.h:435
FORCEINLINE friend FString operator+(FString &&Lhs, FString &&Rhs)
Definition FString.h:661
FORCEINLINE FString & Append(const FString &Text)
Definition FString.h:396
FORCEINLINE uint32 GetAllocatedSize() const
Definition FString.h:214
void ToUpperInline()
Definition FString.h:2097
FString TrimStart() const &
Definition FString.h:2296
int32 Find(const TCHAR *SubStr, ESearchCase::Type SearchCase=ESearchCase::IgnoreCase, ESearchDir::Type SearchDir=ESearchDir::FromStart, int32 StartPosition=INDEX_NONE) const
Definition FString.h:2027
FORCEINLINE friend FString operator/(const FString &Lhs, const FString &Rhs)
Definition FString.h:781
FORCEINLINE FString(const std::string &str)
Definition FString.h:129
int32 ParseIntoArray(TArray< FString > &OutArray, const TCHAR **DelimArray, int32 NumDelims, bool InCullEmpty=true) const
Definition FString.h:2702
bool IsNumeric() const
Definition FString.h:2541
FORCEINLINE friend FString operator+(const FString &Lhs, const TCHAR *Rhs)
Definition FString.h:700
FORCEINLINE friend bool operator!=(const FString &Lhs, const CharType *Rhs)
Definition FString.h:1049
FORCEINLINE int32 Find(const FString &SubStr, ESearchCase::Type SearchCase=ESearchCase::IgnoreCase, ESearchDir::Type SearchDir=ESearchDir::FromStart, int32 StartPosition=INDEX_NONE) const
Definition FString.h:1128
FORCEINLINE friend DataType::RangedForIteratorType end(FString &Str)
Definition FString.h:210
FORCEINLINE friend FString operator+(FString &&Lhs, const FString &Rhs)
Definition FString.h:635
FString(FString &&)=default
FORCEINLINE FString & operator=(const TCHAR *Other)
Definition FString.h:147
FORCEINLINE friend bool operator<(const CharType *Lhs, const FString &Rhs)
Definition FString.h:899
FString TrimEnd() const &
Definition FString.h:2320
void TrimStartInline()
Definition FString.h:2286
FString Replace(const TCHAR *From, const TCHAR *To, ESearchCase::Type SearchCase=ESearchCase::IgnoreCase) const
Definition FString.h:2766
FORCEINLINE FString LeftChop(int32 Count) const
Definition FString.h:1081
FORCEINLINE bool FindChar(TCHAR InChar, int32 &Index) const
Definition FString.h:1169
FORCEINLINE friend bool operator!=(const FString &Lhs, const FString &Rhs)
Definition FString.h:1035
int32 ReplaceInline(const TCHAR *SearchText, const TCHAR *ReplacementText, ESearchCase::Type SearchCase=ESearchCase::IgnoreCase)
Definition FString.h:2805
FORCEINLINE FString Mid(int32 Start, int32 Count=INT_MAX) const
Definition FString.h:1099
FORCEINLINE FString(FString &&Other, int32 ExtraSlack)
Definition FString.h:87
static FORCEINLINE FString ConcatFStrings(typename TIdentity< LhsType >::Type Lhs, typename TIdentity< RhsType >::Type Rhs)
Definition FString.h:550
static FString Chr(TCHAR Ch)
Definition FString.h:2494
FORCEINLINE friend DataType::RangedForIteratorType begin(FString &Str)
Definition FString.h:208
FORCEINLINE friend FString operator+(const FString &Lhs, FString &&Rhs)
Definition FString.h:648
FORCEINLINE DataType & GetCharArray()
Definition FString.h:293
FORCEINLINE friend bool operator==(const FString &Lhs, const CharType *Rhs)
Definition FString.h:1008
static FORCEINLINE FString FromInt(int32 Num)
Definition FString.h:1548
FORCEINLINE FString & operator+=(const FString &Str)
Definition FString.h:500
FString & Append(const TCHAR *Text, int32 Count)
Definition FString.h:402
FORCEINLINE FString & operator/=(const FString &Str)
Definition FString.h:736
FString TrimStart() &&
Definition FString.h:2303
FORCEINLINE friend FString operator+(const FString &Lhs, const FString &Rhs)
Definition FString.h:622
FORCEINLINE int32 Compare(const FString &Other, ESearchCase::Type SearchCase=ESearchCase::CaseSensitive) const
Definition FString.h:1240
FORCEINLINE friend bool operator<=(const CharType *Lhs, const FString &Rhs)
Definition FString.h:858
FORCEINLINE friend bool operator==(const FString &Lhs, const FString &Rhs)
Definition FString.h:994
FString TrimStartAndEnd() &&
Definition FString.h:2279
FORCEINLINE friend FString operator+(const TCHAR *Lhs, const FString &Rhs)
Definition FString.h:674
FORCEINLINE TIterator CreateIterator()
Definition FString.h:192
FORCEINLINE void Reserve(const uint32 CharacterCount)
Definition FString.h:1542
FString ReplaceQuotesWithEscapedQuotes() const
Definition FString.h:2880
FString & operator=(FString &&)=default
static int32 CullArray(TArray< FString > *InArray)
Definition FString.h:2361
bool MatchesWildcard(const FString &Wildcard, ESearchCase::Type SearchCase=ESearchCase::IgnoreCase) const
Definition FString.h:2585
FString Reverse() const
Definition FString.h:2368
FString ConvertTabsToSpaces(const int32 InSpacesPerTab)
Definition FString.h:2980
bool StartsWith(const TCHAR *InSuffix, ESearchCase::Type SearchCase=ESearchCase::IgnoreCase) const
Definition FString.h:2131
FORCEINLINE friend bool operator!=(const CharType *Lhs, const FString &Rhs)
Definition FString.h:1063
static FORCEINLINE FString ConcatTCHARsToFString(const TCHAR *Lhs, typename TIdentity< RhsType >::Type Rhs)
Definition FString.h:569
FORCEINLINE FString Left(int32 Count) const
Definition FString.h:1075
static bool ToHexBlob(const FString &Source, uint8 *DestBuffer, const uint32 DestSize)
Definition FString.h:2471
int32 ParseIntoArrayLines(TArray< FString > &OutArray, bool InCullEmpty=true) const
Definition FString.h:2684
FORCEINLINE bool FindLastChar(TCHAR InChar, int32 &Index) const
Definition FString.h:1181
std::string ToString() const
Convert FString to std::string.
Definition FString.h:1611
FString TrimQuotes(bool *bQuotesRemoved=nullptr) const
Definition FString.h:2334
FORCEINLINE FString & operator+=(const TCHAR *Str)
Definition FString.h:347
void AppendInt(int32 InNum)
Definition FString.h:2415
FORCEINLINE const TCHAR * operator*() const
Definition FString.h:282
FORCEINLINE friend FString operator/(FString &&Lhs, const TCHAR *Rhs)
Definition FString.h:765
FString()=default
FORCEINLINE friend FString operator/(FString &&Lhs, const FString &Rhs)
Definition FString.h:797
FString RightPad(int32 ChCount) const
Definition FString.h:2527
FORCEINLINE friend TEnableIf< TIsCharType< CharType >::Value, FString >::Type operator+(const FString &Lhs, CharType Rhs)
Definition FString.h:519
FORCEINLINE friend DataType::RangedForConstIteratorType end(const FString &Str)
Definition FString.h:211
void PathAppend(const TCHAR *Str, int32 StrLength)
Definition FString.h:2234
FORCEINLINE bool Contains(const FString &SubStr, ESearchCase::Type SearchCase=ESearchCase::IgnoreCase, ESearchDir::Type SearchDir=ESearchDir::FromStart) const
Definition FString.h:1156
FORCEINLINE FString(const CharType *Src, typename TEnableIf< TIsCharType< CharType >::Value >::Type *Dummy=nullptr)
Definition FString.h:98
void TrimEndInline()
Definition FString.h:2310
FORCEINLINE FString RightChop(int32 Count) const
Definition FString.h:1093
FString TrimEnd() &&
Definition FString.h:2327
bool EndsWith(const FString &InSuffix, ESearchCase::Type SearchCase=ESearchCase::IgnoreCase) const
Definition FString.h:2180
FString ToLower() &&
Definition FString.h:2115
static FString ChrN(int32 NumCharacters, TCHAR Char)
Definition FString.h:2501
static FORCEINLINE FString ConcatFStringToTCHARs(typename TIdentity< LhsType >::Type Lhs, const TCHAR *Rhs)
Definition FString.h:596
FORCEINLINE friend FString operator+(const TCHAR *Lhs, FString &&Rhs)
Definition FString.h:687
FORCEINLINE TConstIterator CreateConstIterator() const
Definition FString.h:198
bool StartsWith(const FString &InPrefix, ESearchCase::Type SearchCase=ESearchCase::IgnoreCase) const
Definition FString.h:2143
FString ToUpper() const &
Definition FString.h:2084
FString(const FString &)=default
static FString FormatAsNumber(int32 InNumber)
Definition FString.h:2395
FORCEINLINE bool Equals(const FString &Other, ESearchCase::Type SearchCase=ESearchCase::CaseSensitive) const
Definition FString.h:1221
FORCEINLINE bool IsValidIndex(int32 Index) const
Definition FString.h:272
FORCEINLINE friend FString operator/(const FString &Lhs, const TCHAR *Rhs)
Definition FString.h:749
void ToLowerInline()
Definition FString.h:2121
TArray< TCHAR > DataType
Definition FString.h:58
DataType Data
Definition FString.h:59
FString ToUpper() &&
Definition FString.h:2091
void TrimStartAndEndInline()
Definition FString.h:2266
int32 ParseIntoArray(TArray< FString > &OutArray, const TCHAR *pchDelim, bool InCullEmpty=true) const
Definition FString.h:2560
bool EndsWith(const TCHAR *InSuffix, ESearchCase::Type SearchCase=ESearchCase::IgnoreCase) const
Definition FString.h:2155
FORCEINLINE FString(int32 InCount, const TCHAR *InSrc)
Definition FString.h:116
FORCEINLINE friend DataType::RangedForConstIteratorType begin(const FString &Str)
Definition FString.h:209
FORCEINLINE friend bool operator>(const FString &Lhs, const CharType *Rhs)
Definition FString.h:967
FString ReplaceCharWithEscapedChar(const TArray< TCHAR > *Chars=nullptr) const
Definition FString.h:2934
static bool ToBlob(const FString &Source, uint8 *DestBuffer, const uint32 DestSize)
Definition FString.h:2448
FORCEINLINE TCHAR & operator[](int32 Index)
Definition FString.h:169
FORCEINLINE void InsertAt(int32 Index, TCHAR Character)
Definition FString.h:440
FORCEINLINE friend bool operator>=(const CharType *Lhs, const FString &Rhs)
Definition FString.h:940
FORCEINLINE friend FString operator/(const TCHAR *Lhs, const FString &Rhs)
Definition FString.h:813
FORCEINLINE void AppendChars(const TCHAR *Array, int32 Count)
Definition FString.h:322
FORCEINLINE friend TEnableIf< TIsCharType< CharType >::Value, FString >::Type operator+(FString &&Lhs, CharType Rhs)
Definition FString.h:538
FORCEINLINE void Shrink()
Definition FString.h:260
FORCEINLINE friend bool operator>(const CharType *Lhs, const FString &Rhs)
Definition FString.h:981
void ReverseString()
Definition FString.h:2375
FORCEINLINE bool IsEmpty() const
Definition FString.h:241
FORCEINLINE FString Right(int32 Count) const
Definition FString.h:1087
FORCEINLINE void InsertAt(int32 Index, const FString &Characters)
Definition FString.h:455
FORCEINLINE bool Contains(const TCHAR *SubStr, ESearchCase::Type SearchCase=ESearchCase::IgnoreCase, ESearchDir::Type SearchDir=ESearchDir::FromStart) const
Definition FString.h:1142
FORCEINLINE friend bool operator>(const FString &Lhs, const FString &Rhs)
Definition FString.h:953
FORCEINLINE friend bool operator==(const CharType *Lhs, const FString &Rhs)
Definition FString.h:1022
FORCEINLINE friend bool operator<(const FString &Lhs, const CharType *Rhs)
Definition FString.h:885
static FString Join(const TArray< T, Allocator > &Array, const TCHAR *Separator)
Definition FString.h:1587
bool RemoveFromEnd(const FString &InSuffix, ESearchCase::Type SearchCase=ESearchCase::IgnoreCase)
Definition FString.h:2212
FORCEINLINE TEnableIf< TIsCharType< CharType >::Value, FString & >::Type operator+=(CharType InChar)
Definition FString.h:363
FORCEINLINE const TCHAR & operator[](int32 Index) const
Definition FString.h:180
FORCEINLINE friend bool operator<(const FString &Lhs, const FString &Rhs)
Definition FString.h:871
FORCEINLINE friend bool operator>=(const FString &Lhs, const FString &Rhs)
Definition FString.h:912
FString ToLower() const &
Definition FString.h:2108
int32 ParseIntoArrayWS(TArray< FString > &OutArray, const TCHAR *pchExtraDelim=nullptr, bool InCullEmpty=true) const
Definition FString.h:2660
bool Split(const FString &InS, FString *LeftS, FString *RightS, ESearchCase::Type SearchCase=ESearchCase::IgnoreCase, ESearchDir::Type SearchDir=ESearchDir::FromStart) const
Definition FString.h:1262
static FString Format(const T *format, Args &&... args)
Formats text using fmt::format.
Definition FString.h:1633
FString LeftPad(int32 ChCount) const
Definition FString.h:2513
FORCEINLINE int32 FindLastCharByPredicate(Predicate Pred) const
Definition FString.h:1209
FORCEINLINE void Reset(int32 NewReservedSize=0)
Definition FString.h:251
FORCEINLINE void Empty(int32 Slack=0)
Definition FString.h:231
FORCEINLINE int32 Len() const
Definition FString.h:1069
FORCEINLINE int32 FindLastCharByPredicate(Predicate Pred, int32 Count) const
Definition FString.h:1195
void TrimToNullTerminator()
Definition FString.h:2015
bool RemoveFromStart(const FString &InPrefix, ESearchCase::Type SearchCase=ESearchCase::IgnoreCase)
Definition FString.h:2196
FORCEINLINE FString & AppendChar(const TCHAR InChar)
Definition FString.h:390
FORCEINLINE friend bool operator>=(const FString &Lhs, const CharType *Rhs)
Definition FString.h:926
FORCEINLINE friend bool operator<=(const FString &Lhs, const FString &Rhs)
Definition FString.h:830
FORCEINLINE void CheckInvariants() const
Definition FString.h:222
FORCEINLINE friend FString operator+(FString &&Lhs, const TCHAR *Rhs)
Definition FString.h:713
FString ReplaceEscapedCharWithChar(const TArray< TCHAR > *Chars=nullptr) const
Definition FString.h:2956
FORCEINLINE FString(const FString &Other, int32 ExtraSlack)
Definition FString.h:76
FORCEINLINE FString & operator/=(const TCHAR *Str)
Definition FString.h:724
FString & operator=(const FString &)=default
FString TrimStartAndEnd() const &
Definition FString.h:2272
T * value_
Definition Fields.h:82
FieldArray & operator=(const T &other)=delete
T * operator()()
Definition Fields.h:69
static size_t GetSize()
Definition Fields.h:76
Definition Logger.h:9
Log()=default
~Log()=default
std::shared_ptr< spdlog::logger > logger_
Definition Logger.h:41
Log(Log &&)=delete
Log & operator=(Log &&)=delete
static std::shared_ptr< spdlog::logger > & GetLog()
Definition Logger.h:22
Log & operator=(const Log &)=delete
Log(const Log &)=delete
static Log & Get()
Definition Logger.h:16
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
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
~TArray()
Definition TArray.h:517
FORCEINLINE bool Find(const ElementType &Item, int32 &Index) const
Definition TArray.h:760
void Sort()
Definition TArray.h:1964
void RemoveAtImpl(int32 Index, int32 Count, bool bAllowShrinking)
Definition TArray.h:1238
TArray & operator=(TArray &&Other)
Definition TArray.h:506
TCheckedPointerIterator< const ElementType > RangedForConstIteratorType
Definition TArray.h:1930
int32 AddUniqueImpl(ArgsType &&Args)
Definition TArray.h:1609
InAllocator Allocator
Definition TArray.h:275
TArray & operator=(std::initializer_list< InElementType > InitList)
Definition TArray.h:349
void SetNumUninitialized(int32 NewNum, bool bAllowShrinking=true)
Definition TArray.h:1376
FORCEINLINE int32 Num() const
Definition TArray.h:611
int32 FindLastByPredicate(Predicate Pred, int32 Count) const
Definition TArray.h:827
TIterator CreateIterator()
Definition TArray.h:1913
int32 AddZeroed(int32 Count=1)
Definition TArray.h:1578
FORCEINLINE int32 Emplace(ArgsType &&... Args)
Definition TArray.h:1526
FORCEINLINE int32 Max() const
Definition TArray.h:622
ElementAllocatorType AllocatorInstance
Definition TArray.h:2107
FORCENOINLINE void ResizeTo(int32 NewMax)
Definition TArray.h:2047
InElementType ElementType
Definition TArray.h:274
int32 RemoveAll(const PREDICATE_CLASS &Predicate)
Definition TArray.h:1726
void SetNumZeroed(int32 NewNum, bool bAllowShrinking=true)
Definition TArray.h:1359
void InsertZeroed(int32 Index, int32 Count=1)
Definition TArray.h:1102
static FORCEINLINE TEnableIf<!UE4Array_Private::TCanMoveTArrayPointersBetweenArrayTypes< FromArrayType, ToArrayType >::Value >::Type MoveOrCopy(ToArrayType &ToArray, FromArrayType &FromArray, int32 PrevMax)
Definition TArray.h:423
FORCEINLINE const ElementType & Last(int32 IndexFromTheEnd=0) const
Definition TArray.h:732
TIndexedContainerIterator< TArray, ElementType, int32 > TIterator
Definition TArray.h:1905
FORCEINLINE bool operator!=(const TArray &OtherArray) const
Definition TArray.h:1036
TCheckedPointerIterator< ElementType > RangedForIteratorType
Definition TArray.h:1929
TArray & operator+=(TArray &&Other)
Definition TArray.h:1490
static FORCEINLINE TEnableIf< UE4Array_Private::TCanMoveTArrayPointersBetweenArrayTypes< FromArrayType, ToArrayType >::Value >::Type MoveOrCopy(ToArrayType &ToArray, FromArrayType &FromArray, int32 PrevMax)
Definition TArray.h:402
void Init(const ElementType &Element, int32 Number)
Definition TArray.h:1662
FORCEINLINE friend RangedForIteratorType end(TArray &Array)
Definition TArray.h:1945
FORCEINLINE bool ContainsByPredicate(Predicate Pred) const
Definition TArray.h:1012
FORCEINLINE void CheckAddress(const ElementType *Addr) const
Definition TArray.h:1193
TIndexedContainerIterator< const TArray, const ElementType, int32 > TConstIterator
Definition TArray.h:1906
FORCEINLINE void CheckInvariants() const
Definition TArray.h:573
FORCEINLINE TArray(const TArray &Other, int32 ExtraSlack)
Definition TArray.h:338
FORCEINLINE void RemoveAt(int32 Index, CountType Count, bool bAllowShrinking=true)
Definition TArray.h:1290
void StableSort(const PREDICATE_CLASS &Predicate)
Definition TArray.h:2011
FORCEINLINE void Append(std::initializer_list< ElementType > InitList)
Definition TArray.h:1474
TArray & operator+=(const TArray &Other)
Definition TArray.h:1502
FORCEINLINE int32 Add(const ElementType &Item)
Definition TArray.h:1564
FORCEINLINE ElementType & Last(int32 IndexFromTheEnd=0)
Definition TArray.h:718
FORCENOINLINE void ResizeGrow(int32 OldNum)
Definition TArray.h:2032
FORCEINLINE void EmplaceAt(int32 Index, ArgsType &&... Args)
Definition TArray.h:1540
FORCEINLINE const ElementType & operator[](int32 Index) const
Definition TArray.h:645
TArray< ElementType > FilterByPredicate(Predicate Pred) const
Definition TArray.h:972
FORCEINLINE friend RangedForIteratorType begin(TArray &Array)
Definition TArray.h:1943
void Append(TArray< OtherElementType, OtherAllocator > &&Source)
Definition TArray.h:1433
FORCENOINLINE void ResizeForCopy(int32 NewMax, int32 PrevMax)
Definition TArray.h:2059
FORCEINLINE void RemoveAtSwap(int32 Index)
Definition TArray.h:1849
int32 Insert(const ElementType *Ptr, int32 Count, int32 Index)
Definition TArray.h:1175
FORCEINLINE int32 GetSlack() const
Definition TArray.h:564
FORCEINLINE int32 AddUnique(const ElementType &Item)
Definition TArray.h:1640
int32 Find(const ElementType &Item) const
Definition TArray.h:773
void CopyToEmpty(const OtherElementType *OtherData, int32 OtherNum, int32 PrevMax, int32 ExtraSlack)
Definition TArray.h:2084
FORCEINLINE void Shrink()
Definition TArray.h:743
void SetNumUnsafeInternal(int32 NewNum)
Definition TArray.h:1392
FORCEINLINE const ElementType & Top() const
Definition TArray.h:707
static FORCEINLINE TEnableIf< UE4Array_Private::TCanMoveTArrayPointersBetweenArrayTypes< FromArrayType, ToArrayType >::Value >::Type MoveOrCopyWithSlack(ToArrayType &ToArray, FromArrayType &FromArray, int32 PrevMax, int32 ExtraSlack)
Definition TArray.h:439
int32 RemoveSwap(const ElementType &Item)
Definition TArray.h:1822
int32 IndexOfByKey(const KeyType &Key) const
Definition TArray.h:861
void Append(const TArray< OtherElementType, OtherAllocator > &Source)
Definition TArray.h:1407
FORCEINLINE TArray(const TArray &Other)
Definition TArray.h:326
FORCEINLINE ElementType & Top()
Definition TArray.h:694
FORCEINLINE friend RangedForConstIteratorType end(const TArray &Array)
Definition TArray.h:1946
TArray(std::initializer_list< InElementType > InitList)
Definition TArray.h:302
FORCEINLINE bool FindLast(const ElementType &Item, int32 &Index) const
Definition TArray.h:794
int32 ArrayMax
Definition TArray.h:2109
FORCEINLINE int32 AddUnique(ElementType &&Item)
Definition TArray.h:1631
FORCEINLINE friend RangedForConstIteratorType begin(const TArray &Array)
Definition TArray.h:1944
int32 Insert(const ElementType &Item, int32 Index)
Definition TArray.h:1226
FORCEINLINE uint32 GetTypeSize() const
Definition TArray.h:543
TArray & operator+=(std::initializer_list< ElementType > InitList)
Definition TArray.h:1513
void Append(const ElementType *Ptr, int32 Count)
Definition TArray.h:1460
static FORCEINLINE TEnableIf<!UE4Array_Private::TCanMoveTArrayPointersBetweenArrayTypes< FromArrayType, ToArrayType >::Value >::Type MoveOrCopyWithSlack(ToArrayType &ToArray, FromArrayType &FromArray, int32 PrevMax, int32 ExtraSlack)
Definition TArray.h:457
int32 Insert(ElementType &&Item, int32 Index)
Definition TArray.h:1207
FORCEINLINE TArray(TArray &&Other)
Definition TArray.h:468
FORCENOINLINE void ResizeShrink()
Definition TArray.h:2037
FORCEINLINE void RangeCheck(int32 Index) const
Definition TArray.h:583
void Reset(int32 NewSize=0)
Definition TArray.h:1302
bool Contains(const ComparisonType &Item) const
Definition TArray.h:992
TArray(TArray< OtherElementType, Allocator > &&Other, int32 ExtraSlack)
Definition TArray.h:492
FORCEINLINE void RemoveAt(int32 Index)
Definition TArray.h:1276
int32 RemoveSingle(const ElementType &Item)
Definition TArray.h:1679
int32 FindLast(const ElementType &Item) const
Definition TArray.h:806
void RemoveAllSwap(const PREDICATE_CLASS &Predicate, bool bAllowShrinking=true)
Definition TArray.h:1774
FORCEINLINE ElementType & operator[](int32 Index)
Definition TArray.h:632
TArray & operator=(const TArray &Other)
Definition TArray.h:381
int32 Remove(const ElementType &Item)
Definition TArray.h:1709
bool operator==(const TArray &OtherArray) const
Definition TArray.h:1023
FORCEINLINE const ElementType * FindByPredicate(Predicate Pred) const
Definition TArray.h:938
FORCEINLINE TArray(const ElementType *Ptr, int32 Count)
Definition TArray.h:292
FORCEINLINE ElementType Pop(bool bAllowShrinking=true)
Definition TArray.h:657
FORCEINLINE int32 FindLastByPredicate(Predicate Pred) const
Definition TArray.h:848
FORCEINLINE TArray()
Definition TArray.h:280
void Empty(int32 Slack=0)
Definition TArray.h:1321
TChooseClass< Allocator::NeedsElementType, typenameAllocator::templateForElementType< ElementType >, typenameAllocator::ForAnyElementType >::Result ElementAllocatorType
Definition TArray.h:2105
void SetNum(int32 NewNum, bool bAllowShrinking=true)
Definition TArray.h:1340
int32 ArrayNum
Definition TArray.h:2108
FORCEINLINE const ElementType * FindByKey(const KeyType &Key) const
Definition TArray.h:903
FORCEINLINE void Push(const ElementType &Item)
Definition TArray.h:683
TConstIterator CreateConstIterator() const
Definition TArray.h:1923
FORCEINLINE void Reserve(int32 Number)
Definition TArray.h:1648
void InsertDefaulted(int32 Index, int32 Count=1)
Definition TArray.h:1116
FORCEINLINE int32 AddUninitialized(int32 Count=1)
Definition TArray.h:1051
int32 RemoveSingleSwap(const ElementType &Item, bool bAllowShrinking=true)
Definition TArray.h:1798
FORCEINLINE TArray(TArray< OtherElementType, OtherAllocator > &&Other)
Definition TArray.h:479
FORCEINLINE ElementType * GetData() const
Definition TArray.h:533
FORCEINLINE bool IsValidIndex(int32 Index) const
Definition TArray.h:600
int32 Insert(std::initializer_list< ElementType > InitList, const int32 InIndex)
Definition TArray.h:1129
FORCEINLINE uint32 GetAllocatedSize(void) const
Definition TArray.h:554
int32 Insert(const TArray< ElementType > &Items, const int32 InIndex)
Definition TArray.h:1150
FORCEINLINE int32 Add(ElementType &&Item)
Definition TArray.h:1555
FORCEINLINE void RemoveAtSwap(int32 Index, CountType Count, bool bAllowShrinking=true)
Definition TArray.h:1867
TArray & operator=(const TArray< ElementType, OtherAllocator > &Other)
Definition TArray.h:368
ElementType * FindByPredicate(Predicate Pred)
Definition TArray.h:950
FORCEINLINE TArray(const TArray< OtherElementType, OtherAllocator > &Other)
Definition TArray.h:316
void InsertUninitialized(int32 Index, int32 Count=1)
Definition TArray.h:1076
ElementType * FindByKey(const KeyType &Key)
Definition TArray.h:917
void Sort(const PREDICATE_CLASS &Predicate)
Definition TArray.h:1980
int32 AddDefaulted(int32 Count=1)
Definition TArray.h:1593
void RemoveAtSwapImpl(int32 Index, int32 Count=1, bool bAllowShrinking=true)
Definition TArray.h:1873
void StableSort()
Definition TArray.h:1994
FORCEINLINE void Push(ElementType &&Item)
Definition TArray.h:670
int32 IndexOfByPredicate(Predicate Pred) const
Definition TArray.h:881
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
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)
Definition TArray.h:130
ElementType * operator->() const
Definition TArray.h:93
FORCEINLINE friend bool operator==(const TIndexedContainerIterator &Lhs, const TIndexedContainerIterator &Rhs)
Definition TArray.h:129
IndexType GetIndex() const
Definition TArray.h:105
TIndexedContainerIterator operator+(int32 Offset) const
Definition TArray.h:71
TIndexedContainerIterator operator++(int)
Definition TArray.h:44
TIndexedContainerIterator & operator--()
Definition TArray.h:52
TIndexedContainerIterator & operator-=(int32 Offset)
Definition TArray.h:77
FORCEINLINE operator bool() const
Definition TArray.h:99
TIndexedContainerIterator(ContainerType &InContainer, IndexType StartIndex=0)
Definition TArray.h:32
ContainerType & Container
Definition TArray.h:134
TIndexedContainerIterator & operator++()
Definition TArray.h:39
TIndexedContainerIterator & operator+=(int32 Offset)
Definition TArray.h:65
TIndexedContainerIterator operator--(int)
Definition TArray.h:57
TIndexedContainerIterator operator-(int32 Offset) const
Definition TArray.h:82
ElementType & operator*() const
Definition TArray.h:88
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
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)
Definition Sorting.h:202
Definition Map.h:856
static void Sort(T *First, const int32 Num, const PREDICATE_CLASS &Predicate)
Definition Sorting.h:286
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)
Definition Sorting.h:245
static FORCEINLINE uint32 GetNumberOfHashBuckets(uint32 NumHashedElements)
InSparseArrayAllocator SparseArrayAllocator
FORCEINLINE ObjectType * Get() const
ArgFormatter(BasicFormatter< Char > &formatter, FormatSpec &spec, const Char *fmt)
Definition format.h:2289
uint64_t types_
Definition format.h:1567
ArgList(ULongLong types, const internal::Value *values)
Definition format.h:1591
internal::Arg::Type type(unsigned index) const
Definition format.h:1578
friend class internal::ArgMap
Definition format.h:1583
@ MAX_PACKED_ARGS
Definition format.h:1587
internal::Arg operator[](unsigned index) const
Definition format.h:1599
static internal::Arg::Type type(uint64_t types, unsigned index)
Definition format.h:1624
uint64_t types() const
Definition format.h:1596
ArgList(ULongLong types, const internal::Arg *args)
Definition format.h:1593
void report_unhandled_arg()
Definition format.h:1664
Result visit_custom(Arg::CustomValue)
Definition format.h:1744
Result visit(const Arg &arg)
Definition format.h:1756
Result visit_double(double value)
Definition format.h:1708
Result visit_uint(unsigned value)
Definition format.h:1682
Result visit_any_int(T)
Definition format.h:1703
Result visit_cstring(const char *)
Definition format.h:1724
Result visit_pointer(const void *)
Definition format.h:1739
Result visit_unhandled_arg()
Definition format.h:1666
Result visit_any_double(T)
Definition format.h:1719
Result visit_long_double(long double value)
Definition format.h:1713
Result visit_long_long(LongLong value)
Definition format.h:1677
Result visit_wstring(Arg::StringValue< wchar_t >)
Definition format.h:1734
Result visit_string(Arg::StringValue< char >)
Definition format.h:1729
Result visit_ulong_long(ULongLong value)
Definition format.h:1687
Result visit_int(int value)
Definition format.h:1672
Result visit_bool(bool value)
Definition format.h:1692
Result visit_char(int value)
Definition format.h:1697
BasicFormatter< Char, Impl > & formatter_
Definition format.h:2260
const Char * format_
Definition format.h:2261
BasicArgFormatter(BasicFormatter< Char, Impl > &formatter, Spec &spec, const Char *fmt)
Definition format.h:2272
void visit_custom(internal::Arg::CustomValue c)
Definition format.h:2278
BasicArrayWriter(Char *array, std::size_t size)
Definition format.h:3353
internal::FixedBuffer< Char > buffer_
Definition format.h:3344
BasicArrayWriter(Char(&array)[SIZE])
Definition format.h:3363
const Char * data_
Definition format.h:660
const Char * c_str() const
Definition format.h:677
BasicCStringRef(const Char *s)
Definition format.h:664
BasicFormatter(const ArgList &args, BasicWriter< Char > &w)
Definition format.h:2328
void format(BasicCStringRef< Char > format_str)
Definition format.h:4012
internal::ArgMap< Char > map_
Definition format.h:2304
internal::Arg get_arg(BasicStringRef< Char > arg_name, const char *&error)
Definition format.h:3800
const Char * format(const Char *&format_str, const internal::Arg &arg)
Definition format.h:3840
BasicWriter< Char > & writer()
Definition format.h:2332
internal::Arg parse_arg_name(const Char *&s)
Definition format.h:3825
BasicWriter< Char > & writer_
Definition format.h:2303
internal::Arg parse_arg_index(const Char *&s)
Definition format.h:3813
const Char * data_
Definition format.h:539
BasicStringRef(const Char *s)
Definition format.h:552
std::size_t size() const
Definition format.h:598
friend bool operator!=(BasicStringRef lhs, BasicStringRef rhs)
Definition format.h:612
friend bool operator<(BasicStringRef lhs, BasicStringRef rhs)
Definition format.h:615
const Char * data() const
Definition format.h:595
friend bool operator<=(BasicStringRef lhs, BasicStringRef rhs)
Definition format.h:618
friend bool operator>(BasicStringRef lhs, BasicStringRef rhs)
Definition format.h:621
std::basic_string< Char > to_string() const
Definition format.h:590
friend bool operator>=(BasicStringRef lhs, BasicStringRef rhs)
Definition format.h:624
BasicStringRef(const Char *s, std::size_t size)
Definition format.h:544
friend bool operator==(BasicStringRef lhs, BasicStringRef rhs)
Definition format.h:609
std::size_t size_
Definition format.h:540
int compare(BasicStringRef other) const
Definition format.h:601
static CharPtr fill_padding(CharPtr buffer, unsigned total_size, std::size_t content_size, wchar_t fill)
Definition format.h:2926
void write_decimal(Int value)
Definition format.h:2647
virtual ~BasicWriter()
Definition format.h:2722
void append_float_length(Char *&, T)
Definition format.h:2702
void write_int(T value, Spec spec)
Definition format.h:3006
static Char * get(Char *p)
Definition format.h:2620
Buffer< Char > & buffer_
Definition format.h:2610
friend class BasicPrintfArgFormatter
Definition format.h:2708
BasicWriter(Buffer< Char > &b)
Definition format.h:2714
CharPtr prepare_int_buffer(unsigned num_digits, const Spec &spec, const char *prefix, unsigned prefix_size)
Definition format.h:2943
Char * write_unsigned_decimal(UInt value, unsigned prefix_size=0)
Definition format.h:2638
void append_float_length(Char *&format_ptr, long double)
Definition format.h:2697
void operator<<(typename internal::WCharHelper< const wchar_t *, Char >::Unsupported)
std::size_t size() const
Definition format.h:2727
CharPtr grow_buffer(std::size_t n)
Definition format.h:2630
void write_str(const internal::Arg::StringValue< StrChar > &str, const Spec &spec)
Definition format.h:2905
const Char * data() const FMT_NOEXCEPT
Definition format.h:2733
std::basic_string< Char > str() const
Definition format.h:2751
void clear() FMT_NOEXCEPT
Definition format.h:2875
CharPtr write_str(const StrChar *s, std::size_t size, const AlignSpec &spec)
Definition format.h:2882
void write(BasicCStringRef< Char > format, ArgList args)
Definition format.h:2780
Buffer< Char > & buffer() FMT_NOEXCEPT
Definition format.h:2877
CharPtr prepare_int_buffer(unsigned num_digits, const EmptySpec &, const char *prefix, unsigned prefix_size)
Definition format.h:2659
void operator<<(typename internal::WCharHelper< wchar_t, Char >::Unsupported)
internal::CharTraits< Char >::CharPtr CharPtr
Definition format.h:2614
void write_double(T value, const Spec &spec)
Definition format.h:3099
const Char * c_str() const
Definition format.h:2739
void resize(std::size_t new_size)
Definition format.h:770
std::size_t size() const
Definition format.h:762
std::size_t size_
Definition format.h:744
void push_back(const T &value)
Definition format.h:788
void clear() FMT_NOEXCEPT
Definition format.h:786
virtual ~Buffer()
Definition format.h:759
void append(const U *begin, const U *end)
Definition format.h:804
void reserve(std::size_t capacity)
Definition format.h:781
std::size_t capacity_
Definition format.h:745
virtual void grow(std::size_t size)=0
Buffer(T *ptr=FMT_NULL, std::size_t capacity=0)
Definition format.h:747
T & operator[](std::size_t index)
Definition format.h:798
std::size_t capacity() const
Definition format.h:765
const T & operator[](std::size_t index) const
Definition format.h:799
FormatError(const FormatError &ferr)
Definition format.h:688
FMT_API ~FormatError() FMT_DTOR_NOEXCEPT FMT_OVERRIDE
FormatError(CStringRef message)
Definition format.h:686
const char * data() const
Definition format.h:3537
char * str_
Definition format.h:3486
FormatInt(unsigned long value)
Definition format.h:3525
void FormatSigned(LongLong value)
Definition format.h:3510
char * format_decimal(ULongLong value)
Definition format.h:3489
FormatInt(unsigned value)
Definition format.h:3524
std::string str() const
Definition format.h:3553
std::size_t size() const
Definition format.h:3529
FormatInt(int value)
Definition format.h:3521
FormatInt(ULongLong value)
Definition format.h:3526
char buffer_[BUFFER_SIZE]
Definition format.h:3485
const char * c_str() const
Definition format.h:3543
FormatInt(LongLong value)
Definition format.h:3523
FormatInt(long value)
Definition format.h:3522
T value() const
Definition format.h:1879
IntFormatSpec(T val, const SpecT &spec=SpecT())
Definition format.h:1876
StrFormatSpec(const Char *str, unsigned width, FillChar fill)
Definition format.h:1890
const Char * str_
Definition format.h:1886
const Char * str() const
Definition format.h:1895
int error_code() const
Definition format.h:2566
SystemError(int error_code, CStringRef message)
Definition format.h:2558
FMT_API ~SystemError() FMT_DTOR_NOEXCEPT FMT_OVERRIDE
FMT_API void init(int err_code, CStringRef format_str, ArgList args)
Definition format.cc:225
void visit_wstring(internal::Arg::StringValue< Char > value)
Definition format.h:2182
void visit_string(internal::Arg::StringValue< char > value)
Definition format.h:2176
BasicWriter< Char > & writer_
Definition format.h:2090
void visit_pointer(const void *value)
Definition format.h:2186
BasicWriter< Char > & writer()
Definition format.h:2105
void visit_cstring(const char *value)
Definition format.h:2169
void write(const char *value)
Definition format.h:2114
void write_pointer(const void *p)
Definition format.h:2095
void visit_bool(bool value)
Definition format.h:2131
ArgFormatterBase(BasicWriter< Char > &w, Spec &s)
Definition format.h:2122
MapType::value_type Pair
Definition format.h:2024
void init(const ArgList &args)
Definition format.h:2043
static Char cast(int value)
Definition format.h:916
static char convert(char value)
Definition format.h:929
static char convert(wchar_t)
static wchar_t convert(char value)
Definition format.h:949
static wchar_t convert(wchar_t value)
Definition format.h:950
bool check_no_auto_index(const char *&error)
Definition format.h:2223
FormatterBase(const ArgList &args)
Definition format.h:2204
const ArgList & args() const
Definition format.h:2202
void write(BasicWriter< Char > &w, const Char *start, const Char *end)
Definition format.h:2233
Arg next_arg(const char *&error)
Definition format.h:2210
Arg get_arg(unsigned arg_index, const char *&error)
Definition format.h:2219
FMT_API Arg do_get_arg(unsigned arg_index, const char *&error)
MakeArg(const T &value)
Definition format.h:1530
MakeValue(unsigned long value)
Definition format.h:1420
MakeValue(typename WCharHelper< wchar_t, Char >::Unsupported)
MakeValue(typename WCharHelper< WStringRef, Char >::Unsupported)
static uint64_t type(long)
Definition format.h:1416
MakeValue(typename WCharHelper< const wchar_t *, Char >::Unsupported)
MakeValue(typename WCharHelper< wchar_t *, Char >::Unsupported)
Formatter::Char Char
Definition format.h:1345
void set_string(WStringRef str)
Definition format.h:1378
static uint64_t type(unsigned long)
Definition format.h:1426
void set_string(StringRef str)
Definition format.h:1373
MakeValue(const T *value)
static void format_custom_arg(void *formatter, const void *arg, void *format_str_ptr)
Definition format.h:1385
MakeValue(long value)
Definition format.h:1408
RuntimeError(const RuntimeError &rerr)
Definition format.h:1554
FMT_API ~RuntimeError() FMT_DTOR_NOEXCEPT FMT_OVERRIDE
ThousandsSep(fmt::StringRef sep)
Definition format.h:1068
void operator()(Char *&buffer)
Definition format.h:1071
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
Definition formatter.h:37
const pattern_time_type _pattern_time
Definition formatter.h:38
virtual log_err_handler error_handler() override
void flush() override
std::vector< std::unique_ptr< details::flag_formatter > > _formatters
Definition formatter.h:39
void format(details::log_msg &msg, const std::tm &tm_time) override
void format(details::log_msg &msg, const std::tm &tm_time) override
const std::chrono::seconds cache_refresh
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
void format(details::log_msg &msg, const std::tm &tm_time) override
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 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
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
void set_error_handler(spdlog::log_err_handler err_handler)
void format(details::log_msg &msg, const std::tm &tm_time) override
void reopen(bool truncate)
Definition file_helper.h:64
const filename_t & filename() const
file_helper(const file_helper &)=delete
void write(const log_msg &msg)
Definition file_helper.h:86
file_helper & operator=(const file_helper &)=delete
virtual void format(details::log_msg &msg, const std::tm &tm_time)=0
void format(details::log_msg &msg, const std::tm &) override
mpmc_bounded_queue(mpmc_bounded_queue const &)=delete
void operator=(mpmc_bounded_queue const &)=delete
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)
Definition registry.h:163
std::function< void()> _worker_warmup_cb
Definition registry.h:204
std::function< void()> _worker_teardown_cb
Definition registry.h:206
void formatter(formatter_ptr f)
Definition registry.h:132
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)
Definition registry.h:75
void throw_if_exists(const std::string &logger_name)
Definition registry.h:191
void drop(const std::string &logger_name)
Definition registry.h:101
std::shared_ptr< logger > create(const std::string &logger_name, sink_ptr sink)
Definition registry.h:117
level::level_enum _level
Definition registry.h:199
std::chrono::milliseconds _flush_interval_ms
Definition registry.h:205
void apply_all(std::function< void(std::shared_ptr< logger >)> fun)
Definition registry.h:94
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)
Definition registry.h:122
void register_logger(std::shared_ptr< logger > logger)
Definition registry.h:33
log_err_handler _err_handler
Definition registry.h:200
void set_error_handler(log_err_handler handler)
Definition registry.h:156
std::shared_ptr< logger > create(const std::string &logger_name, sinks_init_list sinks)
Definition registry.h:112
void set_pattern(const std::string &pattern)
Definition registry.h:140
registry_t< Mutex > & operator=(const registry_t< Mutex > &)=delete
void set_level(level::level_enum log_level)
Definition registry.h:148
std::shared_ptr< logger > get(const std::string &logger_name)
Definition registry.h:42
std::shared_ptr< logger > create(const std::string &logger_name, const It &sinks_begin, const It &sinks_end)
Definition registry.h:50
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)
Definition registry.h:127
async_overflow_policy _overflow_policy
Definition registry.h:203
static registry_t< Mutex > & instance()
Definition registry.h:180
void format(details::log_msg &msg, const std::tm &) override
virtual ~formatter()
Definition formatter.h:24
virtual void format(details::log_msg &msg)=0
const std::vector< sink_ptr > & sinks() const
std::atomic< time_t > _last_err_time
Definition logger.h:105
void log(level::level_enum lvl, const T &)
void log(level::level_enum lvl, const char *fmt, const Args &... args)
Definition logger_impl.h:61
log_err_handler _err_handler
Definition logger.h:104
void critical(const T &)
void debug(const char *fmt, const Arg1 &, const Args &... args)
virtual ~logger()
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)
Definition logger_impl.h:88
void flush_on(level::level_enum log_level)
virtual log_err_handler error_handler()
spdlog::level_t _flush_level
Definition logger.h:103
void set_formatter(formatter_ptr)
Definition logger_impl.h:50
void warn(const char *fmt, const Arg1 &, const Args &... args)
void info(const char *fmt, const Arg1 &, const Args &... args)
void warn(const T &)
void error(const char *fmt, const Arg1 &, const Args &... args)
const std::string _name
Definition logger.h:99
virtual void flush()
spdlog::level_t _level
Definition logger.h:102
void trace(const T &)
logger & operator=(const logger &)=delete
std::vector< sink_ptr > _sinks
Definition logger.h:100
logger(const logger &)=delete
void error(const T &)
std::atomic< size_t > _msg_counter
Definition logger.h:106
void debug(const T &)
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 info(const T &)
formatter_ptr _formatter
Definition logger.h:101
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)
Definition file_sinks.h:197
details::file_helper _file_helper
Definition file_sinks.h:54
void _sink_it(const details::log_msg &msg) override
void set_force_flush(bool force_flush)
Definition file_sinks.h:37
static std::shared_ptr< MyType > instance()
simple_file_sink(const filename_t &filename, bool truncate=false)
Definition file_sinks.h:32
std::chrono::system_clock::time_point _next_rotation_tp()
Definition file_sinks.h:228
std::chrono::system_clock::time_point _rotation_tp
Definition file_sinks.h:246
rotating_file_sink(const filename_t &base_filename, std::size_t max_size, std::size_t max_files)
Definition file_sinks.h:68
static filename_t calc_filename(const filename_t &filename, std::size_t index)
Definition file_sinks.h:82
virtual void _flush()=0
virtual ~base_sink()=default
base_sink & operator=(const base_sink &)=delete
void log(const details::log_msg &msg) SPDLOG_FINAL override
Definition base_sink.h:34
void flush() SPDLOG_FINAL override
Definition base_sink.h:39
virtual void _sink_it(const details::log_msg &msg)=0
base_sink(const base_sink &)=delete
void set_level(level::level_enum log_level)
Definition sink.h:41
bool should_log(level::level_enum msg_level) const
Definition sink.h:36
virtual void log(const details::log_msg &msg)=0
level_t _level
Definition sink.h:32
virtual ~sink()
Definition sink.h:23
virtual void flush()=0
std::string _msg
Definition common.h:147
const char * what() const SPDLOG_NOEXCEPT override
Definition common.h:142
#define SPDLOG_NOEXCEPT
Definition common.h:28
#define SPDLOG_FINAL
Definition common.h:36
#define SPDLOG_CONSTEXPR
Definition common.h:29
#define SPDLOG_LEVEL_NAMES
Definition common.h:86
Definition Reverse.h:20
FORCEINLINE void Sort(RangeType &Range)
Definition Sort.h:16
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)
Definition Sort.h:40
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)
Definition Sort.h:28
FORCEINLINE void IntroSort(RangeType &Range)
Definition IntroSort.h:137
FORCEINLINE int32 BinarySearchBy(RangeType &Range, const ValueType &Value, ProjectionType Projection)
FORCEINLINE void IntroSortBy(RangeType &Range, ProjectionType Projection, PredicateType Predicate)
Definition IntroSort.h:174
FORCEINLINE void IntroSort(RangeType &Range, PredicateType Predicate)
Definition IntroSort.h:149
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)
Definition IntroSort.h:161
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)
Definition Sort.h:53
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)
Definition BinaryHeap.h:27
FORCEINLINE int32 HeapGetParentIndex(int32 Index)
Definition BinaryHeap.h:38
void IntroSortInternal(T *First, SIZE_T Num, ProjectionType Projection, PredicateType Predicate)
Definition IntroSort.h:26
FORCEINLINE int32 HeapGetLeftChildIndex(int32 Index)
Definition BinaryHeap.h:16
FORCEINLINE int32 HeapSiftUp(RangeValueType *Heap, int32 RootIndex, int32 NodeIndex, const ProjectionType &Projection, const PredicateType &Predicate)
Definition BinaryHeap.h:88
FORCEINLINE void HeapSiftDown(RangeValueType *Heap, int32 Index, const int32 Count, const ProjectionType &Projection, const PredicateType &Predicate)
Definition BinaryHeap.h:53
FORCEINLINE void HeapifyInternal(RangeValueType *First, SIZE_T Num, ProjectionType Projection, PredicateType Predicate)
Definition BinaryHeap.h:115
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)
Definition BinaryHeap.h:132
IApiUtils & GetApiUtils()
Definition ApiUtils.cpp:99
@ CaseSensitive
Definition FString.h:28
@ FromStart
Definition FString.h:41
void FromString(float &OutValue, const TCHAR *Buffer)
Definition FString.h:1845
void FromString(int8 &OutValue, const TCHAR *Buffer)
Definition FString.h:1837
void FromString(uint8 &OutValue, const TCHAR *Buffer)
Definition FString.h:1841
void FromString(uint32 &OutValue, const TCHAR *Buffer)
Definition FString.h:1843
TEnableIf< TIsCharType< CharType >::Value, FString >::Type ToString(const CharType *Ptr)
Definition FString.h:1851
void FromString(int32 &OutValue, const TCHAR *Buffer)
Definition FString.h:1839
void FromString(uint64 &OutValue, const TCHAR *Buffer)
Definition FString.h:1844
FString ToSanitizedString(const T &Value)
Definition FString.h:1873
void FromString(FString &OutValue, const TCHAR *Buffer)
Definition FString.h:1847
void FromString(double &OutValue, const TCHAR *Buffer)
Definition FString.h:1846
void FromString(uint16 &OutValue, const TCHAR *Buffer)
Definition FString.h:1842
static TEnableIf< TIsArithmetic< T >::Value, bool >::Type TryParseString(T &OutValue, const TCHAR *Buffer)
Definition FString.h:1882
void FromString(int16 &OutValue, const TCHAR *Buffer)
Definition FString.h:1838
FString ToString(bool Value)
Definition FString.h:1856
FORCEINLINE FString ToString(FString &&Str)
Definition FString.h:1861
FORCEINLINE FString ToString(const FString &Str)
Definition FString.h:1866
void FromString(int64 &OutValue, const TCHAR *Buffer)
Definition FString.h:1840
FORCEINLINE auto DereferenceIfNecessary(CallableType &&Callable) -> typename TEnableIf< TPointerIsConvertibleFromTo< typename TDecay< CallableType >::Type, typename TDecay< BaseType >::Type >::Value, decltype((CallableType &&) Callable)>::Type
Definition Invoke.h:13
bool MatchesWildcardRecursive(const TCHAR *Target, int32 TargetLength, const TCHAR *Wildcard, int32 WildcardLength)
Definition FString.h:1933
No & convert(...)
unsigned parse_nonnegative_int(const Char *&s)
Definition format.h:3758
T * make_ptr(T *ptr, std::size_t)
Definition format.h:728
bool is_name_start(Char c)
Definition format.h:3751
Yes & convert(fmt::ULongLong)
bool is_negative(T value)
Definition format.h:982
DummyInt _finite(...)
Definition format.h:421
char Yes[1]
Definition format.h:1230
fmt::StringRef thousands_sep(...)
Definition format.h:1310
DummyInt isinf(...)
Definition format.h:420
DummyInt signbit(...)
Definition format.h:418
DummyInt _ecvt_s(...)
Definition format.h:419
void require_numeric_argument(const Arg &arg, char spec)
Definition format.h:3779
MakeUnsigned< Int >::Type to_unsigned(Int value)
Definition format.h:711
uint64_t make_type()
Definition format.h:2361
void format_decimal(Char *buffer, UInt value, unsigned num_digits)
Definition format.h:1109
@ INLINE_BUFFER_SIZE
Definition format.h:718
void check_sign(const Char *&s, const Arg &arg)
Definition format.h:3788
StringRef thousands_sep(LConv *lc, LConvCheck< char *LConv::*, &LConv::thousands_sep >=0)
Definition format.h:1305
DummyInt isnan(...)
Definition format.h:422
uint64_t make_type(const T &arg)
Definition format.h:2364
T const_check(T value)
Definition format.h:428
char No[2]
Definition format.h:1231
DummyInt _isnan(...)
Definition format.h:423
void format_arg(Formatter &,...)
Definition format.h:1334
void format_decimal(Char *buffer, UInt value, unsigned num_digits, ThousandsSep thousands_sep)
Definition format.h:1084
BasicData Data
Definition format.h:1016
Definition format.h:408
ArgJoin< wchar_t, It > join(It first, It last, const BasicCStringRef< wchar_t > &sep)
Definition format.h:4051
void format_decimal(char *&buffer, T value)
Definition format.h:3560
FMT_API void print(CStringRef format_str, ArgList args)
Definition format.cc:449
FMT_API void print_colored(Color c, CStringRef format, ArgList args)
Definition format.cc:453
ArgJoin< char, It > join(It first, It last, const BasicCStringRef< char > &sep)
Definition format.h:4046
@ HASH_FLAG
Definition format.h:1799
@ PLUS_FLAG
Definition format.h:1799
@ SIGN_FLAG
Definition format.h:1799
@ CHAR_FLAG
Definition format.h:1800
@ MINUS_FLAG
Definition format.h:1799
__pad6__
Definition format.cc:296
IntFormatSpec< int, TypeSpec< 'o'> > oct(int value)
BasicWriter< char > Writer
Definition format.h:496
StrFormatSpec< wchar_t > pad(const wchar_t *str, unsigned width, char fill=' ')
Definition format.h:2012
BasicArrayWriter< wchar_t > WArrayWriter
Definition format.h:3368
std::string format(CStringRef format_str, ArgList args)
Definition format.h:3443
BasicArrayWriter< char > ArrayWriter
Definition format.h:3367
IntFormatSpec< int, TypeSpec< 'b'> > bin(int value)
BasicMemoryWriter< wchar_t > WMemoryWriter
Definition format.h:3319
IntFormatSpec< int, TypeSpec< 'x'> > hex(int value)
BasicStringRef< wchar_t > WStringRef
Definition format.h:630
BasicMemoryWriter< char > MemoryWriter
Definition format.h:3318
void arg(WStringRef, const internal::NamedArg< Char > &) FMT_DELETED_OR_UNDEFINED
FMT_API void report_system_error(int error_code, StringRef message) FMT_NOEXCEPT
Definition format.cc:429
void format_arg(fmt::BasicFormatter< Char, ArgFormatter > &f, const Char *&format_str, const ArgJoin< Char, It > &e)
Definition format.h:4070
__pad1__
Definition format.cc:236
std::wstring format(WCStringRef format_str, ArgList args)
Definition format.h:3449
__pad2__
Definition format.cc:250
Alignment
Definition format.h:1793
@ ALIGN_LEFT
Definition format.h:1794
@ ALIGN_DEFAULT
Definition format.h:1794
@ ALIGN_NUMERIC
Definition format.h:1794
@ ALIGN_RIGHT
Definition format.h:1794
@ ALIGN_CENTER
Definition format.h:1794
Color
Definition format.h:3424
@ BLUE
Definition format.h:3424
@ BLACK
Definition format.h:3424
@ RED
Definition format.h:3424
@ GREEN
Definition format.h:3424
@ WHITE
Definition format.h:3424
@ YELLOW
Definition format.h:3424
@ CYAN
Definition format.h:3424
@ MAGENTA
Definition format.h:3424
FMT_API void print(std::FILE *f, CStringRef format_str, ArgList args)
Definition format.cc:443
internal::NamedArgWithType< char, T > arg(StringRef name, const T &arg)
Definition format.h:3593
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
Definition format.cc:388
void arg(StringRef, const internal::NamedArg< Char > &) FMT_DELETED_OR_UNDEFINED
internal::NamedArgWithType< wchar_t, T > arg(WStringRef name, const T &arg)
Definition format.h:3598
IntFormatSpec< int, TypeSpec< 'X'> > hexu(int value)
BasicStringRef< char > StringRef
Definition format.h:629
StrFormatSpec< Char > pad(const Char *str, unsigned width, Char fill=' ')
Definition format.h:2007
BasicCStringRef< wchar_t > WCStringRef
Definition format.h:681
FMT_GCC_EXTENSION typedef long long LongLong
Definition format.h:486
BasicCStringRef< char > CStringRef
Definition format.h:680
FMT_GCC_EXTENSION typedef unsigned long long ULongLong
Definition format.h:487
BasicWriter< wchar_t > WWriter
Definition format.h:497
size_t thread_id()
Definition os.h:353
bool operator!=(const std::tm &tm1, const std::tm &tm2)
Definition os.h:129
std::string errno_to_string(char[256], char *res)
Definition os.h:382
bool in_terminal(FILE *file)
Definition os.h:468
std::string errno_to_string(char buf[256], int res)
Definition os.h:387
void prevent_child_fd(FILE *f)
Definition os.h:156
size_t filesize(FILE *f)
Definition os.h:230
int utc_minutes_offset(const std::tm &tm=details::os::localtime())
Definition os.h:267
std::tm gmtime(const std::time_t &time_tt)
Definition os.h:100
bool is_color_terminal()
Definition os.h:439
std::tm localtime()
Definition os.h:93
static SPDLOG_CONSTEXPR int eol_size
Definition os.h:144
std::tm localtime(const std::time_t &time_tt)
Definition os.h:80
std::tm gmtime()
Definition os.h:113
spdlog::log_clock::time_point now()
Definition os.h:64
std::string errno_str(int err_num)
Definition os.h:400
size_t _thread_id()
Definition os.h:330
static SPDLOG_CONSTEXPR const char * eol
Definition os.h:143
bool operator==(const std::tm &tm1, const std::tm &tm2)
Definition os.h:118
registry_t< std::mutex > registry
Definition registry.h:211
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)
Definition common.h:97
const char * to_str(spdlog::level::level_enum l)
Definition common.h:92
static const char * short_level_names[]
Definition common.h:90
stderr_sink< details::null_mutex > stderr_sink_st
rotating_file_sink< std::mutex > rotating_file_sink_mt
Definition file_sinks.h:152
daily_file_sink< std::mutex > daily_file_sink_mt
Definition file_sinks.h:250
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
Definition file_sinks.h:58
simple_file_sink< details::null_mutex > simple_file_sink_st
Definition file_sinks.h:59
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
Definition file_sinks.h:153
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
Definition file_sinks.h:251
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)
Definition spdlog_impl.h:92
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)
Definition spdlog_impl.h:35
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)
Definition spdlog_impl.h:67
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)
Definition spdlog_impl.h:62
void set_error_handler(log_err_handler)
async_overflow_policy
Definition common.h:108
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)
Definition spdlog_impl.h:40
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)
Definition spdlog_impl.h:73
std::shared_ptr< logger > stdout_logger_mt(const std::string &logger_name)
Definition spdlog_impl.h:87
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)
Definition spdlog_impl.h:78
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)
Definition spdlog_impl.h:51
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)
Definition spdlog_impl.h:97
std::shared_ptr< spdlog::logger > create(const std::string &logger_name, Args...)
void drop_all()
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)
pattern_time_type
Definition common.h:118
void set_sync_mode()
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)
Definition spdlog_impl.h:45
std::shared_ptr< logger > basic_logger_st(const std::string &logger_name, const filename_t &filename, bool truncate=false)
Definition spdlog_impl.h:56
Definition json.hpp:4518
#define SPDLOG_EOL
Definition os.h:139
#define SPDLOG_FILENAME_T(s)
Definition os.h:375
#define __has_feature(x)
Definition os.h:53
FVector & DefaultActorLocationField()
Definition Actor.h:920
int & TargetingTeamField()
Definition Actor.h:902
USceneComponent * RootComponentField()
Definition Actor.h:911
APlayerState * PlayerStateField()
Definition Actor.h:2062
UCheatManager * CheatManagerField()
Definition Actor.h:2133
FString * GetPlayerNetworkAddress(FString *result)
Definition Actor.h:2292
FUniqueNetIdRepl & UniqueIdField()
Definition Actor.h:1782
FString & PlayerNameField()
Definition Actor.h:1776
bool TeleportTo(FVector *DestLocation, FRotator *DestRotation, bool bIsATest, bool bNoCheck)
Definition Actor.h:4554
UPrimalInventoryComponent * MyInventoryComponentField()
Definition Actor.h:3798
bool IsDead()
Definition Actor.h:4360
void DoNeuter_Implementation()
Definition Actor.h:7051
static UClass * GetPrivateStaticClass()
Definition Actor.h:6963
void TameDino(AShooterPlayerController *ForPC, bool bIgnoreMaxTameLimit, int OverrideTamingTeamID)
Definition Actor.h:7328
int & TamingTeamIDField()
Definition Actor.h:6194
FString & TamerStringField()
Definition Actor.h:6057
int & AbsoluteBaseLevelField()
Definition Actor.h:6324
UPrimalPlayerData * GetPlayerData()
Definition Actor.h:5166
APrimalDinoCharacter * GetRidingDino()
Definition Actor.h:5159
unsigned __int64 GetSteamIDForPlayerID(int playerDataID)
Definition GameMode.h:1620
void AddPlayerID(int playerDataID, unsigned __int64 netUniqueID)
Definition GameMode.h:1534
__int64 & LinkedPlayerIDField()
Definition Actor.h:2504
void SetPlayerPos(float X, float Y, float Z)
Definition Actor.h:3202
AActor * SpawnActor(FString *blueprintPath, float spawnDistance, float spawnYOffset, float ZOffset, bool bDoDeferBeginPlay)
Definition Actor.h:3222
AShooterCharacter * GetPlayerCharacter()
Definition Actor.h:2916
FString * GetPlayerName(FString *result)
Definition Actor.h:1902
void SetTribeTamingDinoSettings(APrimalDinoCharacter *aDinoChar)
Definition Actor.h:1986
DWORD64 offset
Definition Base.h:674
DWORD bit_position
Definition Base.h:675
ULONGLONG length
Definition Base.h:677
ULONGLONG num_bits
Definition Base.h:676
FName PackageName
Definition UE.h:710
bool IsUAsset()
Definition UE.h:720
UObject * GetAsset()
Definition UE.h:722
char unk[80]
Definition UE.h:715
FName AssetName
Definition UE.h:713
FName GroupNames
Definition UE.h:712
FName PackagePath
Definition UE.h:711
FName ObjectPath
Definition UE.h:709
TArray< int > ChunkIDs
Definition UE.h:716
void PrintAssetData()
Definition UE.h:721
FName AssetClass
Definition UE.h:714
void PrioritizeAssetInstall(FAssetData *AssetData)
Definition UE.h:774
EAssetAvailability::Type GetAssetAvailability(FAssetData *AssetData)
Definition UE.h:771
bool GetDependencies(FName PackageName, TArray< FName > *OutDependencies)
Definition UE.h:766
bool IsLoadingAssets()
Definition UE.h:782
float GetAssetAvailabilityProgress(FAssetData *AssetData, EAssetAvailabilityProgressReportingType::Type ReportType)
Definition UE.h:772
bool GetAssetsByPackageName(FName PackageName, TArray< FAssetData > *OutAssetData)
Definition UE.h:759
void AssetRenamed(UObject *RenamedAsset, FString *OldObjectPath)
Definition UE.h:781
void GetSubPaths(FString *InBasePath, TArray< FString > *OutPathList, bool bInRecurse)
Definition UE.h:770
void AddAssetData(FAssetData *AssetData)
Definition UE.h:790
void PrioritizeSearchPath(FString *PathToPrioritize)
Definition UE.h:778
bool GetAssetsByClass(FName ClassName, TArray< FAssetData > *OutAssetData, bool bSearchSubClasses)
Definition UE.h:761
bool GetAllAssets(TArray< FAssetData > *OutAssetData)
Definition UE.h:765
void SearchAllAssets(bool bSynchronousSearch)
Definition UE.h:758
void ScanPathsSynchronous_Internal(TArray< FString > *InPaths, bool bForceRescan, bool bUseCache)
Definition UE.h:785
void OnContentPathMounted(FString *InAssetPath, FString *FileSystemPath)
Definition UE.h:792
bool RemoveAssetData(FAssetData *AssetData)
Definition UE.h:791
FAssetData * GetAssetByObjectPath(FAssetData *result, FName ObjectPath)
Definition UE.h:764
void AssetDeleted(UObject *DeletedAsset)
Definition UE.h:780