duckdb::deque< DATA_TYPE, SAFE > Class Template Reference

Inheritance diagram for duckdb::deque< DATA_TYPE, SAFE >:

Collaboration diagram for duckdb::deque< DATA_TYPE, SAFE >:

Public Types
using	original = std::deque< DATA_TYPE, std::allocator< DATA_TYPE > >
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
	deque (original &&other)
template<bool INTERNAL_SAFE>
	deque (deque< 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

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

Constructor & Destructor Documentation

deque() [1/2]

template<class DATA_TYPE , bool SAFE = true>

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

inline

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

deque() [2/2]

template<class DATA_TYPE , bool SAFE = true>

template<bool INTERNAL_SAFE>

duckdb::deque< DATA_TYPE, SAFE >::deque ( deque< 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>

static void duckdb::deque< DATA_TYPE, SAFE >::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 deque of size %ld", index, size);
        }
#endif
    }

clear()

template<class DATA_TYPE , bool SAFE = true>

void duckdb::deque< DATA_TYPE, SAFE >::clear ( )

inlinenoexcept

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

get() [1/2]

template<class DATA_TYPE , bool SAFE = true>

template<bool INTERNAL_SAFE = false>

original::reference duckdb::deque< DATA_TYPE, SAFE >::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>

template<bool INTERNAL_SAFE = false>

original::const_reference duckdb::deque< DATA_TYPE, SAFE >::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>

original::reference duckdb::deque< DATA_TYPE, SAFE >::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>

original::const_reference duckdb::deque< DATA_TYPE, SAFE >::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>

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

inline

                                       { // NOLINT: hiding on purpose
        if (MemorySafety<SAFE>::ENABLED && original::empty()) {
            throw InternalException("'front' called on an empty deque!");
        }
        return get<SAFE>(0);
    }

front() [2/2]

template<class DATA_TYPE , bool SAFE = true>

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

inline

                                                   { // NOLINT: hiding on purpose
        if (MemorySafety<SAFE>::ENABLED && original::empty()) {
            throw InternalException("'front' called on an empty deque!");
        }
        return get<SAFE>(0);
    }

back() [1/2]

template<class DATA_TYPE , bool SAFE = true>

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

inline

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

back() [2/2]

template<class DATA_TYPE , bool SAFE = true>

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

inline

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

---

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

• external/duckdb/duckdb.hpp