duckdb::RegisteredStateManager Class Reference

Collaboration diagram for duckdb::RegisteredStateManager:

Public Member Functions
template<class T , typename... ARGS>
shared_ptr< T >	GetOrCreate (const string &key, ARGS &&... args)
template<class T >
shared_ptr< T >	Get (const string &key)
void	Insert (const string &key, shared_ptr< ClientContextState > state_p)
void	Remove (const string &key)
vector< shared_ptr< ClientContextState > >	States ()

Private Attributes
mutex	lock
unordered_map< string, shared_ptr< ClientContextState > >	registered_state

Member Function Documentation

GetOrCreate()

template<class T , typename... ARGS>

shared_ptr< T > duckdb::RegisteredStateManager::GetOrCreate ( const string &  key, ARGS &&...  args  )

inline

                                                                  {
        lock_guard<mutex> l(lock);
        auto lookup = registered_state.find(key);
        if (lookup != registered_state.end()) {
            return shared_ptr_cast<ClientContextState, T>(lookup->second);
        }
        auto cache = make_shared_ptr<T>(std::forward<ARGS>(args)...);
        registered_state[key] = cache;
        return cache;
    }

Get()

template<class T >

shared_ptr< T > duckdb::RegisteredStateManager::Get ( const string &  key )

inline

                                         {
        lock_guard<mutex> l(lock);
        auto lookup = registered_state.find(key);
        if (lookup == registered_state.end()) {
            return nullptr;
        }
        return shared_ptr_cast<ClientContextState, T>(lookup->second);
    }

Insert()

void duckdb::RegisteredStateManager::Insert ( const string &  key, shared_ptr< ClientContextState >  state_p  )

inline

                                                                           {
        lock_guard<mutex> l(lock);
        registered_state.insert(make_pair(key, std::move(state_p)));
    }

Remove()

void duckdb::RegisteredStateManager::Remove ( const string &  key )

inline

                                   {
        lock_guard<mutex> l(lock);
        registered_state.erase(key);
    }

States()

vector< shared_ptr< ClientContextState > > duckdb::RegisteredStateManager::States ( )

inline

                                                    {
        lock_guard<mutex> l(lock);
        vector<shared_ptr<ClientContextState>> states;
        for (auto &entry : registered_state) {
            states.push_back(entry.second);
        }
        return states;
    }

---

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

• external/duckdb/duckdb.hpp