lifecycle.h

Go to the documentation of this file.

#pragma once
 
#include <parcel/cell.h>
#include <parcel/common.h>
#include <parcel/defaults.h>
#include <parcel/descriptor.h>
#include <parcel/json.h>
 
#include <commons/json/lifecycle.hpp>
#include <commons/lifecycle.hpp>
 
#include <compare>
#include <string>
#include <string_view>
#include <vector>
 
namespace parcel {
 
class LifecycleStatusCell : public BaseCell<LifecycleStatusCell, comms::LifecycleStatus> {
    using base_t = BaseCell<LifecycleStatusCell, comms::LifecycleStatus>;
 
public:
    using base_t::base_t;
    using base_t::operator=;
 
    static constexpr std::string_view kind_id = "lifecycle_status";
 
    [[nodiscard]] std::string to_string() const override {
        return this->value.name();
    }
 
    static cell_t from_json(json_t const& j, ParcelRegistry const&) {
        return base_t::from_json_strict(j);
    }
 
    static cell_type_descriptor_t descriptor() {
        static const auto d = std::make_shared<SimpleCellTypeDescriptor<LifecycleStatusCell>>(
            DisplayInfo{.name = "LifecycleStatus",
                        .description = "Lifecycle status (string name on the wire)"});
        return d;
    }
};
 
template <CellLike P = LifecycleStatusCell>
class StatusTransitionCell
    : public BaseCell<StatusTransitionCell<P>, comms::StatusTransition<typename P::storage_t>> {
    using base_t = BaseCell<StatusTransitionCell, comms::StatusTransition<typename P::storage_t>>;
 
    [[nodiscard]] static std::string render(const typename P::storage_t& s) {
        return P{s}.to_string();
    }
 
public:
    using element_type = P;
 
    using base_t::base_t;
    using base_t::operator=;
 
    static constexpr std::string_view kind_id = prefixed_id_v<"status_transition:", P::kind_id>;
 
    [[nodiscard]] std::string to_string() const override {
        return this->value.previous
                   ? render(*this->value.previous) + " \xe2\x86\x92 " + render(this->value.status)
                   : render(this->value.status);
    }
 
    static cell_t from_json(json_t const& j, ParcelRegistry const&) {
        return base_t::from_json_strict(j);
    }
 
    static cell_type_descriptor_t descriptor() {
        static const auto d = std::make_shared<SimpleCellTypeDescriptor<StatusTransitionCell>>(
            DisplayInfo{.name = "StatusTransition",
                        .description = std::string("Lifecycle transition event (status of ") +
                                       std::string(P::kind_id) + ")"});
        return d;
    }
};
 
template <CellLike P = LifecycleStatusCell>
class StatusReportCell
    : public BaseCell<StatusReportCell<P>, comms::StatusReport<typename P::storage_t>> {
    using base_t = BaseCell<StatusReportCell, comms::StatusReport<typename P::storage_t>>;
 
public:
    using element_type = P;
 
    using base_t::base_t;
    using base_t::operator=;
 
    static constexpr std::string_view kind_id = prefixed_id_v<"status_report:", P::kind_id>;
 
    [[nodiscard]] std::string to_string() const override {
        return P{this->value.status}.to_string();
    }
 
    static cell_t from_json(json_t const& j, ParcelRegistry const&) {
        return base_t::from_json_strict(j);
    }
 
    static cell_type_descriptor_t descriptor() {
        static const auto d = std::make_shared<SimpleCellTypeDescriptor<StatusReportCell>>(
            DisplayInfo{.name = "StatusReport",
                        .description = std::string("Per-status period summary (status of ") +
                                       std::string(P::kind_id) + ")"});
        return d;
    }
};
 
template <CellLike P = LifecycleStatusCell>
class StatusTransitionTimelineCell
    : public BaseCell<StatusTransitionTimelineCell<P>,
                      std::vector<comms::StatusTransition<typename P::storage_t>>> {
    using base_t = BaseCell<StatusTransitionTimelineCell,
                            std::vector<comms::StatusTransition<typename P::storage_t>>>;
 
public:
    using element_type = P;
    using status_t = typename P::storage_t;
    using transition_t = comms::StatusTransition<status_t>;
    using timeline_t = comms::StatusTransitionTimeline<status_t>;
 
    using base_t::base_t;
    using base_t::operator=;
 
    explicit StatusTransitionTimelineCell(const timeline_t& tl) : base_t(tl.transitions()) {}
 
    static constexpr std::string_view kind_id =
        prefixed_id_v<"status_transition_timeline:", P::kind_id>;
 
    void load_into(timeline_t& tl) const {
        tl.load_transitions(this->value);
    }
 
    [[nodiscard]] std::string to_string() const override {
        return "[" + std::to_string(this->value.size()) + " status transitions]";
    }
 
    // std::vector storage opts out of BaseCell's default compare (see list.h), so
    // compare element-wise here — StatusTransition is equality-comparable only.
    [[nodiscard]] std::partial_ordering compare(ICell const& other) const override {
        if (const auto k = this->kind() <=> other.kind(); k != 0) {
            return k;
        }
        const auto* o = dynamic_cast<StatusTransitionTimelineCell const*>(&other);
        if (o == nullptr) {
            return std::partial_ordering::unordered;
        }
        return this->value == o->value ? std::partial_ordering::equivalent
                                       : std::partial_ordering::unordered;
    }
 
    static cell_t from_json(json_t const& j, ParcelRegistry const&) {
        return base_t::from_json_strict(j);
    }
 
    static cell_type_descriptor_t descriptor() {
        static const auto d =
            std::make_shared<SimpleCellTypeDescriptor<StatusTransitionTimelineCell>>(
                DisplayInfo{.name = "StatusTransitionTimeline",
                            .description = std::string("Lifecycle transition history (status of ") +
                                           std::string(P::kind_id) + ")"});
        return d;
    }
};
 
}  // namespace parcel
 
PARCEL_DEFAULT_CELL(parcel::LifecycleStatusCell);
PARCEL_DEFAULT_CELL(parcel::StatusTransitionCell<parcel::LifecycleStatusCell>);
PARCEL_DEFAULT_CELL(parcel::StatusReportCell<parcel::LifecycleStatusCell>);
PARCEL_DEFAULT_CELL(parcel::StatusTransitionTimelineCell<parcel::LifecycleStatusCell>);