duckdb::queue< DATA_TYPE, CONTAINER, SAFE > Class Template Reference

Inheritance diagram for duckdb::queue< DATA_TYPE, CONTAINER, SAFE >:

Collaboration diagram for duckdb::queue< DATA_TYPE, CONTAINER, SAFE >:

Public Types
using	original = std::queue< DATA_TYPE, CONTAINER >
using	container_type = typename original::container_type
using	value_type = typename original::value_type
using	size_type = typename container_type::size_type
using	reference = typename container_type::reference
using	const_reference = typename container_type::const_reference

Public Member Functions
	queue (original &&other)
template<bool INTERNAL_SAFE>
	queue (queue< DATA_TYPE, CONTAINER, INTERNAL_SAFE > &&other)
void	clear () noexcept
reference	front ()
const_reference	front () const
reference	back ()
const_reference	back () const
void	pop ()

Constructor & Destructor Documentation

queue() [1/2]

template<class DATA_TYPE , class CONTAINER = std::deque<DATA_TYPE>, bool SAFE = true>

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

inline

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

queue() [2/2]

template<class DATA_TYPE , class CONTAINER = std::deque<DATA_TYPE>, bool SAFE = true>

template<bool INTERNAL_SAFE>

duckdb::queue< DATA_TYPE, CONTAINER, SAFE >::queue ( queue< DATA_TYPE, CONTAINER, INTERNAL_SAFE > &&  other )

inline

                                                              : original(std::move(other)) { // NOLINT
    }

Member Function Documentation

clear()

template<class DATA_TYPE , class CONTAINER = std::deque<DATA_TYPE>, bool SAFE = true>

void duckdb::queue< DATA_TYPE, CONTAINER, SAFE >::clear ( )

inlinenoexcept

                                 {
        original::c.clear();
    }

front() [1/2]

template<class DATA_TYPE , class CONTAINER = std::deque<DATA_TYPE>, bool SAFE = true>

reference duckdb::queue< DATA_TYPE, CONTAINER, SAFE >::front ( )

inline

                      {
        if (MemorySafety<SAFE>::ENABLED && original::empty()) {
            throw InternalException("'front' called on an empty queue!");
        }
        return original::front();
    }

front() [2/2]

template<class DATA_TYPE , class CONTAINER = std::deque<DATA_TYPE>, bool SAFE = true>

const_reference duckdb::queue< DATA_TYPE, CONTAINER, SAFE >::front ( ) const

inline

                                  {
        if (MemorySafety<SAFE>::ENABLED && original::empty()) {
            throw InternalException("'front' called on an empty queue!");
        }
        return original::front();
    }

back() [1/2]

template<class DATA_TYPE , class CONTAINER = std::deque<DATA_TYPE>, bool SAFE = true>

reference duckdb::queue< DATA_TYPE, CONTAINER, SAFE >::back ( )

inline

                     {
        if (MemorySafety<SAFE>::ENABLED && original::empty()) {
            throw InternalException("'back' called on an empty queue!");
        }
        return original::back();
    }

back() [2/2]

template<class DATA_TYPE , class CONTAINER = std::deque<DATA_TYPE>, bool SAFE = true>

const_reference duckdb::queue< DATA_TYPE, CONTAINER, SAFE >::back ( ) const

inline

                                 {
        if (MemorySafety<SAFE>::ENABLED && original::empty()) {
            throw InternalException("'back' called on an empty queue!");
        }
        return original::back();
    }

pop()

template<class DATA_TYPE , class CONTAINER = std::deque<DATA_TYPE>, bool SAFE = true>

void duckdb::queue< DATA_TYPE, CONTAINER, SAFE >::pop ( )

inline

               {
        if (MemorySafety<SAFE>::ENABLED && original::empty()) {
            throw InternalException("'pop' called on an empty queue!");
        }
        original::pop();
    }

---

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

• external/duckdb/duckdb.hpp