serialization.hpp

Go to the documentation of this file.

#pragma once
 
 
#include <conduit/envelope.hpp>
#include <conduit/event.hpp>
#include <conduit/exception.hpp>
 
#include <cstdint>
#include <memory>
#include <mutex>
#include <shared_mutex>
#include <span>
#include <vector>
 
#include <parcel/parcel.h>
 
namespace conduit {
 
class EventRegistry {
public:
    EventRegistry() {
        auto reg = std::make_shared<parcel::ParcelRegistry>();
        reg->register_cells<EventEnvelope>();
        registry_ = std::move(reg);
    }
 
    EventRegistry(const EventRegistry& other) {
        const auto snap = other.snapshot();
        registry_ = std::make_shared<parcel::ParcelRegistry>(*snap);
    }
 
    EventRegistry(EventRegistry&&) noexcept = delete;
    EventRegistry& operator=(const EventRegistry&) = delete;
    EventRegistry& operator=(EventRegistry&&) noexcept = delete;
    ~EventRegistry() = default;
 
    template <typename T>
    EventRegistry& add() {
        add_descriptor(T::descriptor());
        return *this;
    }
 
    EventRegistry& add_descriptor(parcel::cell_type_descriptor_t desc) {
        const auto current = snapshot();
        auto next = std::make_shared<parcel::ParcelRegistry>(*current);
        next->register_kind(std::move(desc));
        std::unique_lock lock(mu_);
        registry_ = std::move(next);
        return *this;
    }
 
    [[nodiscard]] EventEnvelope decode_json(parcel::json_t const& j) const {
        const auto reg = snapshot();
        try {
            const auto cell = EventEnvelope::from_json(j, *reg);
            const auto env = parcel::cell_cast<EventEnvelope>(cell);
            return *env;
        } catch (const parcel::ParcelException& e) {
            throw SerializationError{e.what()};
        }
    }
 
    [[nodiscard]] EventEnvelope decode_cbor(std::span<const std::uint8_t> bytes) const {
        try {
            const auto j = parcel::json_t::from_cbor(bytes);
            return decode_json(j);
        } catch (const parcel::ParcelException& e) {
            throw SerializationError{e.what()};
        } catch (const SerializationError&) {
            throw;
        } catch (const std::exception& e) {
            throw SerializationError{e.what()};
        }
    }
 
    [[nodiscard]] EventEnvelope decode_cbor(std::span<const char> bytes) const {
        try {
            const auto j = parcel::json_t::from_cbor(bytes);
            return decode_json(j);
        } catch (const parcel::ParcelException& e) {
            throw SerializationError{e.what()};
        } catch (const SerializationError&) {
            throw;
        } catch (const std::exception& e) {
            throw SerializationError{e.what()};
        }
    }
 
    [[nodiscard]] std::shared_ptr<const parcel::ParcelRegistry>
    parcel_registry_snapshot() const noexcept {
        return snapshot();
    }
 
private:
    [[nodiscard]] std::shared_ptr<parcel::ParcelRegistry> snapshot() const {
        std::shared_lock lock(mu_);
        return registry_;
    }
 
    mutable std::shared_mutex mu_;
    std::shared_ptr<parcel::ParcelRegistry> registry_;
};
 
[[nodiscard]] inline parcel::json_t encode_json(const EventEnvelope& env) {
    return env.to_json();
}
 
[[nodiscard]] inline std::vector<char> encode_cbor(const EventEnvelope& env) {
    std::vector<char> out;
    parcel::json_t::to_cbor(env.to_json(), out);
    return out;
}
 
namespace serialization {
 
using EventRegistry = ::conduit::EventRegistry;
 
using ::conduit::encode_cbor;
using ::conduit::encode_json;
 
}  // namespace serialization
 
}  // namespace conduit