Threads.h

#pragma once
 
#include "../FoundationBase.h"
 
#include <future>
#include <mutex>
#include <thread>
 
namespace Cogs {
#if defined(COGS_SINGLETHREADED)
 
  struct Mutex {
    constexpr void lock() noexcept {}
    constexpr void unlock() noexcept {}
  };
 
  struct [[nodiscard]] LockGuard {
    constexpr LockGuard(Mutex& m) noexcept : mutex(m) { mutex.lock(); }
    constexpr ~LockGuard() noexcept { mutex.unlock(); }
 
  private:
    Mutex& mutex;
  };
 
  struct [[nodiscard]] UniqueLock {
    constexpr UniqueLock(Mutex& m) noexcept : mutex(m) { mutex.lock(); }
    constexpr ~UniqueLock() noexcept { mutex.unlock(); }
    constexpr UniqueLock(Mutex& m, std::defer_lock_t /*t*/) noexcept
      : mutex(m)
    {
    }
 
    constexpr void lock() { mutex.lock(); }
 
    constexpr void unlock() { mutex.unlock(); }
 
  private:
    Mutex& mutex;
  };
 
  struct Thread {
  };
 
  template<typename T> struct Future {
    T     get() { return T(); }
    bool  valid() { return true; }
  };
 
  template<> struct Future<void> {
    void get() {}
    bool valid() { return true; }
  };
 
#else
  typedef std::thread             Thread;
  typedef std::mutex              Mutex;
  typedef std::lock_guard<Mutex>  LockGuard;
  typedef std::unique_lock<Mutex> UniqueLock;
 
  template<typename T> using Future = std::future<T>;
#endif
 
  namespace Threads {
    COGSFOUNDATION_API void    setName(Thread& thread, const std::string& name);
    COGSFOUNDATION_API void    sleep(int milliseconds);
    COGSFOUNDATION_API void    yield();
    COGSFOUNDATION_API size_t  hardwareConcurrency();
  }
}