crypto-crawler-cpp/crypto_crawler.cpp at main · crypto-crawler/crypto-crawler-cpp · 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
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
#include "crypto_crawler.h"

#include <array>
#include <cstring>
#include <iostream>

static inline bool is_null_terminated_view(std::string_view sv) noexcept {
  return !sv.empty() && sv.data()[sv.length()] == '\0';
}

static std::vector<const char *> convert_symbols(
    const std::vector<std::string> &symbols) {
  std::vector<const char *> result;
  std::transform(
      symbols.begin(), symbols.end(), std::back_inserter(result),
      [](const std::string &symbol) -> const char * { return symbol.c_str(); });
  return result;
}

void crawl_template(std::string_view exchange, MarketType market_type,
                    const std::vector<std::string> &symbols,
                    void (*on_msg)(const Message *), uint64_t duration,
                    void (*crawl_ffi_func)(const char *, MarketType,
                                           const char *const *, unsigned int,
                                           void (*)(const Message *),
                                           uint64_t)) {
  const char *exchange_c_str = nullptr;
  std::string exchange_string;
  if (is_null_terminated_view(exchange)) {
    exchange_c_str = exchange.data();
  } else {
    exchange_string = std::move(std::string(exchange));
    exchange_c_str = exchange_string.c_str();
  }
  std::vector<const char *> symbols_c_str = convert_symbols(symbols);
  crawl_ffi_func(exchange_c_str, market_type, symbols_c_str.data(),
                 symbols_c_str.size(), on_msg, duration);
}

void crawl_trade(std::string_view exchange, MarketType market_type,
                 const std::vector<std::string> &symbols,
                 void (*on_msg)(const Message *), uint64_t duration) {
  crawl_template(exchange, market_type, symbols, on_msg, duration, crawl_trade);
}

void crawl_l2_event(std::string_view exchange, MarketType market_type,
                    const std::vector<std::string> &symbols,
                    void (*on_msg)(const Message *), uint64_t duration) {
  crawl_template(exchange, market_type, symbols, on_msg, duration,
                 crawl_l2_event);
}

void crawl_l3_event(std::string_view exchange, MarketType market_type,
                    const std::vector<std::string> &symbols,
                    void (*on_msg)(const Message *), uint64_t duration) {
  crawl_template(exchange, market_type, symbols, on_msg, duration,
                 crawl_l3_event);
}

void crawl_l2_snapshot(std::string_view exchange, MarketType market_type,
                       const std::vector<std::string> &symbols,
                       void (*on_msg)(const Message *), uint64_t duration) {
  crawl_template(exchange, market_type, symbols, on_msg, duration,
                 crawl_l2_snapshot);
}

void crawl_bbo(std::string_view exchange, MarketType market_type,
               const std::vector<std::string> &symbols,
               void (*on_msg)(const Message *), uint64_t duration) {
  crawl_template(exchange, market_type, symbols, on_msg, duration, crawl_bbo);
}

void crawl_l2_topk(std::string_view exchange, MarketType market_type,
                   const std::vector<std::string> &symbols,
                   void (*on_msg)(const Message *), uint64_t duration) {
  crawl_template(exchange, market_type, symbols, on_msg, duration,
                 crawl_l2_topk);
}

void crawl_l3_snapshot(std::string_view exchange, MarketType market_type,
                       const std::vector<std::string> &symbols,
                       void (*on_msg)(const Message *), uint64_t duration) {
  crawl_template(exchange, market_type, symbols, on_msg, duration,
                 crawl_l3_snapshot);
}

void crawl_ticker(std::string_view exchange, MarketType market_type,
                  const std::vector<std::string> &symbols,
                  void (*on_msg)(const Message *), uint64_t duration) {
  crawl_template(exchange, market_type, symbols, on_msg, duration,
                 crawl_ticker);
}

void crawl_funding_rate(std::string_view exchange, MarketType market_type,
                        const std::vector<std::string> &symbols,
                        void (*on_msg)(const Message *), uint64_t duration) {
  crawl_template(exchange, market_type, symbols, on_msg, duration,
                 crawl_funding_rate);
}

void crawl_candlestick(
    std::string_view exchange, MarketType market_type,
    const std::vector<std::pair<std::string, int>> &symbol_interval_list,
    void (*on_msg)(const Message *), uint64_t duration) {
  const char *exchange_c_str = nullptr;
  std::string exchange_string;
  if (is_null_terminated_view(exchange)) {
    exchange_c_str = exchange.data();
  } else {
    exchange_string = std::move(std::string(exchange));
    exchange_c_str = exchange_string.c_str();
  }

  std::vector<const char *> symbols_c_str;
  std::vector<unsigned int> intervals;
  std::transform(
      symbol_interval_list.begin(), symbol_interval_list.end(),
      std::back_inserter(symbols_c_str),
      [](const std::pair<std::string, int> &symbol_interval) -> const char * {
        return symbol_interval.first.c_str();
      });
  std::transform(
      symbol_interval_list.begin(), symbol_interval_list.end(),
      std::back_inserter(intervals),
      [](const std::pair<std::string, int> &symbol_interval) -> unsigned int {
        return static_cast<unsigned int>(symbol_interval.second);
      });
  crawl_candlestick(exchange_c_str, market_type, symbols_c_str.data(),
                    intervals.data(), symbols_c_str.size(), on_msg, duration);
}

void crawl_open_interest(std::string_view exchange, MarketType market_type,
                         void (*on_msg)(const Message *), uint64_t duration) {
  const char *exchange_c_str = nullptr;
  std::string exchange_string;
  if (is_null_terminated_view(exchange)) {
    exchange_c_str = exchange.data();
  } else {
    exchange_string = std::move(std::string(exchange));
    exchange_c_str = exchange_string.c_str();
  }

  crawl_open_interest(exchange_c_str, market_type, on_msg, duration);
}

void subscribe_symbol(std::string_view exchange, MarketType market_type,
                      std::string_view symbol,
                      const std::vector<MessageType> &msg_types,
                      void (*on_msg)(const char *), uint64_t duration) {
  const char *exchange_c_str = nullptr;
  std::string exchange_string;
  if (is_null_terminated_view(exchange)) {
    exchange_c_str = exchange.data();
  } else {
    exchange_string = std::move(std::string(exchange));
    exchange_c_str = exchange_string.c_str();
  }

  const char *symbol_c_str = nullptr;
  std::string symbol_string;
  if (is_null_terminated_view(exchange)) {
    symbol_c_str = exchange.data();
  } else {
    symbol_string = std::move(std::string(exchange));
    symbol_c_str = symbol_string.c_str();
  }

  subscribe_symbol(exchange_c_str, market_type, symbol_c_str, msg_types.data(),
                   msg_types.size(), on_msg, duration);
}