include/library/triplebuffer.hpp

   1 #ifndef _library_triplebuffer__hpp__included__
   2 #define _library_triplebuffer__hpp__included__
   3
   4 #include <functional>
   5 #include <stdexcept>
   6 #include "threads.hpp"
   7
   8 namespace triplebuffer
   9 {
  10 /**
  11  * Triple-buffering logic.
  12  */
  13 class logic
  14 {
  15 public:
  16 /**
  17  * Create a new triple buffer.
  18  */
  19         logic() throw();
  20 /**
  21  * Get read pointer and increment read count by 1.
  22  *
  23  * Return value: Read pointer (0-2).
  24  *
  25  * Note: If read count is zero, last complete buffer is returned. Otherwise the same buffer as last call is returned.
  26  */
  27         unsigned get_read() throw();
  28 /**
  29  * Put read pointer and decrement read count by 1.
  30  *
  31  * Throws std::logic_error: If read count is 0.
  32  */
  33         void put_read() throw(std::logic_error);
  34 /**
  35  * Get write pointer and increment write count by 1.
  36  *
  37  * Return value: Write pointer (0-2).
  38  *
  39  * Note: If write count is nonzero before call, the returned buffer is the same as last time.
  40  */
  41         unsigned get_write() throw();
  42 /**
  43  * Put write pointer and decrement write count by 1. If write count hits 0, the buffer is marked as last complete
  44  * buffer.
  45  *
  46  * Throws std::logic_error: If write count is 0.
  47  */
  48         void put_write() throw(std::logic_error);
  49 /**
  50  * Call specified function synchronously for last written buffer.
  51  *
  52  * The buffer number is passed to specified function.
  53  */
  54         void read_last_write_synchronous(std::function<void(unsigned)> fn) throw();
  55 private:
  56         threads::lock lock;
  57         unsigned last_complete;         //Number of last completed buffer
  58         unsigned current_read;          //Number of current read buffer (only valid if count_read > 0).
  59         unsigned current_write;         //Number of current write buffer (only valid if count_write > 0).
  60         unsigned count_read;            //Number of readers.
  61         unsigned count_write;           //Number of writers.
  62 };
  63
  64 /**
  65  * Triple buffer with objects.
  66  */
  67 template<typename T>
  68 class triplebuffer
  69 {
  70 public:
  71 /**
  72  * Create a new triple buffer.
  73  *
  74  * Parameter A: Object #1.
  75  * Parameter B: Object #2.
  76  * Parameter C: Object #3.
  77  */
  78         triplebuffer(T& A, T& B, T& C) throw()
  79         {
  80                 objs[0] = &A;
  81                 objs[1] = &B;
  82                 objs[2] = &C;
  83         }
  84 /**
  85  * Get read pointer and increment read count by 1.
  86  *
  87  * Return value: Read pointer.
  88  *
  89  * Note: If read count is zero, last complete buffer is returned. Otherwise the same buffer as last call is returned.
  90  */
  91         T& get_read() throw() { return *objs[l.get_read()]; }
  92 /**
  93  * Put read pointer and decrement read count by 1.
  94  *
  95  * Throws std::logic_error: If read count is 0.
  96  */
  97         void put_read() throw(std::logic_error) { l.put_read(); }
  98 /**
  99  * Get write pointer and increment write count by 1.
 100  *
 101  * Return value: Write pointer.
 102  *
 103  * Note: If write count is nonzero before call, the returned buffer is the same as last time.
 104  */
 105         T& get_write() throw() { return *objs[l.get_write()]; }
 106 /**
 107  * Put write pointer and decrement write count by 1. If write count hits 0, the buffer is marked as last complete
 108  * buffer.
 109  *
 110  * Throws std::logic_error: If write count is 0.
 111  */
 112         void put_write() throw(std::logic_error) { l.put_write(); }
 113 /**
 114  * Call specified function synchronously for last written buffer.
 115  *
 116  * The buffer itself is passed to the function.
 117  */
 118         void read_last_write_synchronous(std::function<void(T&)> fn) throw()
 119         {
 120                 l.read_last_write_synchronous([this,fn](unsigned x){ fn(*objs[x]); });
 121         }
 122 private:
 123         T* objs[3];
 124         logic l;
 125 };
 126 }
 127
 128 #endif