context.hpp

/*
 * This file is part of libtcspc
 * Copyright 2019-2026 Board of Regents of the University of Wisconsin System
 * SPDX-License-Identifier: MIT
 */
 
#pragma once
 
#include <any>
#include <cassert>
#include <cstddef>
#include <functional>
#include <memory>
#include <stdexcept>
#include <string>
#include <unordered_map>
#include <utility>
 
namespace tcspc {
 
class context;

template <typename Accessor> class access_tracker {
    std::shared_ptr<context> ctx; // Null iff 'empty' state.
    std::string name;
    std::function<Accessor(access_tracker &)> accessor_factory;
 
    friend class context;
 
    // Construct only via friend context.
    explicit access_tracker(std::shared_ptr<context> context, std::string name)
        : ctx(std::move(context)), name(std::move(name)) {}
 
  public:
    access_tracker() = default;

    access_tracker(access_tracker const &) = delete;
    auto operator=(access_tracker const &) = delete;
 
    // Definitions for move and destruction are below, out of line.
    access_tracker(access_tracker &&other) noexcept;
    auto operator=(access_tracker &&rhs) noexcept -> access_tracker &;
    ~access_tracker();

    template <typename F> void register_accessor_factory(F factory) {
        assert(ctx);
        assert(not accessor_factory);
        accessor_factory = std::move(factory);
    }
};

class context : public std::enable_shared_from_this<context> {
    // Map keys are names identifying the tracked object and values are pointer
    // to access_tracker<Accessor> for some Accessor. Values are kept up to
    // date when a tracker is moved or destroyed. If the tracked object has
    // been destroyed, the entry remains and the value is an empty std::any()).
    // Reuse of name is not allowed.
    std::unordered_map<std::string, std::any> trackers;
 
    template <typename Accessor> friend class access_tracker;
 
    template <typename Accessor>
    void update_tracker_address(std::string const &name,
                                access_tracker<Accessor> *ptr) {
        // Enforce no type change in std::any; just update the value directly.
        *std::any_cast<access_tracker<Accessor> *>(&trackers.at(name)) = ptr;
    }
 
    context() = default;
 
  public:
    // Move not permitted (only handled by shared_ptr).
    context(context const &) = delete;
    auto operator=(context const &) = delete;
    context(context &&) = delete;
    auto operator=(context &&) = delete;
    ~context() = default;

    static auto create() -> std::shared_ptr<context> {
        return std::shared_ptr<context>(new context());
    }

    template <typename Accessor>
    auto tracker(std::string name) -> access_tracker<Accessor> {
        if (trackers.count(name) != 0) {
            throw std::logic_error(
                "cannot create tracker for existing name: " + name);
        }
        auto ret =
            access_tracker<Accessor>(shared_from_this(), std::move(name));
        trackers.insert({ret.name, std::any(&ret)});
        return ret;
    }

    template <typename Accessor>
    auto access(std::string const &name) -> Accessor {
        auto tracker_ptr =
            std::any_cast<access_tracker<Accessor> *>(trackers.at(name));
        if (tracker_ptr == nullptr)
            throw std::logic_error("cannot access destroyed object: " + name);
        return tracker_ptr->accessor_factory(*tracker_ptr);
    }
};

 
// Move/destroy for access_tracker, defined out-of-line because they require
// the definition of context.
 
template <typename Accessor>
access_tracker<Accessor>::access_tracker(access_tracker &&other) noexcept
    : ctx(std::move(other.ctx)), name(std::move(other.name)),
      accessor_factory(std::move(other.accessor_factory)) {
    if (ctx)
        ctx->update_tracker_address(name, this);
}
 
template <typename Accessor>
auto access_tracker<Accessor>::operator=(access_tracker &&rhs) noexcept
    -> access_tracker & {
    ctx = std::move(rhs.ctx);
    name = std::move(rhs.name);
    accessor_factory = std::move(rhs.accessor_factory);
    if (ctx)
        ctx->update_tracker_address(name, this);
    return *this;
}
 
template <typename Accessor> access_tracker<Accessor>::~access_tracker() {
    if (ctx)
        ctx->update_tracker_address<Accessor>(name, nullptr);
}

 
// NOLINTBEGIN
 
// Locally silence GCC/Clang warnings for using offsetof() on
// non-standard-layout types. Semicolons used only to assist clang-format.
#if defined(__GNUC__) || defined(__clang__)
#define LIBTCSPC_INTERNAL_DISABLE_OFFSETOF_WARNING                            \
    _Pragma("GCC diagnostic push");                                           \
    _Pragma("GCC diagnostic ignored \"-Winvalid-offsetof\"")
#define LIBTCSPC_INTERNAL_POP_OFFSETOF_WARNING _Pragma("GCC diagnostic pop")
#else
#define LIBTCSPC_INTERNAL_DISABLE_OFFSETOF_WARNING
#define LIBTCSPC_INTERNAL_POP_OFFSETOF_WARNING
#endif

#define LIBTCSPC_OBJECT_FROM_TRACKER(obj_type, tracker_field_name, tracker)   \
    std::invoke([&tracker]() {                                                \
        LIBTCSPC_INTERNAL_DISABLE_OFFSETOF_WARNING;                           \
        return reinterpret_cast<std::add_pointer_t<obj_type>>(                \
            reinterpret_cast<std::byte *>(&(tracker)) -                       \
            offsetof(obj_type, tracker_field_name));                          \
        LIBTCSPC_INTERNAL_POP_OFFSETOF_WARNING;                               \
    })
 
// Note: offsetof() is "conditionally-supported" on non-standard-layout types
// as of C++17. I expect this not to be a problem in practice, as long as
// virtual inheritance is not involved.
 
// Pointer arithmetic on the underlying bytes of an object is technically
// undefined behavior in C++ (but not C), because no array of bytes was created
// there. But compilers treat this as valid (see https://wg21.link/p1839r6).
// (Also see https://wg21.link/p3407r0 on another technical aspect.)
 
// NOLINTEND
 
} // namespace tcspc