duckdb::ArenaLinkedList< T > Class Template Reference

Collaboration diagram for duckdb::ArenaLinkedList< T >:

Classes
struct	ConstIterator
struct	Iterator
struct	Node

Public Member Functions
	ArenaLinkedList (ArenaAllocator &arena)
	ArenaLinkedList (const ArenaLinkedList &)=delete
ArenaLinkedList &	operator= (const ArenaLinkedList &)=delete
	ArenaLinkedList (ArenaLinkedList &&other) noexcept
ArenaLinkedList &	operator= (ArenaLinkedList &&other) noexcept
bool	empty () const
idx_t	size () const
void	push_back (const T &value)
template<class... ARGS>
void	emplace_back (ARGS &&... args)
T &	operator[] (const idx_t index)
	FIXME: eventually remove this.
const T &	operator[] (const idx_t index) const
	FIXME: eventually remove this.
Iterator	begin ()
Iterator	end ()
ConstIterator	begin () const
ConstIterator	end () const

Private Attributes
ArenaAllocator &	arena
Node *	head = nullptr
Node *	tail = nullptr
idx_t	_size = 0

Constructor & Destructor Documentation

ArenaLinkedList() [1/2]

template<class T >

duckdb::ArenaLinkedList< T >::ArenaLinkedList ( ArenaAllocator &  arena )

inlineexplicit

                                                    : arena(arena) {
    }

ArenaLinkedList() [2/2]

template<class T >

duckdb::ArenaLinkedList< T >::ArenaLinkedList ( ArenaLinkedList< T > &&  other )

inlinenoexcept

                                                      : head(other.head), tail(other.tail) {
        other.head = nullptr;
        other.tail = nullptr;
    }

Member Function Documentation

operator=()

template<class T >

ArenaLinkedList & duckdb::ArenaLinkedList< T >::operator= ( ArenaLinkedList< T > &&  other )

inlinenoexcept

                                                                 {
        if (this != &other) {
            head = other.head;
            tail = other.tail;
            other.head = nullptr;
            other.tail = nullptr;
        }
        return *this;
    }

empty()

template<class T >

bool duckdb::ArenaLinkedList< T >::empty ( ) const

inline

                       {
        return head == nullptr;
    }

size()

template<class T >

idx_t duckdb::ArenaLinkedList< T >::size ( ) const

inline

                       {
        return _size;
    }

push_back()

template<class T >

void duckdb::ArenaLinkedList< T >::push_back ( const T &  value )

inline

                                   {
        auto node = arena.Make<Node>(value);
        auto ptr = head ? &tail->next : &head;
        *ptr = node;
        tail = node;
        _size++;
    }

emplace_back()

template<class T >

template<class... ARGS>

void duckdb::ArenaLinkedList< T >::emplace_back ( ARGS &&...  args )

inline

                                       {
        auto node = arena.Make<Node>(std::forward<ARGS>(args)...);
        auto ptr = head ? &tail->next : &head;
        *ptr = node;
        tail = node;
        _size++;
    }

operator[]() [1/2]

template<class T >

T & duckdb::ArenaLinkedList< T >::operator[] ( const idx_t  index )

inline

FIXME: eventually remove this.

                                     {
        idx_t i = 0;
        for (auto &elem : *this) {
            if (i == index) {
                return elem;
            }
            i++;
        }
        throw InternalException("index out of bounds in ArenaLinkedList");
    }

operator[]() [2/2]

template<class T >

const T & duckdb::ArenaLinkedList< T >::operator[] ( const idx_t  index ) const

inline

FIXME: eventually remove this.

                                                 {
        idx_t i = 0;
        for (const auto &elem : *this) {
            if (i == index) {
                return elem;
            }
            i++;
        }
        throw InternalException("index out of bounds in ArenaLinkedList");
    }

begin() [1/2]

template<class T >

ArenaLinkedList< T >::Iterator duckdb::ArenaLinkedList< T >::begin

(

)

                                                              {
    return Iterator(head);
}

end() [1/2]

template<class T >

ArenaLinkedList< T >::Iterator duckdb::ArenaLinkedList< T >::end

(

)

                                                            {
    return Iterator(nullptr);
}

begin() [2/2]

template<class T >

ArenaLinkedList< T >::ConstIterator duckdb::ArenaLinkedList< T >::begin

(

)

const

                                                                         {
    return ConstIterator(head);
}

end() [2/2]

template<class T >

ArenaLinkedList< T >::ConstIterator duckdb::ArenaLinkedList< T >::end

(

)

const

                                                                       {
    return ConstIterator(nullptr);
}

---

The documentation for this class was generated from the following file:

• external/duckdb/duckdb.hpp