descriptor.h

Go to the documentation of this file.

#pragma once
 
#include <parcel/cell.h>
#include <parcel/common.h>
 
#include <map>
#include <memory>
#include <string>
#include <string_view>
#include <typeindex>
#include <typeinfo>
#include <utility>
#include <vector>
 
namespace parcel::descriptor {
 
enum class CellCategory { Primitive, TypedList, List, TypedMap, Map, Struct, Union, Custom };
 
NLOHMANN_JSON_SERIALIZE_ENUM(CellCategory,
                             {
                                 {CellCategory::Primitive, "primitive"},
                                 {CellCategory::TypedList, "typed_list"},
                                 {CellCategory::List, "list"},
                                 {CellCategory::TypedMap, "typed_map"},
                                 {CellCategory::Map, "map"},
                                 {CellCategory::Struct, "struct"},
                                 {CellCategory::Union, "union"},
                                 {CellCategory::Custom, "custom"},
                             })
 
}  // namespace parcel::descriptor
 
namespace parcel {
class ParcelRegistry;
 
struct ICellTypeDescriptor {
    virtual ~ICellTypeDescriptor() = default;
 
    [[nodiscard]] virtual std::string_view kind() const = 0;
 
    [[nodiscard]] virtual DisplayInfo display_info() const = 0;
 
    [[nodiscard]] virtual descriptor::CellCategory category() const = 0;
 
    [[nodiscard]] virtual std::type_index storage_type() const = 0;
 
    [[nodiscard]] virtual cell_t cell_from_json(const json_t& j,
                                                ParcelRegistry const& reg) const = 0;
 
    [[nodiscard]] virtual json_t to_json() const = 0;
};
 
struct IFieldDescriptor {
    virtual ~IFieldDescriptor() = default;
 
    [[nodiscard]] virtual std::string_view key() const = 0;
 
    [[nodiscard]] virtual std::string_view kind() const = 0;
 
    [[nodiscard]] virtual DisplayInfo display_info() const = 0;
 
    [[nodiscard]] virtual bool is_required() const = 0;
 
    [[nodiscard]] virtual json_t to_json() const = 0;
};
 
using field_descriptor_t = std::shared_ptr<IFieldDescriptor>;
 
using field_descriptors_t = std::map<std::string, field_descriptor_t>;
 
struct IHasFields {
    virtual ~IHasFields() = default;
 
    [[nodiscard]] virtual field_descriptors_t fields() const = 0;
};
 
struct ISubTypes {
    virtual ~ISubTypes() = default;
 
    [[nodiscard]] virtual std::vector<std::string_view> sub_kinds() const = 0;
};
 
template <CellLike T>
class BaseCellTypeDescriptor : public virtual ICellTypeDescriptor {
public:
    using cell_type = T;
 
    static constexpr std::string_view kind_id = T::kind_id;
 
    explicit BaseCellTypeDescriptor(DisplayInfo info) : display_info_(std::move(info)) {}
 
    [[nodiscard]] std::string_view kind() const override {
        return kind_id;
    }
 
    [[nodiscard]] DisplayInfo display_info() const override {
        return display_info_;
    }
 
    [[nodiscard]] std::type_index storage_type() const override {
        return std::type_index(typeid(typename T::storage_t));
    }
 
    [[nodiscard]] json_t to_json() const override {
        return base_to_json();
    }
 
protected:
    DisplayInfo display_info_;
 
    [[nodiscard]] json_t base_to_json() const {
        return json_t{
            {"kind", kind_id},
            {"display_info", json_t(display_info_)},
            {"category", this->category()},
        };
    }
};
 
template <CellLike T>
class SimpleCellTypeDescriptor final : public BaseCellTypeDescriptor<T> {
public:
    using cell_type = T;
 
    explicit SimpleCellTypeDescriptor(DisplayInfo info)
        : BaseCellTypeDescriptor<T>(std::move(info)) {}
 
    [[nodiscard]] descriptor::CellCategory category() const override {
        return descriptor::CellCategory::Primitive;
    }
 
    [[nodiscard]] cell_t cell_from_json(const json_t& j, const ParcelRegistry& reg) const override {
        return T::from_json(j, reg);
    }
};
 
}  // namespace parcel