#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 >
boost::shared_ptr< R >	shared_from_this ()

template<typename R >
boost::shared_ptr< R const >	shared_from_this () const

Private Types
using	MapType = typename std::map< K, boost::weak_ptr< Detail::ValueType< V > >>

Private Attributes
MapType	map

boost::mutex	mut

Member Typedef Documentation

◆ MapType

template<typename K , typename V >

using Scroom::Bookkeeping::MapBase< K, V >::MapType = typename std::map<K, boost::weak_ptr<Detail::ValueType<V> >>

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");
   }

Referenced by BOOST_AUTO_TEST_CASE().

Here is the caller graph for this function:

◆ 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");
   }

Referenced by BOOST_AUTO_TEST_CASE().

Here is the caller graph for this function:

◆ keys()

template<typename K , typename V >

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

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;
   }

Referenced by BOOST_AUTO_TEST_CASE().

Here is the caller graph for this function:

◆ 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;
   }

Referenced by BOOST_AUTO_TEST_CASE().

Here is the caller 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;
   }

Referenced by BOOST_AUTO_TEST_CASE().

Here is the caller 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");
   }

Referenced by BOOST_AUTO_TEST_CASE().

Here is the caller graph for this function:

◆ values()

template<typename K , typename V >

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

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;
   }