duckdb::vector< DATA_TYPE, SAFE, ALLOCATOR > Class Template Reference

Inheritance diagram for duckdb::vector< DATA_TYPE, SAFE, ALLOCATOR >:

Collaboration diagram for duckdb::vector< DATA_TYPE, SAFE, ALLOCATOR >:

Public Types
using	original = std::vector< DATA_TYPE, ALLOCATOR >
using	value_type = typename original::value_type
using	allocator_type = typename original::allocator_type
using	size_type = typename original::size_type
using	difference_type = typename original::difference_type
using	reference = typename original::reference
using	const_reference = typename original::const_reference
using	pointer = typename original::pointer
using	const_pointer = typename original::const_pointer
using	iterator = typename original::iterator
using	const_iterator = typename original::const_iterator
using	reverse_iterator = typename original::reverse_iterator
using	const_reverse_iterator = typename original::const_reverse_iterator

Public Member Functions
void	clear () noexcept
	vector (original &&other)
template<bool INTERNAL_SAFE>
	vector (vector< DATA_TYPE, INTERNAL_SAFE > &&other)
template<bool INTERNAL_SAFE = false>
original::reference	get (typename original::size_type __n)
template<bool INTERNAL_SAFE = false>
original::const_reference	get (typename original::size_type __n) const
original::reference	operator[] (typename original::size_type __n)
original::const_reference	operator[] (typename original::size_type __n) const
original::reference	front ()
original::const_reference	front () const
original::reference	back ()
original::const_reference	back () const
void	unsafe_erase_at (idx_t idx)
void	erase_at (idx_t idx)

Static Private Member Functions
static void	AssertIndexInBounds (idx_t index, idx_t size)

Constructor & Destructor Documentation

vector() [1/2]

template<class DATA_TYPE , bool SAFE = true, class ALLOCATOR = std::allocator<DATA_TYPE>>

duckdb::vector< DATA_TYPE, SAFE, ALLOCATOR >::vector ( original &&  other )

inline

                             : original(std::move(other)) { // NOLINT: allow implicit conversion
    }

vector() [2/2]

template<class DATA_TYPE , bool SAFE = true, class ALLOCATOR = std::allocator<DATA_TYPE>>

template<bool INTERNAL_SAFE>

duckdb::vector< DATA_TYPE, SAFE, ALLOCATOR >::vector ( vector< DATA_TYPE, INTERNAL_SAFE > &&  other )

inline

                                                     : original(std::move(other)) { // NOLINT: allow implicit conversion
    }

Member Function Documentation

AssertIndexInBounds()

template<class DATA_TYPE , bool SAFE = true, class ALLOCATOR = std::allocator<DATA_TYPE>>

static void duckdb::vector< DATA_TYPE, SAFE, ALLOCATOR >::AssertIndexInBounds ( idx_t  index, idx_t  size  )

inlinestaticprivate

                                                                    {
#if defined(DUCKDB_DEBUG_NO_SAFETY) || defined(DUCKDB_CLANG_TIDY)
        return;
#else
        if (DUCKDB_UNLIKELY(index >= size)) {
            throw InternalException("Attempted to access index %ld within vector of size %ld", index, size);
        }
#endif
    }

clear()

template<class DATA_TYPE , bool SAFE = true, class ALLOCATOR = std::allocator<DATA_TYPE>>

void duckdb::vector< DATA_TYPE, SAFE, ALLOCATOR >::clear ( )

inlinenoexcept

                     { // NOLINT: hiding on purpose
        original::clear();
    }

get() [1/2]

template<class DATA_TYPE , bool SAFE = true, class ALLOCATOR = std::allocator<DATA_TYPE>>

template<bool INTERNAL_SAFE = false>

original::reference duckdb::vector< DATA_TYPE, SAFE, ALLOCATOR >::get ( typename original::size_type  __n )

inline

                                                                          { // NOLINT: hiding on purpose
        if (MemorySafety<INTERNAL_SAFE>::ENABLED) {
            AssertIndexInBounds(__n, original::size());
        }
        return original::operator[](__n);
    }

get() [2/2]

template<class DATA_TYPE , bool SAFE = true, class ALLOCATOR = std::allocator<DATA_TYPE>>

template<bool INTERNAL_SAFE = false>

original::const_reference duckdb::vector< DATA_TYPE, SAFE, ALLOCATOR >::get ( typename original::size_type  __n ) const

inline

                                                                                      { // NOLINT: hiding on purpose
        if (MemorySafety<INTERNAL_SAFE>::ENABLED) {
            AssertIndexInBounds(__n, original::size());
        }
        return original::operator[](__n);
    }

operator[]() [1/2]

template<class DATA_TYPE , bool SAFE = true, class ALLOCATOR = std::allocator<DATA_TYPE>>

original::reference duckdb::vector< DATA_TYPE, SAFE, ALLOCATOR >::operator[] ( typename original::size_type  __n )

inline

                                                                          { // NOLINT: hiding on purpose
        return get<SAFE>(__n);
    }

operator[]() [2/2]

template<class DATA_TYPE , bool SAFE = true, class ALLOCATOR = std::allocator<DATA_TYPE>>

original::const_reference duckdb::vector< DATA_TYPE, SAFE, ALLOCATOR >::operator[] ( typename original::size_type  __n ) const

inline

                                                                                      { // NOLINT: hiding on purpose
        return get<SAFE>(__n);
    }

front() [1/2]

template<class DATA_TYPE , bool SAFE = true, class ALLOCATOR = std::allocator<DATA_TYPE>>

original::reference duckdb::vector< DATA_TYPE, SAFE, ALLOCATOR >::front ( )

inline

                                       { // NOLINT: hiding on purpose
        return get<SAFE>(0);
    }

front() [2/2]

template<class DATA_TYPE , bool SAFE = true, class ALLOCATOR = std::allocator<DATA_TYPE>>

original::const_reference duckdb::vector< DATA_TYPE, SAFE, ALLOCATOR >::front ( ) const

inline

                                                   { // NOLINT: hiding on purpose
        return get<SAFE>(0);
    }

back() [1/2]

template<class DATA_TYPE , bool SAFE = true, class ALLOCATOR = std::allocator<DATA_TYPE>>

original::reference duckdb::vector< DATA_TYPE, SAFE, ALLOCATOR >::back ( )

inline

                                      { // NOLINT: hiding on purpose
        if (MemorySafety<SAFE>::ENABLED && original::empty()) {
            throw InternalException("'back' called on an empty vector!");
        }
        return get<SAFE>(original::size() - 1);
    }

back() [2/2]

template<class DATA_TYPE , bool SAFE = true, class ALLOCATOR = std::allocator<DATA_TYPE>>

original::const_reference duckdb::vector< DATA_TYPE, SAFE, ALLOCATOR >::back ( ) const

inline

                                                  { // NOLINT: hiding on purpose
        if (MemorySafety<SAFE>::ENABLED && original::empty()) {
            throw InternalException("'back' called on an empty vector!");
        }
        return get<SAFE>(original::size() - 1);
    }

unsafe_erase_at()

template<class DATA_TYPE , bool SAFE = true, class ALLOCATOR = std::allocator<DATA_TYPE>>

void duckdb::vector< DATA_TYPE, SAFE, ALLOCATOR >::unsafe_erase_at ( idx_t  idx )

inline

                                    { // NOLINT: not using camelcase on purpose here
        original::erase(original::begin() + static_cast<typename original::iterator::difference_type>(idx));
    }

erase_at()

template<class DATA_TYPE , bool SAFE = true, class ALLOCATOR = std::allocator<DATA_TYPE>>

void duckdb::vector< DATA_TYPE, SAFE, ALLOCATOR >::erase_at ( idx_t  idx )

inline

                             { // NOLINT: not using camelcase on purpose here
        if (MemorySafety<SAFE>::ENABLED && idx > original::size()) {
            throw InternalException("Can't remove offset %d from vector of size %d", idx, original::size());
        }
        unsafe_erase_at(idx);
    }

---

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

• external/duckdb/duckdb.hpp