guard - Auto-lock/unlock-er

Introduction

detail/guard.hpp provides a type guard<Mutex> that allows scoped access to the Mutex's locking and unlocking operations. It is used to ensure that a Mutex is unlocked, even if an exception is thrown.

Synopsis

namespace details {
namespace pool {

template <typename Mutex>
class guard
{
  private:
    guard(const guard &);
    void operator=(const guard &);

  public:
    explicit guard(Mutex & mtx);
    ~guard();
};

} // namespace pool
} // namespace details

Semantics

*Symbol Table*
Symbol	Meaning
T	guard<Mutex>
m	value of type Mutex &
g	value of type guard<Mutex>

*Requirements on Mutex*
Expression	Return Type	Assertion/Note/Pre/Post-Condition
m.lock()	not used	Locks the mutex referred to by m
m.unlock()	not used	Unlocks the mutex referred to by m

*Requirements satisfied by guard*
Expression	Assertion/Note/Pre/Post-Condition
T(m)	Locks the mutex referred to by m; binds T(m) to m
(&g)->~T()	Unlocks the mutex that g is bound to

Example

Given a (platform-specific) mutex class, we can wrap code as follows:

extern mutex global_lock;

static void f()
{
  boost::details::pool::guard<mutex> g(global_lock);
  // g's constructor locks "global_lock"

  ... // do anything:
      //   throw exceptions
      //   return
      //   or just fall through
} // g's destructor unlocks "global_lock"

Dependencies

None.

Future Directions

This header will eventually be replaced by a Boost multithreading library.

This file can be redistributed and/or modified under the terms found in copyright.html

This software and its documentation is provided "as is" without express or implied warranty, and with no claim as to its suitability for any purpose.