device.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
 
#ifndef MODDEF_DEVICE_HPP
#define MODDEF_DEVICE_HPP
 
#include <cstdint>
#include <span>
#include <string_view>
 
#include "moddef/document.hpp"
#include "moddef/error.hpp"
#include "moddef/transport.hpp"
#include "moddef/value.hpp"
 
extern "C" {
#include "moddef/device.h"
}
 
namespace moddef {
 
class Device {
   public:
    static Result<Device> open(const Document& doc, std::string_view device_id,
                               Transport& transport) {
        Device d;
        d.ct_ = detail::bind(transport);
        if (auto e = md_dev_init(&d.dev_, doc.c_doc(), to_c(device_id), &d.ct_); e != MD_OK)
            return std::unexpected(from_c(e));
        return d;
    }
 
    Result<Value> read(std::string_view point_id) {
        md_value_t v{};
        if (auto e = md_dev_read(&dev_, to_c(point_id), &v); e != MD_OK)
            return std::unexpected(from_c(e));
        return Value{v};
    }
 
    Result<std::string_view> read_string(std::string_view point_id, std::span<char> buf) {
        std::size_t len = 0;
        if (auto e = md_dev_read_string(&dev_, to_c(point_id), buf.data(), buf.size(), &len);
            e != MD_OK)
            return std::unexpected(from_c(e));
        return std::string_view{buf.data(), len};
    }
 
    Result<void> write_f64(std::string_view point_id, double value) {
        return check(md_dev_write_f64(&dev_, to_c(point_id), value));
    }
    Result<void> write_i64(std::string_view point_id, std::int64_t value) {
        return check(md_dev_write_i64(&dev_, to_c(point_id), value));
    }
    Result<void> write_bool(std::string_view point_id, bool on) {
        md_value_t v = md_value_bool(on);
        return check(md_dev_write(&dev_, to_c(point_id), &v));
    }
 
    // Movable: md_dev_t stores a pointer to our inline transport table, so a
    // move must re-point it at the moved-to member.
    Device(Device&& o) noexcept : dev_(o.dev_), ct_(o.ct_) { dev_.t = &ct_; }
    Device& operator=(Device&& o) noexcept {
        dev_ = o.dev_;
        ct_ = o.ct_;
        dev_.t = &ct_;
        return *this;
    }
    Device(const Device&) = delete;
    Device& operator=(const Device&) = delete;
 
   private:
    Device() = default;
 
    md_dev_t dev_{};
    md_transport_t ct_{};
};
 
}  // namespace moddef
 
#endif  // MODDEF_DEVICE_HPP