ADCLIB/examples/device_exam.cpp

#include <print>

#include <adclib/adclib_device1.h>


using namespace adc;


template <typename ID_T, typename VT>
void add_attr_mark(ID_T id, VT const& val, std::string_view acc = "RW")
{
    auto tp = snplib::type_name_as_string<VT>();

    std::println("add {}-attr with ID='{}' of type '{}'", acc, id, tp);
}

template <typename DEV_T, typename VT>
void set_attr(DEV_T& dev, typename DEV_T::attr_id_t id, VT const& val)
{
    auto tp = snplib::type_name_as_string<VT>();

    std::print("set '{}'-attr value to {} of type '{}':\t", id, val, tp);

    auto err = dev[id] = val;
    if (err) {
        std::println("ERROR = {}", err.message());
    } else {
        std::println("OK");
    }
}

template <typename DEV_T, typename VT>
void get_attr(DEV_T& dev, typename DEV_T::attr_id_t id, ret_result_t<VT>& val)
{
    std::string tp;

    [&tp]<typename T>(T v) { tp = snplib::type_name_as_string<T>(); }(val.value());

    std::print("get '{}'-attr value as one of type '{}':\t", id, tp);

    val = dev[id];
    if (val) {
        std::println("OK (value = {})", val.value());
    } else {
        std::println("ERROR = {}", val.error().message());
    }
}

int main()
{
    std::string id1 = "1", id2 = "2", id3 = "str", id4 = "fsp";

    int i = 10;
    double d = 8.1;
    std::string s{"dwedjkwlk"};
    std::filesystem::path pt{"/etc/ewk/dwkej.wed"};

    AdcGenericDevice<> dev("DEV#1");

    std::println("add arith RW-attr with id='{}' (val={})", id1, i);
    dev.addArithAttr(
        id1, [&i]() -> ret_result_t<int> { return i; },
        [&i](int const& ii) -> adc_error_t {
            i = ii;
            return AdcDeviceErrorCode::ERROR_OK;
        });

    // dev.addAttr(
    //     id1, [&i]() -> adc_result_t<int> { return i; },
    //     [&i](int ii) -> adc_error_t {
    //         i = ii;
    //         return AdcDeviceErrorCode::ERROR_OK;
    //     },
    //     std::tuple<double, int, long>{});

    std::println("add RO-attr with id='{}' (val={})", id2, d);
    dev.addAttr(id2, [&d]() -> ret_result_t<double> { return d; }, nullptr);

    // std::println("add RW-attr with id='{}' (val={})", id3, s);
    // dev.addAttr(
    //     id3, [&s]() -> adc_result_t<std::string> { return s; },
    //     [&s](std::string const& sv) -> adc_error_t {
    //         s = sv;
    //         return {};
    //     },
    //     [](std::string const& v) -> adc_result_t<const char*> { return v.c_str(); },
    //     [](const char* p) -> adc_result_t<std::string> { return std::string(p); }
    //     // [&s](adc_result_t<std::string> const&) -> adc_result_t<const char*> { return s.c_str(); },
    //     // [&s](adc_result_t<const char*> const& p) mutable -> adc_result_t<std::string> {
    //     //     // s = p.value();
    //     //     // return s;
    //     //     return std::string(p.value());
    //     // }
    // );

    std::println("add RW-attr with id='{}' (val={})", id3, s);
    dev.addCharRangeAttr(
        id3, [&s]() -> ret_result_t<std::string> { return s; },
        [&s](std::string const& sv) -> adc_error_t {
            s = sv;
            return {};
        });

    // std::println("add RW-attr with id='{}' (val={})", id4, pt.native());
    add_attr_mark(id4, pt);
    dev.addFSPathAttr(
        id4, [&pt]() -> ret_result_t<std::filesystem::path> { return pt; },
        [&pt](std::filesystem::path const& p) -> adc_error_t {
            pt = p;
            return {};
        });

    std::print("get '{}'-attr value as native int:\t", id1);
    ret_result_t<int> ri = dev[id1];
    if (ri) {
        std::println("dev[{}] = {}", id1, ri.value());
    } else {
        std::println("cannot get dev[{}] as int: {}", id1, ri.error().message());
    }

    int ii = 77;
    std::print("set '{}'-attr value to {} as native int:\t", id1, ii);
    auto err = dev[id1] = ii;
    if (err) {
        std::println("cannot set dev[{}] as int: {}", id1, err.message());
    } else {
        std::println("OK");
    }

    std::print("get '{}'-attr value as double:\t", id1);
    ret_result_t<double> rd = dev[id1];
    if (rd) {
        std::println("dev[{}] = {}", id1, rd.value());
    } else {
        std::println("cannot get dev[{}] as double: {}", id1, rd.error().message());
    }

    double dd = 33.333;
    std::print("set '{}'-attr value to {} as double:\t", id1, dd);
    err = dev[id1] = dd;
    if (err) {
        std::println("cannot set dev[{}] as double: {}", id1, err.message());
    } else {
        std::println("OK");
    }

    std::print("get '{}'-attr value as native int:\t", id1);
    ri = dev[id1];
    if (ri) {
        std::println("dev[{}] = {}", id1, ri.value());
    } else {
        std::println("cannot get dev[{}] as int: {}", id1, ri.error().message());
    }

    err = dev[id2] = 0.29817;
    if (err) {
        std::println("cannot set dev[{}] as double: {}", id2, err.message());
    }

    std::println("\n");

    std::print("get '{}'-attr value as native string:\t", id3);
    ret_result_t<std::string> rs = dev[id3];
    if (rs) {
        std::println("dev[{}] = {}", id3, rs.value());
    } else {
        std::println("cannot get dev[{}] as string: {}", id3, rs.error().message());
    }

    const char* sp = "QWERTY";
    std::print("set '{}'-attr value to '{}' as const char*:\t", id3, sp);
    err = dev[id3] = sp;
    if (err) {
        std::println("cannot set dev[{}] as const char*: {}", id3, err.message());
    } else {
        std::println("OK");
    }

    std::print("get '{}'-attr value as native string:\t", id3);
    rs = dev[id3];
    if (rs) {
        std::println("dev[{}] = {}", id3, rs.value());
    } else {
        std::println("cannot get dev[{}] as string: {}", id3, rs.error().message());
    }


    s = "/kgtr/grth/hth34.rth";
    std::vector<char> vch{std::from_range_t{}, s};
    std::print("set '{}'-attr value to {} as std::vector<char>:\t", id4, vch);
    err = dev[id4] = vch;
    if (err) {
        std::println("cannot set dev[{}] as std::vector<char>: {}", id4, err.message());
    } else {
        std::println("OK");
    }

    set_attr(dev, id4, vch);

    std::print("get '{}'-attr value as string:\t", id4);
    rs = dev[id4];
    if (rs) {
        std::println("dev[{}] = {}", id3, rs.value());
    } else {
        std::println("cannot get dev[{}] as string: {}", id4, rs.error().message());
    }

    get_attr(dev, id4, rs);

    return 0;
}