New idiom for creating non-movable objects with the builder pattern

[elBoberido]

Currently, when an object is not movable, the builder create method takes an out parameter reference to an optional<T> and returns an expected<void, Error>. This approach has a few drawbacks:

• the object cannot be initialized when declared
  • this has the additional drawback that other objects depending on the T in option<T> also cannot be initialized when declared
• one can call reset on the option any time and therefore theoretically one have to take care of this null-ability

I would much more prefer the following idiom shown with the Mutex as example

MutexStorage m_mutexStorage;
Mutex m_mutex{MutexBuilder().create(m_mutexStorage).expect("Valid Mutex")};

with

class Mutex;
class MutexStorage {
private:
  MutexStorage() noexcept = default;
  MutexStorage(const MutexStorage&) noexcept = delete;
  MutexStorage(MutexStorage&&) noexcept = delete;
  // also delete assignment operators

  expected<Mutex, MutexError> create(/*params*/) noexcept;

private:
  optional<pthread_mutex_t> m_handle;
  RefTrackerSource<pthread_mutex_t> m_refTrackerSource;
};

and

class Mutex {
public:
  Mutex(MutexStorage&&) noexcept = default;

  Mutex(const MutexStorage&) noexcept = delete;

  expected<void, MutexLockError> lock();
  // and so on

private:
  Mutex() noexcept = delete;

private:
  RefTracker<pthread_mutex_t> m_mutexHandle;
};

RefTrackerSource would provide the memory for an atomic refcount and RefTracker would access this memory via a relocatable pointer. When RefTrackerSource is destroyed but the refcount is not zero, the application will be terminated. This has the advantage that one cannot accidentally reset the Mutex (or the Semaphore which also uses this idiom). The only disadvantage is that Mutex could easily be moved to another thread but this could be prevented by adding an assert(false, "should not be moved") to the move ctor of Mutex. The move ctor will not be called on creation due to RVO but the move ctor must still be declared. This limitation is lifted with C++17 and then the runtime error would be propagated to a compile time error when one would try to move the Mutex. In this case, the RefTracker would not be required, only the MutexStorage and Mutex classes.