Reference

Active Objects

Header <poet/active_object.hpp>
Header <poet/active_function.hpp>
Header <poet/exception_ptr.hpp>
Header <poet/exceptions.hpp>
Header <poet/future.hpp>
Header <poet/future_barrier.hpp>
Header <poet/future_select.hpp>

Header <poet/active_object.hpp>

namespace poet {
  class method_request_base;
  class activation_queue_base;
  class in_order_activation_queue;
  class out_of_order_activation_queue;
  class scheduler_base;
  class scheduler;
}

Header <poet/active_function.hpp>

namespace poet {
  template<typename Signature> class active_function;
}

Header <poet/exception_ptr.hpp>

namespace poet {
  typedef boost::shared_ptr<detail::_exp_throwable> exception_ptr;
  exception_ptr current_exception();

  // Throws the exception held by the exception_ptr
  void rethrow_exception(exception_ptr p);

  // Creates an exception_ptr from an exception.
  template<typename E> exception_ptr copy_exception(E e);
}

Header <poet/exceptions.hpp>

namespace poet {
  class cancelled_future;
  class uncertain_future;
  class unknown_exception;
}

Header <poet/future.hpp>

namespace poet {
  template<typename T> class future;
  template<typename T> void swap(future<T> &, future<T> &);

  template<> class future<void>;

  template<typename T> class promise;
  template<typename T> void swap(promise<T> &, promise<T> &);

  template<> class promise<void>;
}

Header <poet/future_barrier.hpp>

namespace poet {
  struct null_type;
  template<typename T1, typename T2> 
    future<void> future_barrier(const future<T1> &, const future<T1> &);
  template<typename T1, typename T2, ..., typename TN> 
    future<void> 
    future_barrier(const future<T1> &, const future<T2> &, ..., 
                   const future<TN> &);
  template<typename FutureInputIterator> 
    future<void> 
    future_barrier_range(FutureInputIterator, FutureInputIterator);
  template<typename R, typename Combiner, typename ExceptionHandler, 
           typename T1> 
    future<R> future_combining_barrier(const Combiner &, 
                                       const ExceptionHandler &, 
                                       const future<T1> &);
  template<typename R, typename Combiner, typename ExceptionHandler, 
           typename T1, typename T2> 
    future<R> future_combining_barrier(const Combiner &, 
                                       const ExceptionHandler &, 
                                       const future<T1> &, 
                                       const future<T1> &);
  template<typename R, typename Combiner, typename ExceptionHandler, 
           typename T1, typename T2, ..., typename TN> 
    future<R> future_combining_barrier(const Combiner &, 
                                       const ExceptionHandler &, 
                                       const future<T1> &, 
                                       const future<T2> &, ..., 
                                       const future<TN> &);
  template<typename R, typename Combiner, typename ExceptionHandler, 
           typename FutureInputIterator> 
    future<R> future_combining_barrier_range(const Combiner &, 
                                             const ExceptionHandler &, 
                                             FutureInputIterator, 
                                             FutureInputIterator);
}

Header <poet/future_select.hpp>

namespace poet {
  template<typename T> class future_selector;
  template<typename T> void swap(future_selector<T> &, future_selector<T> &);
  template<typename T> 
    future<T> future_select(const future<T> &, const future<T> &);
  template<typename T> 
    future<T> future_select(const future<T> &, const future<T> &, ..., 
                            const future<T> &);
  template<typename InputFutureIterator> 
    future<std::iterator_traits<InputFutureIterator>::value_type> 
    future_select_range(InputFutureIterator, InputFutureIterator);
}

Monitor Objects

Header <poet/monitor_base.hpp>
Header <poet/monitor_ptr.hpp>
Header <poet/monitor.hpp>
Header <poet/monitor_locks.hpp>

Header <poet/monitor_base.hpp>

namespace poet {
  class monitor_base;
}

Header <poet/monitor_ptr.hpp>

namespace poet {
  template<typename T, typename Mutex = boost::mutex> class monitor_ptr;
  template<typename T, typename U, typename Mutex> 
    monitor_ptr<T, Mutex> static_pointer_cast(const monitor_ptr<U, Mutex> &);
  template<typename T, typename U, typename Mutex> 
    monitor_ptr<T, Mutex> dynamic_pointer_cast(const monitor_ptr<U, Mutex> &);
  template<typename T, typename U, typename Mutex> 
    monitor_ptr<T, Mutex> const_pointer_cast(const monitor_ptr<U, Mutex> &);
  template<typename T, typename MutexA, typename U, typename MutexB> 
    bool operator==(const monitor_ptr<T, MutexT> &, 
                    const monitor_ptr<U, MutexU> &);
  template<typename T, typename MutexA, typename U, typename MutexB> 
    bool operator!=(const monitor_ptr<T, MutexT> &, 
                    const monitor_ptr<U, MutexU> &);
  template<typename T, typename MutexA, typename U, typename MutexB> 
    bool operator<(const monitor_ptr<T, MutexT> &, 
                   const monitor_ptr<U, MutexU> &);
  template<typename T, typename Mutex> 
    void swap(monitor_ptr<T, Mutex> &, monitor_ptr<T, Mutex> &);
}

Header <poet/monitor.hpp>

namespace poet {
  template<typename T, typename Mutex = boost::mutex> class monitor;
  template<typename T, typename Mutex> 
    void swap(monitor<T, Mutex> &, monitor<T, Mutex> &);
}

Header <poet/monitor_locks.hpp>

namespace poet {
  template<typename MonitorType> class monitor_unique_lock;
  template<typename Monitor> 
    boost::detail::thread_move_t<monitor_unique_lock<Monitor> > 
    move(monitor_unique_lock<Monitor> &);
  template<typename Monitor> 
    void swap(monitor_unique_lock<Monitor> &, monitor_unique_lock<Monitor> &);
  template<typename MonitorType> class monitor_shared_lock;
  template<typename Monitor> 
    boost::detail::thread_move_t<monitor_shared_lock<Monitor> > 
    move(monitor_shared_lock<Monitor> &);
  template<typename Monitor> 
    void swap(monitor_shared_lock<Monitor> &, monitor_shared_lock<Monitor> &);
  template<typename MonitorType> class monitor_upgrade_lock;
  template<typename Monitor> 
    boost::detail::thread_move_t<monitor_upgrade_lock<Monitor> > 
    move(monitor_upgrade_lock<Monitor> &);
  template<typename Monitor> 
    void swap(monitor_upgrade_lock<Monitor> &, 
              monitor_upgrade_lock<Monitor> &);
  template<typename MonitorType> class monitor_upgrade_to_unique_lock;
  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> &);
}

Mutex Debugging

Header <poet/acyclic_mutex_base.hpp>
Header <poet/acyclic_mutex.hpp>
Header <poet/mutex_grapher.hpp>

Header <poet/acyclic_mutex_base.hpp>

namespace poet {
  class acyclic_mutex_base;
}

Header <poet/acyclic_mutex.hpp>

namespace poet {
  template<typename Mutex = boost::mutex, typename Key = std::string, 
           typename KeyCompare = std::less<Key> > 
    class acyclic_mutex;
}

Header <poet/mutex_grapher.hpp>

namespace poet {
  class mutex_grapher;
}

Miscellaneous

Header <poet/mutex_properties.hpp>

Header <poet/mutex_properties.hpp>

namespace poet {
  template<typename Mutex> class mutex_properties;

  enum mutex_model { Lockable, TimedLockable, SharedLockable, UpgradeLockable };
}