Class template monitor_upgrade_to_unique

Class template monitor_upgrade_to_unique_lock

poet::monitor_upgrade_to_unique_lock — upgrade_to_unique_lock with monitor object access

Synopsis

template<typename MonitorType> 
class monitor_upgrade_to_unique_lock {
public:
  // types
  typedef MonitorType               monitor_type;
  typedef MonitorType::element_type element_type;  // will additionally be const-qualified if MonitorType is "const monitor<T>"

  // construct/copy/destruct
  explicit monitor_upgrade_to_unique_lock(monitor_upgrade_lock<MonitorType> &);
  monitor_upgrade_to_unique_lock(boost::detail::thread_move_t<monitor_upgrade_to_unique_lock>);
  ~monitor_upgrade_to_unique_lock();

  // public boost::upgrade_to_unique_lock interface
  boost::detail::thread_move_t<monitor_upgrade_to_unique_lock> move();
  monitor_upgrade_to_unique_lock & 
  operator=(boost::detail::thread_move_t<monitor_upgrade_to_unique_lock>);
  bool operator!() const;
   operator boost::detail::thread_move_t<monitor_upgrade_to_unique_lock>();
   operator unspecified_bool_type() const;
  bool owns_lock() const;
  void swap(monitor_upgrade_to_unique_lock &);

  // public member functions
  element_type * operator->() const;
  element_type & operator*() const;
private:
  // construct/copy/destruct
  monitor_upgrade_to_unique_lock(monitor_upgrade_to_unique_lock &);
  monitor_upgrade_to_unique_lock& operator=(monitor_upgrade_to_unique_lock &);
};

// free functions
template<typename Monitor> 
  boost::detail::thread_move_t<monitor_upgrade_to_unique_lock<Monitor> > 
  move(monitor_upgrade_to_unique_lock<Monitor> &);
template<typename Monitor> 
  void swap(monitor_upgrade_to_unique_lock<Monitor> &, 
            monitor_upgrade_to_unique_lock<Monitor> &);

Description

monitor_upgrade_to_unique_lock is an extension of boost::upgrade_to_unique_lock from the Boost.Thread library. It extends the interface of boost::upgrade_to_unique_lock by adding operator-> and operator* methods, which permit access to the object protected by the lock's associated monitor. This tight coupling of locking with access helps insure the monitor's mutex is always locked when the object it is protecting is accessed.

The MonitorType template type parameter may be one of the monitor or monitor_ptr types.

See the documentation of boost::upgrade_to_unique_lock in the Boost.Thread library for more information about the upgrade_to_unique_lock interface.

`monitor_upgrade_to_unique_lock` public construct/copy/destruct

```
explicit monitor_upgrade_to_unique_lock(monitor_upgrade_lock<MonitorType> & lock);
```
If lock.owns_lock(), then *this takes exclusive ownership of the upgrade lock's mutex.

monitor_upgrade_to_unique_lock(boost::detail::thread_move_t<monitor_upgrade_to_unique_lock> other);

Move constructor.

```
~monitor_upgrade_to_unique_lock();
```
If owns_lock(), releases exclusive ownership and returns upgrade ownership to the upgrade_lock *this was constructed from.

`monitor_upgrade_to_unique_lock` public boost::upgrade_to_unique_lock interface

boost::detail::thread_move_t<monitor_upgrade_to_unique_lock> move();

monitor_upgrade_to_unique_lock & 
operator=(boost::detail::thread_move_t<monitor_upgrade_to_unique_lock>);

```
bool operator!() const;
```

 operator boost::detail::thread_move_t<monitor_upgrade_to_unique_lock>();

 operator unspecified_bool_type() const;

```
bool owns_lock() const;
```

void swap(monitor_upgrade_to_unique_lock & other);

`monitor_upgrade_to_unique_lock` public member functions

element_type * operator->() const;

Provides access to the members of the object protected by the lock's associated monitor.

Throws:

boost::lock_error if owns_lock() != true.

element_type & operator*() const;

Provides access to the object protected by the lock's associated monitor.

Throws:

boost::lock_error if owns_lock() != true.

`monitor_upgrade_to_unique_lock` private construct/copy/destruct

monitor_upgrade_to_unique_lock(monitor_upgrade_to_unique_lock & other);

Locks are moveable but not copyable.

monitor_upgrade_to_unique_lock& 
operator=(monitor_upgrade_to_unique_lock & other);

Locks are moveable but not copyable.

`monitor_upgrade_to_unique_lock` free functions

template<typename Monitor> 
  boost::detail::thread_move_t<monitor_upgrade_to_unique_lock<Monitor> > 
  move(monitor_upgrade_to_unique_lock<Monitor> & lock);

Returns:

lock.move()

template<typename Monitor> 
  void swap(monitor_upgrade_to_unique_lock<Monitor> & lock_a, 
            monitor_upgrade_to_unique_lock<Monitor> & lock_b);

Effects:

lock_a.swap(lock_b)