thread.h

// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
 
#pragma once
 
#include <xrpl/beast/unit_test/suite.h>
 
#include <exception>
#include <functional>
#include <string>
#include <thread>
#include <utility>
 
namespace beast::unit_test {

class Thread
{
private:
    Suite* s_ = nullptr;
    std::thread t_;
 
public:
    using Id = std::thread::id;
    using native_handle_type = std::thread::native_handle_type;
 
    Thread() = default;
    Thread(Thread const&) = delete;
    Thread&
    operator=(Thread const&) = delete;
 
    Thread(Thread&& other) : s_(other.s_), t_(std::move(other.t_))
    {
    }
 
    Thread&
    operator=(Thread&& other)
    {
        s_ = other.s_;
        t_ = std::move(other.t_);
        return *this;
    }
 
    template <class F, class... Args>
    explicit Thread(Suite& s, F&& f, Args&&... args) : s_(&s)
    {
        std::function<void(void)> b = [f = std::forward<F>(f),
                                       ... args = std::forward<Args>(args)]() mutable {
            std::invoke(f, args...);
        };
        t_ = std::thread(&Thread::run, this, std::move(b));
    }
 
    [[nodiscard]] bool
    joinable() const
    {
        return t_.joinable();
    }
 
    [[nodiscard]] std::thread::id
    getId() const
    {
        return t_.get_id();
    }
 
    static unsigned
    hardwareConcurrency() noexcept
    {
        return std::thread::hardware_concurrency();
    }
 
    void
    join()
    {
        t_.join();
        s_->propagateAbort();
    }
 
    void
    detach()
    {
        t_.detach();
    }
 
    void
    swap(Thread& other)
    {
        std::swap(s_, other.s_);
        std::swap(t_, other.t_);
    }
 
private:
    void
    run(std::function<void(void)> f)
    {
        try
        {
            f();
        }
        catch (Suite::AbortException const&)  // NOLINT(bugprone-empty-catch)
        {
        }
        catch (std::exception const& e)
        {
            s_->fail("unhandled exception: " + std::string(e.what()));
        }
        catch (...)
        {
            s_->fail("unhandled exception");
        }
    }
};
 
}  // namespace beast::unit_test