duckdb::fixed_size_map_iterator< T, is_const > Class Template Reference

Public Types
using	key_type = idx_t
using	mapped_type = T
using	fixed_size_map_type = fixed_size_map_t< mapped_type >
using	map_type = typename std::conditional< is_const, const fixed_size_map_type, fixed_size_map_type >::type
using	occupied_mask = typename fixed_size_map_t< mapped_type >::occupied_mask

Public Member Functions
	fixed_size_map_iterator (map_type &map_p, key_type index)
fixed_size_map_iterator &	operator++ ()
fixed_size_map_iterator	operator++ (int)
key_type	GetKey () const
mapped_type &	GetValue ()
const mapped_type &	GetValue () const

Private Member Functions
void	NextEntry ()

Private Attributes
map_type &	map
idx_t	entry_idx
idx_t	idx_in_entry

Friends
bool	operator== (const fixed_size_map_iterator &a, const fixed_size_map_iterator &b)
bool	operator!= (const fixed_size_map_iterator &a, const fixed_size_map_iterator &b)
bool	operator< (const fixed_size_map_iterator &a, const fixed_size_map_iterator &b)

Constructor & Destructor Documentation

fixed_size_map_iterator()

template<class T , bool is_const>

duckdb::fixed_size_map_iterator< T, is_const >::fixed_size_map_iterator ( map_type &  map_p, key_type  index  )

inline

                                                             : map(map_p) {
        occupied_mask::GetEntryIndex(index, entry_idx, idx_in_entry);
    }

Member Function Documentation

operator++() [1/2]

template<class T , bool is_const>

fixed_size_map_iterator & duckdb::fixed_size_map_iterator< T, is_const >::operator++ ( )

inline

                                          {
        // Prefix increment
        if (++idx_in_entry == occupied_mask::BITS_PER_VALUE) {
            NextEntry();
        }
        // Loop until we find an occupied index, or until the end
        auto end = map.end();
        while (*this < end) {
            const auto &entry = map.occupied.GetValidityEntryUnsafe(entry_idx);
            if (entry == static_cast<uint8_t>(~occupied_mask::ValidityBuffer::MAX_ENTRY)) {
                // Entire entry is unoccupied, skip
                if (entry_idx == end.entry_idx) {
                    // This is the last entry
                    idx_in_entry = end.idx_in_entry;
                    break;
                }
                NextEntry();
            } else {
                // One or more occupied in entry, loop over it
                const auto idx_to = entry_idx == end.entry_idx ? end.idx_in_entry : occupied_mask::BITS_PER_VALUE;
                for (; idx_in_entry < idx_to; idx_in_entry++) {
                    if (map.occupied.RowIsValid(entry, idx_in_entry)) {
                        // We found an occupied index
                        return *this;
                    }
                }
                // We did not find an occupied index
                if (*this != end) {
                    NextEntry();
                }
            }
        }
        return *this;
    }

operator++() [2/2]

template<class T , bool is_const>

fixed_size_map_iterator duckdb::fixed_size_map_iterator< T, is_const >::operator++ ( int  )

inline

                                            {
        fixed_size_map_iterator tmp = *this;
        ++(*this);
        return tmp;
    }

GetKey()

template<class T , bool is_const>

key_type duckdb::fixed_size_map_iterator< T, is_const >::GetKey ( ) const

inline

                            {
        return entry_idx * occupied_mask::BITS_PER_VALUE + idx_in_entry;
    }

GetValue() [1/2]

template<class T , bool is_const>

mapped_type & duckdb::fixed_size_map_iterator< T, is_const >::GetValue ( )

inline

                            {
        return map.values[GetKey()];
    }

GetValue() [2/2]

template<class T , bool is_const>

const mapped_type & duckdb::fixed_size_map_iterator< T, is_const >::GetValue ( ) const

inline

                                        {
        return map.values[GetKey()];
    }

NextEntry()

template<class T , bool is_const>

void duckdb::fixed_size_map_iterator< T, is_const >::NextEntry ( )

inlineprivate

                     {
        entry_idx++;
        idx_in_entry = 0;
    }

Friends And Related Symbol Documentation

operator==

template<class T , bool is_const>

bool operator== ( const fixed_size_map_iterator< T, is_const > &  a, const fixed_size_map_iterator< T, is_const > &  b  )

friend

                                                                                               {
        return a.entry_idx == b.entry_idx && a.idx_in_entry == b.idx_in_entry;
    }

operator!=

template<class T , bool is_const>

bool operator!= ( const fixed_size_map_iterator< T, is_const > &  a, const fixed_size_map_iterator< T, is_const > &  b  )

friend

                                                                                               {
        return !(a == b);
    }

operator<

template<class T , bool is_const>

bool operator< ( const fixed_size_map_iterator< T, is_const > &  a, const fixed_size_map_iterator< T, is_const > &  b  )

friend

                                                                                              {
        if (a.entry_idx < b.entry_idx) {
            return true;
        }
        if (a.entry_idx == b.entry_idx) {
            return a.idx_in_entry < b.idx_in_entry;
        }
        return false;
    }

---

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

• external/duckdb/duckdb.hpp