duckdb::InsertionOrderPreservingMap< V > Class Template Reference

Collaboration diagram for duckdb::InsertionOrderPreservingMap< V >:

Public Types
typedef vector< pair< string, V > >	VECTOR_TYPE
typedef string	key_type

Public Member Functions
vector< string >	Keys () const
VECTOR_TYPE::iterator	begin ()
VECTOR_TYPE::iterator	end ()
VECTOR_TYPE::const_iterator	begin () const
VECTOR_TYPE::const_iterator	end () const
VECTOR_TYPE::reverse_iterator	rbegin ()
VECTOR_TYPE::reverse_iterator	rend ()
VECTOR_TYPE::iterator	find (const string &key)
VECTOR_TYPE::const_iterator	find (const string &key) const
idx_t	size () const
bool	empty () const
void	resize (idx_t nz)
void	clear ()
void	insert (const string &key, V &&value)
void	insert (const string &key, const V &value)
void	insert (pair< string, V > &&value)
void	erase (typename VECTOR_TYPE::iterator it)
bool	contains (const string &key) const
const V &	at (const string &key) const
V &	operator[] (const string &key)
bool	operator== (const InsertionOrderPreservingMap &other) const
bool	operator!= (const InsertionOrderPreservingMap &other) const

Private Attributes
VECTOR_TYPE	map
case_insensitive_map_t< idx_t >	map_idx

Constructor & Destructor Documentation

InsertionOrderPreservingMap()

template<typename V >

duckdb::InsertionOrderPreservingMap< V >::InsertionOrderPreservingMap ( )

inline

                                  {
    }

Member Function Documentation

Keys()

template<typename V >

vector< string > duckdb::InsertionOrderPreservingMap< V >::Keys ( ) const

inline

                                {
        vector<string> keys;
        keys.resize(this->size());
        for (auto &kv : map_idx) {
            keys[kv.second] = kv.first;
        }
 
        return keys;
    }

begin() [1/2]

template<typename V >

VECTOR_TYPE::iterator duckdb::InsertionOrderPreservingMap< V >::begin ( )

inline

                                         { // NOLINT: match stl API
        return map.begin();
    }

end() [1/2]

template<typename V >

VECTOR_TYPE::iterator duckdb::InsertionOrderPreservingMap< V >::end ( )

inline

                                       { // NOLINT: match stl API
        return map.end();
    }

begin() [2/2]

template<typename V >

VECTOR_TYPE::const_iterator duckdb::InsertionOrderPreservingMap< V >::begin ( ) const

inline

                                                     { // NOLINT: match stl API
        return map.begin();
    }

end() [2/2]

template<typename V >

VECTOR_TYPE::const_iterator duckdb::InsertionOrderPreservingMap< V >::end ( ) const

inline

                                                   { // NOLINT: match stl API
        return map.end();
    }

rbegin()

template<typename V >

VECTOR_TYPE::reverse_iterator duckdb::InsertionOrderPreservingMap< V >::rbegin ( )

inline

                                                  { // NOLINT: match stl API
        return map.rbegin();
    }

rend()

template<typename V >

VECTOR_TYPE::reverse_iterator duckdb::InsertionOrderPreservingMap< V >::rend ( )

inline

                                                { // NOLINT: match stl API
        return map.rend();
    }

find() [1/2]

template<typename V >

VECTOR_TYPE::iterator duckdb::InsertionOrderPreservingMap< V >::find ( const string &  key )

inline

                                                         { // NOLINT: match stl API
        auto entry = map_idx.find(key);
        if (entry == map_idx.end()) {
            return map.end();
        }
        return map.begin() + static_cast<typename VECTOR_TYPE::difference_type>(entry->second);
    }

find() [2/2]

template<typename V >

VECTOR_TYPE::const_iterator duckdb::InsertionOrderPreservingMap< V >::find ( const string &  key ) const

inline

                                                                     { // NOLINT: match stl API
        auto entry = map_idx.find(key);
        if (entry == map_idx.end()) {
            return map.end();
        }
        return map.begin() + static_cast<typename VECTOR_TYPE::difference_type>(entry->second);
    }

size()

template<typename V >

idx_t duckdb::InsertionOrderPreservingMap< V >::size ( ) const

inline

                       { // NOLINT: match stl API
        return map_idx.size();
    }

empty()

template<typename V >

bool duckdb::InsertionOrderPreservingMap< V >::empty ( ) const

inline

                       { // NOLINT: match stl API
        return map_idx.empty();
    }

resize()

template<typename V >

void duckdb::InsertionOrderPreservingMap< V >::resize ( idx_t  nz )

inline

                          { // NOLINT: match stl API
        map.resize(nz);
    }

clear()

template<typename V >

void duckdb::InsertionOrderPreservingMap< V >::clear ( )

inline

                 { // NOLINT: match stl API
        map.clear();
    }

insert() [1/3]

template<typename V >

void duckdb::InsertionOrderPreservingMap< V >::insert ( const string &  key, V &&  value  )

inline

                                              { // NOLINT: match stl API
        if (contains(key)) {
            return;
        }
        map.emplace_back(key, std::move(value));
        map_idx[key] = map.size() - 1;
    }

insert() [2/3]

template<typename V >

void duckdb::InsertionOrderPreservingMap< V >::insert ( const string &  key, const V &  value  )

inline

                                                   { // NOLINT: match stl API
        if (contains(key)) {
            return;
        }
        map.emplace_back(key, value);
        map_idx[key] = map.size() - 1;
    }

insert() [3/3]

template<typename V >

void duckdb::InsertionOrderPreservingMap< V >::insert ( pair< string, V > &&  value )

inline

                                         { // NOLINT: match stl API
        auto &key = value.first;
        if (contains(key)) {
            return;
        }
        map_idx[key] = map.size();
        map.push_back(std::move(value));
    }

erase()

template<typename V >

void duckdb::InsertionOrderPreservingMap< V >::erase ( typename VECTOR_TYPE::iterator  it )

inline

                                                { // NOLINT: match stl API
        auto key = it->first;
        auto idx = map_idx[key];
        map.erase(it);
        map_idx.erase(key);
        for (auto &kv : map_idx) {
            if (kv.second > idx) {
                kv.second--;
            }
        }
    }

contains()

template<typename V >

bool duckdb::InsertionOrderPreservingMap< V >::contains ( const string &  key ) const

inline

                                           { // NOLINT: match stl API
        return map_idx.find(key) != map_idx.end();
    }

at()

template<typename V >

const V & duckdb::InsertionOrderPreservingMap< V >::at ( const string &  key ) const

inline

                                         { // NOLINT: match stl API
        return map[map_idx.at(key)].second;
    }

operator[]()

template<typename V >

V & duckdb::InsertionOrderPreservingMap< V >::operator[] ( const string &  key )

inline

                                     {
        if (!contains(key)) {
            auto v = V();
            insert(key, std::move(v));
        }
        return map[map_idx[key]].second;
    }

operator==()

template<typename V >

bool duckdb::InsertionOrderPreservingMap< V >::operator== ( const InsertionOrderPreservingMap< V > &  other ) const

inline

                                                                    {
        return map == other.map && map_idx == other.map_idx;
    }

operator!=()

template<typename V >

bool duckdb::InsertionOrderPreservingMap< V >::operator!= ( const InsertionOrderPreservingMap< V > &  other ) const

inline

                                                                    {
        return !(*this == other);
    }

---

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

• external/duckdb/duckdb.hpp