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

array_ptr is a non-owning (optionally) bounds-checked pointer to an array More...

#include <duckdb.hpp>

Public Types
using	iterator_type = array_ptr_iterator< DATA_TYPE >

Public Member Functions
	array_ptr (DATA_TYPE *ptr_p, idx_t count)
	array_ptr (DATA_TYPE &ref)
const DATA_TYPE &	operator[] (idx_t idx) const
DATA_TYPE &	operator[] (idx_t idx)
idx_t	size () const
array_ptr_iterator< DATA_TYPE >	begin ()
array_ptr_iterator< DATA_TYPE >	begin () const
array_ptr_iterator< DATA_TYPE >	cbegin ()
array_ptr_iterator< DATA_TYPE >	end ()
array_ptr_iterator< DATA_TYPE >	end () const
array_ptr_iterator< DATA_TYPE >	cend ()

Static Private Member Functions
static void	AssertNotNull (const bool null)
static void	AssertIndexInBounds (idx_t index, idx_t size)

Private Attributes
DATA_TYPE *	ptr
idx_t	count

Detailed Description

template<class DATA_TYPE, bool SAFE = true>
class duckdb::array_ptr< DATA_TYPE, SAFE >

array_ptr is a non-owning (optionally) bounds-checked pointer to an array

Constructor & Destructor Documentation

array_ptr() [1/2]

template<class DATA_TYPE , bool SAFE = true>

duckdb::array_ptr< DATA_TYPE, SAFE >::array_ptr ( DATA_TYPE *  ptr_p, idx_t  count  )

inline

                                             : ptr(ptr_p), count(count) {
        if (MemorySafety<SAFE>::ENABLED) {
            AssertNotNull(!ptr);
        }
    }

array_ptr() [2/2]

template<class DATA_TYPE , bool SAFE = true>

duckdb::array_ptr< DATA_TYPE, SAFE >::array_ptr ( DATA_TYPE &  ref )

inlineexplicit

                                       : ptr(&ref), count(1) {
    }

Member Function Documentation

AssertNotNull()

template<class DATA_TYPE , bool SAFE = true>

static void duckdb::array_ptr< DATA_TYPE, SAFE >::AssertNotNull ( const bool  null )

inlinestaticprivate

                                                      {
#if defined(DUCKDB_DEBUG_NO_SAFETY) || defined(DUCKDB_CLANG_TIDY)
        return;
#else
        if (DUCKDB_UNLIKELY(null)) {
            throw duckdb::InternalException("Attempted to construct an array_ptr from a NULL pointer");
        }
#endif
    }

AssertIndexInBounds()

template<class DATA_TYPE , bool SAFE = true>

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

operator[]() [1/2]

template<class DATA_TYPE , bool SAFE = true>

const DATA_TYPE & duckdb::array_ptr< DATA_TYPE, SAFE >::operator[] ( idx_t  idx ) const

inline

                                                 {
        if (MemorySafety<SAFE>::ENABLED) {
            AssertIndexInBounds(idx, count);
        }
        return ptr[idx];
    }

operator[]() [2/2]

template<class DATA_TYPE , bool SAFE = true>

DATA_TYPE & duckdb::array_ptr< DATA_TYPE, SAFE >::operator[] ( idx_t  idx )

inline

                                     {
        if (MemorySafety<SAFE>::ENABLED) {
            AssertIndexInBounds(idx, count);
        }
        return ptr[idx];
    }

size()

template<class DATA_TYPE , bool SAFE = true>

idx_t duckdb::array_ptr< DATA_TYPE, SAFE >::size ( ) const

inline

                       { // NOLINT: match std naming style
        return count;
    }

begin() [1/2]

template<class DATA_TYPE , bool SAFE = true>

array_ptr_iterator< DATA_TYPE > duckdb::array_ptr< DATA_TYPE, SAFE >::begin ( )

inline

                                          { // NOLINT: match std naming style
        return array_ptr_iterator<DATA_TYPE>(ptr, 0, count);
    }

begin() [2/2]

template<class DATA_TYPE , bool SAFE = true>

array_ptr_iterator< DATA_TYPE > duckdb::array_ptr< DATA_TYPE, SAFE >::begin ( ) const

inline

                                                { // NOLINT: match std naming style
        return array_ptr_iterator<const DATA_TYPE>(ptr, 0, count);
    }

cbegin()

template<class DATA_TYPE , bool SAFE = true>

array_ptr_iterator< DATA_TYPE > duckdb::array_ptr< DATA_TYPE, SAFE >::cbegin ( )

inline

                                           { // NOLINT: match std naming style
        return array_ptr_iterator<const DATA_TYPE>(ptr, 0, count);
    }

end() [1/2]

template<class DATA_TYPE , bool SAFE = true>

array_ptr_iterator< DATA_TYPE > duckdb::array_ptr< DATA_TYPE, SAFE >::end ( )

inline

                                        { // NOLINT: match std naming style
        return array_ptr_iterator<DATA_TYPE>(ptr, count, count);
    }

end() [2/2]

template<class DATA_TYPE , bool SAFE = true>

array_ptr_iterator< DATA_TYPE > duckdb::array_ptr< DATA_TYPE, SAFE >::end ( ) const

inline

                                              { // NOLINT: match std naming style
        return array_ptr_iterator<const DATA_TYPE>(ptr, count, count);
    }

cend()

template<class DATA_TYPE , bool SAFE = true>

array_ptr_iterator< DATA_TYPE > duckdb::array_ptr< DATA_TYPE, SAFE >::cend ( )

inline

                                         { // NOLINT: match std naming style
        return array_ptr_iterator<const DATA_TYPE>(ptr, count, count);
    }

---

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

• external/duckdb/duckdb.hpp