transport.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
 
#ifndef MODDEF_TRANSPORT_HPP
#define MODDEF_TRANSPORT_HPP
 
#include <cstdint>
#include <span>
 
#include "moddef/error.hpp"
 
extern "C" {
#include "moddef/transport.h"
}
 
namespace moddef {
 
class Transport {
   public:
    virtual ~Transport() = default;
 
    virtual Result<void> read_holding(std::uint16_t offset, std::span<std::uint16_t> out) = 0;
    virtual Result<void> read_input(std::uint16_t offset, std::span<std::uint16_t> out) = 0;
    virtual Result<void> read_coils(std::uint16_t offset, std::span<bool> out) = 0;
    virtual Result<void> read_discrete(std::uint16_t offset, std::span<bool> out) = 0;
    virtual Result<void> write_holding(std::uint16_t offset,
                                       std::span<const std::uint16_t> words) = 0;
    virtual Result<void> write_coil(std::uint16_t offset, bool on) = 0;
};
 
namespace detail {
 
inline md_err_t status_of(const Result<void>& r) noexcept {
    return r ? MD_OK : to_c(r.error());
}
 
inline md_err_t c_read_holding(void* ctx, std::uint16_t off, std::uint16_t n, std::uint16_t* out) {
    return status_of(static_cast<Transport*>(ctx)->read_holding(off, {out, n}));
}
inline md_err_t c_read_input(void* ctx, std::uint16_t off, std::uint16_t n, std::uint16_t* out) {
    return status_of(static_cast<Transport*>(ctx)->read_input(off, {out, n}));
}
inline md_err_t c_read_coils(void* ctx, std::uint16_t off, std::uint16_t n, bool* out) {
    return status_of(static_cast<Transport*>(ctx)->read_coils(off, {out, n}));
}
inline md_err_t c_read_discrete(void* ctx, std::uint16_t off, std::uint16_t n, bool* out) {
    return status_of(static_cast<Transport*>(ctx)->read_discrete(off, {out, n}));
}
inline md_err_t c_write_holding(void* ctx, std::uint16_t off, std::uint16_t n,
                                const std::uint16_t* w) {
    return status_of(static_cast<Transport*>(ctx)->write_holding(off, {w, n}));
}
inline md_err_t c_write_coil(void* ctx, std::uint16_t off, bool on) {
    return status_of(static_cast<Transport*>(ctx)->write_coil(off, on));
}
 
// Build a C transport table bound to `t`.
inline md_transport_t bind(Transport& t) noexcept {
    md_transport_t ct{};
    ct.ctx = &t;
    ct.read_holding = c_read_holding;
    ct.read_input = c_read_input;
    ct.read_coils = c_read_coils;
    ct.read_discrete = c_read_discrete;
    ct.write_holding = c_write_holding;
    ct.write_coil = c_write_coil;
    return ct;
}
 
}  // namespace detail
 
}  // namespace moddef
 
#endif  // MODDEF_TRANSPORT_HPP