Scroom::Bookkeeping::MapBase< K, V > Class Template Reference

#include <bookkeeping.hh>

Inheritance diagram for Scroom::Bookkeeping::MapBase< K, V >:

Collaboration diagram for Scroom::Bookkeeping::MapBase< K, V >:

Public Member Functions
Token	reserve (const K &k)
Token	reReserve (const K &k)
void	remove (const K &k)
void	remove (const K &k, const WeakToken &t)
Detail::LValue< V >	at (const K &k)
void	set (const K &k, const V &v)
V	get (const K &k)
std::list< K >	keys () const
std::list< V >	values () const
Public Member Functions inherited from Scroom::Utils::Base
	Base ()=default
	Base (const Base &)=delete
	Base (Base &&)=delete
Base &	operator= (const Base &)=delete
Base &	operator= (Base &&)=delete
virtual	~Base ()=default
template<typename R >
std::shared_ptr< R >	shared_from_this ()
template<typename R >
std::shared_ptr< R const >	shared_from_this () const

Private Types
using	MapType = typename Detail::MapType< K, V >::Type

Private Attributes
MapType	map
boost::mutex	mut

Member Typedef Documentation

MapType

template<typename K , typename V >

using Scroom::Bookkeeping::MapBase< K, V >::MapType = typename Detail::MapType<K, V>::Type

private

Member Function Documentation

at()

template<typename K , typename V >

Detail::LValue< V > Scroom::Bookkeeping::MapBase< K, V >::at ( const K &  k )

inline

  {
    boost::mutex::scoped_lock const lock(mut);
    auto i = map.find(k);
 
    if(map.end() != i)
    {
      typename Detail::ValueType<V>::Ptr const pv = i->second.lock();
      if(pv)
      {
        return Detail::LValue<V>(pv);
      }
    }
 
    throw std::invalid_argument("Invalid key");
  }

get()

template<typename K , typename V >

V Scroom::Bookkeeping::MapBase< K, V >::get ( const K &  k )

inline

  {
    boost::mutex::scoped_lock const lock(mut);
    auto i = map.find(k);
 
    if(map.end() != i)
    {
      typename Detail::ValueType<V>::Ptr const pv = i->second.lock();
      if(pv)
      {
        return pv->value;
      }
    }
 
    throw std::invalid_argument("Invalid key");
  }

keys()

template<typename K , typename V >

std::list< K > Scroom::Bookkeeping::MapBase< K, V >::keys ( ) const

inline

  {
    boost::mutex::scoped_lock const lock(mut);
    std::list<K> result;
    for(const typename MapType::value_type& el: map)
    {
      result.push_back(el.first);
    }
    return result;
  }

remove() [1/2]

template<typename K , typename V >

void Scroom::Bookkeeping::MapBase< K, V >::remove ( const K &  k )

inline

  {
    boost::mutex::scoped_lock lock(mut);
    typename MapType::iterator i = map.find(k);
 
    if(map.end() != i)
    {
      map.erase(i);
    }
  }

remove() [2/2]

template<typename K , typename V >

void Scroom::Bookkeeping::MapBase< K, V >::remove ( const K &  k, const WeakToken &  t  )

inline

  {
    boost::mutex::scoped_lock const lock(mut);
    auto i = map.find(k);
 
    if(map.end() != i)
    {
      typename Detail::ValueType<V>::Ptr const pv = i->second.lock();
      if(pv)
      {
        Token const t(wt.lock());
        Token const t_orig(pv->token.lock());
        if(t == t_orig)
        {
          map.erase(i);
        }
      }
      else
      {
        map.erase(i);
      }
    }
  }

reReserve()

template<typename K , typename V >

Token Scroom::Bookkeeping::MapBase< K, V >::reReserve ( const K &  k )

inline

  {
    boost::mutex::scoped_lock const lock(mut);
    auto i = map.find(k);
 
    if(map.end() == i)
    {
      map[k] = typename Detail::ValueType<V>::WeakPtr();
      i = map.find(k);
    }
 
    typename Detail::ValueType<V>::Ptr pv = i->second.lock();
    if(!pv)
    {
      pv = Detail::ValueType<V>::create(V());
      i->second = pv;
    }
 
    Token t(pv->token.lock());
    if(!t)
    {
      t = Detail::MapTokenImpl<K, V>::create(shared_from_this<MapBase<K, V>>(), k);
      t.add(pv);
      pv->token = t;
    }
 
    return t;
  }

Here is the call graph for this function:

reserve()

template<typename K , typename V >

Token Scroom::Bookkeeping::MapBase< K, V >::reserve ( const K &  k )

inline

  {
    boost::mutex::scoped_lock const lock(mut);
    if(map.end() != map.find(k))
    {
      throw std::invalid_argument("Key already exists");
    }
 
    typename Detail::ValueType<V>::Ptr const pv = Detail::ValueType<V>::create(V());
    map[k] = pv;
 
    Token t = Detail::MapTokenImpl<K, V>::create(shared_from_this<MapBase<K, V>>(), k);
    t.add(pv);
    pv->token = t;
    return t;
  }

Here is the call graph for this function:

set()

template<typename K , typename V >

void Scroom::Bookkeeping::MapBase< K, V >::set ( const K &  k, const V &  v  )

inline

  {
    boost::mutex::scoped_lock const lock(mut);
    auto i = map.find(k);
 
    if(map.end() != i)
    {
      typename Detail::ValueType<V>::Ptr const pv = i->second.lock();
      if(pv)
      {
        pv->value = v;
        return;
      }
    }
 
    throw std::invalid_argument("Invalid key");
  }

values()

template<typename K , typename V >

std::list< V > Scroom::Bookkeeping::MapBase< K, V >::values ( ) const

inline

  {
    boost::mutex::scoped_lock const lock(mut);
    std::list<V> result;
    for(const typename MapType::value_type& el: map)
    {
      typename Detail::ValueType<V>::Ptr const pv = el.second.lock();
      if(pv)
      {
        result.push_back(pv->value);
      }
    }
    return result;
  }

Member Data Documentation

map

template<typename K , typename V >

MapType Scroom::Bookkeeping::MapBase< K, V >::map

private

mut

template<typename K , typename V >

boost::mutex Scroom::Bookkeeping::MapBase< K, V >::mut

mutableprivate

---

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

• libs/util/inc/scroom/bookkeeping.hh
• libs/util/inc/scroom/impl/bookkeepingimpl.hh