CLASS INTERPRO(3)

NAME
boost::interprocess::interprocess_condition

SYNOPSIS

// In header: <boost/interprocess/sync/interprocess_condition.hpp>
class interprocess_condition {
public:
  // construct/copy/destruct
  interprocess_condition(const interprocess_condition &);
  interprocess_condition();
  interprocess_condition& operator=(const interprocess_condition &);
  ~interprocess_condition();
  // public member functions
  void notify_one();
  void notify_all();
  template<typename L> void wait(L &);
  template<typename L, typename Pr> void wait(L &, Pr);
  template<typename L> bool timed_wait(L &, const boost::posix_time::ptime &);
  template<typename L, typename Pr>
    bool timed_wait(L &, const boost::posix_time::ptime &, Pr);
  void do_wait(interprocess_mutex &);
  bool do_timed_wait(const boost::posix_time::ptime &, interprocess_mutex &);
};

DESCRIPTION

This class is a condition variable that can be placed in shared memory or memory mapped files.

  interprocess_condition public construct/copy/destruct

    1.

    interprocess_condition(const interprocess_condition &);
    @ //Non-copyable .RE

        2.

        interprocess_condition();

        Constructs a interprocess_condition. On error throws interprocess_exception.

        3.

        interprocess_condition& operator=(const interprocess_condition &);

        4.

        ~interprocess_condition();

        Destroys *this liberating system resources.

  interprocess_condition public member functions

    1.

    void notify_one();

    If there is a thread waiting on *this, change that thread's state to ready. Otherwise there is no effect.

    2.

    void notify_all();

    Change the state of all threads waiting on *this to ready. If there are no waiting threads, notify_all() has no effect.

    3.

    template<typename L> void wait(L & lock);

    Releases the lock on the interprocess_mutex object associated with lock, blocks the current thread of execution until readied by a call to this->notify_one() or this->notify_all(), and then reacquires the lock.

    4.

    template<typename L, typename Pr> void wait(L & lock, Pr pred);

    The same as: while (!pred()) wait(lock)

    5.

    template<typename L>
      bool timed_wait(L & lock, const boost::posix_time::ptime & abs_time);

    Releases the lock on the interprocess_mutex object associated with lock, blocks the current thread of execution until readied by a call to this->notify_one() or this->notify_all(), or until time abs_time is reached, and then reacquires the lock. Returns: false if time abs_time is reached, otherwise true.

    6.

    template<typename L, typename Pr>
      bool timed_wait(L & lock, const boost::posix_time::ptime & abs_time,
                      Pr pred);

    The same as: while (!pred()) { if (!timed_wait(lock, abs_time)) return pred(); } return true;

    7.

    void do_wait(interprocess_mutex & mut);
    @ private: .RE

        8.

        bool do_timed_wait(const boost::posix_time::ptime & abs_time,
                           interprocess_mutex & mut);