Ark Server API (ASE) - Wiki
Loading...
Searching...
No Matches
SparseArray.h
Go to the documentation of this file.
1// Copyright 1998-2017 Epic Games, Inc. All Rights Reserved.
2
3#pragma once
4
5#include "../BasicTypes.h"
6#include "../HAL/UnrealMemory.h"
7#include "../Templates/IsTriviallyCopyConstructible.h"
8#include "../Templates/UnrealTypeTraits.h"
9#include "../Templates/UnrealTemplate.h"
10#include "../Templates/IsTriviallyDestructible.h"
12#include "TArray.h"
13#include "../Math/UnrealMathUtility.h"
14#include "ScriptArray.h"
15#include "BitArray.h"
16
17#define TSPARSEARRAY_RANGED_FOR_CHECKS 1
18
19// Forward declarations.
20template<typename ElementType,typename Allocator = FDefaultSparseArrayAllocator >
21class TSparseArray;
22
23
24/** The result of a sparse array allocation. */
26{
27 int32 Index;
28 void* Pointer;
29};
30
31/** Allocated elements are overlapped with free element info in the element list. */
32template<typename ElementType>
34{
35 /** If the element is allocated, its value is stored here. */
36 ElementType ElementData;
37
38 struct
39 {
40 /** If the element isn't allocated, this is a link to the previous element in the array's free list. */
42
43 /** If the element isn't allocated, this is a link to the next element in the array's free list. */
45 };
46};
47
49
50/**
51 * A dynamically sized array where element indices aren't necessarily contiguous. Memory is allocated for all
52 * elements in the array's index range, so it doesn't save memory; but it does allow O(1) element removal that
53 * doesn't invalidate the indices of subsequent elements. It uses TArray to store the elements, and a TBitArray
54 * to store whether each element index is allocated (for fast iteration over allocated elements).
55 *
56 **/
57template<typename InElementType,typename Allocator /*= FDefaultSparseArrayAllocator */>
58class TSparseArray
59{
60 using ElementType = InElementType;
61
62 friend struct TContainerTraits<TSparseArray>;
63 friend class FScriptSparseArray;
64
65public:
66
67 /** Destructor. */
69 {
70 // Destruct the elements in the array.
71 Empty();
72 }
73
74 /** Marks an index as allocated, and returns information about the allocation. */
76 {
77 check(Index >= 0);
78 check(Index < GetMaxIndex());
79 check(!AllocationFlags[Index]);
80
81 // Flag the element as allocated.
82 AllocationFlags[Index] = true;
83
84 // Set the allocation info.
85 FSparseArrayAllocationInfo Result;
86 Result.Index = Index;
87 Result.Pointer = &GetData(Result.Index).ElementData;
88
89 return Result;
90 }
91
92 /**
93 * Allocates space for an element in the array. The element is not initialized, and you must use the corresponding placement new operator
94 * to construct the element in the allocated memory.
95 */
97 {
98 int32 Index;
99 if(NumFreeIndices)
100 {
101 // Remove and use the first index from the list of free elements.
102 Index = FirstFreeIndex;
103 FirstFreeIndex = GetData(FirstFreeIndex).NextFreeIndex;
104 --NumFreeIndices;
105 if(NumFreeIndices)
106 {
107 GetData(FirstFreeIndex).PrevFreeIndex = -1;
108 }
109 }
110 else
111 {
112 // Add a new element.
113 Index = Data.AddUninitialized(1);
114 AllocationFlags.Add(false);
115 }
116
117 return AllocateIndex(Index);
118 }
119
120 /** Adds an element to the array. */
121 int32 Add(typename TTypeTraits<ElementType>::ConstInitType Element)
122 {
123 FSparseArrayAllocationInfo Allocation = AddUninitialized();
124 new(Allocation) ElementType(Element);
125 return Allocation.Index;
126 }
127
128 /**
129 * Allocates space for an element in the array at a given index. The element is not initialized, and you must use the corresponding placement new operator
130 * to construct the element in the allocated memory.
131 */
133 {
134 // Enlarge the array to include the given index.
135 if(Index >= Data.Num())
136 {
137 Data.AddUninitialized(Index + 1 - Data.Num());
138 while(AllocationFlags.Num() < Data.Num())
139 {
140 const int32 FreeIndex = AllocationFlags.Num();
141 GetData(FreeIndex).PrevFreeIndex = -1;
142 GetData(FreeIndex).NextFreeIndex = FirstFreeIndex;
143 if(NumFreeIndices)
144 {
145 GetData(FirstFreeIndex).PrevFreeIndex = FreeIndex;
146 }
147 FirstFreeIndex = FreeIndex;
148 verify(AllocationFlags.Add(false) == FreeIndex);
149 ++NumFreeIndices;
150 };
151 }
152
153 // Verify that the specified index is free.
154 check(!AllocationFlags[Index]);
155
156 // Remove the index from the list of free elements.
157 --NumFreeIndices;
158 const int32 PrevFreeIndex = GetData(Index).PrevFreeIndex;
159 const int32 NextFreeIndex = GetData(Index).NextFreeIndex;
160 if(PrevFreeIndex != -1)
161 {
162 GetData(PrevFreeIndex).NextFreeIndex = NextFreeIndex;
163 }
164 else
165 {
166 FirstFreeIndex = NextFreeIndex;
167 }
168 if(NextFreeIndex != -1)
169 {
170 GetData(NextFreeIndex).PrevFreeIndex = PrevFreeIndex;
171 }
172
173 return AllocateIndex(Index);
174 }
175
176 /**
177 * Inserts an element to the array.
178 */
179 void Insert(int32 Index,typename TTypeTraits<ElementType>::ConstInitType Element)
180 {
181 new(InsertUninitialized(Index)) ElementType(Element);
182 }
183
184 /** Removes Count elements from the array, starting from Index. */
185 void RemoveAt(int32 Index,int32 Count = 1)
186 {
187 if (!TIsTriviallyDestructible<ElementType>::Value)
188 {
189 for (int32 It = Index, ItCount = Count; ItCount; ++It, --ItCount)
190 {
191 ((ElementType&)GetData(It).ElementData).~ElementType();
192 }
193 }
194
195 RemoveAtUninitialized(Index, Count);
196 }
197
198 /** Removes Count elements from the array, starting from Index, without destructing them. */
199 void RemoveAtUninitialized(int32 Index,int32 Count = 1)
200 {
201 for (; Count; --Count)
202 {
203 check(AllocationFlags[Index]);
204
205 // Mark the element as free and add it to the free element list.
206 if(NumFreeIndices)
207 {
208 GetData(FirstFreeIndex).PrevFreeIndex = Index;
209 }
210 auto& IndexData = GetData(Index);
211 IndexData.PrevFreeIndex = -1;
212 IndexData.NextFreeIndex = NumFreeIndices > 0 ? FirstFreeIndex : INDEX_NONE;
213 FirstFreeIndex = Index;
214 ++NumFreeIndices;
215 AllocationFlags[Index] = false;
216
217 ++Index;
218 }
219 }
220
221 /**
222 * Removes all elements from the array, potentially leaving space allocated for an expected number of elements about to be added.
223 * @param ExpectedNumElements - The expected number of elements about to be added.
224 */
225 void Empty(int32 ExpectedNumElements = 0)
226 {
227 // Destruct the allocated elements.
228 if( !TIsTriviallyDestructible<ElementType>::Value )
229 {
230 for(TIterator It(*this);It;++It)
231 {
232 ElementType& Element = *It;
233 Element.~ElementType();
234 }
235 }
236
237 // Free the allocated elements.
238 Data.Empty(ExpectedNumElements);
239 FirstFreeIndex = -1;
240 NumFreeIndices = 0;
241 AllocationFlags.Empty(ExpectedNumElements);
242 }
243
244 /** Empties the array, but keep its allocated memory as slack. */
245 void Reset()
246 {
247 // Destruct the allocated elements.
248 if( !TIsTriviallyDestructible<ElementType>::Value )
249 {
250 for(TIterator It(*this);It;++It)
251 {
252 ElementType& Element = *It;
253 Element.~ElementType();
254 }
255 }
256
257 // Free the allocated elements.
258 Data.Reset();
259 FirstFreeIndex = -1;
260 NumFreeIndices = 0;
261 AllocationFlags.Reset();
262 }
263
264 /**
265 * Preallocates enough memory to contain the specified number of elements.
266 *
267 * @param ExpectedNumElements the total number of elements that the array will have
268 */
269 void Reserve(int32 ExpectedNumElements)
270 {
271 if ( ExpectedNumElements > Data.Num() )
272 {
273 const int32 ElementsToAdd = ExpectedNumElements - Data.Num();
274
275 // allocate memory in the array itself
276 int32 ElementIndex = Data.AddUninitialized(ElementsToAdd);
277
278 // now mark the new elements as free
279 for ( int32 FreeIndex = ExpectedNumElements - 1; FreeIndex >= ElementIndex; --FreeIndex )
280 {
281 if(NumFreeIndices)
282 {
283 GetData(FirstFreeIndex).PrevFreeIndex = FreeIndex;
284 }
285 GetData(FreeIndex).PrevFreeIndex = -1;
286 GetData(FreeIndex).NextFreeIndex = NumFreeIndices > 0 ? FirstFreeIndex : INDEX_NONE;
287 FirstFreeIndex = FreeIndex;
288 ++NumFreeIndices;
289 }
290 //@fixme - this will have to do until TBitArray has a Reserve method....
291 for ( int32 i = 0; i < ElementsToAdd; i++ )
292 {
293 AllocationFlags.Add(false);
294 }
295 }
296 }
297
298 /** Shrinks the array's storage to avoid slack. */
299 void Shrink()
300 {
301 // Determine the highest allocated index in the data array.
302 int32 MaxAllocatedIndex = INDEX_NONE;
303 for(TConstSetBitIterator<typename Allocator::BitArrayAllocator> AllocatedIndexIt(AllocationFlags);AllocatedIndexIt;++AllocatedIndexIt)
304 {
305 MaxAllocatedIndex = FMath::Max(MaxAllocatedIndex,AllocatedIndexIt.GetIndex());
306 }
307
308 const int32 FirstIndexToRemove = MaxAllocatedIndex + 1;
309 if(FirstIndexToRemove < Data.Num())
310 {
311 if(NumFreeIndices > 0)
312 {
313 // Look for elements in the free list that are in the memory to be freed.
314 int32 FreeIndex = FirstFreeIndex;
315 while(FreeIndex != INDEX_NONE)
316 {
317 if(FreeIndex >= FirstIndexToRemove)
318 {
319 const int32 PrevFreeIndex = GetData(FreeIndex).PrevFreeIndex;
320 const int32 NextFreeIndex = GetData(FreeIndex).NextFreeIndex;
321 if(NextFreeIndex != -1)
322 {
323 GetData(NextFreeIndex).PrevFreeIndex = PrevFreeIndex;
324 }
325 if(PrevFreeIndex != -1)
326 {
327 GetData(PrevFreeIndex).NextFreeIndex = NextFreeIndex;
328 }
329 else
330 {
331 FirstFreeIndex = NextFreeIndex;
332 }
333 --NumFreeIndices;
334
335 FreeIndex = NextFreeIndex;
336 }
337 else
338 {
339 FreeIndex = GetData(FreeIndex).NextFreeIndex;
340 }
341 }
342 }
343
344 // Truncate unallocated elements at the end of the data array.
345 Data.RemoveAt(FirstIndexToRemove,Data.Num() - FirstIndexToRemove);
346 AllocationFlags.RemoveAt(FirstIndexToRemove,AllocationFlags.Num() - FirstIndexToRemove);
347 }
348
349 // Shrink the data array.
350 Data.Shrink();
351 }
352
353 /** Compacts the allocated elements into a contiguous index range. */
354 /** Returns true if any elements were relocated, false otherwise. */
355 bool Compact()
356 {
357 int32 NumFree = NumFreeIndices;
358 if (NumFree == 0)
359 {
360 return false;
361 }
362
363 bool bResult = false;
364
365 FElementOrFreeListLink* ElementData = Data.GetData();
366
367 int32 EndIndex = Data.Num();
368 int32 TargetIndex = EndIndex - NumFree;
369 int32 FreeIndex = FirstFreeIndex;
370 while (FreeIndex != -1)
371 {
372 int32 NextFreeIndex = GetData(FreeIndex).NextFreeIndex;
373 if (FreeIndex < TargetIndex)
374 {
375 // We need an element here
376 do
377 {
378 --EndIndex;
379 }
380 while (!AllocationFlags[EndIndex]);
381
382 RelocateConstructItems<FElementOrFreeListLink>(ElementData + FreeIndex, ElementData + EndIndex, 1);
383 AllocationFlags[FreeIndex] = true;
384
385 bResult = true;
386 }
387
388 FreeIndex = NextFreeIndex;
389 }
390
391 Data .RemoveAt(TargetIndex, NumFree);
392 AllocationFlags.RemoveAt(TargetIndex, NumFree);
393
394 NumFreeIndices = 0;
395 FirstFreeIndex = -1;
396
397 return bResult;
398 }
399
400 /** Compacts the allocated elements into a contiguous index range. Does not change the iteration order of the elements. */
401 /** Returns true if any elements were relocated, false otherwise. */
403 {
404 if (NumFreeIndices == 0)
405 {
406 return false;
407 }
408
409 // Copy the existing elements to a new array.
410 TSparseArray<ElementType,Allocator> CompactedArray;
411 CompactedArray.Empty(Num());
412 for(TConstIterator It(*this);It;++It)
413 {
414 new(CompactedArray.AddUninitialized()) ElementType(*It);
415 }
416
417 // Replace this array with the compacted array.
418 Exchange(*this,CompactedArray);
419
420 return true;
421 }
422
423 /**
424 * Helper function to return the amount of memory allocated by this container
425 * @return number of bytes allocated by this container
426 */
427 uint32 GetAllocatedSize( void ) const
428 {
429 return (Data.Num() + Data.GetSlack()) * sizeof(FElementOrFreeListLink) +
430 AllocationFlags.GetAllocatedSize();
431 }
432
433 /**
434 * Equality comparison operator.
435 * Checks that both arrays have the same elements and element indices; that means that unallocated elements are signifigant!
436 */
437 friend bool operator==(const TSparseArray& A,const TSparseArray& B)
438 {
439 if(A.GetMaxIndex() != B.GetMaxIndex())
440 {
441 return false;
442 }
443
444 for(int32 ElementIndex = 0;ElementIndex < A.GetMaxIndex();ElementIndex++)
445 {
446 const bool bIsAllocatedA = A.IsAllocated(ElementIndex);
447 const bool bIsAllocatedB = B.IsAllocated(ElementIndex);
448 if(bIsAllocatedA != bIsAllocatedB)
449 {
450 return false;
451 }
452 else if(bIsAllocatedA)
453 {
454 if(A[ElementIndex] != B[ElementIndex])
455 {
456 return false;
457 }
458 }
459 }
460
461 return true;
462 }
463
464 /**
465 * Inequality comparison operator.
466 * Checks that both arrays have the same elements and element indices; that means that unallocated elements are signifigant!
467 */
468 friend bool operator!=(const TSparseArray& A,const TSparseArray& B)
469 {
470 return !(A == B);
471 }
472
473 /** Default constructor. */
475 : FirstFreeIndex(-1)
476 , NumFreeIndices(0)
477 {}
478
479 /** Move constructor. */
480 TSparseArray(TSparseArray&& InCopy)
481 {
482 MoveOrCopy(*this, InCopy);
483 }
484
485 /** Copy constructor. */
486 TSparseArray(const TSparseArray& InCopy)
487 : FirstFreeIndex(-1)
488 , NumFreeIndices(0)
489 {
490 *this = InCopy;
491 }
492
493 /** Move assignment operator. */
494 TSparseArray& operator=(TSparseArray&& InCopy)
495 {
496 if(this != &InCopy)
497 {
498 MoveOrCopy(*this, InCopy);
499 }
500 return *this;
501 }
502
503 /** Copy assignment operator. */
504 TSparseArray& operator=(const TSparseArray& InCopy)
505 {
506 if (this != &InCopy)
507 {
508 int32 SrcMax = InCopy.GetMaxIndex();
509
510 // Reallocate the array.
511 Empty(SrcMax);
512 Data.AddUninitialized(SrcMax);
513
514 // Copy the other array's element allocation state.
515 FirstFreeIndex = InCopy.FirstFreeIndex;
516 NumFreeIndices = InCopy.NumFreeIndices;
517 AllocationFlags = InCopy.AllocationFlags;
518
519 // Determine whether we need per element construction or bulk copy is fine
520 if (!TIsTriviallyCopyConstructible<ElementType>::Value)
521 {
522 FElementOrFreeListLink* DestData = (FElementOrFreeListLink*)Data.GetData();
523 const FElementOrFreeListLink* SrcData = (FElementOrFreeListLink*)InCopy.Data.GetData();
524
525 // Use the inplace new to copy the element to an array element
526 for (int32 Index = 0; Index < SrcMax; ++Index)
527 {
528 FElementOrFreeListLink& DestElement = DestData[Index];
529 const FElementOrFreeListLink& SrcElement = SrcData [Index];
530 if (InCopy.IsAllocated(Index))
531 {
532 ::new((uint8*)&DestElement.ElementData) ElementType(*(const ElementType*)&SrcElement.ElementData);
533 }
534 else
535 {
536 DestElement.PrevFreeIndex = SrcElement.PrevFreeIndex;
537 DestElement.NextFreeIndex = SrcElement.NextFreeIndex;
538 }
539 }
540 }
541 else
542 {
543 // Use the much faster path for types that allow it
544 FMemory::Memcpy(Data.GetData(), InCopy.Data.GetData(), sizeof(FElementOrFreeListLink) * SrcMax);
545 }
546 }
547 return *this;
548 }
549
550private:
551 template <typename SparseArrayType>
552 FORCEINLINE static typename TEnableIf<TContainerTraits<SparseArrayType>::MoveWillEmptyContainer>::Type MoveOrCopy(SparseArrayType& ToArray, SparseArrayType& FromArray)
553 {
554 // Destruct the allocated elements.
555 if( !TIsTriviallyDestructible<ElementType>::Value )
556 {
557 for (ElementType& Element : ToArray)
558 {
559 DestructItem(&Element);
560 }
561 }
562
563 ToArray.Data = (DataType&&)FromArray.Data;
564 ToArray.AllocationFlags = (AllocationBitArrayType&&)FromArray.AllocationFlags;
565
566 ToArray.FirstFreeIndex = FromArray.FirstFreeIndex;
567 ToArray.NumFreeIndices = FromArray.NumFreeIndices;
568 FromArray.FirstFreeIndex = -1;
569 FromArray.NumFreeIndices = 0;
570 }
571
572 template <typename SparseArrayType>
573 FORCEINLINE static typename TEnableIf<!TContainerTraits<SparseArrayType>::MoveWillEmptyContainer>::Type MoveOrCopy(SparseArrayType& ToArray, SparseArrayType& FromArray)
574 {
575 ToArray = FromArray;
576 }
577
578public:
579 // Accessors.
580 ElementType& operator[](int32 Index)
581 {
582 checkSlow(Index >= 0 && Index < Data.Num() && Index < AllocationFlags.Num());
583 //checkSlow(AllocationFlags[Index]); // Disabled to improve loading times -BZ
584 return *(ElementType*)&GetData(Index).ElementData;
585 }
586 const ElementType& operator[](int32 Index) const
587 {
588 checkSlow(Index >= 0 && Index < Data.Num() && Index < AllocationFlags.Num());
589 //checkSlow(AllocationFlags[Index]); // Disabled to improve loading times -BZ
590 return *(ElementType*)&GetData(Index).ElementData;
591 }
592
593 bool IsAllocated(int32 Index) const { return AllocationFlags[Index]; }
594 int32 GetMaxIndex() const { return Data.Num(); }
595 int32 Num() const { return Data.Num() - NumFreeIndices; }
596
597 /**
598 * Checks that the specified address is not part of an element within the container. Used for implementations
599 * to check that reference arguments aren't going to be invalidated by possible reallocation.
600 *
601 * @param Addr The address to check.
602 */
603 FORCEINLINE void CheckAddress(const ElementType* Addr) const
604 {
605 Data.CheckAddress(Addr);
606 }
607
608private:
609
610 /** The base class of sparse array iterators. */
611 template<bool bConst>
613 {
614 public:
616
617 private:
618 typedef typename TChooseClass<bConst,const TSparseArray,TSparseArray>::Result ArrayType;
619 typedef typename TChooseClass<bConst,const ElementType,ElementType>::Result ItElementType;
620
621 public:
622 explicit TBaseIterator(ArrayType& InArray, const BitArrayItType& InBitArrayIt)
623 : Array (InArray)
625 {
626 }
627
628 FORCEINLINE TBaseIterator& operator++()
629 {
630 // Iterate to the next set allocation flag.
631 ++BitArrayIt;
632 return *this;
633 }
634
635 FORCEINLINE int32 GetIndex() const { return BitArrayIt.GetIndex(); }
636
637 FORCEINLINE friend bool operator==(const TBaseIterator& Lhs, const TBaseIterator& Rhs) { return Lhs.BitArrayIt == Rhs.BitArrayIt && &Lhs.Array == &Rhs.Array; }
638 FORCEINLINE friend bool operator!=(const TBaseIterator& Lhs, const TBaseIterator& Rhs) { return Lhs.BitArrayIt != Rhs.BitArrayIt || &Lhs.Array != &Rhs.Array; }
639
640 /** conversion to "bool" returning true if the iterator is valid. */
641 FORCEINLINE explicit operator bool() const
642 {
643 return !!BitArrayIt;
644 }
645
646 /** inverse of the "bool" operator */
647 FORCEINLINE bool operator !() const
648 {
649 return !(bool)*this;
650 }
651
652 FORCEINLINE ItElementType& operator*() const { return Array[GetIndex()]; }
653 FORCEINLINE ItElementType* operator->() const { return &Array[GetIndex()]; }
654 FORCEINLINE const FRelativeBitReference& GetRelativeBitReference() const { return BitArrayIt; }
655
656 protected:
659 };
660
661public:
662
663 /** Iterates over all allocated elements in a sparse array. */
664 class TIterator : public TBaseIterator<false>
665 {
666 public:
667 TIterator(TSparseArray& InArray)
669 {
670 }
671
672 TIterator(TSparseArray& InArray, const typename TBaseIterator<false>::BitArrayItType& InBitArrayIt)
674 {
675 }
676
677 /** Safely removes the current element from the array. */
679 {
680 this->Array.RemoveAt(this->GetIndex());
681 }
682 };
683
684 /** Iterates over all allocated elements in a const sparse array. */
685 class TConstIterator : public TBaseIterator<true>
686 {
687 public:
688 TConstIterator(const TSparseArray& InArray)
690 {
691 }
692
693 TConstIterator(const TSparseArray& InArray, const typename TBaseIterator<true>::BitArrayItType& InBitArrayIt)
695 {
696 }
697 };
698
701 {
702 public:
703 TRangedForIterator(TSparseArray& InArray, const typename TBaseIterator<false>::BitArrayItType& InBitArrayIt)
706 {
707 }
708
709 private:
711
712 friend FORCEINLINE bool operator!=(const TRangedForIterator& Lhs, const TRangedForIterator& Rhs)
713 {
714 // We only need to do the check in this operator, because no other operator will be
715 // called until after this one returns.
716 //
717 // Also, we should only need to check one side of this comparison - if the other iterator isn't
718 // even from the same array then the compiler has generated bad code.
719 ensureMsgf(Lhs.Array.Num() == Lhs.InitialNum, TEXT("Container has changed during ranged-for iteration!"));
720 return *(TIterator*)&Lhs != *(TIterator*)&Rhs;
721 }
722 };
723
725 {
726 public:
727 TRangedForConstIterator(const TSparseArray& InArray, const typename TBaseIterator<true>::BitArrayItType& InBitArrayIt)
730 {
731 }
732
733 private:
735
736 friend FORCEINLINE bool operator!=(const TRangedForConstIterator& Lhs, const TRangedForConstIterator& Rhs)
737 {
738 // We only need to do the check in this operator, because no other operator will be
739 // called until after this one returns.
740 //
741 // Also, we should only need to check one side of this comparison - if the other iterator isn't
742 // even from the same array then the compiler has generated bad code.
743 ensureMsgf(Lhs.Array.Num() == Lhs.InitialNum, TEXT("Container has changed during ranged-for iteration!"));
744 return *(TIterator*)&Lhs != *(TIterator*)&Rhs;
745 }
746 };
747 #else
748 using TRangedForIterator = TIterator;
749 using TRangedForConstIterator = TConstIterator;
750 #endif
751
752 /** Creates an iterator for the contents of this array */
754 {
755 return TIterator(*this);
756 }
757
758 /** Creates a const iterator for the contents of this array */
760 {
761 return TConstIterator(*this);
762 }
763
764private:
765 /**
766 * DO NOT USE DIRECTLY
767 * STL-like iterators to enable range-based for loop support.
768 */
769 FORCEINLINE friend TRangedForIterator begin( TSparseArray& Array) { return TRangedForIterator (Array, TConstSetBitIterator<typename Allocator::BitArrayAllocator>(Array.AllocationFlags)); }
770 FORCEINLINE friend TRangedForConstIterator begin(const TSparseArray& Array) { return TRangedForConstIterator(Array, TConstSetBitIterator<typename Allocator::BitArrayAllocator>(Array.AllocationFlags)); }
771 FORCEINLINE friend TRangedForIterator end ( TSparseArray& Array) { return TRangedForIterator (Array, TConstSetBitIterator<typename Allocator::BitArrayAllocator>(Array.AllocationFlags, Array.AllocationFlags.Num())); }
772 FORCEINLINE friend TRangedForConstIterator end (const TSparseArray& Array) { return TRangedForConstIterator(Array, TConstSetBitIterator<typename Allocator::BitArrayAllocator>(Array.AllocationFlags, Array.AllocationFlags.Num())); }
773
774public:
775 /** An iterator which only iterates over the elements of the array which correspond to set bits in a separate bit array. */
776 template<typename SubsetAllocator = FDefaultBitArrayAllocator>
778 {
779 public:
780 TConstSubsetIterator( const TSparseArray& InArray, const TBitArray<SubsetAllocator>& InBitArray ):
781 Array(InArray),
783 {}
785 {
786 // Iterate to the next element which is both allocated and has its bit set in the other bit array.
787 ++BitArrayIt;
788 return *this;
789 }
790 FORCEINLINE int32 GetIndex() const { return BitArrayIt.GetIndex(); }
791
792 /** conversion to "bool" returning true if the iterator is valid. */
793 FORCEINLINE explicit operator bool() const
794 {
795 return !!BitArrayIt;
796 }
797 /** inverse of the "bool" operator */
798 FORCEINLINE bool operator !() const
799 {
800 return !(bool)*this;
801 }
802
803 FORCEINLINE const ElementType& operator*() const { return Array(GetIndex()); }
804 FORCEINLINE const ElementType* operator->() const { return &Array(GetIndex()); }
805 FORCEINLINE const FRelativeBitReference& GetRelativeBitReference() const { return BitArrayIt; }
806 private:
807 const TSparseArray& Array;
808 TConstDualSetBitIterator<typename Allocator::BitArrayAllocator,SubsetAllocator> BitArrayIt;
809 };
810
811 /** Concatenation operators */
812 TSparseArray& operator+=( const TSparseArray& OtherArray )
813 {
814 this->Reserve(this->Num() + OtherArray.Num());
815 for ( typename TSparseArray::TConstIterator It(OtherArray); It; ++It )
816 {
817 this->Add(*It);
818 }
819 return *this;
820 }
821 TSparseArray& operator+=( const TArray<ElementType>& OtherArray )
822 {
823 this->Reserve(this->Num() + OtherArray.Num());
824 for ( int32 Idx = 0; Idx < OtherArray.Num(); Idx++ )
825 {
826 this->Add(OtherArray[Idx]);
827 }
828 return *this;
829 }
830
831private:
832
833 /**
834 * The element type stored is only indirectly related to the element type requested, to avoid instantiating TArray redundantly for
835 * compatible types.
836 */
838 TAlignedBytes<sizeof(ElementType), alignof(ElementType)>
840
841 /** Extracts the element value from the array's element structure and passes it to the user provided comparison class. */
842 template <typename PREDICATE_CLASS>
844 {
845 const PREDICATE_CLASS& Predicate;
846
847 public:
848 FElementCompareClass( const PREDICATE_CLASS& InPredicate )
850 {}
851
853 {
855 }
856 };
857
858 /** Accessor for the element or free list data. */
860 {
861 return ((FElementOrFreeListLink*)Data.GetData())[Index];
862 }
863
864 /** Accessor for the element or free list data. */
865 const FElementOrFreeListLink& GetData(int32 Index) const
866 {
867 return ((FElementOrFreeListLink*)Data.GetData())[Index];
868 }
869
872
873 typedef TBitArray<typename Allocator::BitArrayAllocator> AllocationBitArrayType;
875
876 /** The index of an unallocated element in the array that currently contains the head of the linked list of free elements. */
878
879 /** The number of elements in the free list. */
881};
882
883template<typename ElementType, typename Allocator>
884struct TContainerTraits<TSparseArray<ElementType, Allocator> > : public TContainerTraitsBase<TSparseArray<ElementType, Allocator> >
885{
887 TContainerTraits<typename TSparseArray<ElementType, Allocator>::DataType>::MoveWillEmptyContainer &&
888 TContainerTraits<typename TSparseArray<ElementType, Allocator>::AllocationBitArrayType>::MoveWillEmptyContainer };
889};
890
892{
895 int32 Size;
896};
897
898// Untyped sparse array type for accessing TSparseArray data, like FScriptArray for TArray.
899// Must have the same memory representation as a TSet.
901{
902public:
903 static FScriptSparseArrayLayout GetScriptLayout(int32 ElementSize, int32 ElementAlignment)
904 {
906 Result.ElementOffset = 0;
907 Result.Alignment = FMath::Max(ElementAlignment, (int32)alignof(FFreeListLink));
908 Result.Size = FMath::Max(ElementSize, (int32)sizeof (FFreeListLink));
909
910 return Result;
911 }
912
914 : FirstFreeIndex(-1)
915 , NumFreeIndices(0)
916 {
917 }
918
919 bool IsValidIndex(int32 Index) const
920 {
922 }
923
924 int32 Num() const
925 {
926 return Data.Num() - NumFreeIndices;
927 }
928
929 int32 GetMaxIndex() const
930 {
931 return Data.Num();
932 }
933
934 void* GetData(int32 Index, const FScriptSparseArrayLayout& Layout)
935 {
936 return (uint8*)Data.GetData() + Layout.Size * Index;
937 }
938
939 const void* GetData(int32 Index, const FScriptSparseArrayLayout& Layout) const
940 {
941 return (const uint8*)Data.GetData() + Layout.Size * Index;
942 }
943
944 void Empty(int32 Slack, const FScriptSparseArrayLayout& Layout)
945 {
946 // Free the allocated elements.
947 Data.Empty(Slack, Layout.Size);
948 FirstFreeIndex = -1;
949 NumFreeIndices = 0;
951 }
952
953 /**
954 * Adds an uninitialized object to the array.
955 *
956 * @return The index of the added element.
957 */
959 {
960 int32 Index;
961 if (NumFreeIndices)
962 {
963 // Remove and use the first index from the list of free elements.
964 Index = FirstFreeIndex;
968 {
970 }
971 }
972 else
973 {
974 // Add a new element.
975 Index = Data.Add(1, Layout.Size);
977 }
978
979 AllocationFlags[Index] = true;
980
981 return Index;
982 }
983
984 /** Removes Count elements from the array, starting from Index, without destructing them. */
985 void RemoveAtUninitialized(const FScriptSparseArrayLayout& Layout, int32 Index, int32 Count = 1)
986 {
987 for (; Count; --Count)
988 {
989 check(AllocationFlags[Index]);
990
991 // Mark the element as free and add it to the free element list.
993 {
995 }
996
997 auto* IndexData = GetFreeListLink(Index, Layout);
998 IndexData->PrevFreeIndex = -1;
1000 FirstFreeIndex = Index;
1002 AllocationFlags[Index] = false;
1003
1004 ++Index;
1005 }
1006 }
1007
1008private:
1013
1014 // This function isn't intended to be called, just to be compiled to validate the correctness of the type.
1015 static void CheckConstraints()
1016 {
1017 typedef FScriptSparseArray ScriptType;
1018 typedef TSparseArray<int32> RealType;
1019
1020 // Check that the class footprint is the same
1021 static_assert(sizeof (ScriptType) == sizeof (RealType), "FScriptSparseArray's size doesn't match TSparseArray");
1022 static_assert(alignof(ScriptType) == alignof(RealType), "FScriptSparseArray's alignment doesn't match TSparseArray");
1023
1024 // Check member sizes
1025 static_assert(sizeof(DeclVal<ScriptType>().Data) == sizeof(DeclVal<RealType>().Data), "FScriptSparseArray's Data member size does not match TSparseArray's");
1026 static_assert(sizeof(DeclVal<ScriptType>().AllocationFlags) == sizeof(DeclVal<RealType>().AllocationFlags), "FScriptSparseArray's AllocationFlags member size does not match TSparseArray's");
1027 static_assert(sizeof(DeclVal<ScriptType>().FirstFreeIndex) == sizeof(DeclVal<RealType>().FirstFreeIndex), "FScriptSparseArray's FirstFreeIndex member size does not match TSparseArray's");
1028 static_assert(sizeof(DeclVal<ScriptType>().NumFreeIndices) == sizeof(DeclVal<RealType>().NumFreeIndices), "FScriptSparseArray's NumFreeIndices member size does not match TSparseArray's");
1029
1030 // Check member offsets
1031 static_assert(STRUCT_OFFSET(ScriptType, Data) == STRUCT_OFFSET(RealType, Data), "FScriptSparseArray's Data member offset does not match TSparseArray's");
1032 static_assert(STRUCT_OFFSET(ScriptType, AllocationFlags) == STRUCT_OFFSET(RealType, AllocationFlags), "FScriptSparseArray's AllocationFlags member offset does not match TSparseArray's");
1033 static_assert(STRUCT_OFFSET(ScriptType, FirstFreeIndex) == STRUCT_OFFSET(RealType, FirstFreeIndex), "FScriptSparseArray's FirstFreeIndex member offset does not match TSparseArray's");
1034 static_assert(STRUCT_OFFSET(ScriptType, NumFreeIndices) == STRUCT_OFFSET(RealType, NumFreeIndices), "FScriptSparseArray's NumFreeIndices member offset does not match TSparseArray's");
1035
1036 // Check free index offsets
1037 static_assert(STRUCT_OFFSET(ScriptType::FFreeListLink, PrevFreeIndex) == STRUCT_OFFSET(RealType::FElementOrFreeListLink, PrevFreeIndex), "FScriptSparseArray's FFreeListLink's PrevFreeIndex member offset does not match TSparseArray's");
1038 static_assert(STRUCT_OFFSET(ScriptType::FFreeListLink, NextFreeIndex) == STRUCT_OFFSET(RealType::FElementOrFreeListLink, NextFreeIndex), "FScriptSparseArray's FFreeListLink's NextFreeIndex member offset does not match TSparseArray's");
1039 }
1040
1042 {
1043 /** If the element isn't allocated, this is a link to the previous element in the array's free list. */
1045
1046 /** If the element isn't allocated, this is a link to the next element in the array's free list. */
1048 };
1049
1050 /** Accessor for the element or free list data. */
1051 FORCEINLINE FFreeListLink* GetFreeListLink(int32 Index, const FScriptSparseArrayLayout& Layout)
1052 {
1053 return (FFreeListLink*)GetData(Index, Layout);
1054 }
1055
1056public:
1057 // These should really be private, because they shouldn't be called, but there's a bunch of code
1058 // that needs to be fixed first.
1060 void operator=(const FScriptSparseArray&) { check(false); }
1061};
1062
1063template <>
1065{
1066 enum { Value = true };
1067};
1068
1069/**
1070 * A placement new operator which constructs an element in a sparse array allocation.
1071 */
1072inline void* operator new(size_t Size,const FSparseArrayAllocationInfo& Allocation)
1073{
1074 ASSUME(Allocation.Pointer);
1075 return Allocation.Pointer;
1076}
EBlueprintType
Definition Enums.h:3920
T AlignArbitrary(const T Ptr, uint32 Alignment)
static FORCEINLINE bool IsAligned(const volatile void *Ptr, const uint32 Alignment)
CONSTEXPR T AlignDown(const T Ptr, int32 Alignment)
CONSTEXPR T Align(const T Ptr, int32 Alignment)
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 ASSUME(Expr)
Definition BasicTypes.h:18
#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 PLATFORM_COMPILER_HAS_DEFAULTED_FUNCTIONS
Definition BasicTypes.h:11
#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
#define PLATFORM_64BITS
Definition BasicTypes.h:10
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 bool operator==(TYPE_OF_NULLPTR, const TFunction< FuncType > &Func)
Definition Function.h:665
#define ENABLE_TFUNCTIONREF_VISUALIZATION
Definition Function.h:18
void * operator new(size_t Size, UE4Function_Private::FFunctionStorage &Storage)
Definition Function.h:133
FORCEINLINE bool operator!=(TYPE_OF_NULLPTR, const TFunction< FuncType > &Func)
Definition Function.h:683
FORCEINLINE bool operator!=(const TFunction< FuncType > &Func, TYPE_OF_NULLPTR)
Definition Function.h:692
FORCEINLINE bool operator==(const TFunction< FuncType > &Func, TYPE_OF_NULLPTR)
Definition Function.h:674
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
FORCEINLINE void MoveByRelocate(T &A, T &B)
Definition Set.h:76
FORCEINLINE SharedPointerInternals::FRawPtrProxy< ObjectType > MakeShareable(ObjectType *InObject, DeleterType &&InDeleter)
FORCEINLINE bool operator==(TSharedRef< ObjectTypeA, Mode > const &InSharedRefA, TWeakPtr< ObjectTypeB, Mode > const &InWeakPtrB)
FORCEINLINE bool operator!=(TSharedRef< ObjectTypeA, Mode > const &InSharedRefA, TWeakPtr< ObjectTypeB, Mode > const &InWeakPtrB)
FORCEINLINE TSharedRef< InObjectType, InMode > MakeShared(InArgTypes &&... Args)
FORCEINLINE bool operator!=(TWeakPtr< ObjectTypeA, Mode > const &InWeakPtrA, TWeakPtr< ObjectTypeB, Mode > const &InWeakPtrB)
FORCEINLINE TSharedPtr< CastToType, Mode > StaticCastSharedPtr(TSharedPtr< CastFromType, Mode > const &InSharedPtr)
FORCEINLINE bool operator==(TWeakPtr< ObjectTypeA, Mode > const &InWeakPtrA, TWeakPtr< ObjectTypeB, Mode > const &InWeakPtrB)
FORCEINLINE bool operator==(TWeakPtr< ObjectTypeA, Mode > const &InWeakPtrA, decltype(nullptr))
FORCEINLINE bool operator==(TWeakPtr< ObjectTypeA, Mode > const &InWeakPtrA, TSharedPtr< ObjectTypeB, Mode > const &InSharedPtrB)
FORCEINLINE bool operator==(TSharedRef< ObjectTypeA, Mode > const &InSharedRef, TSharedPtr< ObjectTypeB, Mode > const &InSharedPtr)
FORCEINLINE bool operator==(TSharedPtr< ObjectTypeA, Mode > const &InSharedPtrA, TSharedPtr< ObjectTypeB, Mode > const &InSharedPtrB)
FORCEINLINE bool operator==(TSharedRef< ObjectTypeA, Mode > const &InSharedRefA, TSharedRef< ObjectTypeB, Mode > const &InSharedRefB)
FORCEINLINE void CleanupPointerMap(TMap< TWeakPtr< KeyType >, ValueType > &PointerMap)
FORCEINLINE bool operator!=(TWeakPtr< ObjectTypeA, Mode > const &InWeakPtrA, TSharedPtr< ObjectTypeB, Mode > const &InSharedPtrB)
FORCEINLINE bool operator!=(TWeakPtr< ObjectTypeA, Mode > const &InWeakPtrA, TSharedRef< ObjectTypeB, Mode > const &InSharedRefB)
FORCEINLINE bool operator!=(TSharedPtr< ObjectTypeB, Mode > const &InSharedPtr, TSharedRef< ObjectTypeA, Mode > const &InSharedRef)
FORCEINLINE void CleanupPointerArray(TArray< TWeakPtr< Type > > &PointerArray)
FORCEINLINE bool operator!=(TSharedRef< ObjectTypeA, Mode > const &InSharedRefA, TSharedRef< ObjectTypeB, Mode > const &InSharedRefB)
FORCEINLINE bool operator!=(TWeakPtr< ObjectTypeA, Mode > const &InWeakPtrA, decltype(nullptr))
FORCEINLINE TSharedRef< CastToType, Mode > StaticCastSharedRef(TSharedRef< CastFromType, Mode > const &InSharedRef)
FORCEINLINE SharedPointerInternals::FRawPtrProxy< ObjectType > MakeShareable(ObjectType *InObject)
FORCEINLINE bool operator==(decltype(nullptr), TWeakPtr< ObjectTypeB, Mode > const &InWeakPtrB)
FORCEINLINE bool operator!=(TSharedPtr< ObjectTypeA, Mode > const &InSharedPtrA, TSharedPtr< ObjectTypeB, Mode > const &InSharedPtrB)
FORCEINLINE TSharedRef< CastToType, Mode > ConstCastSharedRef(TSharedRef< CastFromType, Mode > const &InSharedRef)
FORCEINLINE bool operator==(TSharedPtr< ObjectTypeA, Mode > const &InSharedPtrA, TWeakPtr< ObjectTypeB, Mode > const &InWeakPtrB)
FORCEINLINE bool operator!=(decltype(nullptr), TWeakPtr< ObjectTypeB, Mode > const &InWeakPtrB)
FORCEINLINE TSharedPtr< CastToType, Mode > ConstCastSharedPtr(TSharedPtr< CastFromType, Mode > const &InSharedPtr)
FORCEINLINE bool operator==(TSharedPtr< ObjectTypeB, Mode > const &InSharedPtr, TSharedRef< ObjectTypeA, Mode > const &InSharedRef)
FORCEINLINE bool operator!=(TSharedPtr< ObjectTypeA, Mode > const &InSharedPtrA, TWeakPtr< ObjectTypeB, Mode > const &InWeakPtrB)
FORCEINLINE bool operator!=(TSharedRef< ObjectTypeA, Mode > const &InSharedRef, TSharedPtr< ObjectTypeB, Mode > const &InSharedPtr)
FORCEINLINE bool operator==(TWeakPtr< ObjectTypeA, Mode > const &InWeakPtrA, TSharedRef< ObjectTypeB, Mode > const &InSharedRefB)
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
void * operator new(size_t Size, const FSparseArrayAllocationInfo &Allocation)
#define TSPARSEARRAY_RANGED_FOR_CHECKS
Definition SparseArray.h:17
#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 USE_TUPLE_AUTO_RETURN_TYPES
Definition Tuple.h:15
FORCEINLINE void VisitTupleElements(TupleType &Tuple, FuncType Func)
Definition Tuple.h:711
FORCEINLINE decltype(auto) TransformTuple(const TTuple< Types... > &Tuple, FuncType Func)
Definition Tuple.h:695
#define TUPLES_USE_DEFAULTED_FUNCTIONS
Definition Tuple.h:18
TTuple< typename TDecay< Types >::Type... > MakeTuple(Types &&... Args)
Definition Tuple.h:656
FORCEINLINE decltype(auto) TransformTuple(TTuple< Types... > &&Tuple, FuncType Func)
Definition Tuple.h:685
#define IMPLEMENT_ALIGNED_STORAGE(Align)
FORCEINLINE uint32 GetTypeHash(const TTuple<> &Tuple)
Definition TypeHash.h:155
uint32 GetTypeHash(double Value)
Definition TypeHash.h:105
uint32 GetTypeHash(const int64 A)
Definition TypeHash.h:86
uint32 HashCombine(uint32 A, uint32 C)
Definition TypeHash.h:13
uint32 GetTypeHash(const void *A)
Definition TypeHash.h:110
uint32 GetTypeHash(const uint16 A)
Definition TypeHash.h:61
FORCEINLINE uint32 GetTypeHash(const TTuple< Types... > &Tuple)
Definition TypeHash.h:150
uint32 GetTypeHash(const uint8 A)
Definition TypeHash.h:51
uint32 GetTypeHash(const int16 A)
Definition TypeHash.h:66
uint32 PointerHash(const void *Key, uint32 C=0)
Definition TypeHash.h:32
uint32 GetTypeHash(void *A)
Definition TypeHash.h:115
uint32 GetTypeHash(float Value)
Definition TypeHash.h:100
FORCEINLINE TEnableIf< TIsEnum< EnumType >::Value, uint32 >::Type GetTypeHash(EnumType E)
Definition TypeHash.h:121
uint32 GetTypeHash(const uint32 A)
Definition TypeHash.h:76
uint32 GetTypeHash(const int32 A)
Definition TypeHash.h:71
uint32 GetTypeHash(const uint64 A)
Definition TypeHash.h:81
uint32 GetTypeHash(const int8 A)
Definition TypeHash.h:56
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)
#define STRUCT_OFFSET(struc, member)
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
FORCEINLINE void operator=(const bool NewValue)
Definition BitArray.h:54
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 void * GetData()
Definition ScriptArray.h:18
FORCEINLINE const void * GetData() const
Definition ScriptArray.h:22
void Empty(int32 Slack, int32 NumBytesPerElement)
Definition ScriptArray.h:90
FORCEINLINE int32 Num() const
Definition ScriptArray.h:30
int32 Add(int32 Count, int32 NumBytesPerElement)
Definition ScriptArray.h:61
int32 Add(const bool Value)
Definition BitArray.h:997
FBitReference operator[](int32 Index)
Definition BitArray.h:972
bool IsValidIndex(int32 Index) const
Definition BitArray.h:967
FConstBitReference operator[](int32 Index) const
Definition BitArray.h:978
void Empty(int32 Slack=0)
Definition BitArray.h:984
int32 FindPairIndex(const void *Key, const FScriptMapLayout &MapLayout, TFunctionRef< uint32(const void *)> GetKeyHash, TFunctionRef< bool(const void *, const void *)> KeyEqualityFn)
Definition Map.h:1341
FScriptMap()
Definition Map.h:1285
FScriptSet Pairs
Definition Map.h:1407
FScriptMap(const FScriptMap &)
Definition Map.h:1429
void Empty(int32 Slack, const FScriptMapLayout &Layout)
Definition Map.h:1314
bool IsValidIndex(int32 Index) const
Definition Map.h:1289
uint8 * FindValue(const void *Key, const FScriptMapLayout &MapLayout, TFunctionRef< uint32(const void *)> GetKeyHash, TFunctionRef< bool(const void *, const void *)> KeyEqualityFn)
Definition Map.h:1363
int32 AddUninitialized(const FScriptMapLayout &Layout)
Definition Map.h:1330
const void * GetData(int32 Index, const FScriptMapLayout &Layout) const
Definition Map.h:1309
void * GetData(int32 Index, const FScriptMapLayout &Layout)
Definition Map.h:1304
void Add(const void *Key, const void *Value, const FScriptMapLayout &Layout, TFunctionRef< uint32(const void *)> GetKeyHash, TFunctionRef< bool(const void *, const void *)> KeyEqualityFn, TFunctionRef< void(void *)> KeyConstructAndAssignFn, TFunctionRef< void(void *)> ValueConstructAndAssignFn, TFunctionRef< void(void *)> ValueAssignFn, TFunctionRef< void(void *)> DestructKeyFn, TFunctionRef< void(void *)> DestructValueFn)
Definition Map.h:1376
void operator=(const FScriptMap &)
Definition Map.h:1430
static FScriptMapLayout GetScriptLayout(int32 KeySize, int32 KeyAlignment, int32 ValueSize, int32 ValueAlignment)
Definition Map.h:1272
int32 GetMaxIndex() const
Definition Map.h:1299
void Rehash(const FScriptMapLayout &Layout, TFunctionRef< uint32(const void *)> GetKeyHash)
Definition Map.h:1335
int32 Num() const
Definition Map.h:1294
void RemoveAt(int32 Index, const FScriptMapLayout &Layout)
Definition Map.h:1319
static void CheckConstraints()
Definition Map.h:1410
void Add(const void *Element, const FScriptSetLayout &Layout, TFunctionRef< uint32(const void *)> GetKeyHash, TFunctionRef< bool(const void *, const void *)> EqualityFn, TFunctionRef< void(void *)> ConstructFn, TFunctionRef< void(void *)> DestructFn)
Definition Set.h:1385
int32 Num() const
Definition Set.h:1246
FScriptSet()
Definition Set.h:1236
static void CheckConstraints()
Definition Set.h:1450
void * GetData(int32 Index, const FScriptSetLayout &Layout)
Definition Set.h:1256
void RemoveAt(int32 Index, const FScriptSetLayout &Layout)
Definition Set.h:1289
int32 FindIndex(const void *Element, const FScriptSetLayout &Layout, TFunctionRef< uint32(const void *)> GetKeyHash, TFunctionRef< bool(const void *, const void *)> EqualityFn)
Definition Set.h:1362
static int32 & GetHashIndexRef(const void *Element, const FScriptSetLayout &Layout)
Definition Set.h:1444
void Rehash(const FScriptSetLayout &Layout, TFunctionRef< uint32(const void *)> GetKeyHash)
Definition Set.h:1319
static FScriptSetLayout GetScriptLayout(int32 ElementSize, int32 ElementAlignment)
Definition Set.h:1221
HashType Hash
Definition Set.h:1431
int32 AddUninitialized(const FScriptSetLayout &Layout)
Definition Set.h:1313
void Empty(int32 Slack, const FScriptSetLayout &Layout)
Definition Set.h:1266
int32 HashSize
Definition Set.h:1432
Allocator::HashAllocator::ForElementType< FSetElementId > HashType
Definition Set.h:1428
int32 GetMaxIndex() const
Definition Set.h:1251
static FSetElementId & GetHashNextIdRef(const void *Element, const FScriptSetLayout &Layout)
Definition Set.h:1439
FScriptSet(const FScriptSet &)
Definition Set.h:1473
const void * GetData(int32 Index, const FScriptSetLayout &Layout) const
Definition Set.h:1261
FScriptSparseArray Elements
Definition Set.h:1430
FDefaultSetAllocator Allocator
Definition Set.h:1427
void operator=(const FScriptSet &)
Definition Set.h:1474
FORCEINLINE FSetElementId & GetTypedHash(int32 HashIndex) const
Definition Set.h:1434
bool IsValidIndex(int32 Index) const
Definition Set.h:1241
FScriptArray Data
FORCEINLINE FFreeListLink * GetFreeListLink(int32 Index, const FScriptSparseArrayLayout &Layout)
bool IsValidIndex(int32 Index) const
int32 AddUninitialized(const FScriptSparseArrayLayout &Layout)
static FScriptSparseArrayLayout GetScriptLayout(int32 ElementSize, int32 ElementAlignment)
int32 GetMaxIndex() const
void operator=(const FScriptSparseArray &)
void Empty(int32 Slack, const FScriptSparseArrayLayout &Layout)
FScriptBitArray AllocationFlags
FScriptSparseArray(const FScriptSparseArray &)
void * GetData(int32 Index, const FScriptSparseArrayLayout &Layout)
static void CheckConstraints()
int32 Num() const
const void * GetData(int32 Index, const FScriptSparseArrayLayout &Layout) const
void RemoveAtUninitialized(const FScriptSparseArrayLayout &Layout, int32 Index, int32 Count=1)
friend class TSet
Definition Set.h:91
int32 Index
Definition Set.h:125
FORCEINLINE bool IsValidId() const
Definition Set.h:101
FORCEINLINE FSetElementId(int32 InIndex)
Definition Set.h:128
FORCEINLINE int32 AsInteger() const
Definition Set.h:112
FORCEINLINE FSetElementId()
Definition Set.h:96
FORCEINLINE operator int32() const
Definition Set.h:133
static FORCEINLINE FSetElementId FromInteger(int32 Integer)
Definition Set.h:117
FORCEINLINE friend bool operator==(const FSetElementId &A, const FSetElementId &B)
Definition Set.h:107
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
int32 GetAlignment() const
int32 AddMember(int32 MemberSize, int32 MemberAlignment)
int32 GetSize() const
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
friend class TConstSetBitIterator
Definition BitArray.h:160
friend class TConstDualSetBitIterator
Definition BitArray.h:163
FORCEINLINE TEnumAsByte(TEnum InValue)
Definition EnumAsByte.h:40
TEnum GetValue() const
Definition EnumAsByte.h:122
FORCEINLINE TEnumAsByte(int32 InValue)
Definition EnumAsByte.h:49
FORCEINLINE TEnumAsByte & operator=(TEnum InValue)
Definition EnumAsByte.h:81
FORCEINLINE TEnumAsByte(const TEnumAsByte &InValue)
Definition EnumAsByte.h:31
FORCEINLINE TEnumAsByte(uint8 InValue)
Definition EnumAsByte.h:58
TEnum EnumType
Definition EnumAsByte.h:21
bool operator==(TEnum InValue) const
Definition EnumAsByte.h:93
operator TEnum() const
Definition EnumAsByte.h:110
FORCEINLINE TEnumAsByte()
Definition EnumAsByte.h:24
TEnumAsByte_EnumClass< TIsEnumClass< TEnum >::Value > Check
Definition EnumAsByte.h:18
FORCEINLINE TEnumAsByte & operator=(TEnumAsByte InValue)
Definition EnumAsByte.h:70
FORCEINLINE friend uint32 GetTypeHash(const TEnumAsByte &Enum)
Definition EnumAsByte.h:133
bool operator==(TEnumAsByte InValue) const
Definition EnumAsByte.h:104
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
TFunction(const TFunction &Other)
Definition Function.h:581
TFunction(FunctorType &&InFunc)
Definition Function.h:556
UE4Function_Private::FFunctionStorage Storage
Definition Function.h:658
FORCEINLINE operator bool() const
Definition Function.h:643
TFunction(TYPE_OF_NULLPTR=nullptr)
Definition Function.h:546
UE4Function_Private::TFunctionRefBase< TFunction< FuncType >, FuncType > Super
Definition Function.h:540
TFunction & operator=(TYPE_OF_NULLPTR)
Definition Function.h:617
void * GetPtr() const
Definition Function.h:652
TFunction(TFunction &&Other)
Definition Function.h:598
~TFunctionRef()=default
TFunctionRef(const FunctorType &Functor)
Definition Function.h:404
void CopyAndReseat(const TFunctionRef &Other, void *Functor)
Definition Function.h:480
void * GetPtr() const
Definition Function.h:489
void Set(FunctorType *Functor)
Definition Function.h:467
TFunctionRef(FunctorType &Functor)
Definition Function.h:391
void * Ptr
Definition Function.h:495
UE4Function_Private::TFunctionRefBase< TFunctionRef< FuncType >, FuncType > Super
Definition Function.h:384
TFunctionRef & operator=(const TFunctionRef &) const =delete
TFunctionRef(FunctionType *Function)
Definition Function.h:417
TFunctionRef(const TFunctionRef &Other)
Definition Function.h:430
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
TRValueToLValueReference< KeyInitType >::Type Key
Definition Map.h:57
FORCEINLINE TKeyInitializer(KeyInitType InKey)
Definition Map.h:60
operator TPair< KeyType, ValueType >() const
Definition Map.h:65
TChooseClass< bConst, constKeyType, KeyType >::Result ItKeyType
Definition Map.h:540
TChooseClass< bConst, constTMapBase, TMapBase >::Result MapType
Definition Map.h:539
FORCEINLINE friend bool operator==(const TBaseIterator &Lhs, const TBaseIterator &Rhs)
Definition Map.h:567
FORCEINLINE TBaseIterator(const PairItType &InElementIt)
Definition Map.h:545
FORCEINLINE bool operator!() const
Definition Map.h:562
FORCEINLINE ItKeyType & Key() const
Definition Map.h:570
FORCEINLINE PairType & operator*() const
Definition Map.h:573
PairItType PairIt
Definition Map.h:577
FORCEINLINE friend bool operator!=(const TBaseIterator &Lhs, const TBaseIterator &Rhs)
Definition Map.h:568
FORCEINLINE TBaseIterator & operator++()
Definition Map.h:550
FORCEINLINE ItValueType & Value() const
Definition Map.h:571
TChooseClass< bConst, typenameTChooseClass< bRangedFor, typenameElementSetType::TRangedForConstIterator, typenameElementSetType::TConstIterator >::Result, typenameTChooseClass< bRangedFor, typenameElementSetType::TRangedForIterator, typenameElementSetType::TIterator >::Result >::Result PairItType
Definition Map.h:537
FORCEINLINE PairType * operator->() const
Definition Map.h:574
FORCEINLINE operator bool() const
Definition Map.h:557
TChooseClass< bConst, constValueType, ValueType >::Result ItValueType
Definition Map.h:541
TChooseClass< bConst, consttypenameElementSetType::ElementType, typenameElementSetType::ElementType >::Result PairType
Definition Map.h:542
TChooseClass< bConst, constValueType, ValueType >::Result ItValueType
Definition Map.h:587
FORCEINLINE TBaseKeyIterator(const SetItType &InSetIt)
Definition Map.h:591
FORCEINLINE operator bool() const
Definition Map.h:603
TChooseClass< bConst, constKeyType, KeyType >::Result ItKeyType
Definition Map.h:586
FORCEINLINE ItKeyType & Key() const
Definition Map.h:613
FORCEINLINE bool operator!() const
Definition Map.h:608
FORCEINLINE ItValueType & Value() const
Definition Map.h:614
FORCEINLINE TBaseKeyIterator & operator++()
Definition Map.h:596
TChooseClass< bConst, typenameElementSetType::TConstKeyIterator, typenameElementSetType::TKeyIterator >::Result SetItType
Definition Map.h:585
FORCEINLINE TConstIterator(const TMapBase &InMap)
Definition Map.h:665
FORCEINLINE TConstKeyIterator(const TMapBase &InMap, KeyInitType InKey)
Definition Map.h:678
FORCEINLINE ~TIterator()
Definition Map.h:640
TMapBase & Map
Definition Map.h:656
bool bRequiresRehashOnRemoval
Definition Map.h:658
bool bElementsHaveBeenRemoved
Definition Map.h:657
FORCEINLINE void RemoveCurrent()
Definition Map.h:649
FORCEINLINE TIterator(TMapBase &InMap, bool bInRequiresRehashOnRemoval=false)
Definition Map.h:631
FORCEINLINE void RemoveCurrent()
Definition Map.h:692
FORCEINLINE TKeyIterator(TMapBase &InMap, KeyInitType InKey)
Definition Map.h:687
FORCEINLINE ValueType & FindOrAddImpl(ArgType &&Arg)
Definition Map.h:403
FORCEINLINE friend TRangedForIterator end(TMapBase &MapBase)
Definition Map.h:729
FORCEINLINE bool Contains(KeyConstPointerType Key) const
Definition Map.h:492
TSet< ElementType, KeyFuncs, SetAllocator > ElementSetType
Definition Map.h:526
const KeyType * FindKey(ValueInitType Value) const
Definition Map.h:360
FORCEINLINE ValueType * Find(KeyConstPointerType Key)
Definition Map.h:379
FORCEINLINE ValueType & Add(KeyType &&InKey, ValueType &&InValue)
Definition Map.h:299
ElementSetType Pairs
Definition Map.h:621
void GenerateValueArray(TArray< ValueType, Allocator > &OutArray) const
Definition Map.h:516
FORCEINLINE ValueType FindRef(KeyConstPointerType Key) const
Definition Map.h:476
void GenerateKeyArray(TArray< KeyType, Allocator > &OutArray) const
Definition Map.h:502
FORCEINLINE const ValueType * Find(KeyConstPointerType Key) const
Definition Map.h:388
FORCEINLINE ValueType & Add(const KeyType &InKey)
Definition Map.h:307
friend bool LegacyCompareEqual(const TMapBase &A, const TMapBase &B)
Definition Map.h:166
FORCEINLINE TIterator CreateIterator()
Definition Map.h:699
FORCEINLINE friend TRangedForConstIterator end(const TMapBase &MapBase)
Definition Map.h:730
FORCEINLINE void Shrink()
Definition Map.h:229
FORCEINLINE void Empty(int32 ExpectedNumElements=0)
Definition Map.h:217
FORCEINLINE void Reserve(int32 Number)
Definition Map.h:247
TMapBase & operator=(const TMapBase &)=default
FORCEINLINE TConstKeyIterator CreateConstKeyIterator(KeyInitType InKey) const
Definition Map.h:717
TMapBase(const TMapBase &)=default
TMapBase(TMapBase &&)=default
TTypeTraits< KeyType >::ConstInitType KeyInitType
Definition Map.h:112
FORCEINLINE ValueType & FindOrAdd(KeyType &&Key)
Definition Map.h:421
FORCEINLINE TConstIterator CreateConstIterator() const
Definition Map.h:705
FORCEINLINE int32 Remove(KeyConstPointerType InKey)
Definition Map.h:344
TTypeTraits< ValueType >::ConstInitType ValueInitType
Definition Map.h:113
FORCEINLINE ValueType & Add(KeyType &&InKey)
Definition Map.h:308
TTypeTraits< KeyType >::ConstPointerType KeyConstPointerType
Definition Map.h:111
TMapBase & operator=(const TMapBase< KeyType, ValueType, OtherSetAllocator, KeyFuncs > &Other)
Definition Map.h:158
FORCEINLINE TKeyIterator CreateKeyIterator(KeyInitType InKey)
Definition Map.h:711
ValueType & Emplace(InitKeyType &&InKey)
Definition Map.h:331
int32 GetKeys(TArray< KeyType, Allocator > &OutKeys) const
Definition Map.h:264
TMapBase & operator=(TMapBase &&)=default
TMapBase(TMapBase< KeyType, ValueType, OtherSetAllocator, KeyFuncs > &&Other)
Definition Map.h:138
FORCEINLINE ValueType & Add(KeyType &&InKey, const ValueType &InValue)
Definition Map.h:298
FORCEINLINE friend TRangedForIterator begin(TMapBase &MapBase)
Definition Map.h:727
bool OrderIndependentCompareEqual(const TMapBase &Other) const
Definition Map.h:183
FORCEINLINE const ValueType & FindChecked(KeyConstPointerType Key) const
Definition Map.h:450
FORCEINLINE int32 Num() const
Definition Map.h:253
FORCEINLINE void CompactStable()
Definition Map.h:241
FORCEINLINE ValueType & Add(const KeyType &InKey, const ValueType &InValue)
Definition Map.h:296
FORCEINLINE friend TRangedForConstIterator begin(const TMapBase &MapBase)
Definition Map.h:728
TMapBase()=default
FORCEINLINE void Compact()
Definition Map.h:235
FORCEINLINE ValueType & FindOrAdd(const KeyType &Key)
Definition Map.h:420
TPair< KeyType, ValueType > ElementType
Definition Map.h:114
FORCEINLINE ValueType & FindChecked(KeyConstPointerType Key)
Definition Map.h:463
FORCEINLINE ValueType & Add(const KeyType &InKey, ValueType &&InValue)
Definition Map.h:297
ValueType & Emplace(InitKeyType &&InKey, InitValueType &&InValue)
Definition Map.h:317
TMapBase(const TMapBase< KeyType, ValueType, OtherSetAllocator, KeyFuncs > &Other)
Definition Map.h:144
FORCEINLINE uint32 GetAllocatedSize() const
Definition Map.h:284
TMapBase & operator=(TMapBase< KeyType, ValueType, OtherSetAllocator, KeyFuncs > &&Other)
Definition Map.h:150
friend bool LegacyCompareNotEqual(const TMapBase &A, const TMapBase &B)
Definition Map.h:170
FORCEINLINE void Reset()
Definition Map.h:223
Definition Map.h:856
FORCEINLINE ValueType & operator[](KeyConstPointerType Key)
Definition Map.h:985
FORCEINLINE bool RemoveAndCopyValue(KeyInitType Key, ValueType &OutRemovedValue)
Definition Map.h:923
FORCEINLINE const ValueType & operator[](KeyConstPointerType Key) const
Definition Map.h:986
TMap(const TMap< KeyType, ValueType, OtherSetAllocator, KeyFuncs > &Other)
Definition Map.h:894
TSortableMapBase< KeyType, ValueType, SetAllocator, KeyFuncs > Super
Definition Map.h:863
FORCEINLINE ValueType FindAndRemoveChecked(KeyConstPointerType Key)
Definition Map.h:942
void Append(const TMap< KeyType, ValueType, OtherSetAllocator, KeyFuncs > &OtherMap)
Definition Map.h:976
TMap & operator=(const TMap< KeyType, ValueType, OtherSetAllocator, KeyFuncs > &Other)
Definition Map.h:909
void Append(TMap< KeyType, ValueType, OtherSetAllocator, KeyFuncs > &&OtherMap)
Definition Map.h:958
TMap()=default
TMap & operator=(const TMap &)=default
TMap(TMap &&)=default
TMap & operator=(TMap &&)=default
TMap & operator=(TMap< KeyType, ValueType, OtherSetAllocator, KeyFuncs > &&Other)
Definition Map.h:901
TMap(const TMap &)=default
TMap(TMap< KeyType, ValueType, OtherSetAllocator, KeyFuncs > &&Other)
Definition Map.h:887
Super::KeyInitType KeyInitType
Definition Map.h:864
Super::KeyConstPointerType KeyConstPointerType
Definition Map.h:865
static void Sort(T *First, const int32 Num, const PREDICATE_CLASS &Predicate)
Definition Sorting.h:286
Super::KeyInitType KeyInitType
Definition Map.h:1001
TMultiMap(TMultiMap< KeyType, ValueType, OtherSetAllocator, KeyFuncs > &&Other)
Definition Map.h:1024
Super::ValueInitType ValueInitType
Definition Map.h:1002
Super::KeyConstPointerType KeyConstPointerType
Definition Map.h:1000
int32 Num(KeyInitType Key) const
Definition Map.h:1239
void MultiFindPointer(KeyInitType Key, TArray< const ValueType *, Allocator > &OutValues, bool bMaintainOrder=false) const
Definition Map.h:1080
int32 RemoveSingle(KeyInitType InKey, ValueInitType InValue)
Definition Map.h:1183
TMultiMap & operator=(TMultiMap &&)=default
void MultiFindPointer(KeyInitType Key, TArray< ValueType *, Allocator > &OutValues, bool bMaintainOrder=false)
Definition Map.h:1092
ValueType * FindPair(KeyInitType Key, ValueInitType Value)
Definition Map.h:1223
TMultiMap(const TMultiMap &)=default
FORCEINLINE ValueType & AddUnique(KeyType &&InKey, ValueType &&InValue)
Definition Map.h:1117
TMultiMap & operator=(TMultiMap< KeyType, ValueType, OtherSetAllocator, KeyFuncs > &&Other)
Definition Map.h:1038
TMultiMap(const TMultiMap< KeyType, ValueType, OtherSetAllocator, KeyFuncs > &Other)
Definition Map.h:1031
FORCEINLINE int32 Num() const
Definition Map.h:1251
int32 Remove(KeyInitType InKey, ValueInitType InValue)
Definition Map.h:1160
TMultiMap & operator=(const TMultiMap &)=default
TSortableMapBase< KeyType, ValueType, SetAllocator, KeyFuncs > Super
Definition Map.h:999
FORCEINLINE const ValueType * FindPair(KeyInitType Key, ValueInitType Value) const
Definition Map.h:1210
TMultiMap & operator=(const TMultiMap< KeyType, ValueType, OtherSetAllocator, KeyFuncs > &Other)
Definition Map.h:1046
void MultiFind(KeyInitType Key, TArray< ValueType, Allocator > &OutValues, bool bMaintainOrder=false) const
Definition Map.h:1059
FORCEINLINE ValueType & AddUnique(const KeyType &InKey, const ValueType &InValue)
Definition Map.h:1114
FORCEINLINE int32 Remove(KeyConstPointerType InKey)
Definition Map.h:1148
FORCEINLINE ValueType & AddUnique(KeyType &&InKey, const ValueType &InValue)
Definition Map.h:1116
TMultiMap()=default
ValueType & EmplaceUnique(InitKeyType &&InKey, InitValueType &&InValue)
Definition Map.h:1131
FORCEINLINE ValueType & AddUnique(const KeyType &InKey, ValueType &&InValue)
Definition Map.h:1115
TMultiMap(TMultiMap &&)=default
FORCEINLINE TPairInitializer(KeyInitType InKey, ValueInitType InValue)
Definition Map.h:30
operator TPair< KeyType, ValueType >() const
Definition Map.h:45
TRValueToLValueReference< ValueInitType >::Type Value
Definition Map.h:27
TRValueToLValueReference< KeyInitType >::Type Key
Definition Map.h:26
FORCEINLINE TPairInitializer(const TPair< KeyType, ValueType > &Pair)
Definition Map.h:38
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
FORCEINLINE FElementCompareClass(const PREDICATE_CLASS &InPredicate)
Definition Set.h:869
FORCEINLINE bool operator()(const SetElementType &A, const SetElementType &B) const
Definition Set.h:873
TDereferenceWrapper< ElementType, PREDICATE_CLASS > Predicate
Definition Set.h:866
TChooseClass< bConst, constElementType, ElementType >::Result ItElementType
Definition Set.h:984
FORCEINLINE ItElementType & operator*() const
Definition Set.h:1025
FORCEINLINE friend bool operator==(const TBaseIterator &Lhs, const TBaseIterator &Rhs)
Definition Set.h:1030
ElementItType ElementIt
Definition Set.h:1033
TChooseClass< bConst, typenameTChooseClass< bRangedFor, typenameElementArrayType::TRangedForConstIterator, typenameElementArrayType::TConstIterator >::Result, typenameTChooseClass< bRangedFor, typenameElementArrayType::TRangedForIterator, typenameElementArrayType::TIterator >::Result >::Result ElementItType
Definition Set.h:991
FORCEINLINE TBaseIterator & operator++()
Definition Set.h:999
FORCEINLINE friend bool operator!=(const TBaseIterator &Lhs, const TBaseIterator &Rhs)
Definition Set.h:1031
FORCEINLINE FSetElementId GetId() const
Definition Set.h:1017
FORCEINLINE TBaseIterator(const ElementItType &InElementIt)
Definition Set.h:993
FORCEINLINE ItElementType * operator->() const
Definition Set.h:1021
FORCEINLINE operator bool() const
Definition Set.h:1006
FORCEINLINE bool operator!() const
Definition Set.h:1011
FORCEINLINE ItElementType & operator*() const
Definition Set.h:1096
FORCEINLINE ItElementType * operator->() const
Definition Set.h:1092
FORCEINLINE TBaseKeyIterator(SetType &InSet, KeyInitType InKey)
Definition Set.h:1046
TTypeTraits< typenameKeyFuncs::KeyType >::ConstPointerType Key
Definition Set.h:1103
TChooseClass< bConst, constTSet, TSet >::Result SetType
Definition Set.h:1041
FSetElementId Id
Definition Set.h:1104
FORCEINLINE operator bool() const
Definition Set.h:1081
FORCEINLINE TBaseKeyIterator & operator++()
Definition Set.h:1061
FSetElementId NextId
Definition Set.h:1105
TChooseClass< bConst, constElementType, ElementType >::Result ItElementType
Definition Set.h:1042
FORCEINLINE bool operator!() const
Definition Set.h:1086
FORCEINLINE TConstIterator(const TSet &InSet)
Definition Set.h:1116
FORCEINLINE TConstKeyIterator(const TSet &InSet, KeyInitType InKey)
Definition Set.h:1151
FORCEINLINE TIterator(TSet &InSet)
Definition Set.h:1128
TSet & Set
Definition Set.h:1141
FORCEINLINE void RemoveCurrent()
Definition Set.h:1135
FORCEINLINE TKeyIterator(TSet &InSet, KeyInitType InKey)
Definition Set.h:1160
FORCEINLINE void RemoveCurrent()
Definition Set.h:1166
static FORCEINLINE uint32 GetNumberOfHashBuckets(uint32 NumHashedElements)
InSparseArrayAllocator SparseArrayAllocator
int32 HashIndex
Definition Set.h:153
FORCEINLINE TSetElement(const TSetElement &Rhs)
Definition Set.h:163
FORCEINLINE TSetElement & operator=(const TSetElement &Rhs)
Definition Set.h:167
InElementType ElementType
Definition Set.h:144
FORCEINLINE bool operator!=(const TSetElement &Other) const
Definition Set.h:175
ElementType Value
Definition Set.h:147
FORCEINLINE TSetElement()
Definition Set.h:156
FORCEINLINE TSetElement & operator=(TSetElement &&Rhs)
Definition Set.h:168
FORCEINLINE TSetElement(TSetElement &&Rhs)
Definition Set.h:164
FSetElementId HashNextId
Definition Set.h:150
FORCEINLINE bool operator==(const TSetElement &Other) const
Definition Set.h:171
FORCEINLINE ElementType * Find(KeyInitType Key)
Definition Set.h:633
FORCEINLINE FSetElementId Add(const InElementType &InElement, bool *bIsAlreadyInSetPtr=NULL)
Definition Set.h:458
FORCEINLINE TSet()
Definition Set.h:207
FORCEINLINE friend TRangedForConstIterator end(const TSet &Set)
Definition Set.h:1195
void Append(const TSet< ElementType, KeyFuncs, OtherAllocator > &OtherSet)
Definition Set.h:549
FORCEINLINE int32 Num() const
Definition Set.h:421
TSet & operator=(const TSet< ElementType, KeyFuncs, OtherAllocator > &Other)
Definition Set.h:321
TSet & operator=(TSet &&Other)
Definition Set.h:284
bool VerifyHashElementsKey(KeyInitType Key)
Definition Set.h:725
KeyFuncs::KeyInitType KeyInitType
Definition Set.h:198
static FORCEINLINE TEnableIf< TContainerTraits< SetType >::MoveWillEmptyContainer >::Type MoveOrCopy(SetType &ToSet, SetType &FromSet)
Definition Set.h:252
void Rehash() const
Definition Set.h:953
FORCEINLINE void Shrink()
Definition Set.h:370
TSet & operator=(TSet< ElementType, KeyFuncs, OtherAllocator > &&Other)
Definition Set.h:312
FORCEINLINE const ElementType & operator[](FSetElementId Id) const
Definition Set.h:446
TSet(TSet &&Other)
Definition Set.h:277
TSet(TSet< ElementType, KeyFuncs, OtherAllocator > &&Other)
Definition Set.h:296
FORCEINLINE TIterator CreateIterator()
Definition Set.h:1176
friend bool LegacyCompareNotEqual(const TSet &A, const TSet &B)
Definition Set.h:751
TSparseArray< SetElementType, typename Allocator::SparseArrayAllocator > ElementArrayType
Definition Set.h:879
FORCEINLINE void Compact()
Definition Set.h:377
FORCEINLINE FSetElementId Add(InElementType &&InElement, bool *bIsAlreadyInSetPtr=NULL)
Definition Set.h:459
FORCEINLINE uint32 GetAllocatedSize(void) const
Definition Set.h:415
FORCEINLINE void CheckAddress(const ElementType *Addr) const
Definition Set.h:856
FORCEINLINE void HashElement(FSetElementId ElementId, const SetElementType &Element) const
Definition Set.h:915
FORCEINLINE SetElementType & GetInternalElement(FSetElementId Id)
Definition Set.h:900
FORCEINLINE friend TRangedForIterator begin(TSet &Set)
Definition Set.h:1192
FORCEINLINE TSet(const TSet &Copy)
Definition Set.h:212
InElementType ElementType
Definition Set.h:204
FORCEINLINE bool IsValidId(FSetElementId Id) const
Definition Set.h:431
FORCEINLINE TSet(TArray< ElementType > &&InArray)
Definition Set.h:224
void Append(const TArray< ElementType, ArrayAllocator > &InElements)
Definition Set.h:524
TSet Intersect(const TSet &OtherSet) const
Definition Set.h:757
FORCEINLINE void Relax()
Definition Set.h:406
FSetElementId FindId(KeyInitType Key) const
Definition Set.h:610
FORCEINLINE friend TRangedForConstIterator begin(const TSet &Set)
Definition Set.h:1193
TSet & operator=(const TSet &Copy)
Definition Set.h:237
int32 HashSize
Definition Set.h:885
FSetElementId Emplace(ArgsType &&Args, bool *bIsAlreadyInSetPtr=NULL)
Definition Set.h:472
FORCEINLINE ElementType & operator[](FSetElementId Id)
Definition Set.h:440
void Append(TSet< ElementType, KeyFuncs, OtherAllocator > &&OtherSet)
Definition Set.h:559
bool ConditionalRehash(int32 NumHashedElements, bool bAllowShrinking=false) const
Definition Set.h:931
FORCEINLINE const SetElementType & GetInternalElement(FSetElementId Id) const
Definition Set.h:896
TSet Difference(const TSet &OtherSet) const
Definition Set.h:794
KeyFuncs::ElementInitType ElementInitType
Definition Set.h:199
TSet(const TSet< ElementType, KeyFuncs, OtherAllocator > &Other)
Definition Set.h:304
FORCEINLINE FSetElementId & GetTypedHash(int32 HashIndex) const
Definition Set.h:887
HashType Hash
Definition Set.h:884
FORCEINLINE void CompactStable()
Definition Set.h:386
Allocator::HashAllocator::template ForElementType< FSetElementId > HashType
Definition Set.h:880
void Append(TArray< ElementType, ArrayAllocator > &&InElements)
Definition Set.h:534
static FORCEINLINE FSetElementId IndexToId(int32 Index)
Definition Set.h:909
void Sort(const PREDICATE_CLASS &Predicate)
Definition Set.h:716
friend bool LegacyCompareEqual(const TSet &A, const TSet &B)
Definition Set.h:747
FORCEINLINE const ElementType * Find(KeyInitType Key) const
Definition Set.h:651
FORCEINLINE void Reserve(int32 Number)
Definition Set.h:395
TSet Union(const TSet &OtherSet) const
Definition Set.h:777
FORCEINLINE ~TSet()
Definition Set.h:231
void Remove(FSetElementId ElementId)
Definition Set.h:582
static FORCEINLINE TEnableIf<!TContainerTraits< SetType >::MoveWillEmptyContainer >::Type MoveOrCopy(SetType &ToSet, SetType &FromSet)
Definition Set.h:263
TSetElement< InElementType > SetElementType
Definition Set.h:201
FORCEINLINE friend TRangedForIterator end(TSet &Set)
Definition Set.h:1194
void Reset()
Definition Set.h:357
TArray< ElementType > Array() const
Definition Set.h:839
ElementArrayType Elements
Definition Set.h:882
FORCEINLINE TSet(const TArray< ElementType > &InArray)
Definition Set.h:218
FORCEINLINE TConstIterator CreateConstIterator() const
Definition Set.h:1182
bool Includes(const TSet< ElementType, KeyFuncs, Allocator > &OtherSet) const
Definition Set.h:816
void Empty(int32 ExpectedNumElements=0)
Definition Set.h:340
FORCEINLINE bool Contains(KeyInitType Key) const
Definition Set.h:707
int32 Remove(KeyInitType Key)
Definition Set.h:669
FORCEINLINE void UpdateWeakReferenceInternal(TSharedRef< SharedRefType, Mode > const *InSharedRef, OtherType *InObject) const
TSharedRef< ObjectType, Mode > AsShared()
FORCEINLINE TSharedFromThis & operator=(TSharedFromThis const &)
static FORCEINLINE TSharedRef< OtherType const, Mode > SharedThis(const OtherType *ThisPtr)
static FORCEINLINE TSharedRef< OtherType, Mode > SharedThis(OtherType *ThisPtr)
TWeakPtr< ObjectType, Mode > WeakThis
TSharedFromThis(TSharedFromThis const &)
FORCEINLINE void UpdateWeakReferenceInternal(TSharedPtr< SharedPtrType, Mode > const *InSharedPtr, OtherType *InObject) const
TSharedRef< ObjectType const, Mode > AsShared() const
FORCEINLINE bool DoesSharedInstanceExist() const
FORCEINLINE const int32 GetSharedReferenceCount() const
FORCEINLINE ObjectType * operator->() const
FORCEINLINE TSharedPtr(OtherType *InObject, DeleterType &&InDeleter)
SharedPointerInternals::FSharedReferencer< Mode > SharedReferenceCount
FORCEINLINE FMakeReferenceTo< ObjectType >::Type operator*() const
FORCEINLINE TSharedPtr(OtherType *InObject)
FORCEINLINE TSharedPtr(SharedPointerInternals::FNullTag *=nullptr)
FORCEINLINE TSharedPtr(TSharedPtr< OtherType, Mode > const &InSharedPtr)
FORCEINLINE TSharedPtr(TSharedPtr< OtherType, Mode > const &InSharedPtr, SharedPointerInternals::FStaticCastTag)
FORCEINLINE TSharedPtr & operator=(SharedPointerInternals::FNullTag *)
FORCEINLINE const bool IsValid() const
FORCEINLINE TSharedPtr(TSharedPtr< OtherType, Mode > &&OtherSharedPtr, ObjectType *InObject)
FORCEINLINE TSharedPtr(TSharedPtr< OtherType, Mode > const &OtherSharedPtr, ObjectType *InObject)
friend uint32 GetTypeHash(const TSharedPtr< ObjectType, Mode > &InSharedPtr)
FORCEINLINE const bool IsUnique() const
FORCEINLINE TSharedPtr(TSharedPtr< OtherType, Mode > const &InSharedPtr, SharedPointerInternals::FConstCastTag)
FORCEINLINE TSharedPtr(TSharedRef< OtherType, Mode > const &InSharedRef)
FORCEINLINE void Reset()
FORCEINLINE TSharedPtr & operator=(SharedPointerInternals::FRawPtrProxy< OtherType > const &InRawPtrProxy)
FORCEINLINE TSharedPtr & operator=(TSharedPtr &&InSharedPtr)
FORCEINLINE TSharedPtr(TSharedPtr &&InSharedPtr)
FORCEINLINE TSharedRef< ObjectType, Mode > ToSharedRef() const
FORCEINLINE TSharedPtr(TSharedRef< OtherType, Mode > const &OtherSharedRef, ObjectType *InObject)
FORCEINLINE TSharedPtr(SharedPointerInternals::FRawPtrProxy< OtherType > const &InRawPtrProxy)
FORCEINLINE TSharedPtr(TSharedPtr const &InSharedPtr)
ObjectType * Object
FORCEINLINE ObjectType * Get() const
FORCEINLINE TSharedPtr & operator=(TSharedPtr const &InSharedPtr)
FORCEINLINE TSharedPtr(TWeakPtr< OtherType, Mode > const &InWeakPtr)
FORCEINLINE TSharedRef & operator=(TSharedRef &&InSharedRef)
FORCEINLINE TSharedRef(TSharedPtr< OtherType, Mode > &&InSharedPtr)
FORCEINLINE ObjectType & Get() const
void Init(OtherType *InObject)
FORCEINLINE ObjectType * operator->() const
FORCEINLINE const bool IsValid() const
FORCEINLINE TSharedRef(TSharedRef &&InSharedRef)
FORCEINLINE TSharedRef & operator=(TSharedRef const &InSharedRef)
FORCEINLINE TSharedRef(OtherType *InObject, DeleterType &&InDeleter)
FORCEINLINE TSharedRef(TSharedPtr< OtherType, Mode > const &InSharedPtr)
FORCEINLINE const bool IsUnique() const
FORCEINLINE TSharedRef(TSharedRef const &InSharedRef)
FORCEINLINE ObjectType & operator*() const
FORCEINLINE TSharedRef(TSharedRef< OtherType, Mode > const &InSharedRef, SharedPointerInternals::FConstCastTag)
FORCEINLINE TSharedRef(SharedPointerInternals::FRawPtrProxy< OtherType > const &InRawPtrProxy)
FORCEINLINE const int32 GetSharedReferenceCount() const
FORCEINLINE TSharedRef(OtherType *InObject)
SharedPointerInternals::FSharedReferencer< Mode > SharedReferenceCount
FORCEINLINE TSharedRef(TSharedRef< OtherType, Mode > const &InSharedRef)
FORCEINLINE TSharedRef(TSharedRef< OtherType, Mode > const &OtherSharedRef, ObjectType *InObject)
friend uint32 GetTypeHash(const TSharedRef< ObjectType, Mode > &InSharedRef)
ObjectType * Object
FORCEINLINE TSharedRef & operator=(SharedPointerInternals::FRawPtrProxy< OtherType > const &InRawPtrProxy)
FORCEINLINE TSharedRef(TSharedRef< OtherType, Mode > const &InSharedRef, SharedPointerInternals::FStaticCastTag)
FORCEINLINE TSharedRef(ObjectType *InObject, SharedPointerInternals::FReferenceControllerBase *InSharedReferenceCount)
TDereferenceWrapper< KeyType, PREDICATE_CLASS > Predicate
Definition Map.h:818
FORCEINLINE FKeyComparisonClass(const PREDICATE_CLASS &InPredicate)
Definition Map.h:822
FORCEINLINE bool operator()(const typename Super::ElementType &A, const typename Super::ElementType &B) const
Definition Map.h:826
FORCEINLINE FValueComparisonClass(const PREDICATE_CLASS &InPredicate)
Definition Map.h:840
TDereferenceWrapper< ValueType, PREDICATE_CLASS > Predicate
Definition Map.h:836
FORCEINLINE bool operator()(const typename Super::ElementType &A, const typename Super::ElementType &B) const
Definition Map.h:844
TSortableMapBase & operator=(TSortableMapBase< KeyType, ValueType, OtherSetAllocator, KeyFuncs > &&Other)
Definition Map.h:777
TSortableMapBase & operator=(TSortableMapBase &&)=default
FORCEINLINE void ValueSort(const PREDICATE_CLASS &Predicate)
Definition Map.h:807
TSortableMapBase(TSortableMapBase &&)=default
TSortableMapBase(const TSortableMapBase &)=default
TSortableMapBase(TSortableMapBase< KeyType, ValueType, OtherSetAllocator, KeyFuncs > &&Other)
Definition Map.h:763
TSortableMapBase()=default
TSortableMapBase & operator=(const TSortableMapBase &)=default
FORCEINLINE void KeySort(const PREDICATE_CLASS &Predicate)
Definition Map.h:797
TMapBase< KeyType, ValueType, SetAllocator, KeyFuncs > Super
Definition Map.h:741
TSortableMapBase & operator=(const TSortableMapBase< KeyType, ValueType, OtherSetAllocator, KeyFuncs > &Other)
Definition Map.h:785
TSortableMapBase(const TSortableMapBase< KeyType, ValueType, OtherSetAllocator, KeyFuncs > &Other)
Definition Map.h:770
FElementCompareClass(const PREDICATE_CLASS &InPredicate)
const PREDICATE_CLASS & Predicate
bool operator()(const FElementOrFreeListLink &A, const FElementOrFreeListLink &B) const
FORCEINLINE ItElementType & operator*() const
FORCEINLINE friend bool operator==(const TBaseIterator &Lhs, const TBaseIterator &Rhs)
FORCEINLINE bool operator!() const
FORCEINLINE TBaseIterator & operator++()
FORCEINLINE int32 GetIndex() const
TChooseClass< bConst, constTSparseArray, TSparseArray >::Result ArrayType
FORCEINLINE friend bool operator!=(const TBaseIterator &Lhs, const TBaseIterator &Rhs)
FORCEINLINE const FRelativeBitReference & GetRelativeBitReference() const
TConstSetBitIterator< typename Allocator::BitArrayAllocator > BitArrayItType
FORCEINLINE ItElementType * operator->() const
FORCEINLINE operator bool() const
TBaseIterator(ArrayType &InArray, const BitArrayItType &InBitArrayIt)
TChooseClass< bConst, constElementType, ElementType >::Result ItElementType
TConstIterator(const TSparseArray &InArray, const typename TBaseIterator< true >::BitArrayItType &InBitArrayIt)
TConstIterator(const TSparseArray &InArray)
FORCEINLINE const ElementType & operator*() const
TConstSubsetIterator(const TSparseArray &InArray, const TBitArray< SubsetAllocator > &InBitArray)
FORCEINLINE const ElementType * operator->() const
FORCEINLINE operator bool() const
FORCEINLINE TConstSubsetIterator & operator++()
TConstDualSetBitIterator< typename Allocator::BitArrayAllocator, SubsetAllocator > BitArrayIt
FORCEINLINE const FRelativeBitReference & GetRelativeBitReference() const
FORCEINLINE bool operator!() const
FORCEINLINE int32 GetIndex() const
TIterator(TSparseArray &InArray, const typename TBaseIterator< false >::BitArrayItType &InBitArrayIt)
TIterator(TSparseArray &InArray)
friend FORCEINLINE bool operator!=(const TRangedForConstIterator &Lhs, const TRangedForConstIterator &Rhs)
TRangedForConstIterator(const TSparseArray &InArray, const typename TBaseIterator< true >::BitArrayItType &InBitArrayIt)
TRangedForIterator(TSparseArray &InArray, const typename TBaseIterator< false >::BitArrayItType &InBitArrayIt)
friend FORCEINLINE bool operator!=(const TRangedForIterator &Lhs, const TRangedForIterator &Rhs)
void RemoveAt(int32 Index, int32 Count=1)
TSparseArrayElementOrFreeListLink< TAlignedBytes< sizeof(ElementType), alignof(ElementType)> > FElementOrFreeListLink
FSparseArrayAllocationInfo AllocateIndex(int32 Index)
Definition SparseArray.h:75
AllocationBitArrayType AllocationFlags
TSparseArray(const TSparseArray &InCopy)
void RemoveAtUninitialized(int32 Index, int32 Count=1)
TIterator CreateIterator()
const FElementOrFreeListLink & GetData(int32 Index) const
uint32 GetAllocatedSize(void) const
TSparseArray & operator+=(const TArray< ElementType > &OtherArray)
ElementType & operator[](int32 Index)
TSparseArray & operator=(const TSparseArray &InCopy)
static FORCEINLINE TEnableIf<!TContainerTraits< SparseArrayType >::MoveWillEmptyContainer >::Type MoveOrCopy(SparseArrayType &ToArray, SparseArrayType &FromArray)
TSparseArray(TSparseArray &&InCopy)
TBitArray< typename Allocator::BitArrayAllocator > AllocationBitArrayType
int32 Num() const
int32 NumFreeIndices
friend bool operator!=(const TSparseArray &A, const TSparseArray &B)
FORCEINLINE void CheckAddress(const ElementType *Addr) const
int32 Add(typename TTypeTraits< ElementType >::ConstInitType Element)
const ElementType & operator[](int32 Index) const
static FORCEINLINE TEnableIf< TContainerTraits< SparseArrayType >::MoveWillEmptyContainer >::Type MoveOrCopy(SparseArrayType &ToArray, SparseArrayType &FromArray)
FORCEINLINE friend TRangedForConstIterator end(const TSparseArray &Array)
friend bool operator==(const TSparseArray &A, const TSparseArray &B)
void Reserve(int32 ExpectedNumElements)
FElementOrFreeListLink & GetData(int32 Index)
TSparseArray & operator+=(const TSparseArray &OtherArray)
DataType Data
TArray< FElementOrFreeListLink, typename Allocator::ElementAllocator > DataType
TConstIterator CreateConstIterator() const
TSparseArray & operator=(TSparseArray &&InCopy)
FORCEINLINE friend TRangedForConstIterator begin(const TSparseArray &Array)
FORCEINLINE friend TRangedForIterator end(TSparseArray &Array)
FSparseArrayAllocationInfo InsertUninitialized(int32 Index)
int32 GetMaxIndex() const
bool IsAllocated(int32 Index) const
bool CompactStable()
void Empty(int32 ExpectedNumElements=0)
FORCEINLINE friend TRangedForIterator begin(TSparseArray &Array)
void Insert(int32 Index, typename TTypeTraits< ElementType >::ConstInitType Element)
int32 FirstFreeIndex
FSparseArrayAllocationInfo AddUninitialized()
Definition SparseArray.h:96
ObjectType * Object
friend uint32 GetTypeHash(const TWeakPtr< ObjectType, Mode > &InWeakPtr)
FORCEINLINE TSharedPtr< ObjectType, Mode > Pin() const
FORCEINLINE const bool IsValid() const
SharedPointerInternals::FWeakReferencer< Mode > WeakReferenceCount
FORCEINLINE TWeakPtr & operator=(TWeakPtr< OtherType, Mode > const &InWeakPtr)
FORCEINLINE void Reset()
FORCEINLINE TWeakPtr(TWeakPtr< OtherType, Mode > const &InWeakPtr)
FORCEINLINE TWeakPtr(TSharedRef< OtherType, Mode > const &InSharedRef)
FORCEINLINE TWeakPtr & operator=(TWeakPtr< OtherType, Mode > &&InWeakPtr)
FORCEINLINE TWeakPtr & operator=(TSharedRef< OtherType, Mode > const &InSharedRef)
FORCEINLINE TWeakPtr(TWeakPtr< OtherType, Mode > &&InWeakPtr)
FORCEINLINE TWeakPtr & operator=(TWeakPtr &&InWeakPtr)
FORCEINLINE TWeakPtr(TWeakPtr &&InWeakPtr)
FORCEINLINE TWeakPtr & operator=(TSharedPtr< OtherType, Mode > const &InSharedPtr)
FORCEINLINE TWeakPtr(TWeakPtr const &InWeakPtr)
FORCEINLINE bool HasSameObject(const void *InOtherPtr) const
FORCEINLINE TWeakPtr(SharedPointerInternals::FNullTag *=nullptr)
FORCEINLINE TWeakPtr & operator=(TWeakPtr const &InWeakPtr)
FORCEINLINE TWeakPtr & operator=(SharedPointerInternals::FNullTag *)
FORCEINLINE TWeakPtr(TSharedPtr< OtherType, Mode > const &InSharedPtr)
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
TAlignedBytes< 16, 16 > AlignedInlineFunctionType
Definition Function.h:91
TInlineAllocator< 2 > FunctionAllocatorType
Definition Function.h:92
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
FORCEINLINE TSharedRef< ObjectType, Mode > MakeSharedRef(ObjectType *InObject, SharedPointerInternals::FReferenceControllerBase *InSharedReferenceCount)
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