context.h

// Copyright (c) 2020-now by the Zeek Project. See LICENSE for details.
 
#pragma once
 
#include <cassert>
#include <memory>
#include <utility>
#include <vector>
 
#include <hilti/rt/fiber.h>
#include <hilti/rt/threading.h>
 
namespace hilti::rt {
 
struct Context {
    explicit Context(vthread::ID vid);
    ~Context();
 
    Context() = delete;
    Context(const Context&) = delete;
    Context(Context&&) = delete;
    Context& operator=(const Context&) = delete;
    Context& operator=(Context&&) = delete;
 
    vthread::ID vid;
 
    resumable::Handle* resumable = nullptr;
 
    detail::FiberContext fiber;
 
    std::vector<std::shared_ptr<void>> hilti_globals;
 
    void* cookie = nullptr;
 
    uint64_t debug_indent{};
 
    const char* location = nullptr;
};
 
namespace context {
namespace detail {
 
extern Context*& current();
 
extern Context* master();
 
inline auto get(bool allow_missing_context = false) {
    auto* ctx = current();
 
    if ( ! allow_missing_context )
        assert(ctx);
 
    return ctx;
}
 
hilti::rt::Context* set(Context* ctx);
 
class ResumableSetter {
public:
    explicit ResumableSetter(resumable::Handle* r) {
        old = get()->resumable;
        get()->resumable = r;
    }
 
    ~ResumableSetter() { get()->resumable = old; }
 
    ResumableSetter(const ResumableSetter&) = delete;
    ResumableSetter(ResumableSetter&&) = delete;
    ResumableSetter& operator=(const ResumableSetter&) = delete;
    ResumableSetter& operator=(ResumableSetter&&) = delete;
 
    resumable::Handle* old;
};
 
} // namespace detail
 
inline void saveCookie(void* cookie) { detail::get()->cookie = cookie; }
 
inline void* cookie() { return detail::get()->cookie; }
 
inline void clearCookie() { detail::get()->cookie = nullptr; }
 
class CookieSetter {
public:
    explicit CookieSetter(void* cookie) {
        _old = detail::get()->cookie;
        detail::get()->cookie = cookie;
    }
 
    ~CookieSetter() { detail::get()->cookie = _old; }
 
    CookieSetter() = delete;
    CookieSetter(const CookieSetter&) = delete;
    CookieSetter(CookieSetter&&) = delete;
    CookieSetter& operator=(const CookieSetter&) = delete;
    CookieSetter& operator=(CookieSetter&&) = delete;
 
private:
    void* _old;
};
 
template<typename Function, typename... Params>
Resumable execute(Function f, Params&&... params) {
    auto cb = [&](resumable::Handle* r) {
        auto _ = detail::ResumableSetter(r);
        return f(std::forward<Params>(params)...);
    };
 
    Resumable r(std::move(cb));
    r.run();
    return r;
}
 
} // namespace context
} // namespace hilti::rt