toast/async/lockable.hpp

#ifndef toast_lockable_hpp_INCLUDED
#define toast_lockable_hpp_INCLUDED

#include <sstream>
#include <boost/shared_ptr.hpp>
#include <boost/thread/recursive_mutex.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/bind.hpp>
#include <toast/contracts.hpp>

namespace toast {
namespace async {

template <typename T>
class locked;

template <typename T>
class lockable
{
  boost::mutex mutex_;
  T data_;
  template <typename Y>
  friend class locked;

public:

#ifndef TOAST_LOCKABLE_MAX_CONSTRUCTOR_ARITY
#define TOAST_LOCKABLE_MAX_CONSTRUCTOR_ARITY 10
#endif

  // constructor iteration
#define BOOST_PP_ITERATION_LIMITS (0, TOAST_LOCKABLE_MAX_CONSTRUCTOR_ARITY)
#define BOOST_PP_FILENAME_1 <toast/async/lockable.hpp>
#include BOOST_PP_ITERATE()

};

template <typename T>
class locked
{
  T &data_;
  boost::mutex::scoped_lock lock_;

public:
  template <typename Y>
  explicit locked(lockable<Y> &t)
    : data_(t.data_), lock_(t.mutex_) {}

  T &operator*() const { return data_; }
  T *operator->() const { return &data_; }
};

}
}

#elif BOOST_PP_IS_ITERATING

#define N BOOST_PP_ITERATION()

#if N > 0
template <BOOST_PP_ENUM_PARAMS(N, typename A) >
#endif
lockable( BOOST_PP_ENUM_BINARY_PARAMS(N, A, a) )
  : data_( BOOST_PP_ENUM_PARAMS(N,a) ) {}

#undef N

#endif

---