libcrbn/rendering/mailbox.hpp

#ifndef __mailbox_hpp__
#define __mailbox_hpp__

#include "mutex.hpp"
#include "semaphore.hpp"

/*
  La boite au lettre est une des structures couramment utilisée pour de la
  communication inter processus. La structure sous-jacente est de type FIFO.

  Dans le cas présent, cette structure est un tampon circulaire et n'ayant
  qu'un nombre limité d'élément (en plus ce sont des entiers), je n'ai pas
  besoin d'une structure plus compliquée.

  Un point à noter est que la vérification si le tampon contient un message
  est inutile car '_wakeup' ne peut être pris que s'il y a au moins un
  message.

  Pour l'écriture, le test de débordement est aussi inutile car il est
  théoriquement impossible d'avoir plus de message (des jetons en fait)
  que de place.
 */
template <class C> class MailBox
{
public:
  MailBox( int size = 20 ) : _size( size ){
    _array = new C [ _size ];
    _head = _tail = 0;
    _access = Mutex();
    _wakeup = Semaphore( 0 );
  }

  ~MailBox() {
    delete [] _array;
  }

  void flush() {
    _access.lock();
    _tail = _head;
    _access.unlock();  
  }

  void read( C& data ) {
    _wakeup.down();
    _access.lock();
    data = _array[ _tail ];
    _tail = (++_tail) % _size;
    _access.unlock();
  }

  void mail( C& data ) {
    _access.lock();
    _array[ _head ] = data;
    _head = (++_head) % _size;
    _access.unlock();
    _wakeup.up();
  }
private:
  // data and relative stuff
  C* _array;
  int _size;
  int _head;
  int _tail;

  // protected access
  Mutex _access;
  Semaphore _wakeup;
};

#endif // __mailbox_hpp__

---