parcel.hpp

Go to the documentation of this file.

#pragma once
 
 
#include <threadman/config.hpp>
 
#if !THREADMAN_WITH_NLOHMANN_JSON
#error "threadman/parcel.hpp requires THREADMAN_WITH_NLOHMANN_JSON to be enabled \
(parcel pulls in nlohmann/json — the threadman cell adapters rely on the JSON-gated \
to_json/from_json overloads of the snapshot types)."
#endif
 
#include <threadman/json.hpp>
#include <threadman/stats.hpp>
 
#include <parcel/parcel.h>
 
#include <memory>
#include <sstream>
#include <string>
#include <string_view>
 
namespace threadman {
 
class ThreadSnapshotCell : public parcel::BaseCell<ThreadSnapshotCell, ThreadSnapshot> {
    using base_t = parcel::BaseCell<ThreadSnapshotCell, ThreadSnapshot>;
 
public:
    using base_t::base_t;
    using base_t::operator=;
    static constexpr std::string_view kind_id = "tm:thread_snapshot";
 
    [[nodiscard]] std::string to_string() const override {
        std::ostringstream os;
        os << this->value.name << "#" << this->value.id;
        return os.str();
    }
 
    [[maybe_unused]] static parcel::cell_t from_json(parcel::json_t const& j,
                                                     parcel::ParcelRegistry const&) {
        return base_t::from_json_strict(j);
    }
 
    static parcel::cell_type_descriptor_t descriptor() {
        static const auto d =
            std::make_shared<parcel::SimpleCellTypeDescriptor<ThreadSnapshotCell>>(
                parcel::DisplayInfo{
                    .name = "ThreadSnapshot",
                    .description = "Snapshot of a ManagedThread.",
                });
        return d;
    }
};
 
class ThreadPoolStatsCell : public parcel::BaseCell<ThreadPoolStatsCell, ThreadPoolStats> {
    using base_t = parcel::BaseCell<ThreadPoolStatsCell, ThreadPoolStats>;
 
public:
    using base_t::base_t;
    using base_t::operator=;
    static constexpr std::string_view kind_id = "tm:thread_pool_stats";
 
    [[nodiscard]] std::string to_string() const override {
        std::ostringstream os;
        os << this->value.name << "#" << this->value.pool_id;
        return os.str();
    }
 
    [[maybe_unused]] static parcel::cell_t from_json(parcel::json_t const& j,
                                                     parcel::ParcelRegistry const&) {
        return base_t::from_json_strict(j);
    }
 
    static parcel::cell_type_descriptor_t descriptor() {
        static const auto d =
            std::make_shared<parcel::SimpleCellTypeDescriptor<ThreadPoolStatsCell>>(
                parcel::DisplayInfo{
                    .name = "ThreadPoolStats",
                    .description = "Headline counters and state of a ThreadPool.",
                });
        return d;
    }
};
 
class TaskSnapshotCell : public parcel::BaseCell<TaskSnapshotCell, TaskSnapshot> {
    using base_t = parcel::BaseCell<TaskSnapshotCell, TaskSnapshot>;
 
public:
    using base_t::base_t;
    using base_t::operator=;
    static constexpr std::string_view kind_id = "tm:task_snapshot";
 
    [[nodiscard]] std::string to_string() const override {
        std::ostringstream os;
        os << "task#" << this->value.id;
        return os.str();
    }
 
    [[maybe_unused]] static parcel::cell_t from_json(parcel::json_t const& j,
                                                     parcel::ParcelRegistry const&) {
        return base_t::from_json_strict(j);
    }
 
    static parcel::cell_type_descriptor_t descriptor() {
        static const auto d = std::make_shared<parcel::SimpleCellTypeDescriptor<TaskSnapshotCell>>(
            parcel::DisplayInfo{
                .name = "TaskSnapshot",
                .description = "Snapshot of a single submitted task.",
            });
        return d;
    }
};
 
class FutureSnapshotCell : public parcel::BaseCell<FutureSnapshotCell, FutureSnapshot> {
    using base_t = parcel::BaseCell<FutureSnapshotCell, FutureSnapshot>;
 
public:
    using base_t::base_t;
    using base_t::operator=;
    static constexpr std::string_view kind_id = "tm:future_snapshot";
 
    [[nodiscard]] std::string to_string() const override {
        return this->value.ready ? "future:ready" : "future:pending";
    }
 
    [[maybe_unused]] static parcel::cell_t from_json(parcel::json_t const& j,
                                                     parcel::ParcelRegistry const&) {
        return base_t::from_json_strict(j);
    }
 
    static parcel::cell_type_descriptor_t descriptor() {
        static const auto d =
            std::make_shared<parcel::SimpleCellTypeDescriptor<FutureSnapshotCell>>(
                parcel::DisplayInfo{
                    .name = "FutureSnapshot",
                    .description = "Snapshot of a Future/SharedFuture state.",
                });
        return d;
    }
};
 
class ManagerSummaryCell : public parcel::BaseCell<ManagerSummaryCell, ManagerSummary> {
    using base_t = parcel::BaseCell<ManagerSummaryCell, ManagerSummary>;
 
public:
    using base_t::base_t;
    using base_t::operator=;
    static constexpr std::string_view kind_id = "tm:manager_summary";
 
    [[nodiscard]] std::string to_string() const override {
        std::ostringstream os;
        os << "summary{pools=" << this->value.total_pools
           << ", workers=" << this->value.total_live_workers
           << ", queued=" << this->value.total_queued << "}";
        return os.str();
    }
 
    [[maybe_unused]] static parcel::cell_t from_json(parcel::json_t const& j,
                                                     parcel::ParcelRegistry const&) {
        return base_t::from_json_strict(j);
    }
 
    static parcel::cell_type_descriptor_t descriptor() {
        static const auto d =
            std::make_shared<parcel::SimpleCellTypeDescriptor<ManagerSummaryCell>>(
                parcel::DisplayInfo{
                    .name = "ManagerSummary",
                    .description = "Aggregate periodic snapshot of the ThreadManager world.",
                });
        return d;
    }
};
 
inline void register_cells(parcel::ParcelRegistry& registry) {
    registry.register_kind(ThreadSnapshotCell::descriptor());
    registry.register_kind(ThreadPoolStatsCell::descriptor());
    registry.register_kind(TaskSnapshotCell::descriptor());
    registry.register_kind(FutureSnapshotCell::descriptor());
    registry.register_kind(ManagerSummaryCell::descriptor());
}
 
}  // namespace threadman
 
PARCEL_DEFAULT_CELL(threadman::ThreadSnapshotCell);
PARCEL_DEFAULT_CELL(threadman::ThreadPoolStatsCell);
PARCEL_DEFAULT_CELL(threadman::TaskSnapshotCell);
PARCEL_DEFAULT_CELL(threadman::FutureSnapshotCell);
PARCEL_DEFAULT_CELL(threadman::ManagerSummaryCell);
 
#define THREADMAN_HAS_PARCEL 1