src/beacon/invokable.hpp

   1 /**
   2  * beacon
   3  * Author: Lukas Krejci <krejci.l@centrum.cz>, (C) 2008
   4  * Copyright: See COPYING file that comes with this distribution
   5  */
   6
   7 #ifndef BEACON_INVOKABLE_H
   8 #define BEACON_INVOKABLE_H
   9
  10 #include <beacon/reference_countable.hpp>
  11 #include <beacon/detail/quick_wait.hpp>
  12 #include <beacon/intrusive_ptr.hpp>
  13
  14 #include <boost/thread/recursive_mutex.hpp>
  15
  16 extern "C" {
  17 #include <atomic_ops.h>
  18 }
  19
  20 namespace beacon {
  21
  22 /**
  23  * This class represents the token that identifies an invokable in
  24  * \a event_queue::dequeue.
  25  */
  26 class invocation_token : public reference_countable {
  27
  28     public:
  29
  30         /** The type of the lock for the \a guard. */
  31         typedef boost::recursive_mutex::scoped_lock lock_t;
  32
  33         invocation_token(bool valid = true) : _valid(valid) {
  34         }
  35
  36         ~invocation_token() {
  37         }
  38
  39         /**
  40          * A true return value indicates that the invokable accompanied
  41          * by this token is valid.
  42          */
  43         bool valid() const {
  44             return _valid;
  45         }
  46
  47         /**
  48          * This causes the \a valid method to return false, indicating that
  49          * the invokable accompanied by this token is no longer valid.
  50          * The guard is locked during the method invocation.
  51          */
  52         void invalidate() {
  53             lock_t l(_guard);
  54             _valid = false;
  55         }
  56
  57         /**
  58          * The guard can be used to lock access to the token.
  59          */
  60         boost::recursive_mutex const & guard() const {
  61             return _guard;
  62         }
  63
  64         /**
  65          * The guard can be used to lock access to the token.
  66          */
  67         boost::recursive_mutex & guard() {
  68             return _guard;
  69         }
  70     private:
  71         bool _valid;
  72         boost::recursive_mutex _guard;
  73 };
  74
  75 /**
  76  * An abstract class that anything invokable from within an
  77  * {@link event_queue} needs to implement.
  78  */
  79 class invokable {
  80     public:
  81
  82         typedef intrusive_ptr<invocation_token> token_ptr;
  83         typedef invocation_token token_type;
  84
  85     protected:
  86
  87         /**
  88          * Creates new instance of an invokable object.
  89          * @param token a token used to match different invokables
  90          */
  91         invokable(token_ptr token) : _token(token) {
  92         }
  93
  94     public:
  95
  96         virtual ~invokable() {
  97         }
  98
  99         virtual void invoke() = 0;
 100
 101         token_ptr token() const {
 102             return _token;
 103         }
 104
 105     private:
 106         token_ptr _token;
 107 };
 108
 109 }
 110
 111 #endif