dnp3.hpp

Go to the documentation of this file.

// This library is provided under the terms of a non-commercial license.
// 
// Please refer to the source repository for details:
// 
// https://github.com/stepfunc/dnp3/blob/master/LICENSE.txt
// 
// Please contact Step Function I/O if you are interested in commercial license:
// 
// info@stepfunc.io
#pragma once
 
#include <cstdint>
#include <stdexcept>
#include <chrono>
#include <memory>
#include <vector>
 
 
namespace dnp3 {
 
constexpr uint64_t dnp3_version_major = 1;
constexpr uint64_t dnp3_version_minor = 6;
constexpr uint64_t dnp3_version_patch = 0;
constexpr char const* dnp3_version_string = "1.6.0";
 
 
class TcpSettings {
    TcpSettings() = delete;
public:
    static void disable_client_tcp_no_delay();
    static void disable_server_tcp_no_delay();
};
 
enum class ParamError {
    ok = 0,
    invalid_timeout = 1,
    null_parameter = 2,
    string_not_utf8 = 3,
    no_support = 4,
    association_does_not_exist = 5,
    association_duplicate_address = 6,
    invalid_socket_address = 7,
    invalid_dnp3_address = 8,
    invalid_buffer_size = 9,
    address_filter_conflict = 10,
    server_already_started = 11,
    server_bind_error = 12,
    master_already_shutdown = 13,
    runtime_creation_failure = 14,
    runtime_destroyed = 15,
    runtime_cannot_block_within_async = 16,
    logging_already_configured = 17,
    point_does_not_exist = 18,
    invalid_peer_certificate = 19,
    invalid_local_certificate = 20,
    invalid_private_key = 21,
    invalid_dns_name = 22,
    other_tls_error = 23,
    wrong_channel_type = 24,
    consumed = 25,
};
 
const char* to_string(ParamError value);
 
class ParamException : public std::logic_error {
public:
    ParamError error;
    ParamException(ParamError error) : std::logic_error(to_string(error)), error(error) {}
};
 
enum class CommandStatus {
    success = 0,
    timeout = 1,
    no_select = 2,
    format_error = 3,
    not_supported = 4,
    already_active = 5,
    hardware_error = 6,
    local = 7,
    too_many_ops = 8,
    not_authorized = 9,
    automation_inhibit = 10,
    processing_limited = 11,
    out_of_range = 12,
    downstream_local = 13,
    already_complete = 14,
    blocked = 15,
    canceled = 16,
    blocked_other_master = 17,
    downstream_fail = 18,
    non_participating = 19,
    unknown = 20,
};
 
const char* to_string(CommandStatus value);
 
namespace flag {
    constexpr uint8_t online = 0x01;
    constexpr uint8_t restart = 0x02;
    constexpr uint8_t comm_lost = 0x04;
    constexpr uint8_t remote_forced = 0x08;
    constexpr uint8_t local_forced = 0x10;
    constexpr uint8_t chatter_filter = 0x20;
    constexpr uint8_t over_range = 0x20;
    constexpr uint8_t discontinuity = 0x40;
    constexpr uint8_t reference_err = 0x40;
}
 
enum class AppDecodeLevel {
    nothing = 0,
    header = 1,
    object_headers = 2,
    object_values = 3,
};
 
const char* to_string(AppDecodeLevel value);
 
enum class TransportDecodeLevel {
    nothing = 0,
    header = 1,
    payload = 2,
};
 
const char* to_string(TransportDecodeLevel value);
 
enum class LinkDecodeLevel {
    nothing = 0,
    header = 1,
    payload = 2,
};
 
const char* to_string(LinkDecodeLevel value);
 
enum class PhysDecodeLevel {
    nothing = 0,
    length = 1,
    data = 2,
};
 
const char* to_string(PhysDecodeLevel value);
 
struct DecodeLevel;
 
struct DecodeLevel {
    friend class CppDecodeLevelFriend;
    
private:
    DecodeLevel(AppDecodeLevel application, TransportDecodeLevel transport, LinkDecodeLevel link, PhysDecodeLevel physical);
    
public:
    
    DecodeLevel();
    
    
    static DecodeLevel nothing();
    
    
    AppDecodeLevel application;
    TransportDecodeLevel transport;
    LinkDecodeLevel link;
    PhysDecodeLevel physical;
};
 
class Runtime;
 
struct RuntimeConfig;
 
struct RuntimeConfig {
    friend class CppRuntimeConfigFriend;
    
private:
    RuntimeConfig(uint16_t num_core_threads);
    
public:
    
    RuntimeConfig();
    
    
    uint16_t num_core_threads;
};
 
class Runtime {
    friend class CppRuntimeFriend;
    // pointer to the underlying C type
    void* self;
    // constructor only accessible internally
    Runtime(void* self): self(self) {}
    // non-copyable
    Runtime(const Runtime&) = delete;
    Runtime& operator=(const Runtime&) = delete;
    // no move assignment
    Runtime& operator=(Runtime&& other) = delete;
 
public:
    Runtime(Runtime&& other) noexcept : self(other.self) { other.self = nullptr; }
    
    Runtime(const RuntimeConfig& config);
    
    ~Runtime();
    
    void set_shutdown_timeout(std::chrono::steady_clock::duration timeout);
};
 
struct ControlField;
 
struct ControlField {
    friend class CppControlFieldFriend;
    
private:
    ControlField(bool fir, bool fin, bool con, bool uns, uint8_t seq);
    
public:
    ControlField() = delete;
    
    bool fir;
    bool fin;
    bool con;
    bool uns;
    uint8_t seq;
};
 
enum class TripCloseCode {
    nul = 0,
    close = 1,
    trip = 2,
    reserved = 3,
};
 
const char* to_string(TripCloseCode value);
 
enum class OpType {
    nul = 0,
    pulse_on = 1,
    pulse_off = 2,
    latch_on = 3,
    latch_off = 4,
};
 
const char* to_string(OpType value);
 
struct ControlCode;
 
struct ControlCode {
    friend class CppControlCodeFriend;
    
private:
    ControlCode(TripCloseCode tcc, bool clear, bool queue, OpType op_type);
    
public:
    ControlCode() = delete;
    
    ControlCode(TripCloseCode tcc, bool clear, OpType op_type);
    
    
    static ControlCode from_op_type(OpType op_type);
    
    
    static ControlCode from_tcc_and_op_type(TripCloseCode tcc, OpType op_type);
    
    
    TripCloseCode tcc;
    bool clear;
    bool queue;
    OpType op_type;
};
 
struct Group12Var1;
 
struct Group12Var1 {
    friend class CppGroup12Var1Friend;
    
    Group12Var1() = delete;
    
    Group12Var1(const ControlCode& code, uint8_t count, uint32_t on_time, uint32_t off_time);
    
    
    static Group12Var1 from_code(const ControlCode& code);
    
    
    ControlCode code;
    uint8_t count;
    uint32_t on_time;
    uint32_t off_time;
};
 
struct Flags;
 
struct Flags {
    friend class CppFlagsFriend;
    
    Flags() = delete;
    
    Flags(uint8_t value);
    
    
    uint8_t value;
};
 
enum class TimeQuality {
    synchronized_time = 0,
    unsynchronized_time = 1,
    invalid_time = 2,
};
 
const char* to_string(TimeQuality value);
 
struct Timestamp;
 
struct Timestamp {
    friend class CppTimestampFriend;
    
private:
    Timestamp(uint64_t value, TimeQuality quality);
    
public:
    Timestamp() = delete;
    
    static Timestamp invalid_timestamp();
    
    
    static Timestamp synchronized_timestamp(uint64_t value);
    
    
    static Timestamp unsynchronized_timestamp(uint64_t value);
    
    
    uint64_t value;
    TimeQuality quality;
};
 
enum class DoubleBit {
    intermediate = 0,
    determined_off = 1,
    determined_on = 2,
    indeterminate = 3,
};
 
const char* to_string(DoubleBit value);
 
struct BinaryInput;
 
struct BinaryInput {
    friend class CppBinaryInputFriend;
    
    BinaryInput() = delete;
    
    BinaryInput(uint16_t index, bool value, const Flags& flags, const Timestamp& time);
    
    
    uint16_t index;
    bool value;
    Flags flags;
    Timestamp time;
};
 
class BinaryInputIterator;
 
class BinaryInputIterator final {
 
    friend class CppBinaryInputIteratorFriend;
 
    // underlying opaque c type
    void* iter;
    // pointer to the last retrieved c value
    void* current;
 
    // internal constructor
    BinaryInputIterator(void* iter) : iter(iter), current(nullptr) {}
 
    BinaryInputIterator() = delete; // no default construction
    BinaryInputIterator(const BinaryInputIterator&) = delete; // no copies
    BinaryInputIterator& operator=(const BinaryInputIterator&) = delete; // no self-assignment
    BinaryInputIterator& operator=(BinaryInputIterator&&) = delete; // no move self-assignment
 
public:
 
    BinaryInputIterator(BinaryInputIterator&&) = default;
 
    bool next();
 
    BinaryInput get();
};
 
struct DoubleBitBinaryInput;
 
struct DoubleBitBinaryInput {
    friend class CppDoubleBitBinaryInputFriend;
    
    DoubleBitBinaryInput() = delete;
    
    DoubleBitBinaryInput(uint16_t index, DoubleBit value, const Flags& flags, const Timestamp& time);
    
    
    uint16_t index;
    DoubleBit value;
    Flags flags;
    Timestamp time;
};
 
class DoubleBitBinaryInputIterator;
 
class DoubleBitBinaryInputIterator final {
 
    friend class CppDoubleBitBinaryInputIteratorFriend;
 
    // underlying opaque c type
    void* iter;
    // pointer to the last retrieved c value
    void* current;
 
    // internal constructor
    DoubleBitBinaryInputIterator(void* iter) : iter(iter), current(nullptr) {}
 
    DoubleBitBinaryInputIterator() = delete; // no default construction
    DoubleBitBinaryInputIterator(const DoubleBitBinaryInputIterator&) = delete; // no copies
    DoubleBitBinaryInputIterator& operator=(const DoubleBitBinaryInputIterator&) = delete; // no self-assignment
    DoubleBitBinaryInputIterator& operator=(DoubleBitBinaryInputIterator&&) = delete; // no move self-assignment
 
public:
 
    DoubleBitBinaryInputIterator(DoubleBitBinaryInputIterator&&) = default;
 
    bool next();
 
    DoubleBitBinaryInput get();
};
 
struct BinaryOutputStatus;
 
struct BinaryOutputStatus {
    friend class CppBinaryOutputStatusFriend;
    
    BinaryOutputStatus() = delete;
    
    BinaryOutputStatus(uint16_t index, bool value, const Flags& flags, const Timestamp& time);
    
    
    uint16_t index;
    bool value;
    Flags flags;
    Timestamp time;
};
 
class BinaryOutputStatusIterator;
 
class BinaryOutputStatusIterator final {
 
    friend class CppBinaryOutputStatusIteratorFriend;
 
    // underlying opaque c type
    void* iter;
    // pointer to the last retrieved c value
    void* current;
 
    // internal constructor
    BinaryOutputStatusIterator(void* iter) : iter(iter), current(nullptr) {}
 
    BinaryOutputStatusIterator() = delete; // no default construction
    BinaryOutputStatusIterator(const BinaryOutputStatusIterator&) = delete; // no copies
    BinaryOutputStatusIterator& operator=(const BinaryOutputStatusIterator&) = delete; // no self-assignment
    BinaryOutputStatusIterator& operator=(BinaryOutputStatusIterator&&) = delete; // no move self-assignment
 
public:
 
    BinaryOutputStatusIterator(BinaryOutputStatusIterator&&) = default;
 
    bool next();
 
    BinaryOutputStatus get();
};
 
struct Counter;
 
struct Counter {
    friend class CppCounterFriend;
    
    Counter() = delete;
    
    Counter(uint16_t index, uint32_t value, const Flags& flags, const Timestamp& time);
    
    
    uint16_t index;
    uint32_t value;
    Flags flags;
    Timestamp time;
};
 
class CounterIterator;
 
class CounterIterator final {
 
    friend class CppCounterIteratorFriend;
 
    // underlying opaque c type
    void* iter;
    // pointer to the last retrieved c value
    void* current;
 
    // internal constructor
    CounterIterator(void* iter) : iter(iter), current(nullptr) {}
 
    CounterIterator() = delete; // no default construction
    CounterIterator(const CounterIterator&) = delete; // no copies
    CounterIterator& operator=(const CounterIterator&) = delete; // no self-assignment
    CounterIterator& operator=(CounterIterator&&) = delete; // no move self-assignment
 
public:
 
    CounterIterator(CounterIterator&&) = default;
 
    bool next();
 
    Counter get();
};
 
struct FrozenCounter;
 
struct FrozenCounter {
    friend class CppFrozenCounterFriend;
    
    FrozenCounter() = delete;
    
    FrozenCounter(uint16_t index, uint32_t value, const Flags& flags, const Timestamp& time);
    
    
    uint16_t index;
    uint32_t value;
    Flags flags;
    Timestamp time;
};
 
class FrozenCounterIterator;
 
class FrozenCounterIterator final {
 
    friend class CppFrozenCounterIteratorFriend;
 
    // underlying opaque c type
    void* iter;
    // pointer to the last retrieved c value
    void* current;
 
    // internal constructor
    FrozenCounterIterator(void* iter) : iter(iter), current(nullptr) {}
 
    FrozenCounterIterator() = delete; // no default construction
    FrozenCounterIterator(const FrozenCounterIterator&) = delete; // no copies
    FrozenCounterIterator& operator=(const FrozenCounterIterator&) = delete; // no self-assignment
    FrozenCounterIterator& operator=(FrozenCounterIterator&&) = delete; // no move self-assignment
 
public:
 
    FrozenCounterIterator(FrozenCounterIterator&&) = default;
 
    bool next();
 
    FrozenCounter get();
};
 
struct AnalogInput;
 
struct AnalogInput {
    friend class CppAnalogInputFriend;
    
    AnalogInput() = delete;
    
    AnalogInput(uint16_t index, double value, const Flags& flags, const Timestamp& time);
    
    
    uint16_t index;
    double value;
    Flags flags;
    Timestamp time;
};
 
class AnalogInputIterator;
 
class AnalogInputIterator final {
 
    friend class CppAnalogInputIteratorFriend;
 
    // underlying opaque c type
    void* iter;
    // pointer to the last retrieved c value
    void* current;
 
    // internal constructor
    AnalogInputIterator(void* iter) : iter(iter), current(nullptr) {}
 
    AnalogInputIterator() = delete; // no default construction
    AnalogInputIterator(const AnalogInputIterator&) = delete; // no copies
    AnalogInputIterator& operator=(const AnalogInputIterator&) = delete; // no self-assignment
    AnalogInputIterator& operator=(AnalogInputIterator&&) = delete; // no move self-assignment
 
public:
 
    AnalogInputIterator(AnalogInputIterator&&) = default;
 
    bool next();
 
    AnalogInput get();
};
 
struct FrozenAnalogInput;
 
struct FrozenAnalogInput {
    friend class CppFrozenAnalogInputFriend;
    
    FrozenAnalogInput() = delete;
    
    FrozenAnalogInput(uint16_t index, double value, const Flags& flags, const Timestamp& time);
    
    
    uint16_t index;
    double value;
    Flags flags;
    Timestamp time;
};
 
class FrozenAnalogInputIterator;
 
class FrozenAnalogInputIterator final {
 
    friend class CppFrozenAnalogInputIteratorFriend;
 
    // underlying opaque c type
    void* iter;
    // pointer to the last retrieved c value
    void* current;
 
    // internal constructor
    FrozenAnalogInputIterator(void* iter) : iter(iter), current(nullptr) {}
 
    FrozenAnalogInputIterator() = delete; // no default construction
    FrozenAnalogInputIterator(const FrozenAnalogInputIterator&) = delete; // no copies
    FrozenAnalogInputIterator& operator=(const FrozenAnalogInputIterator&) = delete; // no self-assignment
    FrozenAnalogInputIterator& operator=(FrozenAnalogInputIterator&&) = delete; // no move self-assignment
 
public:
 
    FrozenAnalogInputIterator(FrozenAnalogInputIterator&&) = default;
 
    bool next();
 
    FrozenAnalogInput get();
};
 
struct AnalogOutputStatus;
 
struct AnalogOutputStatus {
    friend class CppAnalogOutputStatusFriend;
    
    AnalogOutputStatus() = delete;
    
    AnalogOutputStatus(uint16_t index, double value, const Flags& flags, const Timestamp& time);
    
    
    uint16_t index;
    double value;
    Flags flags;
    Timestamp time;
};
 
class AnalogOutputStatusIterator;
 
class AnalogOutputStatusIterator final {
 
    friend class CppAnalogOutputStatusIteratorFriend;
 
    // underlying opaque c type
    void* iter;
    // pointer to the last retrieved c value
    void* current;
 
    // internal constructor
    AnalogOutputStatusIterator(void* iter) : iter(iter), current(nullptr) {}
 
    AnalogOutputStatusIterator() = delete; // no default construction
    AnalogOutputStatusIterator(const AnalogOutputStatusIterator&) = delete; // no copies
    AnalogOutputStatusIterator& operator=(const AnalogOutputStatusIterator&) = delete; // no self-assignment
    AnalogOutputStatusIterator& operator=(AnalogOutputStatusIterator&&) = delete; // no move self-assignment
 
public:
 
    AnalogOutputStatusIterator(AnalogOutputStatusIterator&&) = default;
 
    bool next();
 
    AnalogOutputStatus get();
};
 
struct BinaryOutputCommandEvent;
 
struct BinaryOutputCommandEvent {
    friend class CppBinaryOutputCommandEventFriend;
    
    BinaryOutputCommandEvent() = delete;
    
    BinaryOutputCommandEvent(uint16_t index, CommandStatus status, bool commanded_state, const Timestamp& time);
    
    
    uint16_t index;
    CommandStatus status;
    bool commanded_state;
    Timestamp time;
};
 
class BinaryOutputCommandEventIterator;
 
class BinaryOutputCommandEventIterator final {
 
    friend class CppBinaryOutputCommandEventIteratorFriend;
 
    // underlying opaque c type
    void* iter;
    // pointer to the last retrieved c value
    void* current;
 
    // internal constructor
    BinaryOutputCommandEventIterator(void* iter) : iter(iter), current(nullptr) {}
 
    BinaryOutputCommandEventIterator() = delete; // no default construction
    BinaryOutputCommandEventIterator(const BinaryOutputCommandEventIterator&) = delete; // no copies
    BinaryOutputCommandEventIterator& operator=(const BinaryOutputCommandEventIterator&) = delete; // no self-assignment
    BinaryOutputCommandEventIterator& operator=(BinaryOutputCommandEventIterator&&) = delete; // no move self-assignment
 
public:
 
    BinaryOutputCommandEventIterator(BinaryOutputCommandEventIterator&&) = default;
 
    bool next();
 
    BinaryOutputCommandEvent get();
};
 
enum class AnalogCommandType {
    i16 = 0,
    i32 = 1,
    f32 = 2,
    f64 = 3,
};
 
const char* to_string(AnalogCommandType value);
 
struct AnalogOutputCommandEvent;
 
struct AnalogOutputCommandEvent {
    friend class CppAnalogOutputCommandEventFriend;
    
    AnalogOutputCommandEvent() = delete;
    
    AnalogOutputCommandEvent(uint16_t index, CommandStatus status, double commanded_value, AnalogCommandType command_type, const Timestamp& time);
    
    
    uint16_t index;
    CommandStatus status;
    double commanded_value;
    AnalogCommandType command_type;
    Timestamp time;
};
 
class AnalogOutputCommandEventIterator;
 
class AnalogOutputCommandEventIterator final {
 
    friend class CppAnalogOutputCommandEventIteratorFriend;
 
    // underlying opaque c type
    void* iter;
    // pointer to the last retrieved c value
    void* current;
 
    // internal constructor
    AnalogOutputCommandEventIterator(void* iter) : iter(iter), current(nullptr) {}
 
    AnalogOutputCommandEventIterator() = delete; // no default construction
    AnalogOutputCommandEventIterator(const AnalogOutputCommandEventIterator&) = delete; // no copies
    AnalogOutputCommandEventIterator& operator=(const AnalogOutputCommandEventIterator&) = delete; // no self-assignment
    AnalogOutputCommandEventIterator& operator=(AnalogOutputCommandEventIterator&&) = delete; // no move self-assignment
 
public:
 
    AnalogOutputCommandEventIterator(AnalogOutputCommandEventIterator&&) = default;
 
    bool next();
 
    AnalogOutputCommandEvent get();
};
 
struct UnsignedInteger;
 
struct UnsignedInteger {
    friend class CppUnsignedIntegerFriend;
    
    UnsignedInteger() = delete;
    
    UnsignedInteger(uint16_t index, uint8_t value);
    
    
    uint16_t index;
    uint8_t value;
};
 
class UnsignedIntegerIterator;
 
class UnsignedIntegerIterator final {
 
    friend class CppUnsignedIntegerIteratorFriend;
 
    // underlying opaque c type
    void* iter;
    // pointer to the last retrieved c value
    void* current;
 
    // internal constructor
    UnsignedIntegerIterator(void* iter) : iter(iter), current(nullptr) {}
 
    UnsignedIntegerIterator() = delete; // no default construction
    UnsignedIntegerIterator(const UnsignedIntegerIterator&) = delete; // no copies
    UnsignedIntegerIterator& operator=(const UnsignedIntegerIterator&) = delete; // no self-assignment
    UnsignedIntegerIterator& operator=(UnsignedIntegerIterator&&) = delete; // no move self-assignment
 
public:
 
    UnsignedIntegerIterator(UnsignedIntegerIterator&&) = default;
 
    bool next();
 
    UnsignedInteger get();
};
 
class ByteIterator;
 
class ByteIterator final {
 
    friend class CppByteIteratorFriend;
 
    // underlying opaque c type
    void* iter;
    // pointer to the last retrieved c value
    void* current;
 
    // internal constructor
    ByteIterator(void* iter) : iter(iter), current(nullptr) {}
 
    ByteIterator() = delete; // no default construction
    ByteIterator(const ByteIterator&) = delete; // no copies
    ByteIterator& operator=(const ByteIterator&) = delete; // no self-assignment
    ByteIterator& operator=(ByteIterator&&) = delete; // no move self-assignment
 
public:
 
    ByteIterator(ByteIterator&&) = default;
 
    bool next();
 
    uint8_t get();
};
 
struct OctetString;
 
struct OctetString {
    friend class CppOctetStringFriend;
    
private:
    OctetString(uint16_t index, ByteIterator value);
    
public:
    OctetString() = delete;
    
    uint16_t index;
    ByteIterator value;
};
 
class OctetStringIterator;
 
class OctetStringIterator final {
 
    friend class CppOctetStringIteratorFriend;
 
    // underlying opaque c type
    void* iter;
    // pointer to the last retrieved c value
    void* current;
 
    // internal constructor
    OctetStringIterator(void* iter) : iter(iter), current(nullptr) {}
 
    OctetStringIterator() = delete; // no default construction
    OctetStringIterator(const OctetStringIterator&) = delete; // no copies
    OctetStringIterator& operator=(const OctetStringIterator&) = delete; // no self-assignment
    OctetStringIterator& operator=(OctetStringIterator&&) = delete; // no move self-assignment
 
public:
 
    OctetStringIterator(OctetStringIterator&&) = default;
 
    bool next();
 
    OctetString get();
};
 
class ConnectOptions;
 
class ConnectOptions {
    friend class CppConnectOptionsFriend;
    // pointer to the underlying C type
    void* self;
    // constructor only accessible internally
    ConnectOptions(void* self): self(self) {}
    // non-copyable
    ConnectOptions(const ConnectOptions&) = delete;
    ConnectOptions& operator=(const ConnectOptions&) = delete;
    // no move assignment
    ConnectOptions& operator=(ConnectOptions&& other) = delete;
 
public:
    ConnectOptions(ConnectOptions&& other) noexcept : self(other.self) { other.self = nullptr; }
    
    ConnectOptions();
    
    ~ConnectOptions();
    
    void set_timeout(std::chrono::steady_clock::duration timeout);
    
    void set_local_endpoint(const std::string& endpoint);
};
 
class EndpointList;
 
class EndpointList {
    friend class CppEndpointListFriend;
    // pointer to the underlying C type
    void* self;
    // constructor only accessible internally
    EndpointList(void* self): self(self) {}
    // non-copyable
    EndpointList(const EndpointList&) = delete;
    EndpointList& operator=(const EndpointList&) = delete;
    // no move assignment
    EndpointList& operator=(EndpointList&& other) = delete;
 
public:
    EndpointList(EndpointList&& other) noexcept : self(other.self) { other.self = nullptr; }
    
    EndpointList(const std::string& main_endpoint);
    
    ~EndpointList();
    
    void add(const std::string& endpoint);
};
 
struct ConnectStrategy;
 
struct ConnectStrategy {
    friend class CppConnectStrategyFriend;
    
private:
    ConnectStrategy(std::chrono::steady_clock::duration min_connect_delay, std::chrono::steady_clock::duration max_connect_delay, std::chrono::steady_clock::duration reconnect_delay);
    
public:
    
    ConnectStrategy();
    
    
    std::chrono::steady_clock::duration min_connect_delay;
    std::chrono::steady_clock::duration max_connect_delay;
    std::chrono::steady_clock::duration reconnect_delay;
};
 
enum class MinTlsVersion {
    v12 = 0,
    v13 = 1,
};
 
const char* to_string(MinTlsVersion value);
 
enum class CertificateMode {
    authority_based = 0,
    self_signed = 1,
};
 
const char* to_string(CertificateMode value);
 
struct TlsClientConfig;
 
struct TlsClientConfig {
    friend class CppTlsClientConfigFriend;
    
private:
    TlsClientConfig(const std::string& dns_name, const std::string& peer_cert_path, const std::string& local_cert_path, const std::string& private_key_path, const std::string& password, MinTlsVersion min_tls_version, CertificateMode certificate_mode, bool allow_server_name_wildcard);
    
public:
    TlsClientConfig() = delete;
    
    TlsClientConfig(const std::string& dns_name, const std::string& peer_cert_path, const std::string& local_cert_path, const std::string& private_key_path, const std::string& password);
    
    
    std::string dns_name;
    std::string peer_cert_path;
    std::string local_cert_path;
    std::string private_key_path;
    std::string password;
    MinTlsVersion min_tls_version;
    CertificateMode certificate_mode;
    bool allow_server_name_wildcard;
};
 
namespace attribute_variations {
    constexpr uint8_t config_id = 0xC4;
    constexpr uint8_t config_version = 0xC5;
    constexpr uint8_t config_build_date = 0xC6;
    constexpr uint8_t config_last_change_date = 0xC7;
    constexpr uint8_t config_digest = 0xC8;
    constexpr uint8_t config_digest_algorithm = 0xC9;
    constexpr uint8_t master_resource_id = 0xCA;
    constexpr uint8_t device_location_altitude = 0xCB;
    constexpr uint8_t device_location_longitude = 0xCC;
    constexpr uint8_t device_location_latitude = 0xCD;
    constexpr uint8_t user_assigned_secondary_operator_name = 0xCE;
    constexpr uint8_t user_assigned_primary_operator_name = 0xCF;
    constexpr uint8_t user_assigned_system_name = 0xD0;
    constexpr uint8_t secure_auth_version = 0xD1;
    constexpr uint8_t num_security_stats_per_assoc = 0xD2;
    constexpr uint8_t user_specific_attributes = 0xD3;
    constexpr uint8_t num_master_defined_data_set_proto = 0xD4;
    constexpr uint8_t num_outstation_defined_data_set_proto = 0xD5;
    constexpr uint8_t num_master_defined_data_sets = 0xD6;
    constexpr uint8_t num_outstation_defined_data_sets = 0xD7;
    constexpr uint8_t max_binary_output_per_request = 0xD8;
    constexpr uint8_t local_timing_accuracy = 0xD9;
    constexpr uint8_t duration_of_time_accuracy = 0xDA;
    constexpr uint8_t supports_analog_output_events = 0xDB;
    constexpr uint8_t max_analog_output_index = 0xDC;
    constexpr uint8_t num_analog_outputs = 0xDD;
    constexpr uint8_t supports_binary_output_events = 0xDE;
    constexpr uint8_t max_binary_output_index = 0xDF;
    constexpr uint8_t num_binary_outputs = 0xE0;
    constexpr uint8_t supports_frozen_counter_events = 0xE1;
    constexpr uint8_t supports_frozen_counters = 0xE2;
    constexpr uint8_t supports_counter_events = 0xE3;
    constexpr uint8_t max_counter_index = 0xE4;
    constexpr uint8_t num_counter = 0xE5;
    constexpr uint8_t supports_frozen_analog_inputs = 0xE6;
    constexpr uint8_t supports_analog_input_events = 0xE7;
    constexpr uint8_t max_analog_input_index = 0xE8;
    constexpr uint8_t num_analog_input = 0xE9;
    constexpr uint8_t supports_double_bit_binary_input_events = 0xEA;
    constexpr uint8_t max_double_bit_binary_input_index = 0xEB;
    constexpr uint8_t num_double_bit_binary_input = 0xEC;
    constexpr uint8_t supports_binary_input_events = 0xED;
    constexpr uint8_t max_binary_input_index = 0xEE;
    constexpr uint8_t num_binary_input = 0xEF;
    constexpr uint8_t max_tx_fragment_size = 0xF0;
    constexpr uint8_t max_rx_fragment_size = 0xF1;
    constexpr uint8_t device_manufacturer_software_version = 0xF2;
    constexpr uint8_t device_manufacturer_hardware_version = 0xF3;
    constexpr uint8_t user_assigned_owner_name = 0xF4;
    constexpr uint8_t user_assigned_location = 0xF5;
    constexpr uint8_t user_assigned_id = 0xF6;
    constexpr uint8_t user_assigned_device_name = 0xF7;
    constexpr uint8_t device_serial_number = 0xF8;
    constexpr uint8_t device_subset_and_conformance = 0xF9;
    constexpr uint8_t product_name_and_model = 0xFA;
    constexpr uint8_t device_manufacturers_name = 0xFC;
    constexpr uint8_t all_attributes_request = 0xFE;
    constexpr uint8_t list_of_variations = 0xFF;
}
 
enum class VariationListAttr {
    unknown = 0,
    list_of_variations = 1,
};
 
const char* to_string(VariationListAttr value);
 
enum class StringAttr {
    unknown = 0,
    config_id = 1,
    config_version = 2,
    config_digest_algorithm = 3,
    master_resource_id = 4,
    user_assigned_secondary_operator_name = 5,
    user_assigned_primary_operator_name = 6,
    user_assigned_system_name = 7,
    user_specific_attributes = 8,
    device_manufacturer_software_version = 9,
    device_manufacturer_hardware_version = 10,
    user_assigned_owner_name = 11,
    user_assigned_location = 12,
    user_assigned_id = 13,
    user_assigned_device_name = 14,
    device_serial_number = 15,
    device_subset_and_conformance = 16,
    product_name_and_model = 17,
    device_manufacturers_name = 18,
};
 
const char* to_string(StringAttr value);
 
enum class UintAttr {
    unknown = 0,
    secure_auth_version = 1,
    num_security_stats_per_assoc = 2,
    num_master_defined_data_set_proto = 3,
    num_outstation_defined_data_set_proto = 4,
    num_master_defined_data_sets = 5,
    num_outstation_defined_data_sets = 6,
    max_binary_output_per_request = 7,
    local_timing_accuracy = 8,
    duration_of_time_accuracy = 9,
    max_analog_output_index = 10,
    num_analog_outputs = 11,
    max_binary_output_index = 12,
    num_binary_outputs = 13,
    max_counter_index = 14,
    num_counter = 15,
    max_analog_input_index = 16,
    num_analog_input = 17,
    max_double_bit_binary_input_index = 18,
    num_double_bit_binary_input = 19,
    max_binary_input_index = 20,
    num_binary_input = 21,
    max_tx_fragment_size = 22,
    max_rx_fragment_size = 23,
};
 
const char* to_string(UintAttr value);
 
enum class IntAttr {
    unknown = 0,
};
 
const char* to_string(IntAttr value);
 
enum class BoolAttr {
    unknown = 0,
    supports_analog_output_events = 1,
    supports_binary_output_events = 2,
    supports_frozen_counter_events = 3,
    supports_frozen_counters = 4,
    supports_counter_events = 5,
    supports_frozen_analog_inputs = 6,
    supports_analog_input_events = 7,
    supports_double_bit_binary_input_events = 8,
    supports_binary_input_events = 9,
};
 
const char* to_string(BoolAttr value);
 
enum class TimeAttr {
    unknown = 0,
    config_build_date = 1,
    config_last_change_date = 2,
};
 
const char* to_string(TimeAttr value);
 
enum class OctetStringAttr {
    unknown = 0,
    config_digest = 1,
};
 
const char* to_string(OctetStringAttr value);
 
enum class BitStringAttr {
    unknown = 0,
};
 
const char* to_string(BitStringAttr value);
 
enum class FloatAttr {
    unknown = 0,
    device_location_altitude = 1,
    device_location_longitude = 2,
    device_location_latitude = 3,
};
 
const char* to_string(FloatAttr value);
 
struct AttrProp;
 
struct AttrProp {
    friend class CppAttrPropFriend;
    
private:
    AttrProp(bool is_writable);
    
public:
    AttrProp() = delete;
    
    bool is_writable;
};
 
struct AttrItem;
 
struct AttrItem {
    friend class CppAttrItemFriend;
    
private:
    AttrItem(uint8_t variation, const AttrProp& properties);
    
public:
    AttrItem() = delete;
    
    uint8_t variation;
    AttrProp properties;
};
 
class AttrItemIter;
 
class AttrItemIter final {
 
    friend class CppAttrItemIterFriend;
 
    // underlying opaque c type
    void* iter;
    // pointer to the last retrieved c value
    void* current;
 
    // internal constructor
    AttrItemIter(void* iter) : iter(iter), current(nullptr) {}
 
    AttrItemIter() = delete; // no default construction
    AttrItemIter(const AttrItemIter&) = delete; // no copies
    AttrItemIter& operator=(const AttrItemIter&) = delete; // no self-assignment
    AttrItemIter& operator=(AttrItemIter&&) = delete; // no move self-assignment
 
public:
 
    AttrItemIter(AttrItemIter&&) = default;
 
    bool next();
 
    AttrItem get();
};
 
enum class Nothing {
    nothing = 0,
};
 
const char* to_string(Nothing value);
 
enum class PortState {
    disabled = 0,
    wait = 1,
    open = 2,
    shutdown = 3,
};
 
const char* to_string(PortState value);
 
class PortStateListener {
public:
    virtual ~PortStateListener() = default;
    
    virtual void on_change(PortState state) = 0;
    
};
 
namespace functional {
 
template <class T>
class PortStateListenerLambda final : public PortStateListener
{
    static_assert(std::is_copy_constructible<T>::value, "Lambda expression must be copy constructible. Does it contain something that is move-only?");
    
    T lambda;
 
public:
    PortStateListenerLambda(const T& lambda) : lambda(lambda) {}
    
    void on_change(PortState state) override
    {
        lambda(state);
    }
};
 
template <class T>
std::unique_ptr<PortStateListener> port_state_listener(const T& lambda)
{
    return std::make_unique<PortStateListenerLambda<T>>(lambda); ; 
}
 
} // end namespace functional
 
enum class ClientState {
    disabled = 0,
    connecting = 1,
    connected = 2,
    wait_after_failed_connect = 3,
    wait_after_disconnect = 4,
    shutdown = 5,
};
 
const char* to_string(ClientState value);
 
class ClientStateListener {
public:
    virtual ~ClientStateListener() = default;
    
    virtual void on_change(ClientState state) = 0;
    
};
 
namespace functional {
 
template <class T>
class ClientStateListenerLambda final : public ClientStateListener
{
    static_assert(std::is_copy_constructible<T>::value, "Lambda expression must be copy constructible. Does it contain something that is move-only?");
    
    T lambda;
 
public:
    ClientStateListenerLambda(const T& lambda) : lambda(lambda) {}
    
    void on_change(ClientState state) override
    {
        lambda(state);
    }
};
 
template <class T>
std::unique_ptr<ClientStateListener> client_state_listener(const T& lambda)
{
    return std::make_unique<ClientStateListenerLambda<T>>(lambda); ; 
}
 
} // end namespace functional
 
enum class Variation {
    group0 = 0,
    group0_var254 = 1,
    group1_var0 = 2,
    group1_var1 = 3,
    group1_var2 = 4,
    group2_var0 = 5,
    group2_var1 = 6,
    group2_var2 = 7,
    group2_var3 = 8,
    group3_var0 = 9,
    group3_var1 = 10,
    group3_var2 = 11,
    group4_var0 = 12,
    group4_var1 = 13,
    group4_var2 = 14,
    group4_var3 = 15,
    group10_var0 = 16,
    group10_var1 = 17,
    group10_var2 = 18,
    group11_var0 = 19,
    group11_var1 = 20,
    group11_var2 = 21,
    group12_var1 = 22,
    group13_var1 = 23,
    group13_var2 = 24,
    group20_var0 = 25,
    group20_var1 = 26,
    group20_var2 = 27,
    group20_var5 = 28,
    group20_var6 = 29,
    group21_var0 = 30,
    group21_var1 = 31,
    group21_var2 = 32,
    group21_var5 = 33,
    group21_var6 = 34,
    group21_var9 = 35,
    group21_var10 = 36,
    group22_var0 = 37,
    group22_var1 = 38,
    group22_var2 = 39,
    group22_var5 = 40,
    group22_var6 = 41,
    group23_var0 = 42,
    group23_var1 = 43,
    group23_var2 = 44,
    group23_var5 = 45,
    group23_var6 = 46,
    group30_var0 = 47,
    group30_var1 = 48,
    group30_var2 = 49,
    group30_var3 = 50,
    group30_var4 = 51,
    group30_var5 = 52,
    group30_var6 = 53,
    group31_var0 = 54,
    group31_var1 = 55,
    group31_var2 = 56,
    group31_var3 = 57,
    group31_var4 = 58,
    group31_var5 = 59,
    group31_var6 = 60,
    group31_var7 = 61,
    group31_var8 = 62,
    group32_var0 = 63,
    group32_var1 = 64,
    group32_var2 = 65,
    group32_var3 = 66,
    group32_var4 = 67,
    group32_var5 = 68,
    group32_var6 = 69,
    group32_var7 = 70,
    group32_var8 = 71,
    group33_var0 = 72,
    group33_var1 = 73,
    group33_var2 = 74,
    group33_var3 = 75,
    group33_var4 = 76,
    group33_var5 = 77,
    group33_var6 = 78,
    group33_var7 = 79,
    group33_var8 = 80,
    group34_var0 = 81,
    group34_var1 = 82,
    group34_var2 = 83,
    group34_var3 = 84,
    group40_var0 = 85,
    group40_var1 = 86,
    group40_var2 = 87,
    group40_var3 = 88,
    group40_var4 = 89,
    group41_var1 = 90,
    group41_var2 = 91,
    group41_var3 = 92,
    group41_var4 = 93,
    group42_var0 = 94,
    group42_var1 = 95,
    group42_var2 = 96,
    group42_var3 = 97,
    group42_var4 = 98,
    group42_var5 = 99,
    group42_var6 = 100,
    group42_var7 = 101,
    group42_var8 = 102,
    group43_var1 = 103,
    group43_var2 = 104,
    group43_var3 = 105,
    group43_var4 = 106,
    group43_var5 = 107,
    group43_var6 = 108,
    group43_var7 = 109,
    group43_var8 = 110,
    group50_var1 = 111,
    group50_var2 = 112,
    group50_var3 = 113,
    group50_var4 = 114,
    group51_var1 = 115,
    group51_var2 = 116,
    group52_var1 = 117,
    group52_var2 = 118,
    group60_var1 = 119,
    group60_var2 = 120,
    group60_var3 = 121,
    group60_var4 = 122,
    group70_var2 = 123,
    group70_var3 = 124,
    group70_var4 = 125,
    group70_var5 = 126,
    group70_var6 = 127,
    group70_var7 = 128,
    group70_var8 = 129,
    group80_var1 = 130,
    group102_var0 = 131,
    group102_var1 = 132,
    group110 = 133,
    group111 = 134,
};
 
const char* to_string(Variation value);
 
struct RetryStrategy;
 
struct RetryStrategy {
    friend class CppRetryStrategyFriend;
    
private:
    RetryStrategy(std::chrono::steady_clock::duration min_delay, std::chrono::steady_clock::duration max_delay);
    
public:
    
    RetryStrategy();
    
    
    std::chrono::steady_clock::duration min_delay;
    std::chrono::steady_clock::duration max_delay;
};
 
enum class DataBits {
    five = 0,
    six = 1,
    seven = 2,
    eight = 3,
};
 
const char* to_string(DataBits value);
 
enum class FlowControl {
    none = 0,
    software = 1,
    hardware = 2,
};
 
const char* to_string(FlowControl value);
 
enum class Parity {
    none = 0,
    odd = 1,
    even = 2,
};
 
const char* to_string(Parity value);
 
enum class StopBits {
    one = 0,
    two = 1,
};
 
const char* to_string(StopBits value);
 
struct SerialSettings;
 
struct SerialSettings {
    friend class CppSerialSettingsFriend;
    
private:
    SerialSettings(uint32_t baud_rate, DataBits data_bits, FlowControl flow_control, Parity parity, StopBits stop_bits);
    
public:
    
    SerialSettings();
    
    
    uint32_t baud_rate;
    DataBits data_bits;
    FlowControl flow_control;
    Parity parity;
    StopBits stop_bits;
};
 
enum class LinkErrorMode {
    discard = 0,
    close = 1,
};
 
const char* to_string(LinkErrorMode value);
 
enum class FunctionCode {
    confirm = 0,
    read = 1,
    write = 2,
    select = 3,
    operate = 4,
    direct_operate = 5,
    direct_operate_no_response = 6,
    immediate_freeze = 7,
    immediate_freeze_no_response = 8,
    freeze_clear = 9,
    freeze_clear_no_response = 10,
    freeze_at_time = 11,
    freeze_at_time_no_response = 12,
    cold_restart = 13,
    warm_restart = 14,
    initialize_data = 15,
    initialize_application = 16,
    start_application = 17,
    stop_application = 18,
    save_configuration = 19,
    enable_unsolicited = 20,
    disable_unsolicited = 21,
    assign_class = 22,
    delay_measure = 23,
    record_current_time = 24,
    open_file = 25,
    close_file = 26,
    delete_file = 27,
    get_file_info = 28,
    authenticate_file = 29,
    abort_file = 30,
    response = 31,
    unsolicited_response = 32,
};
 
const char* to_string(FunctionCode value);
 
enum class FileType {
    directory = 0,
    simple = 1,
    other = 2,
};
 
const char* to_string(FileType value);
 
struct PermissionSet;
 
struct PermissionSet {
    friend class CppPermissionSetFriend;
    
    
    PermissionSet(bool execute, bool write, bool read);
    
    
    PermissionSet();
    
    
    bool execute;
    bool write;
    bool read;
};
 
struct Permissions;
 
struct Permissions {
    friend class CppPermissionsFriend;
    
    Permissions() = delete;
    
    Permissions(const PermissionSet& world, const PermissionSet& group, const PermissionSet& owner);
    
    
    static Permissions none();
    
    
    PermissionSet world;
    PermissionSet group;
    PermissionSet owner;
};
 
struct OpenFile;
 
struct OpenFile {
    friend class CppOpenFileFriend;
    
private:
    OpenFile(uint32_t file_handle, uint32_t file_size, uint16_t max_block_size);
    
public:
    OpenFile() = delete;
    
    uint32_t file_handle;
    uint32_t file_size;
    uint16_t max_block_size;
};
 
enum class FileError {
    ok = 0,
    bad_status = 1,
    no_permission = 2,
    bad_block_num = 3,
    abort_by_user = 4,
    max_length_exceeded = 5,
    wrong_handle = 6,
    too_many_requests = 7,
    iin_error = 8,
    bad_response = 9,
    response_timeout = 10,
    write_error = 11,
    no_connection = 12,
    shutdown = 13,
    association_removed = 14,
    bad_encoding = 15,
};
 
const char* to_string(FileError value);
 
class FileException : public std::logic_error {
public:
    FileError error;
    FileException(FileError error) : std::logic_error(to_string(error)), error(error) {}
};
 
struct FileInfo;
 
struct FileInfo {
    friend class CppFileInfoFriend;
    
private:
    FileInfo(const std::string& file_name, FileType file_type, uint32_t size, uint64_t time_created, const Permissions& permissions);
    
public:
    FileInfo() = delete;
    
    std::string file_name;
    FileType file_type;
    uint32_t size;
    uint64_t time_created;
    Permissions permissions;
};
 
class FileOpenCallback {
public:
    virtual ~FileOpenCallback() = default;
    
    virtual void on_complete(const OpenFile& result) = 0;
    
    virtual void on_failure(FileError error) = 0;
    
};
 
class FileOperationCallback {
public:
    virtual ~FileOperationCallback() = default;
    
    virtual void on_complete(Nothing result) = 0;
    
    virtual void on_failure(FileError error) = 0;
    
};
 
class FileAuthCallback {
public:
    virtual ~FileAuthCallback() = default;
    
    virtual void on_complete(uint32_t result) = 0;
    
    virtual void on_failure(FileError error) = 0;
    
};
 
enum class FileMode {
    read = 0,
    write = 1,
    append = 2,
};
 
const char* to_string(FileMode value);
 
enum class UdpSocketMode {
    one_to_one = 0,
    one_to_many = 1,
};
 
const char* to_string(UdpSocketMode value);
 
enum class LinkReadMode {
    stream = 0,
    datagram = 1,
};
 
const char* to_string(LinkReadMode value);
 
enum class LogLevel {
    error = 0,
    warn = 1,
    info = 2,
    debug = 3,
    trace = 4,
};
 
const char* to_string(LogLevel value);
 
struct LoggingConfig;
 
enum class LogOutputFormat {
    text = 0,
    json = 1,
};
 
const char* to_string(LogOutputFormat value);
 
enum class TimeFormat {
    none = 0,
    rfc_3339 = 1,
    system = 2,
};
 
const char* to_string(TimeFormat value);
 
struct LoggingConfig {
    friend class CppLoggingConfigFriend;
    
private:
    LoggingConfig(LogLevel level, LogOutputFormat output_format, TimeFormat time_format, bool print_level, bool print_module_info);
    
public:
    
    LoggingConfig();
    
    
    LogLevel level;
    LogOutputFormat output_format;
    TimeFormat time_format;
    bool print_level;
    bool print_module_info;
};
 
class Logger {
public:
    virtual ~Logger() = default;
    
    virtual void on_message(LogLevel level, const char* message) = 0;
    
};
 
namespace functional {
 
template <class T>
class LoggerLambda final : public Logger
{
    static_assert(std::is_copy_constructible<T>::value, "Lambda expression must be copy constructible. Does it contain something that is move-only?");
    
    T lambda;
 
public:
    LoggerLambda(const T& lambda) : lambda(lambda) {}
    
    void on_message(LogLevel level, const char* message) override
    {
        lambda(level, message);
    }
};
 
template <class T>
std::unique_ptr<Logger> logger(const T& lambda)
{
    return std::make_unique<LoggerLambda<T>>(lambda); ; 
}
 
} // end namespace functional
 
class Logging {
    Logging() = delete;
public:
    static void configure(const LoggingConfig& config, std::unique_ptr<Logger> logger);
};
 
enum class ResponseFunction {
    response = 0,
    unsolicited_response = 1,
};
 
const char* to_string(ResponseFunction value);
 
struct Iin1;
 
struct Iin1 {
    friend class CppIin1Friend;
    
private:
    Iin1(bool broadcast, bool class_1_events, bool class_2_events, bool class_3_events, bool need_time, bool local_control, bool device_trouble, bool device_restart);
    
public:
    Iin1() = delete;
    
    bool broadcast;
    bool class_1_events;
    bool class_2_events;
    bool class_3_events;
    bool need_time;
    bool local_control;
    bool device_trouble;
    bool device_restart;
};
 
struct Iin2;
 
struct Iin2 {
    friend class CppIin2Friend;
    
private:
    Iin2(bool no_func_code_support, bool object_unknown, bool parameter_error, bool event_buffer_overflow, bool already_executing, bool config_corrupt, bool reserved_2, bool reserved_1);
    
public:
    Iin2() = delete;
    
    bool no_func_code_support;
    bool object_unknown;
    bool parameter_error;
    bool event_buffer_overflow;
    bool already_executing;
    bool config_corrupt;
    bool reserved_2;
    bool reserved_1;
};
 
struct Iin;
 
struct Iin {
    friend class CppIinFriend;
    
private:
    Iin(const Iin1& iin1, const Iin2& iin2);
    
public:
    Iin() = delete;
    
    Iin1 iin1;
    Iin2 iin2;
};
 
struct ResponseHeader;
 
struct ResponseHeader {
    friend class CppResponseHeaderFriend;
    
private:
    ResponseHeader(const ControlField& control_field, ResponseFunction func, const Iin& iin);
    
public:
    ResponseHeader() = delete;
    
    ControlField control_field;
    ResponseFunction func;
    Iin iin;
};
 
enum class QualifierCode {
    range8 = 0,
    range16 = 1,
    all_objects = 2,
    count8 = 3,
    count16 = 4,
    count_and_prefix_8 = 5,
    count_and_prefix_16 = 6,
    free_format_16 = 7,
};
 
const char* to_string(QualifierCode value);
 
struct HeaderInfo;
 
struct HeaderInfo {
    friend class CppHeaderInfoFriend;
    
private:
    HeaderInfo(Variation variation, QualifierCode qualifier, bool is_event, bool has_flags);
    
public:
    HeaderInfo() = delete;
    
    Variation variation;
    QualifierCode qualifier;
    bool is_event;
    bool has_flags;
};
 
enum class ReadType {
    startup_integrity = 0,
    unsolicited = 1,
    single_poll = 2,
    periodic_poll = 3,
};
 
const char* to_string(ReadType value);
 
class ReadHandler {
public:
    virtual ~ReadHandler() = default;
    
    virtual void begin_fragment(ReadType read_type, const ResponseHeader& header) {};
    
    virtual void end_fragment(ReadType read_type, const ResponseHeader& header) {};
    
    virtual void handle_binary_input(const HeaderInfo& info, BinaryInputIterator& values) {};
    
    virtual void handle_double_bit_binary_input(const HeaderInfo& info, DoubleBitBinaryInputIterator& values) {};
    
    virtual void handle_binary_output_status(const HeaderInfo& info, BinaryOutputStatusIterator& values) {};
    
    virtual void handle_counter(const HeaderInfo& info, CounterIterator& values) {};
    
    virtual void handle_frozen_counter(const HeaderInfo& info, FrozenCounterIterator& values) {};
    
    virtual void handle_analog_input(const HeaderInfo& info, AnalogInputIterator& values) {};
    
    virtual void handle_frozen_analog_input(const HeaderInfo& info, FrozenAnalogInputIterator& values) {};
    
    virtual void handle_analog_output_status(const HeaderInfo& info, AnalogOutputStatusIterator& values) {};
    
    virtual void handle_binary_output_command_event(const HeaderInfo& info, BinaryOutputCommandEventIterator& values) {};
    
    virtual void handle_analog_output_command_event(const HeaderInfo& info, AnalogOutputCommandEventIterator& values) {};
    
    virtual void handle_unsigned_integer(const HeaderInfo& info, UnsignedIntegerIterator& values) {};
    
    virtual void handle_octet_string(const HeaderInfo& info, OctetStringIterator& values) {};
    
    virtual void handle_string_attr(const HeaderInfo& info, StringAttr attr, uint8_t set, uint8_t variation, const char* value) {};
    
    virtual void handle_variation_list_attr(const HeaderInfo& info, VariationListAttr attr, uint8_t set, uint8_t variation, AttrItemIter& value) {};
    
    virtual void handle_uint_attr(const HeaderInfo& info, UintAttr attr, uint8_t set, uint8_t variation, uint32_t value) {};
    
    virtual void handle_bool_attr(const HeaderInfo& info, BoolAttr attr, uint8_t set, uint8_t variation, bool value) {};
    
    virtual void handle_int_attr(const HeaderInfo& info, IntAttr attr, uint8_t set, uint8_t variation, int32_t value) {};
    
    virtual void handle_time_attr(const HeaderInfo& info, TimeAttr attr, uint8_t set, uint8_t variation, uint64_t value) {};
    
    virtual void handle_float_attr(const HeaderInfo& info, FloatAttr attr, uint8_t set, uint8_t variation, double value) {};
    
    virtual void handle_octet_string_attr(const HeaderInfo& info, OctetStringAttr attr, uint8_t set, uint8_t variation, ByteIterator& value) {};
    
    virtual void handle_bit_string_attr(const HeaderInfo& info, BitStringAttr attr, uint8_t set, uint8_t variation, ByteIterator& value) {};
    
};
 
struct MasterChannelConfig;
 
struct MasterChannelConfig {
    friend class CppMasterChannelConfigFriend;
    
private:
    MasterChannelConfig(uint16_t address, const DecodeLevel& decode_level, uint16_t tx_buffer_size, uint16_t rx_buffer_size);
    
public:
    MasterChannelConfig() = delete;
    
    MasterChannelConfig(uint16_t address);
    
    
    uint16_t address;
    DecodeLevel decode_level;
    uint16_t tx_buffer_size;
    uint16_t rx_buffer_size;
};
 
class MasterChannel;
 
class WriteDeadBandRequest;
 
class WriteDeadBandRequest {
    friend class CppWriteDeadBandRequestFriend;
    // pointer to the underlying C type
    void* self;
    // constructor only accessible internally
    WriteDeadBandRequest(void* self): self(self) {}
    // non-copyable
    WriteDeadBandRequest(const WriteDeadBandRequest&) = delete;
    WriteDeadBandRequest& operator=(const WriteDeadBandRequest&) = delete;
    // no move assignment
    WriteDeadBandRequest& operator=(WriteDeadBandRequest&& other) = delete;
 
public:
    WriteDeadBandRequest(WriteDeadBandRequest&& other) noexcept : self(other.self) { other.self = nullptr; }
    
    WriteDeadBandRequest();
    
    ~WriteDeadBandRequest();
    
    void add_g34v1_u8(uint8_t index, uint16_t dead_band);
    
    void add_g34v2_u8(uint8_t index, uint32_t dead_band);
    
    void add_g34v3_u8(uint8_t index, float dead_band);
    
    void add_g34v1_u16(uint16_t index, uint16_t dead_band);
    
    void add_g34v2_u16(uint16_t index, uint32_t dead_band);
    
    void add_g34v3_u16(uint16_t index, float dead_band);
    
    void finish_header();
};
 
enum class EmptyResponseError {
    ok = 0,
    rejected_by_iin2 = 1,
    too_many_requests = 2,
    iin_error = 3,
    bad_response = 4,
    response_timeout = 5,
    write_error = 6,
    no_connection = 7,
    shutdown = 8,
    association_removed = 9,
    bad_encoding = 10,
};
 
const char* to_string(EmptyResponseError value);
 
class EmptyResponseException : public std::logic_error {
public:
    EmptyResponseError error;
    EmptyResponseException(EmptyResponseError error) : std::logic_error(to_string(error)), error(error) {}
};
 
class EmptyResponseCallback {
public:
    virtual ~EmptyResponseCallback() = default;
    
    virtual void on_complete(Nothing result) = 0;
    
    virtual void on_failure(EmptyResponseError error) = 0;
    
};
 
struct AssociationId;
 
struct AssociationId {
    friend class CppAssociationIdFriend;
    
private:
 
    AssociationId(uint16_t address);
    
    AssociationId() = delete;
    
    uint16_t address;
};
 
struct PollId;
 
struct PollId {
    friend class CppPollIdFriend;
    
private:
 
    PollId(uint16_t association_id, uint64_t id);
    
    PollId() = delete;
    
    uint16_t association_id;
    uint64_t id;
};
 
struct EventClasses;
 
struct EventClasses {
    friend class CppEventClassesFriend;
    
    EventClasses() = delete;
    
    EventClasses(bool class1, bool class2, bool class3);
    
    
    static EventClasses all();
    
    
    static EventClasses none();
    
    
    bool class1;
    bool class2;
    bool class3;
};
 
struct Classes;
 
struct Classes {
    friend class CppClassesFriend;
    
    Classes() = delete;
    
    Classes(bool class0, bool class1, bool class2, bool class3);
    
    
    static Classes all();
    
    
    static Classes none();
    
    
    bool class0;
    bool class1;
    bool class2;
    bool class3;
};
 
enum class AutoTimeSync {
    none = 0,
    lan = 1,
    non_lan = 2,
};
 
const char* to_string(AutoTimeSync value);
 
struct AssociationConfig;
 
struct AssociationConfig {
    friend class CppAssociationConfigFriend;
    
private:
    AssociationConfig(std::chrono::steady_clock::duration response_timeout, const EventClasses& disable_unsol_classes, const EventClasses& enable_unsol_classes, const Classes& startup_integrity_classes, AutoTimeSync auto_time_sync, const RetryStrategy& auto_tasks_retry_strategy, std::chrono::steady_clock::duration keep_alive_timeout, bool auto_integrity_scan_on_buffer_overflow, const EventClasses& event_scan_on_events_available, uint16_t max_queued_user_requests);
    
public:
    AssociationConfig() = delete;
    
    AssociationConfig(const EventClasses& disable_unsol_classes, const EventClasses& enable_unsol_classes, const Classes& startup_integrity_classes, const EventClasses& event_scan_on_events_available);
    
    
    std::chrono::steady_clock::duration response_timeout;
    EventClasses disable_unsol_classes;
    EventClasses enable_unsol_classes;
    Classes startup_integrity_classes;
    AutoTimeSync auto_time_sync;
    RetryStrategy auto_tasks_retry_strategy;
    std::chrono::steady_clock::duration keep_alive_timeout;
    bool auto_integrity_scan_on_buffer_overflow;
    EventClasses event_scan_on_events_available;
    uint16_t max_queued_user_requests;
};
 
struct UtcTimestamp;
 
struct UtcTimestamp {
    friend class CppUtcTimestampFriend;
    
private:
    UtcTimestamp(uint64_t value, bool is_valid);
    
public:
    UtcTimestamp() = delete;
    
    static UtcTimestamp valid(uint64_t value);
    
    
    static UtcTimestamp invalid();
    
    
    uint64_t value;
    bool is_valid;
};
 
class AssociationHandler {
public:
    virtual ~AssociationHandler() = default;
    
    virtual UtcTimestamp get_current_time() = 0;
    
};
 
namespace functional {
 
template <class T>
class AssociationHandlerLambda final : public AssociationHandler
{
    static_assert(std::is_copy_constructible<T>::value, "Lambda expression must be copy constructible. Does it contain something that is move-only?");
    
    T lambda;
 
public:
    AssociationHandlerLambda(const T& lambda) : lambda(lambda) {}
    
    UtcTimestamp get_current_time() override
    {
        return lambda();
    }
};
 
template <class T>
std::unique_ptr<AssociationHandler> association_handler(const T& lambda)
{
    return std::make_unique<AssociationHandlerLambda<T>>(lambda); ; 
}
 
} // end namespace functional
 
enum class TaskType {
    user_read = 0,
    periodic_poll = 1,
    startup_integrity = 2,
    auto_event_scan = 3,
    command = 4,
    clear_restart_bit = 5,
    enable_unsolicited = 6,
    disable_unsolicited = 7,
    time_sync = 8,
    restart = 9,
    write_dead_bands = 10,
    generic_empty_response = 11,
    file_read = 12,
    get_file_info = 13,
    file_auth = 14,
    file_open = 15,
    file_write_block = 16,
    file_close = 17,
};
 
const char* to_string(TaskType value);
 
enum class TaskError {
    too_many_requests = 0,
    iin_error = 1,
    bad_response = 2,
    response_timeout = 3,
    write_error = 4,
    no_connection = 5,
    shutdown = 6,
    association_removed = 7,
    bad_encoding = 8,
};
 
const char* to_string(TaskError value);
 
class AssociationInformation {
public:
    virtual ~AssociationInformation() = default;
    
    virtual void task_start(TaskType task_type, FunctionCode function_code, uint8_t seq) = 0;
    
    virtual void task_success(TaskType task_type, FunctionCode function_code, uint8_t seq) = 0;
    
    virtual void task_fail(TaskType task_type, TaskError error) = 0;
    
    virtual void unsolicited_response(bool is_duplicate, uint8_t seq) = 0;
    
};
 
class Request;
 
class Request {
    friend class CppRequestFriend;
    // pointer to the underlying C type
    void* self;
    // constructor only accessible internally
    Request(void* self): self(self) {}
    // non-copyable
    Request(const Request&) = delete;
    Request& operator=(const Request&) = delete;
    // no move assignment
    Request& operator=(Request&& other) = delete;
 
public:
    Request(Request&& other) noexcept : self(other.self) { other.self = nullptr; }
    
    Request();
    
    ~Request();
    
    void add_one_byte_range_header(Variation variation, uint8_t start, uint8_t stop);
    
    void add_two_byte_range_header(Variation variation, uint16_t start, uint16_t stop);
    
    void add_all_objects_header(Variation variation);
    
    void add_one_byte_limited_count_header(Variation variation, uint8_t count);
    
    void add_two_byte_limited_count_header(Variation variation, uint16_t count);
    
    void add_time_and_interval(uint64_t time, uint32_t interval_ms);
    
    void add_specific_attribute(uint8_t variation, uint8_t set);
    
    void add_string_attribute(uint8_t variation, uint8_t set, const std::string& value);
    
    void add_uint_attribute(uint8_t variation, uint8_t set, uint32_t value);
    
    static Request class_request(bool class0, bool class1, bool class2, bool class3);
    
    static Request all_objects(Variation variation);
    
    static Request one_byte_range(Variation variation, uint8_t start, uint8_t stop);
    
    static Request two_byte_range(Variation variation, uint16_t start, uint16_t stop);
    
    static Request one_byte_limited_count(Variation variation, uint8_t count);
    
    static Request two_byte_limited_count(Variation variation, uint16_t count);
};
 
enum class ReadError {
    ok = 0,
    too_many_requests = 1,
    iin_error = 2,
    bad_response = 3,
    response_timeout = 4,
    write_error = 5,
    no_connection = 6,
    shutdown = 7,
    association_removed = 8,
    bad_encoding = 9,
};
 
const char* to_string(ReadError value);
 
class ReadException : public std::logic_error {
public:
    ReadError error;
    ReadException(ReadError error) : std::logic_error(to_string(error)), error(error) {}
};
 
class ReadTaskCallback {
public:
    virtual ~ReadTaskCallback() = default;
    
    virtual void on_complete(Nothing result) = 0;
    
    virtual void on_failure(ReadError error) = 0;
    
};
 
class CommandSet;
 
class CommandSet {
    friend class CppCommandSetFriend;
    // pointer to the underlying C type
    void* self;
    // constructor only accessible internally
    CommandSet(void* self): self(self) {}
    // non-copyable
    CommandSet(const CommandSet&) = delete;
    CommandSet& operator=(const CommandSet&) = delete;
    // no move assignment
    CommandSet& operator=(CommandSet&& other) = delete;
 
public:
    CommandSet(CommandSet&& other) noexcept : self(other.self) { other.self = nullptr; }
    
    CommandSet();
    
    ~CommandSet();
    
    void add_g12_v1_u8(uint8_t idx, const Group12Var1& header);
    
    void add_g12_v1_u16(uint16_t idx, const Group12Var1& header);
    
    void add_g41_v1_u8(uint8_t idx, int32_t value);
    
    void add_g41_v1_u16(uint16_t idx, int32_t value);
    
    void add_g41_v2_u8(uint8_t idx, int16_t value);
    
    void add_g41_v2_u16(uint16_t idx, int16_t value);
    
    void add_g41_v3_u8(uint8_t idx, float value);
    
    void add_g41_v3_u16(uint16_t idx, float value);
    
    void add_g41_v4_u8(uint8_t idx, double value);
    
    void add_g41_v4_u16(uint16_t idx, double value);
    
    void finish_header();
};
 
enum class CommandMode {
    direct_operate = 0,
    select_before_operate = 1,
};
 
const char* to_string(CommandMode value);
 
enum class CommandError {
    ok = 0,
    bad_status = 1,
    header_mismatch = 2,
    too_many_requests = 3,
    iin_error = 4,
    bad_response = 5,
    response_timeout = 6,
    write_error = 7,
    no_connection = 8,
    shutdown = 9,
    association_removed = 10,
    bad_encoding = 11,
};
 
const char* to_string(CommandError value);
 
class CommandException : public std::logic_error {
public:
    CommandError error;
    CommandException(CommandError error) : std::logic_error(to_string(error)), error(error) {}
};
 
class CommandTaskCallback {
public:
    virtual ~CommandTaskCallback() = default;
    
    virtual void on_complete(Nothing result) = 0;
    
    virtual void on_failure(CommandError error) = 0;
    
};
 
enum class TimeSyncMode {
    lan = 0,
    non_lan = 1,
};
 
const char* to_string(TimeSyncMode value);
 
enum class TimeSyncError {
    ok = 0,
    clock_rollback = 1,
    system_time_not_unix = 2,
    bad_outstation_time_delay = 3,
    overflow = 4,
    still_needs_time = 5,
    system_time_not_available = 6,
    too_many_requests = 7,
    iin_error = 8,
    bad_response = 9,
    response_timeout = 10,
    write_error = 11,
    no_connection = 12,
    shutdown = 13,
    association_removed = 14,
    bad_encoding = 15,
};
 
const char* to_string(TimeSyncError value);
 
class TimeSyncException : public std::logic_error {
public:
    TimeSyncError error;
    TimeSyncException(TimeSyncError error) : std::logic_error(to_string(error)), error(error) {}
};
 
class TimeSyncTaskCallback {
public:
    virtual ~TimeSyncTaskCallback() = default;
    
    virtual void on_complete(Nothing result) = 0;
    
    virtual void on_failure(TimeSyncError error) = 0;
    
};
 
enum class RestartError {
    ok = 0,
    too_many_requests = 1,
    iin_error = 2,
    bad_response = 3,
    response_timeout = 4,
    write_error = 5,
    no_connection = 6,
    shutdown = 7,
    association_removed = 8,
    bad_encoding = 9,
};
 
const char* to_string(RestartError value);
 
class RestartException : public std::logic_error {
public:
    RestartError error;
    RestartException(RestartError error) : std::logic_error(to_string(error)), error(error) {}
};
 
class RestartTaskCallback {
public:
    virtual ~RestartTaskCallback() = default;
    
    virtual void on_complete(std::chrono::steady_clock::duration result) = 0;
    
    virtual void on_failure(RestartError error) = 0;
    
};
 
class FileInfoCallback {
public:
    virtual ~FileInfoCallback() = default;
    
    virtual void on_complete(const FileInfo& result) = 0;
    
    virtual void on_failure(FileError error) = 0;
    
};
 
class FileReader {
public:
    virtual ~FileReader() = default;
    
    virtual bool opened(uint32_t size) = 0;
    
    virtual bool block_received(uint32_t block_num, ByteIterator& data) = 0;
    
    virtual void aborted(FileError error) = 0;
    
    virtual void completed() = 0;
    
};
 
struct FileReadConfig;
 
struct FileReadConfig {
    friend class CppFileReadConfigFriend;
    
private:
    FileReadConfig(uint16_t max_block_size, uint32_t max_file_size);
    
public:
    FileReadConfig() = delete;
    
    static FileReadConfig defaults();
    
    
    uint16_t max_block_size;
    uint32_t max_file_size;
};
 
struct DirReadConfig;
 
struct DirReadConfig {
    friend class CppDirReadConfigFriend;
    
private:
    DirReadConfig(uint16_t max_block_size, uint32_t max_file_size);
    
public:
    DirReadConfig() = delete;
    
    static DirReadConfig defaults();
    
    
    uint16_t max_block_size;
    uint32_t max_file_size;
};
 
class FileInfoIterator;
 
class FileInfoIterator final {
 
    friend class CppFileInfoIteratorFriend;
 
    // underlying opaque c type
    void* iter;
    // pointer to the last retrieved c value
    void* current;
 
    // internal constructor
    FileInfoIterator(void* iter) : iter(iter), current(nullptr) {}
 
    FileInfoIterator() = delete; // no default construction
    FileInfoIterator(const FileInfoIterator&) = delete; // no copies
    FileInfoIterator& operator=(const FileInfoIterator&) = delete; // no self-assignment
    FileInfoIterator& operator=(FileInfoIterator&&) = delete; // no move self-assignment
 
public:
 
    FileInfoIterator(FileInfoIterator&&) = default;
 
    bool next();
 
    FileInfo get();
};
 
class ReadDirectoryCallback {
public:
    virtual ~ReadDirectoryCallback() = default;
    
    virtual void on_complete(FileInfoIterator& result) = 0;
    
    virtual void on_failure(FileError error) = 0;
    
};
 
enum class LinkStatusError {
    ok = 0,
    unexpected_response = 1,
    too_many_requests = 2,
    iin_error = 3,
    bad_response = 4,
    response_timeout = 5,
    write_error = 6,
    no_connection = 7,
    shutdown = 8,
    association_removed = 9,
    bad_encoding = 10,
};
 
const char* to_string(LinkStatusError value);
 
class LinkStatusException : public std::logic_error {
public:
    LinkStatusError error;
    LinkStatusException(LinkStatusError error) : std::logic_error(to_string(error)), error(error) {}
};
 
class LinkStatusCallback {
public:
    virtual ~LinkStatusCallback() = default;
    
    virtual void on_complete(Nothing result) = 0;
    
    virtual void on_failure(LinkStatusError error) = 0;
    
};
 
class MasterChannel {
    friend class CppMasterChannelFriend;
    // pointer to the underlying C type
    void* self;
    // constructor only accessible internally
    MasterChannel(void* self): self(self) {}
    // non-copyable
    MasterChannel(const MasterChannel&) = delete;
    MasterChannel& operator=(const MasterChannel&) = delete;
    // no move assignment
    MasterChannel& operator=(MasterChannel&& other) = delete;
 
public:
    MasterChannel(MasterChannel&& other) noexcept : self(other.self) { other.self = nullptr; }
    
    ~MasterChannel();
    
    void enable();
    
    void disable();
    
    AssociationId add_association(uint16_t address, const AssociationConfig& config, std::unique_ptr<ReadHandler> read_handler, std::unique_ptr<AssociationHandler> association_handler, std::unique_ptr<AssociationInformation> association_information);
    
    AssociationId add_udp_association(uint16_t address, const std::string& destination, const AssociationConfig& config, std::unique_ptr<ReadHandler> read_handler, std::unique_ptr<AssociationHandler> association_handler, std::unique_ptr<AssociationInformation> association_information);
    
    void remove_association(const AssociationId& id);
    
    void set_decode_level(const DecodeLevel& decode_level);
    
    DecodeLevel get_decode_level();
    
    PollId add_poll(const AssociationId& id, Request& request, std::chrono::steady_clock::duration period);
    
    void remove_poll(const PollId& poll_id);
    
    void demand_poll(const PollId& poll_id);
    
    void read_file(const AssociationId& association, const std::string& remote_file_path, const FileReadConfig& config, std::unique_ptr<FileReader> reader);
    
    void read_file_with_auth(const AssociationId& association, const std::string& remote_file_path, const FileReadConfig& config, std::unique_ptr<FileReader> reader, const std::string& user_name, const std::string& password);
    
    static MasterChannel create_tcp_channel(Runtime& runtime, LinkErrorMode link_error_mode, const MasterChannelConfig& config, EndpointList& endpoints, const ConnectStrategy& connect_strategy, std::unique_ptr<ClientStateListener> listener);
    
    static MasterChannel create_tcp_channel_2(Runtime& runtime, LinkErrorMode link_error_mode, const MasterChannelConfig& config, EndpointList& endpoints, const ConnectStrategy& connect_strategy, ConnectOptions& connect_options, std::unique_ptr<ClientStateListener> listener);
    
    static MasterChannel create_tls_channel(Runtime& runtime, LinkErrorMode link_error_mode, const MasterChannelConfig& config, EndpointList& endpoints, const ConnectStrategy& connect_strategy, std::unique_ptr<ClientStateListener> listener, const TlsClientConfig& tls_config);
    
    static MasterChannel create_tls_channel_2(Runtime& runtime, LinkErrorMode link_error_mode, const MasterChannelConfig& config, EndpointList& endpoints, const ConnectStrategy& connect_strategy, ConnectOptions& connect_options, std::unique_ptr<ClientStateListener> listener, const TlsClientConfig& tls_config);
    
    static MasterChannel create_serial_channel(Runtime& runtime, const MasterChannelConfig& config, const std::string& path, const SerialSettings& serial_params, std::chrono::steady_clock::duration open_retry_delay, std::unique_ptr<PortStateListener> listener);
    
    static MasterChannel create_udp_channel(Runtime& runtime, const MasterChannelConfig& config, const std::string& local_endpoint, LinkReadMode link_read_mode, std::chrono::steady_clock::duration retry_delay);
    
    void read(const AssociationId& association, Request& request, std::unique_ptr<ReadTaskCallback> callback);
    
    
    void read_with_handler(const AssociationId& association, Request& request, std::unique_ptr<ReadHandler> handler, std::unique_ptr<ReadTaskCallback> callback);
    
    
    void operate(const AssociationId& association, CommandMode mode, CommandSet& command, std::unique_ptr<CommandTaskCallback> callback);
    
    
    void synchronize_time(const AssociationId& association, TimeSyncMode mode, std::unique_ptr<TimeSyncTaskCallback> callback);
    
    
    void cold_restart(const AssociationId& association, std::unique_ptr<RestartTaskCallback> callback);
    
    
    void warm_restart(const AssociationId& association, std::unique_ptr<RestartTaskCallback> callback);
    
    
    void write_dead_bands(const AssociationId& association, WriteDeadBandRequest& request, std::unique_ptr<EmptyResponseCallback> callback);
    
    
    void send_and_expect_empty_response(const AssociationId& association, FunctionCode function, Request& headers, std::unique_ptr<EmptyResponseCallback> callback);
    
    
    void get_file_info(const AssociationId& association, const std::string& file_name, std::unique_ptr<FileInfoCallback> callback);
    
    
    void get_file_auth_key(const AssociationId& association, const std::string& username, const std::string& password, std::unique_ptr<FileAuthCallback> callback);
    
    
    void open_file(const AssociationId& association, const std::string& file_name, uint32_t auth_key, const Permissions& permissions, uint32_t file_size, FileMode file_mode, uint16_t max_block_size, std::unique_ptr<FileOpenCallback> callback);
    
    
    void write_file_block(const AssociationId& association, uint32_t handle, uint32_t block_number, bool final_block, const std::vector<uint8_t>& block_data, std::unique_ptr<FileOperationCallback> callback);
    
    
    void close_file(const AssociationId& association, uint32_t handle, std::unique_ptr<FileOperationCallback> callback);
    
    
    void read_directory(const AssociationId& association, const std::string& dir_path, const DirReadConfig& config, std::unique_ptr<ReadDirectoryCallback> callback);
    
    
    void read_directory_with_auth(const AssociationId& association, const std::string& dir_path, const DirReadConfig& config, const std::string& user_name, const std::string& password, std::unique_ptr<ReadDirectoryCallback> callback);
    
    
    void check_link_status(const AssociationId& association, std::unique_ptr<LinkStatusCallback> callback);
    
};
 
class AcceptHandler;
 
class AcceptHandler {
    friend class CppAcceptHandlerFriend;
    // pointer to the underlying C type
    void* self;
    // constructor only accessible internally
    AcceptHandler(void* self): self(self) {}
    // non-copyable
    AcceptHandler(const AcceptHandler&) = delete;
    AcceptHandler& operator=(const AcceptHandler&) = delete;
    // no move assignment
    AcceptHandler& operator=(AcceptHandler&& other) = delete;
 
public:
    AcceptHandler(AcceptHandler&& other) noexcept : self(other.self) { other.self = nullptr; }
    
    ParamError accept(LinkErrorMode error_mode, const MasterChannelConfig& config);
    
    ParamError get_link_identity();
};
 
class IdentifiedLinkHandler;
 
class IdentifiedLinkHandler {
    friend class CppIdentifiedLinkHandlerFriend;
    // pointer to the underlying C type
    void* self;
    // constructor only accessible internally
    IdentifiedLinkHandler(void* self): self(self) {}
    // non-copyable
    IdentifiedLinkHandler(const IdentifiedLinkHandler&) = delete;
    IdentifiedLinkHandler& operator=(const IdentifiedLinkHandler&) = delete;
    // no move assignment
    IdentifiedLinkHandler& operator=(IdentifiedLinkHandler&& other) = delete;
 
public:
    IdentifiedLinkHandler(IdentifiedLinkHandler&& other) noexcept : self(other.self) { other.self = nullptr; }
    
    ParamError accept(LinkErrorMode error_mode, const MasterChannelConfig& config);
};
 
class ConnectionHandler {
public:
    virtual ~ConnectionHandler() = default;
    
    virtual void accept(const char* remote_addr, AcceptHandler& acceptor) = 0;
    
    virtual void start(const char* remote_addr, MasterChannel& channel) = 0;
    
    virtual void accept_with_link_id(const char* remote_addr, uint16_t source, uint16_t destination, IdentifiedLinkHandler& acceptor) = 0;
    
    virtual void start_with_link_id(const char* remote_addr, uint16_t source, uint16_t destination, MasterChannel& channel) = 0;
    
};
 
class MasterServer;
 
struct LinkIdConfig;
 
struct LinkIdConfig {
    friend class CppLinkIdConfigFriend;
    
private:
    LinkIdConfig(uint16_t max_tasks, std::chrono::steady_clock::duration timeout, PhysDecodeLevel decode_level);
    
public:
    
    LinkIdConfig();
    
    
    uint16_t max_tasks;
    std::chrono::steady_clock::duration timeout;
    PhysDecodeLevel decode_level;
};
 
class MasterServer {
    friend class CppMasterServerFriend;
    // pointer to the underlying C type
    void* self;
    // constructor only accessible internally
    MasterServer(void* self): self(self) {}
    // non-copyable
    MasterServer(const MasterServer&) = delete;
    MasterServer& operator=(const MasterServer&) = delete;
    // no move assignment
    MasterServer& operator=(MasterServer&& other) = delete;
 
public:
    MasterServer(MasterServer&& other) noexcept : self(other.self) { other.self = nullptr; }
    
    ~MasterServer();
    
    static MasterServer create_tcp_server(Runtime& runtime, const std::string& local_addr, const LinkIdConfig& link_id_config, std::unique_ptr<ConnectionHandler> connection_handler);
};
 
class Database;
 
enum class EventClass {
    none = 0,
    class1 = 1,
    class2 = 2,
    class3 = 3,
};
 
const char* to_string(EventClass value);
 
enum class UpdateResult {
    no_point = 0,
    no_event = 1,
    created = 2,
    overflow = 3,
};
 
const char* to_string(UpdateResult value);
 
struct UpdateInfo;
 
struct UpdateInfo {
    friend class CppUpdateInfoFriend;
    
private:
    UpdateInfo(UpdateResult result, uint64_t created, uint64_t discarded);
    
public:
    UpdateInfo() = delete;
    
    UpdateResult result;
    uint64_t created;
    uint64_t discarded;
};
 
enum class EventMode {
    detect = 0,
    force = 1,
    suppress = 2,
};
 
const char* to_string(EventMode value);
 
struct UpdateOptions;
 
struct UpdateOptions {
    friend class CppUpdateOptionsFriend;
    
private:
    UpdateOptions(bool update_static, EventMode event_mode);
    
public:
    UpdateOptions() = delete;
    
    static UpdateOptions detect_event();
    
    
    static UpdateOptions no_event();
    
    
    bool update_static;
    EventMode event_mode;
};
 
enum class UpdateFlagsType {
    binary_input = 0,
    double_bit_binary_input = 1,
    binary_output_status = 2,
    counter = 3,
    frozen_counter = 4,
    analog_input = 5,
    analog_output_status = 6,
};
 
const char* to_string(UpdateFlagsType value);
 
enum class StaticBinaryInputVariation {
    group1_var1 = 0,
    group1_var2 = 1,
};
 
const char* to_string(StaticBinaryInputVariation value);
 
enum class EventBinaryInputVariation {
    group2_var1 = 0,
    group2_var2 = 1,
    group2_var3 = 2,
};
 
const char* to_string(EventBinaryInputVariation value);
 
struct BinaryInputConfig;
 
struct BinaryInputConfig {
    friend class CppBinaryInputConfigFriend;
    
    
    BinaryInputConfig(StaticBinaryInputVariation static_variation, EventBinaryInputVariation event_variation);
    
    
    BinaryInputConfig();
    
    
    StaticBinaryInputVariation static_variation;
    EventBinaryInputVariation event_variation;
};
 
enum class StaticDoubleBitBinaryInputVariation {
    group3_var1 = 0,
    group3_var2 = 1,
};
 
const char* to_string(StaticDoubleBitBinaryInputVariation value);
 
enum class EventDoubleBitBinaryInputVariation {
    group4_var1 = 0,
    group4_var2 = 1,
    group4_var3 = 2,
};
 
const char* to_string(EventDoubleBitBinaryInputVariation value);
 
struct DoubleBitBinaryInputConfig;
 
struct DoubleBitBinaryInputConfig {
    friend class CppDoubleBitBinaryInputConfigFriend;
    
    
    DoubleBitBinaryInputConfig(StaticDoubleBitBinaryInputVariation static_variation, EventDoubleBitBinaryInputVariation event_variation);
    
    
    DoubleBitBinaryInputConfig();
    
    
    StaticDoubleBitBinaryInputVariation static_variation;
    EventDoubleBitBinaryInputVariation event_variation;
};
 
enum class StaticBinaryOutputStatusVariation {
    group10_var1 = 0,
    group10_var2 = 1,
};
 
const char* to_string(StaticBinaryOutputStatusVariation value);
 
enum class EventBinaryOutputStatusVariation {
    group11_var1 = 0,
    group11_var2 = 1,
};
 
const char* to_string(EventBinaryOutputStatusVariation value);
 
struct BinaryOutputStatusConfig;
 
struct BinaryOutputStatusConfig {
    friend class CppBinaryOutputStatusConfigFriend;
    
    
    BinaryOutputStatusConfig(StaticBinaryOutputStatusVariation static_variation, EventBinaryOutputStatusVariation event_variation);
    
    
    BinaryOutputStatusConfig();
    
    
    StaticBinaryOutputStatusVariation static_variation;
    EventBinaryOutputStatusVariation event_variation;
};
 
enum class StaticCounterVariation {
    group20_var1 = 0,
    group20_var2 = 1,
    group20_var5 = 2,
    group20_var6 = 3,
};
 
const char* to_string(StaticCounterVariation value);
 
enum class EventCounterVariation {
    group22_var1 = 0,
    group22_var2 = 1,
    group22_var5 = 2,
    group22_var6 = 3,
};
 
const char* to_string(EventCounterVariation value);
 
struct CounterConfig;
 
struct CounterConfig {
    friend class CppCounterConfigFriend;
    
    
    CounterConfig(StaticCounterVariation static_variation, EventCounterVariation event_variation, uint32_t deadband);
    
    
    CounterConfig();
    
    
    StaticCounterVariation static_variation;
    EventCounterVariation event_variation;
    uint32_t deadband;
};
 
enum class StaticFrozenCounterVariation {
    group21_var1 = 0,
    group21_var2 = 1,
    group21_var5 = 2,
    group21_var6 = 3,
    group21_var9 = 4,
    group21_var10 = 5,
};
 
const char* to_string(StaticFrozenCounterVariation value);
 
enum class EventFrozenCounterVariation {
    group23_var1 = 0,
    group23_var2 = 1,
    group23_var5 = 2,
    group23_var6 = 3,
};
 
const char* to_string(EventFrozenCounterVariation value);
 
struct FrozenCounterConfig;
 
struct FrozenCounterConfig {
    friend class CppFrozenCounterConfigFriend;
    
    
    FrozenCounterConfig(StaticFrozenCounterVariation static_variation, EventFrozenCounterVariation event_variation, uint32_t deadband);
    
    
    FrozenCounterConfig();
    
    
    StaticFrozenCounterVariation static_variation;
    EventFrozenCounterVariation event_variation;
    uint32_t deadband;
};
 
enum class StaticAnalogInputVariation {
    group30_var1 = 0,
    group30_var2 = 1,
    group30_var3 = 2,
    group30_var4 = 3,
    group30_var5 = 4,
    group30_var6 = 5,
};
 
const char* to_string(StaticAnalogInputVariation value);
 
enum class EventAnalogInputVariation {
    group32_var1 = 0,
    group32_var2 = 1,
    group32_var3 = 2,
    group32_var4 = 3,
    group32_var5 = 4,
    group32_var6 = 5,
    group32_var7 = 6,
    group32_var8 = 7,
};
 
const char* to_string(EventAnalogInputVariation value);
 
struct AnalogInputConfig;
 
struct AnalogInputConfig {
    friend class CppAnalogInputConfigFriend;
    
    
    AnalogInputConfig(StaticAnalogInputVariation static_variation, EventAnalogInputVariation event_variation, double deadband);
    
    
    AnalogInputConfig();
    
    
    StaticAnalogInputVariation static_variation;
    EventAnalogInputVariation event_variation;
    double deadband;
};
 
enum class StaticAnalogOutputStatusVariation {
    group40_var1 = 0,
    group40_var2 = 1,
    group40_var3 = 2,
    group40_var4 = 3,
};
 
const char* to_string(StaticAnalogOutputStatusVariation value);
 
enum class EventAnalogOutputStatusVariation {
    group42_var1 = 0,
    group42_var2 = 1,
    group42_var3 = 2,
    group42_var4 = 3,
    group42_var5 = 4,
    group42_var6 = 5,
    group42_var7 = 6,
    group42_var8 = 7,
};
 
const char* to_string(EventAnalogOutputStatusVariation value);
 
struct AnalogOutputStatusConfig;
 
struct AnalogOutputStatusConfig {
    friend class CppAnalogOutputStatusConfigFriend;
    
    
    AnalogOutputStatusConfig(StaticAnalogOutputStatusVariation static_variation, EventAnalogOutputStatusVariation event_variation, double deadband);
    
    
    AnalogOutputStatusConfig();
    
    
    StaticAnalogOutputStatusVariation static_variation;
    EventAnalogOutputStatusVariation event_variation;
    double deadband;
};
 
enum class AttrDefError {
    ok = 0,
    already_defined = 1,
    reserved_variation = 2,
    bad_type = 3,
    not_writable = 4,
};
 
const char* to_string(AttrDefError value);
 
class Database {
    friend class CppDatabaseFriend;
    // pointer to the underlying C type
    void* self;
    // constructor only accessible internally
    Database(void* self): self(self) {}
    // non-copyable
    Database(const Database&) = delete;
    Database& operator=(const Database&) = delete;
    // no move assignment
    Database& operator=(Database&& other) = delete;
 
public:
    Database(Database&& other) noexcept : self(other.self) { other.self = nullptr; }
    
    UpdateInfo update_flags(uint16_t index, UpdateFlagsType flags_type, const Flags& flags, const Timestamp& time, const UpdateOptions& options);
    
    bool add_binary_input(uint16_t index, EventClass point_class, const BinaryInputConfig& config);
    
    bool remove_binary_input(uint16_t index);
    
    bool update_binary_input(const BinaryInput& value, const UpdateOptions& options);
    
    UpdateInfo update_binary_input_2(const BinaryInput& value, const UpdateOptions& options);
    
    BinaryInput get_binary_input(uint16_t index);
    
    bool add_double_bit_binary_input(uint16_t index, EventClass point_class, const DoubleBitBinaryInputConfig& config);
    
    bool remove_double_bit_binary_input(uint16_t index);
    
    bool update_double_bit_binary_input(const DoubleBitBinaryInput& value, const UpdateOptions& options);
    
    UpdateInfo update_double_bit_binary_input_2(const DoubleBitBinaryInput& value, const UpdateOptions& options);
    
    DoubleBitBinaryInput get_double_bit_binary_input(uint16_t index);
    
    bool add_binary_output_status(uint16_t index, EventClass point_class, const BinaryOutputStatusConfig& config);
    
    bool remove_binary_output_status(uint16_t index);
    
    bool update_binary_output_status(const BinaryOutputStatus& value, const UpdateOptions& options);
    
    UpdateInfo update_binary_output_status_2(const BinaryOutputStatus& value, const UpdateOptions& options);
    
    BinaryOutputStatus get_binary_output_status(uint16_t index);
    
    bool add_counter(uint16_t index, EventClass point_class, const CounterConfig& config);
    
    bool remove_counter(uint16_t index);
    
    bool update_counter(const Counter& value, const UpdateOptions& options);
    
    UpdateInfo update_counter_2(const Counter& value, const UpdateOptions& options);
    
    Counter get_counter(uint16_t index);
    
    bool add_frozen_counter(uint16_t index, EventClass point_class, const FrozenCounterConfig& config);
    
    bool remove_frozen_counter(uint16_t index);
    
    bool update_frozen_counter(const FrozenCounter& value, const UpdateOptions& options);
    
    UpdateInfo update_frozen_counter_2(const FrozenCounter& value, const UpdateOptions& options);
    
    FrozenCounter get_frozen_counter(uint16_t index);
    
    bool add_analog_input(uint16_t index, EventClass point_class, const AnalogInputConfig& config);
    
    bool remove_analog_input(uint16_t index);
    
    bool update_analog_input(const AnalogInput& value, const UpdateOptions& options);
    
    UpdateInfo update_analog_input_2(const AnalogInput& value, const UpdateOptions& options);
    
    AnalogInput get_analog_input(uint16_t index);
    
    bool add_analog_output_status(uint16_t index, EventClass point_class, const AnalogOutputStatusConfig& config);
    
    bool remove_analog_output_status(uint16_t index);
    
    bool update_analog_output_status(const AnalogOutputStatus& value, const UpdateOptions& options);
    
    UpdateInfo update_analog_output_status_2(const AnalogOutputStatus& value, const UpdateOptions& options);
    
    AnalogOutputStatus get_analog_output_status(uint16_t index);
    
    bool add_octet_string(uint16_t index, EventClass point_class);
    
    bool remove_octet_string(uint16_t index);
    
    bool update_octet_string(uint16_t index, const std::vector<uint8_t>& value, const UpdateOptions& options);
    
    UpdateInfo update_octet_string_2(uint16_t index, const std::vector<uint8_t>& value, const UpdateOptions& options);
    
    AttrDefError define_string_attr(uint8_t set, bool writable, uint8_t variation, const std::string& value);
    
    AttrDefError define_int_attr(uint8_t set, bool writable, uint8_t variation, int32_t value);
    
    AttrDefError define_uint_attr(uint8_t set, bool writable, uint8_t variation, uint32_t value);
    
    AttrDefError define_time_attr(uint8_t set, bool writable, uint8_t variation, uint64_t value);
    
    AttrDefError define_bool_attr(uint8_t set, bool writable, uint8_t variation, bool value);
    
    AttrDefError define_float_attr(uint8_t set, bool writable, uint8_t variation, float value);
    
    AttrDefError define_double_attr(uint8_t set, bool writable, uint8_t variation, double value);
};
 
class DatabaseTransaction {
public:
    virtual ~DatabaseTransaction() = default;
    
    virtual void execute(Database& database) = 0;
    
};
 
namespace functional {
 
template <class T>
class DatabaseTransactionLambda final : public DatabaseTransaction
{
    static_assert(std::is_copy_constructible<T>::value, "Lambda expression must be copy constructible. Does it contain something that is move-only?");
    
    T lambda;
 
public:
    DatabaseTransactionLambda(const T& lambda) : lambda(lambda) {}
    
    void execute(Database& database) override
    {
        lambda(database);
    }
};
 
template <class T>
DatabaseTransactionLambda<T> database_transaction(const T& lambda)
{
    return DatabaseTransactionLambda<T>(lambda); 
}
 
} // end namespace functional
 
class DatabaseHandle;
 
class DatabaseHandle {
    friend class CppDatabaseHandleFriend;
    // pointer to the underlying C type
    void* self;
    // constructor only accessible internally
    DatabaseHandle(void* self): self(self) {}
    // non-copyable
    DatabaseHandle(const DatabaseHandle&) = delete;
    DatabaseHandle& operator=(const DatabaseHandle&) = delete;
    // no move assignment
    DatabaseHandle& operator=(DatabaseHandle&& other) = delete;
 
public:
    DatabaseHandle(DatabaseHandle&& other) noexcept : self(other.self) { other.self = nullptr; }
    
    void transaction(DatabaseTransaction& callback);
};
 
struct EventBufferConfig;
 
struct EventBufferConfig {
    friend class CppEventBufferConfigFriend;
    
    EventBufferConfig() = delete;
    
    EventBufferConfig(uint16_t max_binary, uint16_t max_double_bit_binary, uint16_t max_binary_output_status, uint16_t max_counter, uint16_t max_frozen_counter, uint16_t max_analog, uint16_t max_analog_output_status, uint16_t max_octet_string);
    
    
    static EventBufferConfig no_events();
    
    
    uint16_t max_binary;
    uint16_t max_double_bit_binary;
    uint16_t max_binary_output_status;
    uint16_t max_counter;
    uint16_t max_frozen_counter;
    uint16_t max_analog;
    uint16_t max_analog_output_status;
    uint16_t max_octet_string;
};
 
struct ClassZeroConfig;
 
struct ClassZeroConfig {
    friend class CppClassZeroConfigFriend;
    
private:
    ClassZeroConfig(bool binary, bool double_bit_binary, bool binary_output_status, bool counter, bool frozen_counter, bool analog, bool analog_output_status, bool octet_string);
    
public:
    
    ClassZeroConfig();
    
    
    bool binary;
    bool double_bit_binary;
    bool binary_output_status;
    bool counter;
    bool frozen_counter;
    bool analog;
    bool analog_output_status;
    bool octet_string;
};
 
struct OutstationFeatures;
 
struct OutstationFeatures {
    friend class CppOutstationFeaturesFriend;
    
private:
    OutstationFeatures(bool self_address, bool broadcast, bool unsolicited, bool respond_to_any_master);
    
public:
    
    OutstationFeatures();
    
    
    bool self_address;
    bool broadcast;
    bool unsolicited;
    bool respond_to_any_master;
};
 
struct OutstationConfig;
 
struct OutstationConfig {
    friend class CppOutstationConfigFriend;
    
private:
    OutstationConfig(uint16_t outstation_address, uint16_t master_address, const EventBufferConfig& event_buffer_config, uint16_t solicited_buffer_size, uint16_t unsolicited_buffer_size, uint16_t rx_buffer_size, const DecodeLevel& decode_level, std::chrono::steady_clock::duration confirm_timeout, std::chrono::steady_clock::duration select_timeout, const OutstationFeatures& features, uint32_t max_unsolicited_retries, std::chrono::steady_clock::duration unsolicited_retry_delay, std::chrono::steady_clock::duration keep_alive_timeout, uint16_t max_read_request_headers, uint16_t max_controls_per_request, const ClassZeroConfig& class_zero);
    
public:
    OutstationConfig() = delete;
    
    OutstationConfig(uint16_t outstation_address, uint16_t master_address, const EventBufferConfig& event_buffer_config);
    
    
    uint16_t outstation_address;
    uint16_t master_address;
    EventBufferConfig event_buffer_config;
    uint16_t solicited_buffer_size;
    uint16_t unsolicited_buffer_size;
    uint16_t rx_buffer_size;
    DecodeLevel decode_level;
    std::chrono::steady_clock::duration confirm_timeout;
    std::chrono::steady_clock::duration select_timeout;
    OutstationFeatures features;
    uint32_t max_unsolicited_retries;
    std::chrono::steady_clock::duration unsolicited_retry_delay;
    std::chrono::steady_clock::duration keep_alive_timeout;
    uint16_t max_read_request_headers;
    uint16_t max_controls_per_request;
    ClassZeroConfig class_zero;
};
 
enum class RestartDelayType {
    not_supported = 0,
    seconds = 1,
    milli_seconds = 2,
};
 
const char* to_string(RestartDelayType value);
 
struct RestartDelay;
 
struct RestartDelay {
    friend class CppRestartDelayFriend;
    
private:
    RestartDelay(RestartDelayType restart_type, uint16_t value);
    
public:
    RestartDelay() = delete;
    
    static RestartDelay not_supported();
    
    
    static RestartDelay seconds(uint16_t value);
    
    
    static RestartDelay milliseconds(uint16_t value);
    
    
    RestartDelayType restart_type;
    uint16_t value;
};
 
enum class WriteTimeResult {
    ok = 0,
    parameter_error = 1,
    not_supported = 2,
};
 
const char* to_string(WriteTimeResult value);
 
enum class FreezeType {
    immediate_freeze = 0,
    freeze_and_clear = 1,
};
 
const char* to_string(FreezeType value);
 
enum class FreezeResult {
    ok = 0,
    parameter_error = 1,
    not_supported = 2,
};
 
const char* to_string(FreezeResult value);
 
struct ApplicationIin;
 
struct ApplicationIin {
    friend class CppApplicationIinFriend;
    
private:
    ApplicationIin(bool need_time, bool local_control, bool device_trouble, bool config_corrupt);
    
public:
    
    ApplicationIin();
    
    
    bool need_time;
    bool local_control;
    bool device_trouble;
    bool config_corrupt;
};
 
struct ClassCount;
 
struct ClassCount {
    friend class CppClassCountFriend;
    
private:
    ClassCount(uint32_t num_class_1, uint32_t num_class_2, uint32_t num_class_3);
    
public:
    ClassCount() = delete;
    
    uint32_t num_class_1;
    uint32_t num_class_2;
    uint32_t num_class_3;
};
 
struct TypeCount;
 
struct TypeCount {
    friend class CppTypeCountFriend;
    
private:
    TypeCount(uint32_t num_binary_input, uint32_t num_double_bit_binary_input, uint32_t num_binary_output_status, uint32_t num_counter, uint32_t num_frozen_counter, uint32_t num_analog, uint32_t num_analog_output_status, uint32_t num_octet_string);
    
public:
    TypeCount() = delete;
    
    uint32_t num_binary_input;
    uint32_t num_double_bit_binary_input;
    uint32_t num_binary_output_status;
    uint32_t num_counter;
    uint32_t num_frozen_counter;
    uint32_t num_analog;
    uint32_t num_analog_output_status;
    uint32_t num_octet_string;
};
 
struct BufferState;
 
struct BufferState {
    friend class CppBufferStateFriend;
    
private:
    BufferState(const ClassCount& classes, const TypeCount& types);
    
public:
    BufferState() = delete;
    
    ClassCount classes;
    TypeCount types;
};
 
class OutstationApplication {
public:
    virtual ~OutstationApplication() = default;
    
    virtual uint16_t get_processing_delay_ms() = 0;
    
    virtual WriteTimeResult write_absolute_time(uint64_t time) = 0;
    
    virtual ApplicationIin get_application_iin() = 0;
    
    virtual RestartDelay cold_restart() = 0;
    
    virtual RestartDelay warm_restart() = 0;
    
    virtual FreezeResult freeze_counters_all(FreezeType freeze_type, DatabaseHandle& database_handle) {
        return FreezeResult::not_supported;
    }
    
    virtual FreezeResult freeze_counters_all_at_time(DatabaseHandle& database_handle, uint64_t time, uint32_t interval) {
        return FreezeResult::not_supported;
    }
    
    virtual FreezeResult freeze_counters_range(uint16_t start, uint16_t stop, FreezeType freeze_type, DatabaseHandle& database_handle) {
        return FreezeResult::not_supported;
    }
    
    virtual FreezeResult freeze_counters_range_at_time(uint16_t start, uint16_t stop, DatabaseHandle& database_handle, uint64_t time, uint32_t interval) {
        return FreezeResult::not_supported;
    }
    
    virtual bool support_write_analog_dead_bands() {
        return false;
    }
    
    virtual void begin_write_analog_dead_bands() {};
    
    virtual void write_analog_dead_band(uint16_t index, double dead_band) {};
    
    virtual void end_write_analog_dead_bands() {};
    
    virtual bool write_string_attr(uint8_t set, uint8_t variation, StringAttr attr_type, const char* value) {
        return false;
    }
    
    virtual bool write_float_attr(uint8_t set, uint8_t variation, FloatAttr attr_type, float value) {
        return false;
    }
    
    virtual bool write_double_attr(uint8_t set, uint8_t variation, FloatAttr attr_type, double value) {
        return false;
    }
    
    virtual bool write_uint_attr(uint8_t set, uint8_t variation, UintAttr attr_type, uint32_t value) {
        return false;
    }
    
    virtual bool write_int_attr(uint8_t set, uint8_t variation, IntAttr attr_type, int32_t value) {
        return false;
    }
    
    virtual bool write_octet_string_attr(uint8_t set, uint8_t variation, OctetStringAttr attr_type, ByteIterator& value) {
        return false;
    }
    
    virtual bool write_bit_string_attr(uint8_t set, uint8_t variation, BitStringAttr attr_type, ByteIterator& value) {
        return false;
    }
    
    virtual bool write_time_attr(uint8_t set, uint8_t variation, TimeAttr attr_type, uint64_t value) {
        return false;
    }
    
    virtual void begin_confirm() {};
    
    virtual void event_cleared(uint64_t id) {};
    
    virtual void end_confirm(const BufferState& state) {};
    
};
 
struct RequestHeader;
 
struct RequestHeader {
    friend class CppRequestHeaderFriend;
    
private:
    RequestHeader(const ControlField& control_field, FunctionCode function);
    
public:
    RequestHeader() = delete;
    
    ControlField control_field;
    FunctionCode function;
};
 
enum class BroadcastAction {
    processed = 0,
    ignored_by_configuration = 1,
    bad_object_headers = 2,
    unsupported_function = 3,
};
 
const char* to_string(BroadcastAction value);
 
class OutstationInformation {
public:
    virtual ~OutstationInformation() = default;
    
    virtual void process_request_from_idle(const RequestHeader& header) = 0;
    
    virtual void broadcast_received(FunctionCode function_code, BroadcastAction action) = 0;
    
    virtual void enter_solicited_confirm_wait(uint8_t ecsn) = 0;
    
    virtual void solicited_confirm_timeout(uint8_t ecsn) = 0;
    
    virtual void solicited_confirm_received(uint8_t ecsn) = 0;
    
    virtual void solicited_confirm_wait_new_request() = 0;
    
    virtual void wrong_solicited_confirm_seq(uint8_t ecsn, uint8_t seq) = 0;
    
    virtual void unexpected_confirm(bool unsolicited, uint8_t seq) = 0;
    
    virtual void enter_unsolicited_confirm_wait(uint8_t ecsn) = 0;
    
    virtual void unsolicited_confirm_timeout(uint8_t ecsn, bool retry) = 0;
    
    virtual void unsolicited_confirmed(uint8_t ecsn) = 0;
    
    virtual void clear_restart_iin() = 0;
    
};
 
enum class OperateType {
    select_before_operate = 0,
    direct_operate = 1,
    direct_operate_no_ack = 2,
};
 
const char* to_string(OperateType value);
 
class ControlHandler {
public:
    virtual ~ControlHandler() = default;
    
    virtual void begin_fragment() = 0;
    
    virtual void end_fragment(DatabaseHandle& database) = 0;
    
    virtual CommandStatus select_g12v1(const Group12Var1& value, uint16_t index, DatabaseHandle& database_handle) = 0;
    
    virtual CommandStatus operate_g12v1(const Group12Var1& value, uint16_t index, OperateType op_type, DatabaseHandle& database_handle) = 0;
    
    virtual CommandStatus select_g41v1(int32_t value, uint16_t index, DatabaseHandle& database_handle) = 0;
    
    virtual CommandStatus operate_g41v1(int32_t value, uint16_t index, OperateType op_type, DatabaseHandle& database_handle) = 0;
    
    virtual CommandStatus select_g41v2(int16_t value, uint16_t index, DatabaseHandle& database_handle) = 0;
    
    virtual CommandStatus operate_g41v2(int16_t value, uint16_t index, OperateType op_type, DatabaseHandle& database_handle) = 0;
    
    virtual CommandStatus select_g41v3(float value, uint16_t index, DatabaseHandle& database_handle) = 0;
    
    virtual CommandStatus operate_g41v3(float value, uint16_t index, OperateType op_type, DatabaseHandle& database_handle) = 0;
    
    virtual CommandStatus select_g41v4(double value, uint16_t index, DatabaseHandle& database_handle) = 0;
    
    virtual CommandStatus operate_g41v4(double value, uint16_t index, OperateType op_type, DatabaseHandle& database_handle) = 0;
    
};
 
enum class ConnectionState {
    connected = 0,
    disconnected = 1,
};
 
const char* to_string(ConnectionState value);
 
class ConnectionStateListener {
public:
    virtual ~ConnectionStateListener() = default;
    
    virtual void on_change(ConnectionState state) = 0;
    
};
 
namespace functional {
 
template <class T>
class ConnectionStateListenerLambda final : public ConnectionStateListener
{
    static_assert(std::is_copy_constructible<T>::value, "Lambda expression must be copy constructible. Does it contain something that is move-only?");
    
    T lambda;
 
public:
    ConnectionStateListenerLambda(const T& lambda) : lambda(lambda) {}
    
    void on_change(ConnectionState state) override
    {
        lambda(state);
    }
};
 
template <class T>
std::unique_ptr<ConnectionStateListener> connection_state_listener(const T& lambda)
{
    return std::make_unique<ConnectionStateListenerLambda<T>>(lambda); ; 
}
 
} // end namespace functional
 
class Outstation;
 
struct OutstationUdpConfig;
 
struct OutstationUdpConfig {
    friend class CppOutstationUdpConfigFriend;
    
private:
    OutstationUdpConfig(const std::string& local_endpoint, const std::string& remote_endpoint, UdpSocketMode socket_mode, LinkReadMode link_read_mode, std::chrono::steady_clock::duration retry_delay);
    
public:
    OutstationUdpConfig() = delete;
    
    OutstationUdpConfig(const std::string& local_endpoint, const std::string& remote_endpoint);
    
    
    std::string local_endpoint;
    std::string remote_endpoint;
    UdpSocketMode socket_mode;
    LinkReadMode link_read_mode;
    std::chrono::steady_clock::duration retry_delay;
};
 
class Outstation {
    friend class CppOutstationFriend;
    // pointer to the underlying C type
    void* self;
    // constructor only accessible internally
    Outstation(void* self): self(self) {}
    // non-copyable
    Outstation(const Outstation&) = delete;
    Outstation& operator=(const Outstation&) = delete;
    // no move assignment
    Outstation& operator=(Outstation&& other) = delete;
 
public:
    Outstation(Outstation&& other) noexcept : self(other.self) { other.self = nullptr; }
    
    ~Outstation();
    
    void enable();
    
    void disable();
    
    void transaction(DatabaseTransaction& callback);
    
    void set_decode_level(const DecodeLevel& level);
    
    static Outstation create_serial_session(Runtime& runtime, const std::string& serial_path, const SerialSettings& settings, const OutstationConfig& config, std::unique_ptr<OutstationApplication> application, std::unique_ptr<OutstationInformation> information, std::unique_ptr<ControlHandler> control_handler);
    
    static Outstation create_serial_session_fault_tolerant(Runtime& runtime, const std::string& serial_path, const SerialSettings& settings, std::chrono::steady_clock::duration open_retry_delay, const OutstationConfig& config, std::unique_ptr<OutstationApplication> application, std::unique_ptr<OutstationInformation> information, std::unique_ptr<ControlHandler> control_handler);
    
    static Outstation create_serial_session_2(Runtime& runtime, const std::string& serial_path, const SerialSettings& settings, std::chrono::steady_clock::duration open_retry_delay, const OutstationConfig& config, std::unique_ptr<OutstationApplication> application, std::unique_ptr<OutstationInformation> information, std::unique_ptr<ControlHandler> control_handler, std::unique_ptr<PortStateListener> port_listener);
    
    static Outstation create_tcp_client(Runtime& runtime, LinkErrorMode link_error_mode, EndpointList& endpoints, const ConnectStrategy& connect_strategy, ConnectOptions& connect_options, const OutstationConfig& config, std::unique_ptr<OutstationApplication> application, std::unique_ptr<OutstationInformation> information, std::unique_ptr<ControlHandler> control_handler, std::unique_ptr<ClientStateListener> listener);
    
    static Outstation create_tls_client(Runtime& runtime, LinkErrorMode link_error_mode, EndpointList& endpoints, const ConnectStrategy& connect_strategy, ConnectOptions& connect_options, const OutstationConfig& config, std::unique_ptr<OutstationApplication> application, std::unique_ptr<OutstationInformation> information, std::unique_ptr<ControlHandler> control_handler, std::unique_ptr<ClientStateListener> listener, const TlsClientConfig& tls_config);
    
    static Outstation create_udp(Runtime& runtime, const OutstationUdpConfig& udp_config, const OutstationConfig& config, std::unique_ptr<OutstationApplication> application, std::unique_ptr<OutstationInformation> information, std::unique_ptr<ControlHandler> control_handler);
};
 
class AddressFilter;
 
class AddressFilter {
    friend class CppAddressFilterFriend;
    // pointer to the underlying C type
    void* self;
    // constructor only accessible internally
    AddressFilter(void* self): self(self) {}
    // non-copyable
    AddressFilter(const AddressFilter&) = delete;
    AddressFilter& operator=(const AddressFilter&) = delete;
    // no move assignment
    AddressFilter& operator=(AddressFilter&& other) = delete;
 
public:
    AddressFilter(AddressFilter&& other) noexcept : self(other.self) { other.self = nullptr; }
    
    AddressFilter(const std::string& address);
    
    ~AddressFilter();
    
    void add(const std::string& address);
    
    static AddressFilter any();
};
 
struct TlsServerConfig;
 
struct TlsServerConfig {
    friend class CppTlsServerConfigFriend;
    
private:
    TlsServerConfig(const std::string& dns_name, const std::string& peer_cert_path, const std::string& local_cert_path, const std::string& private_key_path, const std::string& password, MinTlsVersion min_tls_version, CertificateMode certificate_mode, bool allow_client_name_wildcard);
    
public:
    TlsServerConfig() = delete;
    
    TlsServerConfig(const std::string& dns_name, const std::string& peer_cert_path, const std::string& local_cert_path, const std::string& private_key_path, const std::string& password);
    
    
    std::string dns_name;
    std::string peer_cert_path;
    std::string local_cert_path;
    std::string private_key_path;
    std::string password;
    MinTlsVersion min_tls_version;
    CertificateMode certificate_mode;
    bool allow_client_name_wildcard;
};
 
class OutstationServer;
 
class OutstationServer {
    friend class CppOutstationServerFriend;
    // pointer to the underlying C type
    void* self;
    // constructor only accessible internally
    OutstationServer(void* self): self(self) {}
    // non-copyable
    OutstationServer(const OutstationServer&) = delete;
    OutstationServer& operator=(const OutstationServer&) = delete;
    // no move assignment
    OutstationServer& operator=(OutstationServer&& other) = delete;
 
public:
    OutstationServer(OutstationServer&& other) noexcept : self(other.self) { other.self = nullptr; }
    
    ~OutstationServer();
    
    Outstation add_outstation(const OutstationConfig& config, std::unique_ptr<OutstationApplication> application, std::unique_ptr<OutstationInformation> information, std::unique_ptr<ControlHandler> control_handler, std::unique_ptr<ConnectionStateListener> listener, AddressFilter& filter);
    
    void bind();
    
    static OutstationServer create_tcp_server(Runtime& runtime, LinkErrorMode link_error_mode, const std::string& address);
    
    static OutstationServer create_tls_server(Runtime& runtime, LinkErrorMode link_error_mode, const std::string& address, const TlsServerConfig& tls_config);
};
 
} // end namespace dnp3