Class fixed_list

Synopsis

#include <include/EASTL/fixed_list.h>

template <typename T, size_t nodeCount, bool bEnableOverflow = true, typename OverflowAllocator = EASTLAllocatorType>
class fixed_list : public list<T, fixed_node_allocator<sizeof(typename list<T>::node_type), 
							   nodeCount, EASTL_ALIGN_OF(T), 0, bEnableOverflow, OverflowAllocator> >

Description

fixed_list

fixed_list is a list which uses a single block of contiguous memory for its nodes. The purpose of this is to reduce memory usage relative to a conventional memory allocation system (with block headers), to increase allocation speed (often due to avoidance of mutex locks), to increase performance (due to better memory locality), and to decrease memory fragmentation due to the way that fixed block allocators work.

The primary downside to a fixed_list is that the number of nodes it can contain is fixed upon its declaration. If you want a fixed_list that doesn't have this limitation, then you probably don't want a fixed_list. You can always create your own memory allocator that works the way you want.

Template parameters: T The type of object the list holds. nodeCount The max number of objects to contain. bEnableOverflow Whether or not we should use the overflow heap if our object pool is exhausted. OverflowAllocator Overflow allocator, which is only used if bEnableOverflow == true. Defaults to the global heap.

Mentioned in

Inheritance

Ancestors: list

Methods

fixed_list overloadfixed_list
assign overloadIt turns out that the C++ std::list specifies a two argument version of assign that takes (int size, int value)
assign overloaditerators, so we need to do a template compiler trick to do the right thing.
can_overflow
full
get_overflow_allocator overloadOverflowAllocator.
has_overflowed
insert overload
max_size
operator= overload
reset_lose_memory
resize overload
set_overflow_allocator
size
swap

Source

Lines 65-121 in include/EASTL/fixed_list.h.

template <typename T, size_t nodeCount, bool bEnableOverflow = true, typename OverflowAllocator = EASTLAllocatorType>
class fixed_list : public list<T, fixed_node_allocator<sizeof(typename list<T>::node_type), 
                               nodeCount, EASTL_ALIGN_OF(T), 0, bEnableOverflow, OverflowAllocator> >
{
public:
    typedef fixed_node_allocator<sizeof(typename list<T>::node_type), nodeCount, 
                 EASTL_ALIGN_OF(T), 0, bEnableOverflow, OverflowAllocator> fixed_allocator_type;
    typedef OverflowAllocator                                              overflow_allocator_type;
    typedef list<T, fixed_allocator_type>                                  base_type;
    typedef fixed_list<T, nodeCount, bEnableOverflow, OverflowAllocator>   this_type;
    typedef typename base_type::size_type                                  size_type;
    typedef typename base_type::value_type                                 value_type;
    typedef typename base_type::node_type                                  node_type;
    typedef typename base_type::iterator                                   iterator;
    enum { kMaxSize = nodeCount };
    using base_type::assign;
    using base_type::resize;
    using base_type::insert;
    using base_type::size;
    using base_type::get_allocator;
protected:
    char mBuffer[fixed_allocator_type::kBufferSize]; // kBufferSize will take into account alignment requirements.
    using base_type::internalAllocator;
public:
    fixed_list();
    explicit fixed_list(const overflow_allocator_type& overflowAllocator); // Only applicable if bEnableOverflow is true.
    explicit fixed_list(size_type n);                                      // Currently we don't support overflowAllocator specification for other constructors, for simplicity.
    fixed_list(size_type n, const value_type& value);
    fixed_list(const this_type& x);
    fixed_list(this_type&& x);
    fixed_list(this_type&&, const overflow_allocator_type& overflowAllocator);
    fixed_list(std::initializer_list<value_type> ilist, const overflow_allocator_type& overflowAllocator = EASTL_FIXED_LIST_DEFAULT_ALLOCATOR);
    template <typename InputIterator>
    fixed_list(InputIterator first, InputIterator last);
    this_type& operator=(const this_type& x);
    this_type& operator=(std::initializer_list<value_type> ilist);
    this_type& operator=(this_type&& x);
    void      swap(this_type& x);
    void      reset_lose_memory();      // This is a unilateral reset to an initially empty state. No destructors are called, no deallocation occurs.
    size_type max_size() const;         // Returns the max fixed size, which is the user-supplied nodeCount parameter.
    bool      full() const;             // Returns true if the fixed space has been fully allocated. Note that if overflow is enabled, the container size can be greater than nodeCount but full() could return true because the fixed space may have a recently freed slot. 
    bool      has_overflowed() const;   // Returns true if the allocations spilled over into the overflow allocator. Meaningful only if overflow is enabled.
    bool      can_overflow() const;     // Returns the value of the bEnableOverflow template parameter.
    // OverflowAllocator
    const overflow_allocator_type& get_overflow_allocator() const EA_NOEXCEPT;
    overflow_allocator_type&       get_overflow_allocator() EA_NOEXCEPT;
    void                           set_overflow_allocator(const overflow_allocator_type& allocator);
}; // fixed_list





Add Discussion as Guest

Log in