FSmallListSet

[FSmallListSet](API\Runtime\GeometryCore\Util\FSmallListSet) stores a set of short integer-valued variable-size lists.

API > API/Runtime > API/Runtime/GeometryCore > API/Runtime/GeometryCore/Util

References

   
Module GeometryCore
Header /Engine/Source/Runtime/GeometryCore/Public/Util/SmallListSet.h
Include #include "Util/SmallListSet.h"

Syntax

class FSmallListSet

Remarks

FSmallListSet stores a set of short integer-valued variable-size lists. The lists are encoded into a few large TDynamicVector buffers, with internal pooling, so adding/removing lists usually does not involve any new or delete ops.

The lists are stored in two parts. The first N elements are stored in a linear subset of a TDynamicVector. If the list spills past these N elements, the extra elements are stored in a linked list (which is also stored in a flat array).

Each list stores its count, so list-size operations are constant time. All the internal "pointers" are 32-bit.

Variables

  Type Name Description
Protected variable int32 AllocatedCount Number of allocated lists
Protected variable TDynamicVector< int32 > FreeBlocks List of free blocks as indices/offsets into ListBlocks
Protected variable int32 FreeHeadIndex Index of first free element in linked_store
Protected variable TDynamicVector< int32 > LinkedListElements Flat buffer used to store linked-list "spill" elements each element is [value, next_ptr]
Protected variable TDynamicVector< int32 > ListBlocks Flat buffer used to store per-list linear-memory blocks.
Protected variable TDynamicVector< int32 > ListHeads Mapping from list index to offset into ListBlocks that contains list data

Functions

  Type Name Description
Protected function void

AddFreeLink ( int32 ptr
)

 Push a link-node onto the free list
Public function void

AllocateAt ( int32 ListIndex
)

 Create a list at the given ListIndex
Protected function int32 Grab a block from the free list, or allocate a new one
Public function Const MappedValueIterator

BeginMappedValues ( int32 ListIndex,
const TFunction< int32(int32)>& MapFunc
)

  
Public function Const ValueIterator

BeginValues ( int32 ListIndex
)

  
Public function void

Clear ( int32 ListIndex
)

 Remove all elements from the list at ListIndex
Public function void

Compact ( int32 MaxListIndex
)

 Clearing any lists at or after MaxListIndex and compact the ListBlocks and LinkedListElements so there are no free blocks or free linked list elements
Public function Const bool

Contains ( int32 ListIndex,
int32 Value
)

 Search for the given Value in list at ListIndex
Public function Const MappedValueIterator

EndMappedValues ( int32 ListIndex,
const TFunction< int32(int32)>& MapFunc
)

  
Public function Const ValueIterator

EndValues ( int32 ListIndex
)

  
Public function Const void

Enumerate ( int32 ListIndex,
const IntToVoidFunc& ApplyFunc
)

 Call ApplyFunc on each element of the list at ListIndex
Public function Const bool

EnumerateEarlyOut ( int32 ListIndex,
TFunctionRef< bool(int32)> ApplyFunc
)

 Call ApplyFunc on each element of the list at ListIndex, until ApplyFunc returns false
Public function Const int32

Find ( int32 ListIndex,
const IntToBoolFunc& PredicateFunc,
int32 InvalidValue
)

 Search the list at ListIndex for a value where PredicateFunc(value) returns true
Public function Const int32

First ( int32 ListIndex
)

 Does not check for zero-size-list!
Public function Const int32

GetCount ( int32 ListIndex
)

  
Public function void

Insert ( int32 ListIndex,
int32 Value
)

 Insert Value into list at ListIndex
Public function Const bool

IsAllocated ( int32 ListIndex
)

  
Public function Const MappedValueEnumerable

MappedValues ( int32 ListIndex,
TFunction< int32(int32)> MapFunc
)

  
Public function Const FString  
Public function void

Move ( int32 FromIndex,
int32 ToIndex
)

 Move list at FromIndex to ToIndex
Public function bool

Remove ( int32 ListIndex,
int32 Value
)

 Remove Value from the list at ListIndex
Protected function bool

RemoveFromLinkedList ( int32 block_ptr,
int32 val
)

 Remove val from the linked-list attached to block_ptr
Public function bool

Replace ( int32 ListIndex,
const IntToBoolFunc& PredicateFunc,
int32 NewValue
)

 Search the list at ListIndex for a value where PredicateFunc(value) returns true, and replace it with NewValue
Public function void

Reset ()

 Reset to initial state
Public function void

Resize ( int32 NewSize
)

 Set new number of lists
Public function void

Serialize ( FArchive& Ar,
bool bCompactData,
bool bUseCompression
)

 Serialize FSmallListSet to an archive.
Public function Const size_t

Size ()

  
Public function Const ValueEnumerable

Values ( int32 ListIndex
)

  

Classes

  Type Name Description
Public class BaseValueIterator BaseValueIterator is a base class for ValueIterator and MappedValueIterator below.  
Public class MappedValueEnumerable MappedValueEnumerable is an object that provides begin/end semantics for a small list, suitable for use with a range-based for loop  
Public class MappedValueIterator MappedValueIterator iterates over the values of a small list An optional mapping function can be provided which will then be applied to the values returned by the * operator  
Public class ValueEnumerable ValueEnumerable is an object that provides begin/end semantics for a small list, suitable for use with a range-based for loop  
Public class ValueIterator ValueIterator iterates over the values of a small list  

Constants

Name Description
BLOCK_LIST_OFFSET Offset from start of linear-memory portion of list that contains pointer to head of variable-length linked list
BLOCKSIZE Size of initial linear-memory portion of lists
NullValue This value is used to indicate Null in internal pointers

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page