FastBinaryEncoding/proto/protoex_final_protocol.h at master · chronoxor/FastBinaryEncoding · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
//------------------------------------------------------------------------------
// Automatically generated by the Fast Binary Encoding compiler, do not modify!
// https://github.com/chronoxor/FastBinaryEncoding
// Source: protoex.fbe
// FBE version: 1.15.0.0
//------------------------------------------------------------------------------

#pragma once

#if defined(__clang__)
#pragma clang system_header
#elif defined(__GNUC__)
#pragma GCC system_header
#elif defined(_MSC_VER)
#pragma system_header
#endif

#include "fbe_protocol.h"

#include "protoex_final_models.h"

#include "proto_final_protocol.h"

namespace FBE {

namespace protoex {

// Fast Binary Encoding protoex protocol version
struct ProtocolVersion
{
    // Protocol major version
    static const int major = 1;
    // Protocol minor version
    static const int minor = 0;
};

// Fast Binary Encoding protoex final sender
class FinalSender : public virtual FBE::Sender
    , public virtual proto::FinalSender
{
public:
    FinalSender()
        : OrderMessageModel(this->_buffer)
        , BalanceMessageModel(this->_buffer)
        , AccountMessageModel(this->_buffer)
    { this->final(true); }
    FinalSender(const FinalSender&) = delete;
    FinalSender(FinalSender&&) noexcept = delete;
    virtual ~FinalSender() = default;

    FinalSender& operator=(const FinalSender&) = delete;
    FinalSender& operator=(FinalSender&&) noexcept = delete;

    // Imported senders
    proto::FinalSender& proto_sender() noexcept { return *this; }

    size_t send(const ::protoex::OrderMessage& value);
    size_t send(const ::protoex::BalanceMessage& value);
    size_t send(const ::protoex::AccountMessage& value);

public:
    // Sender models accessors
    FBE::protoex::OrderMessageFinalModel OrderMessageModel;
    FBE::protoex::BalanceMessageFinalModel BalanceMessageModel;
    FBE::protoex::AccountMessageFinalModel AccountMessageModel;
};

// Fast Binary Encoding protoex final receiver
class FinalReceiver : public virtual FBE::Receiver
    , public virtual proto::FinalReceiver
{
public:
    FinalReceiver() { this->final(true); }
    FinalReceiver(const FinalReceiver&) = delete;
    FinalReceiver(FinalReceiver&&) = delete;
    virtual ~FinalReceiver() = default;

    FinalReceiver& operator=(const FinalReceiver&) = delete;
    FinalReceiver& operator=(FinalReceiver&&) = delete;

protected:
    // Receive handlers
    virtual void onReceive(const ::protoex::OrderMessage& value) {}
    virtual void onReceive(const ::protoex::BalanceMessage& value) {}
    virtual void onReceive(const ::protoex::AccountMessage& value) {}

    // Receive message handler
    bool onReceive(size_t type, const void* data, size_t size) override;

private:
    // Receiver values accessors
    ::protoex::OrderMessage OrderMessageValue;
    ::protoex::BalanceMessage BalanceMessageValue;
    ::protoex::AccountMessage AccountMessageValue;

    // Receiver models accessors
    FBE::protoex::OrderMessageFinalModel OrderMessageModel;
    FBE::protoex::BalanceMessageFinalModel BalanceMessageModel;
    FBE::protoex::AccountMessageFinalModel AccountMessageModel;
};

// Fast Binary Encoding protoex final client
class FinalClient : public virtual FinalSender, protected virtual FinalReceiver
    , public virtual proto::FinalClient
{
public:
    typedef proto::FinalClient protoFinalClient;

    FinalClient() = default;
    FinalClient(const FinalClient&) = delete;
    FinalClient(FinalClient&&) = delete;
    virtual ~FinalClient() = default;

    FinalClient& operator=(const FinalClient&) = delete;
    FinalClient& operator=(FinalClient&&) = delete;

    // Imported clients
    proto::FinalClient& proto_client() noexcept { return *this; }

    // Reset client buffers
    void reset() { std::scoped_lock locker(this->_lock); reset_requests(); }

    // Watchdog for timeouts
    void watchdog(uint64_t utc) { std::scoped_lock locker(this->_lock); watchdog_requests(utc); }


protected:
    virtual bool onReceiveResponse(const ::protoex::OrderMessage& response) { return false; }
    virtual bool onReceiveResponse(const ::protoex::BalanceMessage& response) { return false; }
    virtual bool onReceiveResponse(const ::protoex::AccountMessage& response) { return false; }

    virtual bool onReceiveReject(const ::protoex::OrderMessage& reject) { return false; }
    virtual bool onReceiveReject(const ::protoex::BalanceMessage& reject) { return false; }
    virtual bool onReceiveReject(const ::protoex::AccountMessage& reject) { return false; }

    virtual void onReceiveNotify(const ::protoex::OrderMessage& notify) {}
    virtual void onReceiveNotify(const ::protoex::BalanceMessage& notify) {}
    virtual void onReceiveNotify(const ::protoex::AccountMessage& notify) {}

    virtual void onReceive(const ::protoex::OrderMessage& value) override { if (!onReceiveResponse(value) && !onReceiveReject(value)) onReceiveNotify(value); }
    virtual void onReceive(const ::protoex::BalanceMessage& value) override { if (!onReceiveResponse(value) && !onReceiveReject(value)) onReceiveNotify(value); }
    virtual void onReceive(const ::protoex::AccountMessage& value) override { if (!onReceiveResponse(value) && !onReceiveReject(value)) onReceiveNotify(value); }

    // Reset client requests
    virtual void reset_requests();

    // Watchdog client requests for timeouts
    virtual void watchdog_requests(uint64_t utc);
};

} // namespace protoex

} // namespace FBE