Class StackAllocator

quantum/quantum_stack_allocator.h:34–97

/// @note This allocator is thread safe. For internal use only.
template <typename T, unsigned int SIZE>
struct StackAllocator : public ContiguousPoolManager<T>
{
    //------------------------------ Typedefs ----------------------------------
    typedef StackAllocator<T, SIZE> this_type;
    typedef T                       value_type;
    typedef value_type*             pointer;
    typedef const value_type*       const_pointer;
    typedef value_type&             reference;
    typedef const value_type&       const_reference;
    typedef size_t                  size_type;
    typedef uint16_t                index_type;
    typedef std::ptrdiff_t          difference_type;
    typedef std::false_type         propagate_on_container_move_assignment;
    typedef std::false_type         propagate_on_container_copy_assignment;
    typedef std::false_type         propagate_on_container_swap;
    typedef std::false_type         is_always_equal;
    typedef std::true_type          default_constructor;
    typedef std::aligned_storage<sizeof(value_type),
                                 alignof(value_type)> storage_type;
    typedef typename storage_type::type aligned_type;
    
    template <typename U>
    struct rebind
    {
        typedef StackAllocator<U,SIZE> other;
    };
    //------------------------------- Methods ----------------------------------
    StackAllocator() : ContiguousPoolManager<T>(_buffer, SIZE)
    {}
    
    StackAllocator(const this_type&) : StackAllocator()
    {}
    StackAllocator(this_type&&) : StackAllocator()
    {}
    StackAllocator& operator=(const this_type&) = delete;
    StackAllocator& operator=(this_type&&) = delete;
    
    // Rebound types
    template <typename U>
    StackAllocator(const StackAllocator<U,SIZE>&) : StackAllocator()
    {}
    template <typename U>
    StackAllocator(StackAllocator<U,SIZE>&&) : StackAllocator()
    {}
    template <typename U>
    StackAllocator& operator=(const StackAllocator<U,SIZE>&) = delete;
    template <typename U>
    StackAllocator& operator=(StackAllocator<U,SIZE>&&) = delete;
    
    static StackAllocator select_on_container_copy_construction(const StackAllocator&) {
        return StackAllocator();
    }
    bool operator==(const this_type& other) const {
        return this == &other;
    }
    bool operator!=(const this_type& other) const {
        return !operator==(other);
    }