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 = 1;
constexpr uint64_t dnp3_version_patch = 0;
constexpr char const* dnp3_version_string = "1.1.0";
 
 
enum class ParamError {
    ok = 0,
    invalid_timeout = 1,
    null_parameter = 2,
    no_support = 3,
    association_does_not_exist = 4,
    association_duplicate_address = 5,
    invalid_socket_address = 6,
    invalid_dnp3_address = 7,
    invalid_buffer_size = 8,
    address_filter_conflict = 9,
    server_already_started = 10,
    server_bind_error = 11,
    master_already_shutdown = 12,
    runtime_creation_failure = 13,
    runtime_destroyed = 14,
    runtime_cannot_block_within_async = 15,
    logging_already_configured = 16,
    point_does_not_exist = 17,
    invalid_peer_certificate = 18,
    invalid_local_certificate = 19,
    invalid_private_key = 20,
    invalid_dns_name = 21,
    other_tls_error = 22,
};
 
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) {}
};
 
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 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 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();
};
 
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 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();
};
 
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();
};
 
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 Variation {
    group1_var0 = 0,
    group1_var1 = 1,
    group1_var2 = 2,
    group2_var0 = 3,
    group2_var1 = 4,
    group2_var2 = 5,
    group2_var3 = 6,
    group3_var0 = 7,
    group3_var1 = 8,
    group3_var2 = 9,
    group4_var0 = 10,
    group4_var1 = 11,
    group4_var2 = 12,
    group4_var3 = 13,
    group10_var0 = 14,
    group10_var1 = 15,
    group10_var2 = 16,
    group11_var0 = 17,
    group11_var1 = 18,
    group11_var2 = 19,
    group12_var0 = 20,
    group12_var1 = 21,
    group20_var0 = 22,
    group20_var1 = 23,
    group20_var2 = 24,
    group20_var5 = 25,
    group20_var6 = 26,
    group21_var0 = 27,
    group21_var1 = 28,
    group21_var2 = 29,
    group21_var5 = 30,
    group21_var6 = 31,
    group21_var9 = 32,
    group21_var10 = 33,
    group22_var0 = 34,
    group22_var1 = 35,
    group22_var2 = 36,
    group22_var5 = 37,
    group22_var6 = 38,
    group23_var0 = 39,
    group23_var1 = 40,
    group23_var2 = 41,
    group23_var5 = 42,
    group23_var6 = 43,
    group30_var0 = 44,
    group30_var1 = 45,
    group30_var2 = 46,
    group30_var3 = 47,
    group30_var4 = 48,
    group30_var5 = 49,
    group30_var6 = 50,
    group32_var0 = 51,
    group32_var1 = 52,
    group32_var2 = 53,
    group32_var3 = 54,
    group32_var4 = 55,
    group32_var5 = 56,
    group32_var6 = 57,
    group32_var7 = 58,
    group32_var8 = 59,
    group40_var0 = 60,
    group40_var1 = 61,
    group40_var2 = 62,
    group40_var3 = 63,
    group40_var4 = 64,
    group41_var0 = 65,
    group41_var1 = 66,
    group41_var2 = 67,
    group41_var3 = 68,
    group41_var4 = 69,
    group42_var0 = 70,
    group42_var1 = 71,
    group42_var2 = 72,
    group42_var3 = 73,
    group42_var4 = 74,
    group42_var5 = 75,
    group42_var6 = 76,
    group42_var7 = 77,
    group42_var8 = 78,
    group50_var1 = 79,
    group50_var3 = 80,
    group50_var4 = 81,
    group51_var1 = 82,
    group51_var2 = 83,
    group52_var1 = 84,
    group52_var2 = 85,
    group60_var1 = 86,
    group60_var2 = 87,
    group60_var3 = 88,
    group60_var4 = 89,
    group80_var1 = 90,
    group110 = 91,
    group111 = 92,
};
 
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 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);
 
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 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) = 0;
    virtual void end_fragment(ReadType read_type, const ResponseHeader& header) = 0;
    virtual void handle_binary_input(const HeaderInfo& info, BinaryInputIterator& it) = 0;
    virtual void handle_double_bit_binary_input(const HeaderInfo& info, DoubleBitBinaryInputIterator& it) = 0;
    virtual void handle_binary_output_status(const HeaderInfo& info, BinaryOutputStatusIterator& it) = 0;
    virtual void handle_counter(const HeaderInfo& info, CounterIterator& it) = 0;
    virtual void handle_frozen_counter(const HeaderInfo& info, FrozenCounterIterator& it) = 0;
    virtual void handle_analog_input(const HeaderInfo& info, AnalogInputIterator& it) = 0;
    virtual void handle_analog_output_status(const HeaderInfo& info, AnalogOutputStatusIterator& it) = 0;
    virtual void handle_octet_string(const HeaderInfo& info, OctetStringIterator& it) = 0;
};
 
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 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;
};
 
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
 
class MasterChannel;
 
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);
    
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;
};
 
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 Nothing {
    nothing = 0,
};
 
const char* to_string(Nothing value);
 
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,
};
 
const char* to_string(TaskType value);
 
enum class TaskError {
    too_many_requests = 0,
    bad_response = 1,
    response_timeout = 2,
    write_error = 3,
    no_connection = 4,
    shutdown = 5,
    association_removed = 6,
};
 
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);
    
    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,
    bad_response = 2,
    response_timeout = 3,
    write_error = 4,
    no_connection = 5,
    shutdown = 6,
    association_removed = 7,
};
 
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,
    bad_response = 4,
    response_timeout = 5,
    write_error = 6,
    no_connection = 7,
    shutdown = 8,
    association_removed = 9,
};
 
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,
    iin_error = 7,
    too_many_requests = 8,
    bad_response = 9,
    response_timeout = 10,
    write_error = 11,
    no_connection = 12,
    shutdown = 13,
    association_removed = 14,
};
 
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,
    bad_response = 2,
    response_timeout = 3,
    write_error = 4,
    no_connection = 5,
    shutdown = 6,
    association_removed = 7,
};
 
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;
};
 
enum class LinkStatusError {
    ok = 0,
    unexpected_response = 1,
    too_many_requests = 2,
    bad_response = 3,
    response_timeout = 4,
    write_error = 5,
    no_connection = 6,
    shutdown = 7,
    association_removed = 8,
};
 
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);
    
    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);
    
    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_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_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);
    
    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 check_link_status(const AssociationId& association, std::unique_ptr<LinkStatusCallback> callback);
    
};
 
class Database;
 
enum class EventClass {
    none = 0,
    class1 = 1,
    class2 = 2,
    class3 = 3,
};
 
const char* to_string(EventClass value);
 
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 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;
    
private:
    BinaryInputConfig(StaticBinaryInputVariation static_variation, EventBinaryInputVariation event_variation);
    
public:
    
    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;
    
private:
    DoubleBitBinaryInputConfig(StaticDoubleBitBinaryInputVariation static_variation, EventDoubleBitBinaryInputVariation event_variation);
    
public:
    
    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;
    
private:
    BinaryOutputStatusConfig(StaticBinaryOutputStatusVariation static_variation, EventBinaryOutputStatusVariation event_variation);
    
public:
    
    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;
    
private:
    CounterConfig(StaticCounterVariation static_variation, EventCounterVariation event_variation, uint32_t deadband);
    
public:
    
    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;
    
private:
    FrozenCounterConfig(StaticFrozenCounterVariation static_variation, EventFrozenCounterVariation event_variation, uint32_t deadband);
    
public:
    
    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;
    
private:
    AnalogInputConfig(StaticAnalogInputVariation static_variation, EventAnalogInputVariation event_variation, double deadband);
    
public:
    
    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;
    
private:
    AnalogOutputStatusConfig(StaticAnalogOutputStatusVariation static_variation, EventAnalogOutputStatusVariation event_variation, double deadband);
    
public:
    
    AnalogOutputStatusConfig();
    
    
    StaticAnalogOutputStatusVariation static_variation;
    EventAnalogOutputStatusVariation event_variation;
    double deadband;
};
 
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; }
    
    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);
    
    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);
    
    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);
    
    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);
    
    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);
    
    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);
    
    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);
    
    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);
};
 
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);
    
public:
    
    OutstationFeatures();
    
    
    bool self_address;
    bool broadcast;
    bool unsolicited;
};
 
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;
};
 
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) = 0;
    virtual FreezeResult freeze_counters_range(uint16_t start, uint16_t stop, FreezeType freeze_type, DatabaseHandle& database_handle) = 0;
};
 
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 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);
 
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;
 
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 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);
};
 
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);
    
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;
};
 
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