Class fixed_vector

Synopsis

#include <include/EASTL/fixed_vector.h>

template <typename T, size_t nodeCount, bool bEnableOverflow = true, typename OverflowAllocator = typename eastl::type_select<bEnableOverflow, EASTLAllocatorType, EASTLDummyAllocatorType>::type>
class fixed_vector : public vector<T, fixed_vector_allocator<sizeof(T), nodeCount, EASTL_ALIGN_OF(T), 0, bEnableOverflow, OverflowAllocator> >

Description

fixed_vector

A fixed_vector with bEnableOverflow == true is identical to a regular vector in terms of its behavior. All the expectations of regular vector apply to it and no additional expectations come from it. When bEnableOverflow is false, fixed_vector behaves like regular vector with the exception that its capacity can never increase. All operations you do on such a fixed_vector which require a capacity increase will result in undefined behavior or an C++ allocation exception, depending on the configuration of EASTL.

Template parameters: T The type of object the vector 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.

Note: The nodeCount value must be at least 1.

Example usage: fixed_vector<Widget, 128, true> fixedVector);

fixedVector.push_back(Widget()); fixedVector.resize(200); fixedVector.clear();

Mentioned in

Inheritance

Ancestors: vector

Methods

fixed_vector overloadfixed_vector
assign overload
can_overflow
clear overload
DoAssign overload
DoAssignFromIterator overload
DoPushBack overloadThis template specializes for overflow NOT enabled
DoPushBackMove overloadThis template specializes for overflow NOT enabled
DoPushBackUninitialized overload
full
get_overflow_allocator overloadOverflowAllocator.
has_overflowed
max_size
operator= overload
push_back overload
push_back_uninitialized
reset_lose_memory
resize overload
set_capacity
set_overflow_allocator
size
swap

Source

Lines 70-155 in include/EASTL/fixed_vector.h.

template <typename T, size_t nodeCount, bool bEnableOverflow = true, typename OverflowAllocator = typename eastl::type_select<bEnableOverflow, EASTLAllocatorType, EASTLDummyAllocatorType>::type>
class fixed_vector : public vector<T, fixed_vector_allocator<sizeof(T), nodeCount, EASTL_ALIGN_OF(T), 0, bEnableOverflow, OverflowAllocator> >
{
public:
    typedef fixed_vector_allocator<sizeof(T), nodeCount, EASTL_ALIGN_OF(T), 
                        0, bEnableOverflow, OverflowAllocator>              fixed_allocator_type;
    typedef OverflowAllocator                                               overflow_allocator_type;
    typedef vector<T, fixed_allocator_type>                                 base_type;
    typedef fixed_vector<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::reference                                   reference;
    typedef typename base_type::iterator                                    iterator;
    typedef typename base_type::const_iterator                              const_iterator;
    typedef aligned_buffer<nodeCount * sizeof(T), EASTL_ALIGN_OF(T)>        aligned_buffer_type;
    enum { kMaxSize = nodeCount };
    using base_type::get_allocator;
    using base_type::mpBegin;
    using base_type::mpEnd;
    using base_type::internalCapacityPtr;
    using base_type::resize;
    using base_type::clear;
    using base_type::size;
    using base_type::assign;
    using base_type::npos;
    using base_type::DoAllocate;
    using base_type::DoFree;
    using base_type::DoAssign;
    using base_type::DoAssignFromIterator;
protected:
    aligned_buffer_type mBuffer;
public:
    fixed_vector();
    explicit fixed_vector(const overflow_allocator_type& overflowAllocator); // Only applicable if bEnableOverflow is true.
    explicit fixed_vector(size_type n);                                      // Currently we don't support overflowAllocator specification for other constructors, for simplicity.
    fixed_vector(size_type n, const value_type& value);
    fixed_vector(const this_type& x);
    fixed_vector(this_type&& x);
    fixed_vector(this_type&& x, const overflow_allocator_type& overflowAllocator);
    fixed_vector(std::initializer_list<T> ilist, const overflow_allocator_type& overflowAllocator = EASTL_FIXED_VECTOR_DEFAULT_ALLOCATOR);
    template <typename InputIterator>
    fixed_vector(InputIterator first, InputIterator last);
    this_type& operator=(const this_type& x);
    this_type& operator=(std::initializer_list<T> ilist);
    this_type& operator=(this_type&& x);
    void swap(this_type& x);
    void      set_capacity(size_type n);
    void      clear(bool freeOverflow);
    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.
    void*     push_back_uninitialized();
    void      push_back(const value_type& value);   // We implement push_back here because we have a specialization that's 
    reference push_back();                          // smaller for the case of overflow being disabled.
    void      push_back(value_type&& value);
    // 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);
protected:
    void*     DoPushBackUninitialized(true_type);
    void*     DoPushBackUninitialized(false_type);
    void      DoPushBack(true_type, const value_type& value);
    void      DoPushBack(false_type, const value_type& value);
    void      DoPushBackMove(true_type, value_type&& value);
    void      DoPushBackMove(false_type, value_type&& value);
    reference DoPushBack(false_type);
    reference DoPushBack(true_type);
}; // fixed_vector





Add Discussion as Guest

Log in