mcc/tests/mcc_keyvalue_test.cpp

#include <print>

#include <mcc/mcc_keyvalue.h>

using namespace mcc::impl;


// example of non-default constructible class
struct VT {
    VT(int v) : _v(v) {}

    void set(int v)
    {
        _v = v;
    }

    int v() const
    {
        return _v;
    }

protected:
    int _v{};
};


template <>
struct mcc::impl::MccSerializer<VT> : MccSerializerBase {
    static constexpr std::string_view serializerName{"MCC-VT-SERIALIZER"};

    template <mcc_serialization_params_c ParamsT = mcc_serialization_params_t>
    error_t operator()(traits::mcc_output_char_range auto& output,
                       VT const& value,
                       ParamsT const& params = mcc_serialization_params_t{})
    {
        return MccSerializer<int>{}(output, value.v(), params);
    }
};

template <>
struct mcc::impl::MccDeserializer<VT> : MccDeserializerBase {
    static constexpr std::string_view deserializerName{"MCC-VT-DESERIALIZER"};

    template <mcc_serialization_params_c ParamsT = mcc_serialization_params_t>
    error_t operator()(traits::mcc_input_char_range auto const& input,
                       VT& value,
                       ParamsT const& params = mcc_serialization_params_t{})
    {
        int v;
        auto err = MccDeserializer<int>{}(input, v, params);
        if (!err) {
            value.set(v);
        }

        return err;
    }
};


static auto kv_desc = std::make_tuple(
    mcc_simple_kv_record_t{"bb", MccAngle{11.5_degs}, MccAngle{11.5_degs}, mcc_serialization_params_t{}},
    mcc_simple_kv_record_t{"aaa", std::string("AAA"), std::string("AAA"), mcc_serialization_params_t{}},
    mcc_simple_kv_record_t{"cc", MccCelestialCoordEpoch{}, MccCelestialCoordEpoch{}, mcc_serialization_params_t{}},
    mcc_simple_kv_record_t{
        "ddd", MccAngle{11.5_degs}, MccAngle{11.5_degs},
        mcc_serialization_params_t{.angle_format = mcc::MccSerializedAngleFormat::MCC_SERIALIZED_FORMAT_SXGM_HOURS}},
    mcc_make_simple_kv_record("eee", 1.5),
    mcc_make_simple_kv_record("arr", std::vector<int>{1, 2, 3, 4, 5, 6, 7}),
    mcc_make_simple_kv_record("vt", VT(77)),
    mcc_make_simple_kv_record("sarr", std::array<double, 3>{1, 2, 3}));



static std::string STR = R"--(

aaa = dewl_ewkj23+23998

#
# this is angle
bb=1.24534
cc=   2026-05-15T05:53:20.921723918 # date UTC

)--";

static std::string STR1 = R"--(
aaa = dewl_ewkj23+23998

#
# this is obs date
cc=   2026-05-15T05:53:20.921723918 # date UTC

ddd = 01:02:33.434 # HA in hours:mins:secs
)--";

int main()
{
    std::error_code err;
    std::string buff;

    MccKeyValueHolder kv(kv_desc);

    err = kv.toCharRange(buff);
    if (err) {
        std::println("ERR = {}", err);
        return 1;
    }
    std::println("DEFAULT VALUES:");
    std::println("--(\n{})--", buff);
    std::println("\n\n");


    err = kv.setValue("eee", 15.1515);
    if (err) {
        std::println("ERR = {}", err);
        // return 1;
    }

    // auto err = kv.fromCharRange(STR);
    err = kv.fromCharRange(STR1);
    if (err) {
        std::println("ERR = {}", err);
        return 1;
    }

    std::println("{} = {}", "bb", kv.getValue<MccAngle>(std::string{"bb"}).value().sexagesimal());
    std::println("{} = {}", "cc", kv.getValue<MccCelestialCoordEpoch>("cc").value().UTC());

    err = kv.setValue("cc", std::chrono::system_clock::now());
    if (err) {
        std::println("ERR = {}", err);
        // return 1;
    }

    err = kv.setValue("aaa", "OK");
    if (err) {
        std::println("ERR = {}", err);
        // return 1;
    }

    err = kv.setValue("ddd", 37.5_degs);
    if (err) {
        std::println("ERR = {}", err);
        // return 1;
    }

    err = kv.setValue("arr", std::array{10, 20, 30});
    if (err) {
        std::println("ERR = {}", err);
        // return 1;
    }

    err = kv.setValue("sarr", std::vector{10, 20, 30, 40, 50});
    if (err) {
        std::println("ERR = {}", err);
        // return 1;
    }

    std::println("------------------------------------");


    buff.clear();
    err = kv.toCharRange<decltype(kv)::OPOLICY_FULL>(buff);
    // err = kv.toCharRange(buff);
    if (err) {
        std::println("ERR = {}", err);
        return 1;
    }

    std::println("--(\n{}\n)--", buff);

    std::print("KEYS: ");
    for (auto const& k : kv.keys()) {
        std::print("{} ", k);
    }
    std::println("");

    return 0;
}