Fake mutex

fakemutex

// Example: Queue implementation non thread-safe but still usable if clients
//          are synchronized somehow.
//
//          In this case the macro DFAKE_SCOPED_LOCK has to be
//          used, it checks that if a thread is inside the push/pop then
//          noone else is still inside the pop/push

class NonThreadSafeQueue {
public:
  ...
  void push(int) { DFAKE_SCOPED_LOCK(push_pop_); ... }
  int pop() { DFAKE_SCOPED_LOCK(push_pop_); ... }
  ...
private:
  DFAKE_MUTEX(push_pop_);
};

// Example: Queue implementation non thread-safe but still usable if clients
//          are synchronized somehow, it calls a method to "protect" from
//          a "protected" method
//
//          In this case the macro DFAKE_SCOPED_RECURSIVE_LOCK
//          has to be used, it checks that if a thread is inside the push/pop
//          then noone else is still inside the pop/push

class NonThreadSafeQueue {
 public:
  void push(int) {
    DFAKE_SCOPED_LOCK(push_pop_);
    ...
  }
  int pop() {
    DFAKE_SCOPED_RECURSIVE_LOCK(push_pop_);
    bar();
    ...
  }
  void bar() { DFAKE_SCOPED_RECURSIVE_LOCK(push_pop_); ... }
  ...
 private:
  DFAKE_MUTEX(push_pop_);
};

// Example: Queue implementation not usable even if clients are synchronized,
//          so only one thread in the class life cycle can use the two members
//          push/pop.
//
//          In this case the macro DFAKE_SCOPED_LOCK_THREAD_LOCKED pins the
//          specified
//          critical section the first time a thread enters push or pop, from
//          that time on only that thread is allowed to execute push or pop.

class NonThreadSafeQueue {
 public:
  ...
  void push(int) { DFAKE_SCOPED_LOCK_THREAD_LOCKED(push_pop_); ... }
  int pop() { DFAKE_SCOPED_LOCK_THREAD_LOCKED(push_pop_); ... }
  ...
 private:
  DFAKE_MUTEX(push_pop_);
};

// Example: Class that has to be contructed/destroyed on same thread, it has
//          a "shareable" method (with external synchronization) and a not
//          shareable method (even with external synchronization).
//
//          In this case 3 Critical sections have to be defined

class ExoticClass {
 public:
  ExoticClass() { DFAKE_SCOPED_LOCK_THREAD_LOCKED(ctor_dtor_); ... }
  ~ExoticClass() { DFAKE_SCOPED_LOCK_THREAD_LOCKED(ctor_dtor_); ... }

  void Shareable() { DFAKE_SCOPED_LOCK(shareable_section_); ... }
  void NotShareable() { DFAKE_SCOPED_LOCK_THREAD_LOCKED(ctor_dtor_); ... }
  ...
 private:
  DFAKE_MUTEX(ctor_dtor_);
  DFAKE_MUTEX(shareable_section_);
};