ADC/tests/adc_valueholder_test.cpp

#include <list>
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include <doctest/doctest.h>
#include <chrono>
#include <iostream>

#include "../common/adc_utils.h"
// #include "../common/adc_value_holder.h"
#include "../common/adc_value.h"


static double dbl_val = 99.99;

double gdbl()
{
    return dbl_val;
}


void sdbl(const double& v)
{
    dbl_val = v;
}


bool vdbl(const double& v)
{
    if (v < 1.0) {
        return false;
    }

    return true;
}


TEST_CASE("[ADC VALUEHOLDER]")
{
    int int_val = 10;

    auto getter = [&int_val]() { return int_val; };
    auto setter = [&int_val](const int& v) { int_val = v; };
    auto validator = [](const int& v) {
        if (v < 0)
            return false;
        else
            return true;
    };

    // adc::AdcValueHolder vht(getter, setter, adc::AdcValueHolder::_defaultTrivialConvTypes);
    adc::AdcValueHolder vht(adc::AdcValueHolder::_defaultTrivialConvTypes, getter, setter);
    adc::AdcValueHolder vh(getter, setter, validator);
    // auto vah = adc::make_arith_valueholder(getter, setter);
    auto vah = adc::makeArithmValue<adc::AdcValueHolder>(getter, setter);

    vh = 77;

    REQUIRE_EQ(int_val, 77);

    vh = 100;

    int res = vh;

    REQUIRE_EQ(res, 100);

    CHECK_THROWS_WITH_AS(vh = 1.1, "conversion function is not defined", std::system_error);
    CHECK_THROWS_WITH_AS(vh = -3, "user value is not valid", std::system_error);

    std::cout << "int_val = " << int_val << "\n";

    const double dv = 33.33;
    vah = dv;

    REQUIRE_EQ(int_val, 33);

    vah = 100;
    auto res_long = static_cast<unsigned long>(vah);

    REQUIRE_EQ(res_long, 100ul);

    vah = -10.1234;
    REQUIRE_EQ(int_val, -10);


    /*  std::string holder  */

    std::string str = "THIS IS A STRING";

    auto sget = [&str]() { return str; };
    auto sset = [&str](const std::string& s) { str = s; };
    auto sval = [](const std::string& s) {
        if (s.size())
            return true;
        else
            return false;
    };


    adc::AdcValueHolder vsh(sget, sset, sval);

    // vsh.addConvertFunc<const char*>([](std::any& v) { v = std::string(std::any_cast<const char*>(v)); },
    //                                 [](std::any& v) {
    //                                     auto sval = std::any_cast<std::string>(&v);
    //                                     v = sval->c_str();
    //                                 });

    auto lls = [](const char* v) { return std::string(v); };
    vsh.addConvertFunc([&str](const std::string&) { return str.c_str(); }, lls);

    vsh = "NEW VALUE";

    REQUIRE_EQ(str, "NEW VALUE");

    const char* sptr = vsh;

    std::cout << "SPTR: " << sptr << "\n";

    REQUIRE_EQ(std::strcmp(sptr, "NEW VALUE"), 0);

    using namespace std::literals;

    CHECK_THROWS_WITH_AS(vsh = ""s, "user value is not valid", std::system_error);

    std::string ss = "\t\t1, 2, 3, 4,5      ";

    std::vector<int> vv;
    adc::utils::AdcValueRangeFromCharRange(vv, ss, ",");

    for (auto v : vv) {
        std::cout << "v = " << v << "\n";
    }

    std::list<char> ll;
    adc::utils::AdcCharRangeFromValueRange(ll, vv, "<>");
    for (auto ch : ll) {
        std::cout << ch;
    }
    std::cout << "\n";

    ss.clear();
    adc::utils::AdcCharRangeFromValueRange(ss, vv, "<>");
    std::cout << "STR: [" << ss << "]\n";


    std::tuple<int, float> tp{7, 77.77};
    ss = "3, 33.33";
    adc::utils::AdcTupleFromCharRange(tp, ss, ",");

    std::cout << "TP: {" << std::get<0>(tp) << ", " << std::get<1>(tp) << "}\n";

    std::get<1>(tp) = 77.77;

    ll.clear();
    adc::utils::AdcCharRangeFromTuple(ll, tp, "::");

    for (auto ch : ll) {
        std::cout << ch;
    }
    std::cout << "\n";


    ss = ";\t";
    // adc::utils::AdcDefaultSerializer sr{"; "};
    adc::utils::AdcDefaultSerializer sr{ss};
    std::cout << "SR: " << sr(std::list<float>{11.11, 22.22, 33.33}) << "\n";
    ss = ",\t";
    std::cout << "SR: " << sr.setDelimiter(" , ")(std::vector<float>{11.11, 22.22, 33.33}) << "\n";


    int zz;
    auto t1 = std::chrono::system_clock::now();
    for (int i = 10; i < 1000000; ++i) {
        vah = i;
        zz = (int)vah + 10;
    }
    auto t2 = std::chrono::system_clock::now();
    std::cout << "ZZ = " << zz << "\n";

    std::cout << "ELAPS: " << std::chrono::duration_cast<std::chrono::microseconds>(t2 - t1).count() << " mksec\n";



    // adc::AdcSerializingValueHolder svh(getter, setter, validator, adc::AdcValueHolder::_defaultTrivialConvTypes);
    adc::AdcSerializingValueHolder svh(adc::AdcValueHolder::_defaultTrivialConvTypes, getter, setter, validator);

    svh = 77.65412;

    std::cout << "SERIALIZED: " << svh.serialize() << "\n";

    svh.deserialize("123");
    float fl = svh;
    std::cout << "DESERIALIZED: " << fl << "\n";

    // vsh.resetValueHolder(gdbl, sdbl, vdbl, adc::AdcValueHolder::_defaultTrivialConvTypes);

    // fl = vsh;
    // std::cout << "VSH: " << fl << "\n";

    // svh.resetValueHolder(gdbl, sdbl, vdbl, adc::AdcValueHolder::_defaultTrivialConvTypes);
    svh.resetValueHolder(adc::AdcValueHolder::_defaultTrivialConvTypes, gdbl, sdbl, vdbl);
    // svh.resetValueHolder([]() { return dbl_val; }, [](const double& v) { dbl_val = v; },
    //                      [](const double&) { return true; }, adc::AdcValueHolder::_defaultTrivialConvTypes);
    std::cout << "SERIALIZED: " << svh.serialize() << "\n";
    svh.deserialize("123.123");
    res = svh;
    std::cout << "DESERIALIZED: " << res << "\n";
}