duckdb::fixed_size_map_t< T > Class Template Reference

Alternative to perfect_map_t when min/max keys are integral, small, and known. More...

#include <duckdb.hpp>

Collaboration diagram for duckdb::fixed_size_map_t< T >:

Public Types
using	key_type = idx_t
using	mapped_type = T
using	occupied_mask = TemplatedValidityMask< uint8_t >
using	iterator = fixed_size_map_iterator< mapped_type, false >
using	const_iterator = fixed_size_map_iterator< mapped_type, true >

Public Member Functions
	fixed_size_map_t (idx_t capacity_p=0)
idx_t	size () const
void	resize (idx_t capacity_p)
void	clear ()
mapped_type &	operator[] (const key_type &key)
const mapped_type &	operator[] (const key_type &key) const
iterator	begin ()
const_iterator	begin () const
iterator	end ()
const_iterator	end () const
iterator	find (const key_type &index)
const_iterator	find (const key_type &index) const

Private Attributes
idx_t	capacity
idx_t	count
occupied_mask	occupied
unsafe_unique_array< mapped_type >	values

Friends
class	fixed_size_map_iterator< T, false >
class	fixed_size_map_iterator< T, true >

Detailed Description

template<class T>
class duckdb::fixed_size_map_t< T >

Alternative to perfect_map_t when min/max keys are integral, small, and known.

Constructor & Destructor Documentation

fixed_size_map_t()

template<class T >

duckdb::fixed_size_map_t< T >::fixed_size_map_t ( idx_t  capacity_p = 0 )

inlineexplicit

                                                    : capacity(capacity_p) {
        resize(capacity);
    }

Member Function Documentation

size()

template<class T >

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

inline

                       { // NOLINT: match stl case
        return count;
    }

resize()

template<class T >

void duckdb::fixed_size_map_t< T >::resize ( idx_t  capacity_p )

inline

                                  { // NOLINT: match stl case
        capacity = capacity_p;
        occupied = occupied_mask(capacity);
        values = make_unsafe_uniq_array_uninitialized<mapped_type>(capacity + 1);
        clear();
    }

clear()

template<class T >

void duckdb::fixed_size_map_t< T >::clear ( )

inline

                 { // NOLINT: match stl case
        count = 0;
        occupied.SetAllInvalid(capacity);
    }

operator[]() [1/2]

template<class T >

mapped_type & duckdb::fixed_size_map_t< T >::operator[] ( const key_type &  key )

inline

                                                 {
        D_ASSERT(key < capacity);
        count += 1 - occupied.RowIsValidUnsafe(key);
        occupied.SetValidUnsafe(key);
        return values[key];
    }

operator[]() [2/2]

template<class T >

const mapped_type & duckdb::fixed_size_map_t< T >::operator[] ( const key_type &  key ) const

inline

                                                             {
        D_ASSERT(key < capacity);
        return values[key];
    }

begin() [1/2]

template<class T >

iterator duckdb::fixed_size_map_t< T >::begin ( )

inline

                     { // NOLINT: match stl case
        iterator result(*this, 0);
        if (!occupied_mask::RowIsValid(occupied.GetValidityEntryUnsafe(0), 0)) {
            ++result;
        }
        return result;
    }

begin() [2/2]

template<class T >

const_iterator duckdb::fixed_size_map_t< T >::begin ( ) const

inline

                                 { // NOLINT: match stl case
        const_iterator result(*this, 0);
        if (!occupied_mask::RowIsValid(occupied.GetValidityEntryUnsafe(0), 0)) {
            ++result;
        }
        return result;
    }

end() [1/2]

template<class T >

iterator duckdb::fixed_size_map_t< T >::end ( )

inline

                   { // NOLINT: match stl case
        return iterator(*this, capacity);
    }

end() [2/2]

template<class T >

const_iterator duckdb::fixed_size_map_t< T >::end ( ) const

inline

                               { // NOLINT: match stl case
        return const_iterator(*this, capacity);
    }

find() [1/2]

template<class T >

iterator duckdb::fixed_size_map_t< T >::find ( const key_type &  index )

inline

                                         { // NOLINT: match stl case
        return occupied.RowIsValidUnsafe(index) ? iterator(*this, index) : end();
    }

find() [2/2]

template<class T >

const_iterator duckdb::fixed_size_map_t< T >::find ( const key_type &  index ) const

inline

                                                     { // NOLINT: match stl case
        return occupied.RowIsValidUnsafe(index) ? const_iterator(*this, index) : end();
    }

---

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

• external/duckdb/duckdb.hpp