monitor_ptr();

The default constructor creates an empty monitor_ptr.

template<typename U> explicit monitor_ptr(U* pointer);

Creates a monitor_ptr which wraps the specified pointer. The monitor_ptr internally stores pointer in a boost::shared_ptr. Thus the pointer will be automatically deleted when the last copy of this monitor_ptr is destroyed.

monitor_ptr(boost::shared_ptr<T> smart_pointer);

Creates a monitor_ptr which wraps the specified pointer. This constructor allows the monitor_ptr to be initialized with a boost::shared_ptr that has a custom deleter.

monitor_ptr(const monitor_ptr & other);

The copy constructor creates a monitor_ptr which shares the same pointer, mutex, and condition as the original.

template<typename U> monitor_ptr(const monitor_ptr<U, Mutex> & other);

This constructor creates a monitor_ptr which shares the same pointer (implicitly converted), mutex, and condition as the original.

template<typename U> 
  monitor_ptr(const monitor_ptr<U, Mutex> & other, T* pointer);

This is an aliasing constructor, similar in function to the aliasing constructor of shared_ptr. It creates a monitor_ptr which shares ownership and uses the same mutex as other, but which points at the object specified by pointer when dereferenced. The types T and U may be unrelated. It is useful for creating monitor_ptrs to objects which are only indirectly owned by a monitor_ptr, for example:

struct coordinates
{
	int x;
	int y;
};

// ...

poet::monitor_ptr<coordinates> coords(new coordinates());
// x_mon shares ownership of coords object, but points at coords->x.
// x_mon might be needed to pass the x member of the coords object to a function
// expecting an argument of type poet::monitor_ptr<int>.
poet::monitor_ptr<int> x_mon(coords, &coords->x);
// the following block has the same effect as "coords->x = 5;"
{
	poet::monitor_unique_lock<monitor_ptr<int> > x_lock(x_mon);
	*x_lock = 5;
}

monitor_ptr& operator=(const monitor_ptr & rhs);

After assignment, the two monitor_ptrs will share the same pointer, mutex, and condition variable.

virtual ~monitor_ptr();

A monitor_ptr and all its copies share ownership of an underlying pointer, mutex, and condition variable. The pointer, mutex, and condition are deleted when the last copy of the monitor_ptr is destroyed. The deleter for the underlying pointer may be customized by using the constructor which takes a boost::shared_ptr as its parameter.

const boost::shared_ptr<T> & direct() const;

Gives direct unlocked access to the underlying pointer.

monitor_unique_lock<const monitor_ptr> operator->() const;

Returns a temporary monitor_unique_lock which locks the monitor_ptr's mutex. The operator->() of the returned monitor_unique_lock object will be automatically called in turn (overloading operator->() is special in that way), which will utimately result in a call of operator->() on the monitor_ptr's underlying pointer. The mutex is automatically unlocked after the member access completes by the monitor_unique_lock destructor.

If more flexibility is desired, the lock types from poet/monitor_locks.hpp provide alternatives to monitor_ptr::operator->.

 operator bool() const;

Conversion to bool results in false if the monitor_ptr's underlying pointer is null, true otherwise.

template<typename U> void reset(U* pointer);
void reset(const boost::shared_ptr<T> & smart_pointer);
void reset();
template<typename U> 
  void reset(const monitor_ptr<U, Mutex> & other, T* pointer);

Resets the monitor_ptr's underlying pointer using the specified parameter(s). A new mutex and condition are also created (except in the no-parameter case, where they are simply deleted).

The overload which takes a monitor_ptr and T* argument makes *this into an aliased monitor_ptr, which shares ownership and its mutex with other, but which points at the address given by pointer. See the description of the aliasing constructor for more information.

void swap(monitor_ptr & other);

Swaps *this and other.

void lock() const;

bool try_lock() const;

void unlock() const;

template<typename Timeout> bool timed_lock(const Timeout & t) const;

void lock_shared() const;

bool try_lock_shared() const;

template<typename Timeout> bool timed_lock_shared(const Timeout & t) const;

void unlock_shared() const;

void unlock_and_lock_shared() const;

void lock_upgrade() const;

void unlock_upgrade() const;

void unlock_upgrade_and_lock() const;

void unlock_upgrade_and_lock_shared() const;

void unlock_and_lock_upgrade() const;

template<typename T, typename U, typename Mutex> 
  monitor_ptr<T, Mutex> static_pointer_cast(const monitor_ptr<U, Mutex> & p);

Casts a monitor_ptr by applying boost::static_pointer_cast<U> to the monitor_ptr's underlying shared_ptr.

template<typename T, typename U, typename Mutex> 
  monitor_ptr<T, Mutex> dynamic_pointer_cast(const monitor_ptr<U, Mutex> & p);

Casts a monitor_ptr by applying boost::dynamic_pointer_cast<U> to the monitor_ptr's underlying shared_ptr.

template<typename T, typename U, typename Mutex> 
  monitor_ptr<T, Mutex> const_pointer_cast(const monitor_ptr<U, Mutex> & p);

Casts a monitor_ptr by applying boost::const_pointer_cast<U> to the monitor_ptr's underlying shared_ptr.

template<typename T, typename MutexA, typename U, typename MutexB> 
  bool operator==(const monitor_ptr<T, MutexT> & a, 
                  const monitor_ptr<U, MutexU> & b);

template<typename T, typename MutexA, typename U, typename MutexB> 
  bool operator!=(const monitor_ptr<T, MutexT> & a, 
                  const monitor_ptr<U, MutexU> & b);

template<typename T, typename MutexA, typename U, typename MutexB> 
  bool operator<(const monitor_ptr<T, MutexT> & a, 
                 const monitor_ptr<U, MutexU> & b);

template<typename T, typename Mutex> 
  void swap(monitor_ptr<T, Mutex> & monitor0, 
            monitor_ptr<T, Mutex> & monitor1);

Swaps monitor0 and monitor1. This function is provided to enhance efficiency with generic algorithms.