Ark Server API (ASE) - Wiki
Loading...
Searching...
No Matches
BitArray.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/UnrealTypeTraits.h"
8#include "../Templates/UnrealTemplate.h"
10#include "../Math/UnrealMathUtility.h"
11
12template<typename Allocator > class TBitArray;
13
14// Functions for manipulating bit sets.
15struct FBitSet
16{
17 /** Clears the next set bit in the mask and returns its index. */
18 static FORCEINLINE uint32 GetAndClearNextBit(uint32& Mask)
19 {
20 const uint32 LowestBitMask = (Mask) & (-(int32)Mask);
21 const uint32 BitIndex = FMath::FloorLog2(LowestBitMask);
22 Mask ^= LowestBitMask;
23 return BitIndex;
24 }
25};
26
27
28// Forward declaration.
29template<typename Allocator = FDefaultBitArrayAllocator>
30class TBitArray;
31
32template<typename Allocator = FDefaultBitArrayAllocator>
34
35template<typename Allocator = FDefaultBitArrayAllocator,typename OtherAllocator = FDefaultBitArrayAllocator>
37
38class FScriptBitArray;
39
40/** Used to read/write a bit in the array as a bool. */
42{
43public:
44
45 FORCEINLINE FBitReference(uint32& InData,uint32 InMask)
46 : Data(InData)
47 , Mask(InMask)
48 {}
49
50 FORCEINLINE operator bool() const
51 {
52 return (Data & Mask) != 0;
53 }
54 FORCEINLINE void operator=(const bool NewValue)
55 {
56 if(NewValue)
57 {
58 Data |= Mask;
59 }
60 else
61 {
62 Data &= ~Mask;
63 }
64 }
65 /*FORCEINLINE void AtomicSet(const bool NewValue)
66 {
67 if(NewValue)
68 {
69 if (!(Data & Mask))
70 {
71 while (1)
72 {
73 uint32 Current = Data;
74 uint32 Desired = Current | Mask;
75 if (Current == Desired || FPlatformAtomics::InterlockedCompareExchange((volatile int32*)&Data, (int32)Desired, (int32)Current) == (int32)Current)
76 {
77 return;
78 }
79 }
80 }
81 }
82 else
83 {
84 if (Data & Mask)
85 {
86 while (1)
87 {
88 uint32 Current = Data;
89 uint32 Desired = Current & ~Mask;
90 if (Current == Desired || FPlatformAtomics::InterlockedCompareExchange((volatile int32*)&Data, (int32)Desired, (int32)Current) == (int32)Current)
91 {
92 return;
93 }
94 }
95 }
96 }
97 }*/
98 FORCEINLINE FBitReference& operator=(const FBitReference& Copy)
99 {
100 // As this is emulating a reference, assignment should not rebind,
101 // it should write to the referenced bit.
102 *this = (bool)Copy;
103 return *this;
104 }
105
106private:
107 uint32& Data;
108 uint32 Mask;
109};
110
111
112/** Used to read a bit in the array as a bool. */
114{
115public:
116
117 FORCEINLINE FConstBitReference(const uint32& InData,uint32 InMask)
118 : Data(InData)
119 , Mask(InMask)
120 {}
121
122 FORCEINLINE operator bool() const
123 {
124 return (Data & Mask) != 0;
125 }
126
127private:
128 const uint32& Data;
129 uint32 Mask;
130};
131
132
133/** Used to reference a bit in an unspecified bit array. */
135{
136public:
137 FORCEINLINE explicit FRelativeBitReference(int32 BitIndex)
138 : DWORDIndex(BitIndex >> NumBitsPerDWORDLogTwo)
139 , Mask(1 << (BitIndex & (NumBitsPerDWORD - 1)))
140 {
141 }
142
144 uint32 Mask;
145};
146
147
148/**
149 * A dynamically sized bit array.
150 * An array of Booleans. They stored in one bit/Boolean. There are iterators that efficiently iterate over only set bits.
151 */
152template<typename Allocator /*= FDefaultBitArrayAllocator*/>
153class TBitArray
154{
155 friend class FScriptBitArray;
156
157public:
158
159 template<typename>
161
162 template<typename,typename>
164
165 /**
166 * Minimal initialization constructor.
167 * @param Value - The value to initial the bits to.
168 * @param InNumBits - The initial number of bits in the array.
169 */
170 explicit TBitArray( const bool Value = false, const int32 InNumBits = 0 )
171 : NumBits(0)
172 , MaxBits(0)
173 {
174 Init(Value,InNumBits);
175 }
176
177 /**
178 * Move constructor.
179 */
180 FORCEINLINE TBitArray(TBitArray&& Other)
181 {
182 MoveOrCopy(*this, Other);
183 }
184
185 /**
186 * Copy constructor.
187 */
188 FORCEINLINE TBitArray(const TBitArray& Copy)
189 : NumBits(0)
190 , MaxBits(0)
191 {
192 *this = Copy;
193 }
194
195 /**
196 * Move assignment.
197 */
198 FORCEINLINE TBitArray& operator=(TBitArray&& Other)
199 {
200 if (this != &Other)
201 {
202 MoveOrCopy(*this, Other);
203 }
204
205 return *this;
206 }
207
208 /**
209 * Assignment operator.
210 */
211 FORCEINLINE TBitArray& operator=(const TBitArray& Copy)
212 {
213 // check for self assignment since we don't use swap() mechanic
214 if( this == &Copy )
215 {
216 return *this;
217 }
218
219 Empty(Copy.Num());
220 NumBits = MaxBits = Copy.NumBits;
221 if(NumBits)
222 {
223 const int32 NumDWORDs = FMath::DivideAndRoundUp(MaxBits, NumBitsPerDWORD);
224 Realloc(0);
225 FMemory::Memcpy(GetData(),Copy.GetData(),NumDWORDs * sizeof(uint32));
226 }
227 return *this;
228 }
229
230private:
231 template <typename BitArrayType>
232 static FORCEINLINE typename TEnableIf<TContainerTraits<BitArrayType>::MoveWillEmptyContainer>::Type MoveOrCopy(BitArrayType& ToArray, BitArrayType& FromArray)
233 {
234 ToArray.AllocatorInstance.MoveToEmpty(FromArray.AllocatorInstance);
235
236 ToArray .NumBits = FromArray.NumBits;
237 ToArray .MaxBits = FromArray.MaxBits;
238 FromArray.NumBits = 0;
239 FromArray.MaxBits = 0;
240 }
241
242 template <typename BitArrayType>
243 static FORCEINLINE typename TEnableIf<!TContainerTraits<BitArrayType>::MoveWillEmptyContainer>::Type MoveOrCopy(BitArrayType& ToArray, BitArrayType& FromArray)
244 {
245 ToArray = FromArray;
246 }
247
248public:
249
250 /**
251 * Adds a bit to the array with the given value.
252 * @return The index of the added bit.
253 */
254 int32 Add(const bool Value)
255 {
256 const int32 Index = NumBits;
257 const bool bReallocate = (NumBits + 1) > MaxBits;
258
259 NumBits++;
260
261 if(bReallocate)
262 {
263 // Allocate memory for the new bits.
264 const uint32 MaxDWORDs = AllocatorInstance.CalculateSlackGrow(
265 FMath::DivideAndRoundUp(NumBits, NumBitsPerDWORD),
266 FMath::DivideAndRoundUp(MaxBits, NumBitsPerDWORD),
267 sizeof(uint32)
268 );
269 MaxBits = MaxDWORDs * NumBitsPerDWORD;
270 Realloc(NumBits - 1);
271 }
272
273 (*this)[Index] = Value;
274
275 return Index;
276 }
277
278 /**
279 * Removes all bits from the array, potentially leaving space allocated for an expected number of bits about to be added.
280 * @param ExpectedNumBits - The expected number of bits about to be added.
281 */
282 void Empty(int32 ExpectedNumBits = 0)
283 {
284 NumBits = 0;
285
286 ExpectedNumBits = FMath::DivideAndRoundUp(ExpectedNumBits, NumBitsPerDWORD) * NumBitsPerDWORD;
287 // If the expected number of bits doesn't match the allocated number of bits, reallocate.
288 if(MaxBits != ExpectedNumBits)
289 {
290 MaxBits = ExpectedNumBits;
291 Realloc(0);
292 }
293 }
294
295 /**
296 * Removes all bits from the array retaining any space already allocated.
297 */
298 void Reset()
299 {
300 // We need this because iterators often use whole DWORDs when masking, which includes off-the-end elements
301 FMemory::Memset(GetData(), 0, FMath::DivideAndRoundUp(NumBits, NumBitsPerDWORD) * sizeof(uint32));
302
303 NumBits = 0;
304 }
305
306 /**
307 * Resets the array's contents.
308 * @param Value - The value to initial the bits to.
309 * @param NumBits - The number of bits in the array.
310 */
311 void Init(bool Value,int32 InNumBits)
312 {
313 Empty(InNumBits);
314 if(InNumBits)
315 {
316 NumBits = InNumBits;
317 FMemory::Memset(GetData(),Value ? 0xff : 0, FMath::DivideAndRoundUp(NumBits, NumBitsPerDWORD) * sizeof(uint32));
318 }
319 }
320
321 /**
322 * Sets or unsets a range of bits within the array.
323 * @param Index The index of the first bit to set.
324 * @param Num The number of bits to set.
325 * @param Value The value to set the bits to.
326 */
327 FORCENOINLINE void SetRange(int32 Index, int32 Num, bool Value)
328 {
329 check(Index >= 0 && Num >= 0 && Index + Num <= NumBits);
330
331 if (Num == 0)
332 {
333 return;
334 }
335
336 // Work out which uint32 index to set from, and how many
337 uint32 StartIndex = Index / 32;
338 uint32 Count = (Index + Num + 31) / 32 - StartIndex;
339
340 // Work out masks for the start/end of the sequence
341 uint32 StartMask = 0xFFFFFFFFu << (Index % 32);
342 uint32 EndMask = 0xFFFFFFFFu >> (32 - (Index + Num) % 32) % 32;
343
344 uint32* Data = GetData() + StartIndex;
345 if (Value)
346 {
347 if (Count == 1)
348 {
349 *Data |= StartMask & EndMask;
350 }
351 else
352 {
353 *Data++ |= StartMask;
354 Count -= 2;
355 while (Count != 0)
356 {
357 *Data++ = ~0;
358 --Count;
359 }
360 *Data |= EndMask;
361 }
362 }
363 else
364 {
365 if (Count == 1)
366 {
367 *Data &= ~(StartMask & EndMask);
368 }
369 else
370 {
371 *Data++ &= ~StartMask;
372 Count -= 2;
373 while (Count != 0)
374 {
375 *Data++ = 0;
376 --Count;
377 }
378 *Data &= ~EndMask;
379 }
380 }
381 }
382
383 /**
384 * Removes bits from the array.
385 * @param BaseIndex - The index of the first bit to remove.
386 * @param NumBitsToRemove - The number of consecutive bits to remove.
387 */
388 void RemoveAt(int32 BaseIndex,int32 NumBitsToRemove = 1)
389 {
390 check(BaseIndex >= 0 && NumBitsToRemove >= 0 && BaseIndex + NumBitsToRemove <= NumBits);
391
392 if (BaseIndex + NumBitsToRemove != NumBits)
393 {
394 // Until otherwise necessary, this is an obviously correct implementation rather than an efficient implementation.
395 FIterator WriteIt(*this);
396 for(FConstIterator ReadIt(*this);ReadIt;++ReadIt)
397 {
398 // If this bit isn't being removed, write it back to the array at its potentially new index.
399 if(ReadIt.GetIndex() < BaseIndex || ReadIt.GetIndex() >= BaseIndex + NumBitsToRemove)
400 {
401 if(WriteIt.GetIndex() != ReadIt.GetIndex())
402 {
403 WriteIt.GetValue() = (bool)ReadIt.GetValue();
404 }
405 ++WriteIt;
406 }
407 }
408 }
409 NumBits -= NumBitsToRemove;
410 }
411
412 /* Removes bits from the array by swapping them with bits at the end of the array.
413 * This is mainly implemented so that other code using TArray::RemoveSwap will have
414 * matching indices.
415 * @param BaseIndex - The index of the first bit to remove.
416 * @param NumBitsToRemove - The number of consecutive bits to remove.
417 */
418 void RemoveAtSwap( int32 BaseIndex, int32 NumBitsToRemove=1 )
419 {
420 check(BaseIndex >= 0 && NumBitsToRemove >= 0 && BaseIndex + NumBitsToRemove <= NumBits);
421 if( BaseIndex < NumBits - NumBitsToRemove )
422 {
423 // Copy bits from the end to the region we are removing
424 for( int32 Index=0;Index<NumBitsToRemove;Index++ )
425 {
426#if PLATFORM_MAC || PLATFORM_LINUX
427 // Clang compiler doesn't understand the short syntax, so let's be explicit
428 int32 FromIndex = NumBits - NumBitsToRemove + Index;
429 FConstBitReference From(GetData()[FromIndex / NumBitsPerDWORD],1 << (FromIndex & (NumBitsPerDWORD - 1)));
430
431 int32 ToIndex = BaseIndex + Index;
432 FBitReference To(GetData()[ToIndex / NumBitsPerDWORD],1 << (ToIndex & (NumBitsPerDWORD - 1)));
433
434 To = (bool)From;
435#else
436 (*this)[BaseIndex + Index] = (bool)(*this)[NumBits - NumBitsToRemove + Index];
437#endif
438 }
439 }
440
441 // Remove the bits from the end of the array.
442 NumBits -= NumBitsToRemove;
443 }
444
445
446 /**
447 * Helper function to return the amount of memory allocated by this container
448 * @return number of bytes allocated by this container
449 */
450 uint32 GetAllocatedSize( void ) const
451 {
452 return FMath::DivideAndRoundUp(MaxBits, NumBitsPerDWORD) * sizeof(uint32);
453 }
454
455 /**
456 * Finds the first true/false bit in the array, and returns the bit index.
457 * If there is none, INDEX_NONE is returned.
458 */
459 int32 Find(bool bValue) const
460 {
461 // Iterate over the array until we see a word with a matching bit
462 const uint32 Test = bValue ? 0u : (uint32)-1;
463
464 const uint32* RESTRICT DwordArray = GetData();
465 const int32 LocalNumBits = NumBits;
466 const int32 DwordCount = FMath::DivideAndRoundUp(LocalNumBits, NumBitsPerDWORD);
467 int32 DwordIndex = 0;
468 while (DwordIndex < DwordCount && DwordArray[DwordIndex] == Test)
469 {
470 ++DwordIndex;
471 }
472
473 if (DwordIndex < DwordCount)
474 {
475 // If we're looking for a false, then we flip the bits - then we only need to find the first one bit
476 const uint32 Bits = bValue ? (DwordArray[DwordIndex]) : ~(DwordArray[DwordIndex]);
477 const int32 LowestBitIndex = FMath::CountTrailingZeros(Bits) + (DwordIndex << NumBitsPerDWORDLogTwo);
478 if (LowestBitIndex < LocalNumBits)
479 {
480 return LowestBitIndex;
481 }
482 }
483
484 return INDEX_NONE;
485 }
486
487 FORCEINLINE bool Contains(bool bValue) const
488 {
489 return Find(bValue) != INDEX_NONE;
490 }
491
492 /**
493 * Finds the first zero bit in the array, sets it to true, and returns the bit index.
494 * If there is none, INDEX_NONE is returned.
495 */
497 {
498 // Iterate over the array until we see a word with a zero bit.
499 uint32* RESTRICT DwordArray = GetData();
500 const int32 LocalNumBits = NumBits;
501 const int32 DwordCount = FMath::DivideAndRoundUp(LocalNumBits, NumBitsPerDWORD);
502 int32 DwordIndex = 0;
503 while (DwordIndex < DwordCount && DwordArray[DwordIndex] == (uint32)-1)
504 {
505 ++DwordIndex;
506 }
507
508 if (DwordIndex < DwordCount)
509 {
510 // Flip the bits, then we only need to find the first one bit -- easy.
511 const uint32 Bits = ~(DwordArray[DwordIndex]);
512 const uint32 LowestBit = (Bits) & (-(int32)Bits);
513 const int32 LowestBitIndex = FMath::CountTrailingZeros(Bits) + (DwordIndex << NumBitsPerDWORDLogTwo);
514 if (LowestBitIndex < LocalNumBits)
515 {
516 DwordArray[DwordIndex] |= LowestBit;
517 return LowestBitIndex;
518 }
519 }
520
521 return INDEX_NONE;
522 }
523
524 // Accessors.
525 FORCEINLINE bool IsValidIndex(int32 InIndex) const
526 {
527 return InIndex >= 0 && InIndex < NumBits;
528 }
529
530 FORCEINLINE int32 Num() const { return NumBits; }
531 FORCEINLINE FBitReference operator[](int32 Index)
532 {
533 check(Index>=0 && Index<NumBits);
534 return FBitReference(
535 GetData()[Index / NumBitsPerDWORD],
536 1 << (Index & (NumBitsPerDWORD - 1))
537 );
538 }
539 FORCEINLINE const FConstBitReference operator[](int32 Index) const
540 {
541 check(Index>=0 && Index<NumBits);
542 return FConstBitReference(
543 GetData()[Index / NumBitsPerDWORD],
544 1 << (Index & (NumBitsPerDWORD - 1))
545 );
546 }
547 FORCEINLINE FBitReference AccessCorrespondingBit(const FRelativeBitReference& RelativeReference)
548 {
549 checkSlow(RelativeReference.Mask);
550 checkSlow(RelativeReference.DWORDIndex >= 0);
551 checkSlow(((uint32)RelativeReference.DWORDIndex + 1) * NumBitsPerDWORD - 1 - FMath::CountLeadingZeros(RelativeReference.Mask) < (uint32)NumBits);
552 return FBitReference(
553 GetData()[RelativeReference.DWORDIndex],
554 RelativeReference.Mask
555 );
556 }
557 FORCEINLINE const FConstBitReference AccessCorrespondingBit(const FRelativeBitReference& RelativeReference) const
558 {
559 checkSlow(RelativeReference.Mask);
560 checkSlow(RelativeReference.DWORDIndex >= 0);
561 checkSlow(((uint32)RelativeReference.DWORDIndex + 1) * NumBitsPerDWORD - 1 - FMath::CountLeadingZeros(RelativeReference.Mask) < (uint32)NumBits);
562 return FConstBitReference(
563 GetData()[RelativeReference.DWORDIndex],
564 RelativeReference.Mask
565 );
566 }
567
568 /** BitArray iterator. */
570 {
571 public:
572 FORCEINLINE FIterator(TBitArray<Allocator>& InArray,int32 StartIndex = 0)
574 , Array(InArray)
576 {
577 }
578 FORCEINLINE FIterator& operator++()
579 {
580 ++Index;
581 this->Mask <<= 1;
582 if(!this->Mask)
583 {
584 // Advance to the next uint32.
585 this->Mask = 1;
586 ++this->DWORDIndex;
587 }
588 return *this;
589 }
590 /** conversion to "bool" returning true if the iterator is valid. */
591 FORCEINLINE explicit operator bool() const
592 {
593 return Index < Array.Num();
594 }
595 /** inverse of the "bool" operator */
596 FORCEINLINE bool operator !() const
597 {
598 return !(bool)*this;
599 }
600
601 FORCEINLINE FBitReference GetValue() const { return FBitReference(Array.GetData()[this->DWORDIndex],this->Mask); }
602 FORCEINLINE int32 GetIndex() const { return Index; }
603 private:
604 TBitArray<Allocator>& Array;
605 int32 Index;
606 };
607
608 /** Const BitArray iterator. */
610 {
611 public:
612 FORCEINLINE FConstIterator(const TBitArray<Allocator>& InArray,int32 StartIndex = 0)
614 , Array(InArray)
616 {
617 }
618 FORCEINLINE FConstIterator& operator++()
619 {
620 ++Index;
621 this->Mask <<= 1;
622 if(!this->Mask)
623 {
624 // Advance to the next uint32.
625 this->Mask = 1;
626 ++this->DWORDIndex;
627 }
628 return *this;
629 }
630
631 /** conversion to "bool" returning true if the iterator is valid. */
632 FORCEINLINE explicit operator bool() const
633 {
634 return Index < Array.Num();
635 }
636 /** inverse of the "bool" operator */
637 FORCEINLINE bool operator !() const
638 {
639 return !(bool)*this;
640 }
641
642 FORCEINLINE FConstBitReference GetValue() const { return FConstBitReference(Array.GetData()[this->DWORDIndex],this->Mask); }
643 FORCEINLINE int32 GetIndex() const { return Index; }
644 private:
645 const TBitArray<Allocator>& Array;
646 int32 Index;
647 };
648
649 /** Const reverse iterator. */
651 {
652 public:
653 FORCEINLINE FConstReverseIterator(const TBitArray<Allocator>& InArray)
655 , Array(InArray)
656 , Index(InArray.Num() - 1)
657 {
658 }
660 {
661 --Index;
662 this->Mask >>= 1;
663 if(!this->Mask)
664 {
665 // Advance to the next uint32.
666 this->Mask = (1 << (NumBitsPerDWORD-1));
667 --this->DWORDIndex;
668 }
669 return *this;
670 }
671
672 /** conversion to "bool" returning true if the iterator is valid. */
673 FORCEINLINE explicit operator bool() const
674 {
675 return Index >= 0;
676 }
677 /** inverse of the "bool" operator */
678 FORCEINLINE bool operator !() const
679 {
680 return !(bool)*this;
681 }
682
683 FORCEINLINE FConstBitReference GetValue() const { return FConstBitReference(Array.GetData()[this->DWORDIndex],this->Mask); }
684 FORCEINLINE int32 GetIndex() const { return Index; }
685 private:
686 const TBitArray<Allocator>& Array;
687 int32 Index;
688 };
689
690 FORCEINLINE const uint32* GetData() const
691 {
692 return (uint32*)AllocatorInstance.GetAllocation();
693 }
694
695 FORCEINLINE uint32* GetData()
696 {
697 return (uint32*)AllocatorInstance.GetAllocation();
698 }
699
700private:
701 typedef typename Allocator::template ForElementType<uint32> AllocatorType;
702
704 int32 NumBits;
705 int32 MaxBits;
706
707 FORCENOINLINE void Realloc(int32 PreviousNumBits)
708 {
709 const int32 PreviousNumDWORDs = FMath::DivideAndRoundUp(PreviousNumBits, NumBitsPerDWORD);
710 const int32 MaxDWORDs = FMath::DivideAndRoundUp(MaxBits, NumBitsPerDWORD);
711
712 AllocatorInstance.ResizeAllocation(PreviousNumDWORDs,MaxDWORDs,sizeof(uint32));
713
714 if(MaxDWORDs)
715 {
716 // Reset the newly allocated slack DWORDs.
717 FMemory::Memzero((uint32*)AllocatorInstance.GetAllocation() + PreviousNumDWORDs,(MaxDWORDs - PreviousNumDWORDs) * sizeof(uint32));
718 }
719 }
720};
721
722
723template<typename Allocator>
724struct TContainerTraits<TBitArray<Allocator> > : public TContainerTraitsBase<TBitArray<Allocator> >
725{
726 enum { MoveWillEmptyContainer = TAllocatorTraits<Allocator>::SupportsMove };
727};
728
729
730/** An iterator which only iterates over set bits. */
731template<typename Allocator>
733{
734public:
735
736 /** Constructor. */
737 TConstSetBitIterator(const TBitArray<Allocator>& InArray,int32 StartIndex = 0)
739 , Array (InArray)
740 , UnvisitedBitMask ((~0U) << (StartIndex & (NumBitsPerDWORD - 1)))
743 {
744 check(StartIndex >= 0 && StartIndex <= Array.Num());
745 if (StartIndex != Array.Num())
746 {
748 }
749 }
750
751 /** Forwards iteration operator. */
753 {
754 // Mark the current bit as visited.
755 UnvisitedBitMask &= ~this->Mask;
756
757 // Find the first set bit that hasn't been visited yet.
759
760 return *this;
761 }
762
763 FORCEINLINE friend bool operator==(const TConstSetBitIterator& Lhs, const TConstSetBitIterator& Rhs)
764 {
765 // We only need to compare the bit index and the array... all the rest of the state is unobservable.
767 }
768
769 FORCEINLINE friend bool operator!=(const TConstSetBitIterator& Lhs, const TConstSetBitIterator& Rhs)
770 {
771 return !(Lhs == Rhs);
772 }
773
774 /** conversion to "bool" returning true if the iterator is valid. */
775 FORCEINLINE explicit operator bool() const
776 {
777 return CurrentBitIndex < Array.Num();
778 }
779 /** inverse of the "bool" operator */
780 FORCEINLINE bool operator !() const
781 {
782 return !(bool)*this;
783 }
784
785 /** Index accessor. */
786 FORCEINLINE int32 GetIndex() const
787 {
788 return CurrentBitIndex;
789 }
790
791private:
792
793 const TBitArray<Allocator>& Array;
794
798
799 /** Find the first set bit starting with the current bit, inclusive. */
801 {
802 const uint32* ArrayData = Array.GetData();
803 const int32 ArrayNum = Array.Num();
805
806 // Advance to the next non-zero uint32.
808 while (!RemainingBitMask)
809 {
810 ++this->DWORDIndex;
812 if (this->DWORDIndex > LastDWORDIndex)
813 {
814 // We've advanced past the end of the array.
816 return;
817 }
818
820 UnvisitedBitMask = ~0;
821 }
822
823 // This operation has the effect of unsetting the lowest set bit of BitMask
825
826 // This operation XORs the above mask with the original mask, which has the effect
827 // of returning only the bits which differ; specifically, the lowest bit
829
830 // If the Nth bit was the lowest set bit of BitMask, then this gives us N
832
833 // If we've accidentally iterated off the end of an array but still within the same DWORD
834 // then set the index to the last index of the array
836 {
838 }
839 }
840};
841
842
843/** An iterator which only iterates over the bits which are set in both of two bit-arrays. */
844template<typename Allocator,typename OtherAllocator>
846{
847public:
848
849 /** Constructor. */
851 const TBitArray<Allocator>& InArrayA,
852 const TBitArray<OtherAllocator>& InArrayB,
853 int32 StartIndex = 0
854 )
858 , UnvisitedBitMask((~0U) << (StartIndex & (NumBitsPerDWORD - 1)))
861 {
862 check(ArrayA.Num() == ArrayB.Num());
863
865 }
866
867 /** Advancement operator. */
869 {
870 checkSlow(ArrayA.Num() == ArrayB.Num());
871
872 // Mark the current bit as visited.
873 UnvisitedBitMask &= ~this->Mask;
874
875 // Find the first set bit that hasn't been visited yet.
877
878 return *this;
879
880 }
881
882 /** conversion to "bool" returning true if the iterator is valid. */
883 FORCEINLINE explicit operator bool() const
884 {
885 return CurrentBitIndex < ArrayA.Num();
886 }
887 /** inverse of the "bool" operator */
888 FORCEINLINE bool operator !() const
889 {
890 return !(bool)*this;
891 }
892
893 /** Index accessor. */
894 FORCEINLINE int32 GetIndex() const
895 {
896 return CurrentBitIndex;
897 }
898
899private:
900
901 const TBitArray<Allocator>& ArrayA;
902 const TBitArray<OtherAllocator>& ArrayB;
903
907
908 /** Find the first bit that is set in both arrays, starting with the current bit, inclusive. */
910 {
911 static const uint32 EmptyArrayData = 0;
914
915 // Advance to the next non-zero uint32.
917 while(!RemainingBitMask)
918 {
919 this->DWORDIndex++;
922 if(this->DWORDIndex <= LastDWORDIndex)
923 {
925 UnvisitedBitMask = ~0;
926 }
927 else
928 {
929 // We've advanced past the end of the array.
931 return;
932 }
933 };
934
935 // We can assume that RemainingBitMask!=0 here.
936 checkSlow(RemainingBitMask);
937
938 // This operation has the effect of unsetting the lowest set bit of BitMask
940
941 // This operation XORs the above mask with the original mask, which has the effect
942 // of returning only the bits which differ; specifically, the lowest bit
944
945 // If the Nth bit was the lowest set bit of BitMask, then this gives us N
947 }
948};
949
950
951// Untyped bit array type for accessing TBitArray data, like FScriptArray for TArray.
952// Must have the same memory representation as a TBitArray.
954{
955public:
956 /**
957 * Minimal initialization constructor.
958 * @param Value - The value to initial the bits to.
959 * @param InNumBits - The initial number of bits in the array.
960 */
962 : NumBits(0)
963 , MaxBits(0)
964 {
965 }
966
967 bool IsValidIndex(int32 Index) const
968 {
969 return Index >= 0 && Index < NumBits;
970 }
971
972 FBitReference operator[](int32 Index)
973 {
974 check(IsValidIndex(Index));
975 return FBitReference(GetData()[Index / NumBitsPerDWORD], 1 << (Index & (NumBitsPerDWORD - 1)));
976 }
977
978 FConstBitReference operator[](int32 Index) const
979 {
980 check(IsValidIndex(Index));
981 return FConstBitReference(GetData()[Index / NumBitsPerDWORD], 1 << (Index & (NumBitsPerDWORD - 1)));
982 }
983
984 void Empty(int32 Slack = 0)
985 {
986 NumBits = 0;
987
989 // If the expected number of bits doesn't match the allocated number of bits, reallocate.
990 if (MaxBits != Slack)
991 {
992 MaxBits = Slack;
993 Realloc(0);
994 }
995 }
996
997 int32 Add(const bool Value)
998 {
999 const int32 Index = NumBits;
1000 NumBits++;
1001 if (NumBits > MaxBits)
1002 {
1004 }
1005 (*this)[Index] = Value;
1006 return Index;
1007 }
1008
1009private:
1011
1013 int32 NumBits;
1014 int32 MaxBits;
1015
1016 // This function isn't intended to be called, just to be compiled to validate the correctness of the type.
1017 static void CheckConstraints()
1018 {
1019 typedef FScriptBitArray ScriptType;
1020 typedef TBitArray<> RealType;
1021
1022 // Check that the class footprint is the same
1023 static_assert(sizeof (ScriptType) == sizeof (RealType), "FScriptBitArray's size doesn't match TBitArray");
1024 static_assert(alignof(ScriptType) == alignof(RealType), "FScriptBitArray's alignment doesn't match TBitArray");
1025
1026 // Check member sizes
1027 static_assert(sizeof(DeclVal<ScriptType>().AllocatorInstance) == sizeof(DeclVal<RealType>().AllocatorInstance), "FScriptBitArray's AllocatorInstance member size does not match TBitArray's");
1028 static_assert(sizeof(DeclVal<ScriptType>().NumBits) == sizeof(DeclVal<RealType>().NumBits), "FScriptBitArray's NumBits member size does not match TBitArray's");
1029 static_assert(sizeof(DeclVal<ScriptType>().MaxBits) == sizeof(DeclVal<RealType>().MaxBits), "FScriptBitArray's MaxBits member size does not match TBitArray's");
1030
1031 // Check member offsets
1032 static_assert(STRUCT_OFFSET(ScriptType, AllocatorInstance) == STRUCT_OFFSET(RealType, AllocatorInstance), "FScriptBitArray's AllocatorInstance member offset does not match TBitArray's");
1033 static_assert(STRUCT_OFFSET(ScriptType, NumBits) == STRUCT_OFFSET(RealType, NumBits), "FScriptBitArray's NumBits member offset does not match TBitArray's");
1034 static_assert(STRUCT_OFFSET(ScriptType, MaxBits) == STRUCT_OFFSET(RealType, MaxBits), "FScriptBitArray's MaxBits member offset does not match TBitArray's");
1035 }
1036
1037 FORCEINLINE uint32* GetData()
1038 {
1039 return (uint32*)AllocatorInstance.GetAllocation();
1040 }
1041
1042 FORCEINLINE const uint32* GetData() const
1043 {
1044 return (const uint32*)AllocatorInstance.GetAllocation();
1045 }
1046
1047 FORCENOINLINE void Realloc(int32 PreviousNumBits)
1048 {
1049 const uint32 MaxDWORDs = AllocatorInstance.CalculateSlackReserve(
1051 sizeof(uint32)
1052 );
1053 MaxBits = MaxDWORDs * NumBitsPerDWORD;
1054 const uint32 PreviousNumDWORDs = FMath::DivideAndRoundUp(PreviousNumBits, NumBitsPerDWORD);
1055
1056 AllocatorInstance.ResizeAllocation(PreviousNumDWORDs, MaxDWORDs, sizeof(uint32));
1057
1058 if (MaxDWORDs && MaxDWORDs > PreviousNumDWORDs)
1059 {
1060 // Reset the newly allocated slack DWORDs.
1061 FMemory::Memzero((uint32*)AllocatorInstance.GetAllocation() + PreviousNumDWORDs, (MaxDWORDs - PreviousNumDWORDs) * sizeof(uint32));
1062 }
1063 }
1064 FORCENOINLINE void ReallocGrow(int32 PreviousNumBits)
1065 {
1066 // Allocate memory for the new bits.
1067 const uint32 MaxDWORDs = AllocatorInstance.CalculateSlackGrow(
1070 sizeof(uint32)
1071 );
1072 MaxBits = MaxDWORDs * NumBitsPerDWORD;
1073 const uint32 PreviousNumDWORDs = FMath::DivideAndRoundUp(PreviousNumBits, NumBitsPerDWORD);
1074 AllocatorInstance.ResizeAllocation(PreviousNumDWORDs, MaxDWORDs, sizeof(uint32));
1075 if (MaxDWORDs && MaxDWORDs > PreviousNumDWORDs)
1076 {
1077 // Reset the newly allocated slack DWORDs.
1078 FMemory::Memzero((uint32*)AllocatorInstance.GetAllocation() + PreviousNumDWORDs, (MaxDWORDs - PreviousNumDWORDs) * sizeof(uint32));
1079 }
1080 }
1081
1082public:
1083 // These should really be private, because they shouldn't be called, but there's a bunch of code
1084 // that needs to be fixed first.
1086 void operator=(const FScriptBitArray&) { check(false); }
1087};
1088
1089template <>
1091{
1092 enum { Value = true };
1093};
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 NumBitsPerDWORDLogTwo
#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 FBitReference(uint32 &InData, uint32 InMask)
Definition BitArray.h:45
FORCEINLINE FBitReference & operator=(const FBitReference &Copy)
Definition BitArray.h:98
uint32 Mask
Definition BitArray.h:108
FORCEINLINE void operator=(const bool NewValue)
Definition BitArray.h:54
FORCEINLINE operator bool() const
Definition BitArray.h:50
uint32 & Data
Definition BitArray.h:107
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
const uint32 & Data
Definition BitArray.h:128
FORCEINLINE operator bool() const
Definition BitArray.h:122
FORCEINLINE FConstBitReference(const uint32 &InData, uint32 InMask)
Definition BitArray.h:117
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 FRelativeBitReference(int32 BitIndex)
Definition BitArray.h:137
void operator=(const FScriptArray &)
int32 AddZeroed(int32 Count, int32 NumBytesPerElement)
Definition ScriptArray.h:75
void Insert(int32 Index, int32 Count, int32 NumBytesPerElement)
Definition ScriptArray.h:41
FORCEINLINE void * GetData()
Definition ScriptArray.h:18
FORCEINLINE int32 GetSlack() const
FORCENOINLINE void ResizeGrow(int32 OldNum, int32 NumBytesPerElement)
FORCEINLINE const void * GetData() const
Definition ScriptArray.h:22
void InsertZeroed(int32 Index, int32 Count, int32 NumBytesPerElement)
Definition ScriptArray.h:36
void Shrink(int32 NumBytesPerElement)
Definition ScriptArray.h:81
FORCEINLINE bool IsValidIndex(int32 i) const
Definition ScriptArray.h:26
void Empty(int32 Slack, int32 NumBytesPerElement)
Definition ScriptArray.h:90
FScriptArray(int32 InNum, int32 NumBytesPerElement)
FORCENOINLINE void ResizeInit(int32 NumBytesPerElement)
FScriptArray(const FScriptArray &)
FORCEINLINE int32 Num() const
Definition ScriptArray.h:30
FORCENOINLINE void ResizeTo(int32 NewMax, int32 NumBytesPerElement)
FORCENOINLINE void ResizeShrink(int32 NumBytesPerElement)
int32 Add(int32 Count, int32 NumBytesPerElement)
Definition ScriptArray.h:61
void Remove(int32 Index, int32 Count, int32 NumBytesPerElement)
FORCEINLINE uint32 * GetData()
Definition BitArray.h:1037
static void CheckConstraints()
Definition BitArray.h:1017
FDefaultBitArrayAllocator::ForElementType< uint32 > AllocatorType
Definition BitArray.h:1010
int32 Add(const bool Value)
Definition BitArray.h:997
void operator=(const FScriptBitArray &)
Definition BitArray.h:1086
FORCENOINLINE void Realloc(int32 PreviousNumBits)
Definition BitArray.h:1047
AllocatorType AllocatorInstance
Definition BitArray.h:1012
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
FORCEINLINE const uint32 * GetData() const
Definition BitArray.h:1042
FScriptBitArray(const FScriptBitArray &)
Definition BitArray.h:1085
FORCENOINLINE void ReallocGrow(int32 PreviousNumBits)
Definition BitArray.h:1064
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
FORCEINLINE FConstIterator & operator++()
Definition BitArray.h:618
const TBitArray< Allocator > & Array
Definition BitArray.h:645
FORCEINLINE FConstIterator(const TBitArray< Allocator > &InArray, int32 StartIndex=0)
Definition BitArray.h:612
FORCEINLINE int32 GetIndex() const
Definition BitArray.h:643
FORCEINLINE operator bool() const
Definition BitArray.h:632
FORCEINLINE bool operator!() const
Definition BitArray.h:637
FORCEINLINE FConstBitReference GetValue() const
Definition BitArray.h:642
const TBitArray< Allocator > & Array
Definition BitArray.h:686
FORCEINLINE operator bool() const
Definition BitArray.h:673
FORCEINLINE FConstReverseIterator(const TBitArray< Allocator > &InArray)
Definition BitArray.h:653
FORCEINLINE int32 GetIndex() const
Definition BitArray.h:684
FORCEINLINE FConstBitReference GetValue() const
Definition BitArray.h:683
FORCEINLINE bool operator!() const
Definition BitArray.h:678
FORCEINLINE FConstReverseIterator & operator++()
Definition BitArray.h:659
FORCEINLINE FIterator(TBitArray< Allocator > &InArray, int32 StartIndex=0)
Definition BitArray.h:572
FORCEINLINE FBitReference GetValue() const
Definition BitArray.h:601
FORCEINLINE FIterator & operator++()
Definition BitArray.h:578
FORCEINLINE int32 GetIndex() const
Definition BitArray.h:602
TBitArray< Allocator > & Array
Definition BitArray.h:604
FORCEINLINE operator bool() const
Definition BitArray.h:591
FORCEINLINE bool operator!() const
Definition BitArray.h:596
FORCEINLINE uint32 * GetData()
Definition BitArray.h:695
int32 Add(const bool Value)
Definition BitArray.h:254
FORCENOINLINE void SetRange(int32 Index, int32 Num, bool Value)
Definition BitArray.h:327
void Empty(int32 ExpectedNumBits=0)
Definition BitArray.h:282
FORCEINLINE FBitReference AccessCorrespondingBit(const FRelativeBitReference &RelativeReference)
Definition BitArray.h:547
int32 Find(bool bValue) const
Definition BitArray.h:459
FORCENOINLINE void Realloc(int32 PreviousNumBits)
Definition BitArray.h:707
friend class TConstSetBitIterator
Definition BitArray.h:160
FORCEINLINE int32 Num() const
Definition BitArray.h:530
uint32 GetAllocatedSize(void) const
Definition BitArray.h:450
FORCEINLINE TBitArray(TBitArray &&Other)
Definition BitArray.h:180
FORCEINLINE const FConstBitReference operator[](int32 Index) const
Definition BitArray.h:539
FORCEINLINE const FConstBitReference AccessCorrespondingBit(const FRelativeBitReference &RelativeReference) const
Definition BitArray.h:557
friend class TConstDualSetBitIterator
Definition BitArray.h:163
void Reset()
Definition BitArray.h:298
FORCEINLINE bool IsValidIndex(int32 InIndex) const
Definition BitArray.h:525
Allocator::template ForElementType< uint32 > AllocatorType
Definition BitArray.h:701
int32 NumBits
Definition BitArray.h:704
int32 MaxBits
Definition BitArray.h:705
FORCEINLINE TBitArray & operator=(const TBitArray &Copy)
Definition BitArray.h:211
void RemoveAtSwap(int32 BaseIndex, int32 NumBitsToRemove=1)
Definition BitArray.h:418
FORCEINLINE bool Contains(bool bValue) const
Definition BitArray.h:487
static FORCEINLINE TEnableIf< TContainerTraits< BitArrayType >::MoveWillEmptyContainer >::Type MoveOrCopy(BitArrayType &ToArray, BitArrayType &FromArray)
Definition BitArray.h:232
void Init(bool Value, int32 InNumBits)
Definition BitArray.h:311
int32 FindAndSetFirstZeroBit()
Definition BitArray.h:496
AllocatorType AllocatorInstance
Definition BitArray.h:703
static FORCEINLINE TEnableIf<!TContainerTraits< BitArrayType >::MoveWillEmptyContainer >::Type MoveOrCopy(BitArrayType &ToArray, BitArrayType &FromArray)
Definition BitArray.h:243
FORCEINLINE TBitArray & operator=(TBitArray &&Other)
Definition BitArray.h:198
FORCEINLINE TBitArray(const TBitArray &Copy)
Definition BitArray.h:188
FORCEINLINE FBitReference operator[](int32 Index)
Definition BitArray.h:531
void RemoveAt(int32 BaseIndex, int32 NumBitsToRemove=1)
Definition BitArray.h:388
TBitArray(const bool Value=false, const int32 InNumBits=0)
Definition BitArray.h:170
FORCEINLINE const uint32 * GetData() const
Definition BitArray.h:690
FORCEINLINE int32 GetIndex() const
Definition BitArray.h:894
FORCEINLINE TConstDualSetBitIterator & operator++()
Definition BitArray.h:868
const TBitArray< Allocator > & ArrayA
Definition BitArray.h:901
const TBitArray< OtherAllocator > & ArrayB
Definition BitArray.h:902
FORCEINLINE TConstDualSetBitIterator(const TBitArray< Allocator > &InArrayA, const TBitArray< OtherAllocator > &InArrayB, int32 StartIndex=0)
Definition BitArray.h:850
FORCEINLINE operator bool() const
Definition BitArray.h:883
FORCEINLINE bool operator!() const
Definition BitArray.h:888
FORCEINLINE friend bool operator==(const TConstSetBitIterator &Lhs, const TConstSetBitIterator &Rhs)
Definition BitArray.h:763
FORCEINLINE TConstSetBitIterator & operator++()
Definition BitArray.h:752
FORCEINLINE bool operator!() const
Definition BitArray.h:780
FORCEINLINE friend bool operator!=(const TConstSetBitIterator &Lhs, const TConstSetBitIterator &Rhs)
Definition BitArray.h:769
TConstSetBitIterator(const TBitArray< Allocator > &InArray, int32 StartIndex=0)
Definition BitArray.h:737
FORCEINLINE operator bool() const
Definition BitArray.h:775
FORCEINLINE int32 GetIndex() const
Definition BitArray.h:786
const TBitArray< Allocator > & Array
Definition BitArray.h:793
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()