run_scope.cpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
#include <entropic/types/run_scope.h>
 
#include <string>
#include <utility>
 
namespace entropic {
 
namespace {
 
thread_local std::atomic<bool>* t_run_cancel = nullptr;
 
}  // namespace
 
const std::atomic<bool>* current_run_cancel() { return t_run_cancel; }
 
bool current_run_cancelled() {
    return t_run_cancel != nullptr
        && t_run_cancel->load(std::memory_order_acquire);
}
 
RunCancelScope::RunCancelScope(std::atomic<bool>* token)
    : previous_(t_run_cancel) {
    t_run_cancel = token;
}
 
bool cancel_current_run() {
    if (t_run_cancel == nullptr) {
        return false;
    }
    t_run_cancel->store(true, std::memory_order_release);
    return true;
}
 
RunCancelScope::~RunCancelScope() { t_run_cancel = previous_; }
 
namespace {
thread_local std::string t_run_session;
}  // namespace
 
std::string current_run_session() { return t_run_session; }
 
RunSessionScope::RunSessionScope(std::string key)
    : previous_(t_run_session) {
    t_run_session = std::move(key);
}
 
RunSessionScope::~RunSessionScope() {
    t_run_session = std::move(previous_);
}
 
namespace {
 
thread_local RunStreamFn t_run_stream_fn = nullptr;
thread_local void* t_run_stream_ud = nullptr;
 
}  // namespace
 
bool emit_to_current_run_stream(const char* chunk, size_t len) {
    const bool installed = t_run_stream_fn != nullptr;
    if (installed) { t_run_stream_fn(chunk, len, t_run_stream_ud); }
    return installed;
}
 
RunStreamScope::RunStreamScope(RunStreamFn fn, void* user_data)
    : previous_fn_(t_run_stream_fn), previous_ud_(t_run_stream_ud) {
    t_run_stream_fn = fn;
    t_run_stream_ud = user_data;
}
 
RunStreamScope::~RunStreamScope() {
    t_run_stream_fn = previous_fn_;
    t_run_stream_ud = previous_ud_;
}
 
}  // namespace entropic