InitiallyPausedThread.h

Go to the documentation of this file.

#pragma once
 
#include "Utility/IMoveOnly.h"
 
#include <Common/debug.h>
#include <Common/exceptions.h>
#include <Common/logging.h>
 
#include <thread>
#include <future>
#include <functional>
#include <utility>
 
namespace ph
{
 
class InitiallyPausedThread final : private IMoveOnly
{
public:
    InitiallyPausedThread();
 
    inline InitiallyPausedThread(InitiallyPausedThread&& other) = default;
 
    template<typename Func, typename... Args>
    explicit InitiallyPausedThread(Func&& func, Args&&... args);
 
    ~InitiallyPausedThread();
 
    void start();
 
    void join();
 
    bool hasStarted() const;
 
    bool hasJoined() const;
 
    std::thread::id getId() const;
 
    inline InitiallyPausedThread& operator = (InitiallyPausedThread&& rhs) = default;
 
private:
    void setPromisedValue(bool value);
    bool isEmptyThread() const;
 
    std::thread        m_thread;
    std::promise<bool> m_startPromise;
    bool               m_hasStarted;
    bool               m_hasJoined;
};
 
template<typename Func, typename... Args>
inline InitiallyPausedThread::InitiallyPausedThread(Func&& func, Args&&... args)
    : InitiallyPausedThread()
{
    m_thread = std::thread(
        [startFuture = m_startPromise.get_future(),
         func = std::bind(std::forward<Func>(func), std::forward<Args>(args)...)]
        () mutable
        {
            try
            {
                if(startFuture.get())
                {
                    func();
                }
            }
            catch(const Exception& e)
            {
                PH_DEFAULT_LOG(Error,
                    "[InitiallyPausedThread] unhandled exception thrown: {}", e.what());
 
                PH_DEBUG_BREAK();
            }
        });
}
 
inline bool InitiallyPausedThread::hasStarted() const
{
    return m_hasStarted;
}
 
inline bool InitiallyPausedThread::hasJoined() const
{
    return m_hasJoined;
}
 
inline std::thread::id InitiallyPausedThread::getId() const
{
    return m_thread.get_id();
}
 
inline bool InitiallyPausedThread::isEmptyThread() const
{
    return m_thread.get_id() == std::thread::id();
}
 
}// end namespace ph