feat: Add cme_websocket connector code

This commit is contained in:
John Colvin committed 2023-10-29 15:15:09 -04:00
1 parent d91642ecd0
commit 6cf4200bad
43 files changed
+3964 -7

No files matched your search

+7 -2
View File
@@ -42,8 +42,8 @@ if(WIN32)
add_subdirectory(src/lib)
else()
# make sparkd look for libspark.so in its directory
set(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
set(CMAKE_INSTALL_RPATH ".")
# set(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
# set(CMAKE_INSTALL_RPATH ".")
set(CMAKE_INSTALL_PREFIX "${CMAKE_SOURCE_DIR}/install")
set(SPARK_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}/$<CONFIG>")
@@ -112,6 +112,11 @@ else()
# subdirs
if (BUILD_SPARKD)
add_subdirectory(src/lib_bts-system)
add_subdirectory(src/lib_bts-json)
add_subdirectory(src/lib_bts-http)
add_subdirectory(src/lib_bts-http-client)
add_subdirectory(src/app_bts-websocket-listener)
add_subdirectory(src/server/sparkd)
add_subdirectory(src/data_files)
endif()
-5
View File
@@ -45,12 +45,7 @@
"binaryDir": "${sourceDir}/build/${presetName}",
"cacheVariables": {
"platform": "",
"CMAKE_BUILD_WITH_INSTALL_RPATH": {
"type": "BOOL",
"value": "ON"
},
"CMAKE_CXX_STANDARD": "20",
"CMAKE_INSTALL_RPATH": ".",
"CMAKE_INSTALL_PREFIX": "${sourceDir}/install/${presetName}/sparkd",
"CMAKE_EXE_LINKER_FLAGS": "-Wno-undef",
"EXTERNALS_ROOT": "${sourceDir}/externals/linux",
+44
View File
@@ -0,0 +1,44 @@
#pragma once
#include <nlohmann/detail/macro_scope.hpp>
#include <nlohmann/json.hpp>
#include <string>
#include "lib/io/URL.h"
namespace bts::md::cme_websocket {
class CmeOauthConfig {
public:
std::string protocol{"https"};
std::string host;
std::uint16_t port{443};
std::string endpoint;
std::string client_id;
std::string client_secret;
io::URL get_url() const;
void get_url(io::URL &dest) const;
};
//////////////////////////////////////////////////
// Definition
//////////////////////////////////////////////////
NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(
CmeOauthConfig, protocol, host, port, endpoint, client_id, client_secret);
inline io::URL CmeOauthConfig::get_url() const {
io::URL url;
get_url(url);
return url;
}
inline void CmeOauthConfig::get_url(io::URL &dest) const {
dest.fill_host(host);
dest.fill_path(endpoint);
dest.fill_port(port);
dest.fill_protocol("https");
}
} // namespace bts::websocket
@@ -0,0 +1,26 @@
#pragma once
#include <nlohmann/detail/macro_scope.hpp>
#include <nlohmann/json.hpp>
#include <string>
// {
// "access_token":
// "eyJhbGciOiJSUzI1NiIsImtpZCI6IjF0al9MTVFrT2pGVzJWQTZvdkZzOEZHUWViMCIsInBpLmF0bSI6IjEifQ.eyJzY29wZSI6W10sImNsaWVudF9pZCI6ImFwaV90aGlua2FscGhhMzIxIiwiYXVkIjoiTnIiLCJqdGkiOiJ5bzlWZUdOMWxudzBXNHhCIiwic3ViIjoiYXBpX3RoaW5rYWxwaGEzMjEiLCJleHAiOjE2OTc1Nzg2NjJ9.HO-UzBvYcdHH6EP0WbmKNbwpZWUF3UbScUQ6bEF4iZqzPyZ1eFLS20VSDULbUpTc_Kl0g9IltJL4ZhnhRqoAX_cWGpqDCDI4wk-04NrcU0-I7YZuNXpDaTwJLChTASQX0PXmmGYDascdem-8FAEp3EgRMrQPXug4FOfp1aKXlgmB5U0Q5lKbZsy_52n56N928iuieYH63JhWRFG0wvleXeyeDDKJNmizKLpGWuBPRwyUYhZWFNQCxbla2TwDTXBWLlO_eZyPq16SS_NKVssTarmY8ohAwuD7N_D7mQbWcbeggks1B9r2w66DuKotRzIrSuhK4VlbHj94FLyqE2oVYw",
// "token_type": "Bearer",
// "expires_in": 1799
// }
namespace bts::md::cme_websocket {
class CmeOauthResponse {
public:
std::string access_token;
std::string token_type;
std::int64_t expires_in;
};
NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(
CmeOauthResponse, access_token, token_type, expires_in);
} // namespace bts::md::cme_websocket
@@ -0,0 +1,35 @@
#include "CmeOauthConfig.h"
#include "CmeOauthResponse.h"
#include "lib/io/JsonDumper.h"
#include "lib/io/http/HTTPRequest.h"
#include "lib/io/http/HTTPClient.h"
namespace bts::md::cme_websocket {
class CmeWebsocketOauthRequestor {
public:
using HTTPRequest = io::http::HTTPRequest;
using HTTPClient = io::http::HTTPClient;
static HTTPRequest build_oauth_request(const CmeOauthConfig &cfg) {
HTTPRequest http_req;
http_req.url() = cfg.get_url();
io::QueryParams qp;
qp["grant_type"] = "client_credentials";
qp["client_id"] = cfg.client_id;
qp["client_secret"] = cfg.client_secret;
http_req.body() = qp.to_string();
return http_req;
}
static CmeOauthResponse request_oauth_token(const CmeOauthConfig &cfg) {
HTTPRequest req = build_oauth_request(cfg);
LOG(Gen, Info, "Requesting oauth:\n{}", io::JsonDumper::dump(req));
HTTPClient client;
HTTPResponse res = client.post(req);
LOG(Gen, Info, "Received oauth response:\n{}", io::JsonDumper::dump(res));
const auto j = nlohmann::json::parse(res.body());
return io::JsonReader{&j}.read<OauthResponse>();
}
};
} // namespace bts::md::cme_websocket
@@ -0,0 +1,60 @@
#include "CmeWebsocketSubscription.h"
#include <iostream>
#include <websocketpp/client.hpp>
#include <websocketpp/common/thread.hpp>
#include <websocketpp/config/asio_client.hpp>
#include <websocketpp/config/asio_no_tls_client.hpp>
#include <websocketpp/roles/client_endpoint.hpp>
namespace bts::md::cme_websocket {
struct CmeWebsocketSubscription::PImpl {
// TODO
void connect() {}
static void on_open(websocketpp::connection_hdl hdl) {
(void)(hdl);
// Connection opened, you can send WebSocket messages here
}
int run() {
websocketpp::client<websocketpp::config::asio_tls_client> client;
// Set up connection settings
std::string server_uri = "wss://example.com/websocket_endpoint";
client.init_asio();
client.set_open_handler(&on_open);
// Define the headers, including the Authorization header
websocketpp::lib::error_code ec;
websocketpp::client<websocketpp::config::asio_tls_client>::connection_ptr
con = client.get_connection(server_uri, ec);
if (!ec) {
con->append_header("Authorization", "Bearer your_token_here");
// Connect to the server
client.connect(con);
// Start the WebSocket++ event loop
client.run();
} else {
std::cerr << "Error creating the connection: " << ec.message()
<< std::endl;
}
return 0;
}
};
CmeWebsocketSubscription::CmeWebsocketSubscription()
: me_(std::make_unique<PImpl>()) {
// TODO
}
CmeWebsocketSubscription::~CmeWebsocketSubscription() = default;
int CmeWebsocketSubscription::run() { return me_->run(); }
} // namespace bts::md::cme_websocket
@@ -0,0 +1,17 @@
#pragma once
#include <memory>
namespace bts::md::cme_websocket {
class CmeWebsocketSubscription {
public:
CmeWebsocketSubscription();
~CmeWebsocketSubscription();
int run();
private:
struct PImpl;
std::unique_ptr<PImpl> me_;
};
}
+26
View File
@@ -0,0 +1,26 @@
cmake_minimum_required(VERSION 3.23)
project(bts-http-client)
include(FetchContent)
include (GNUInstallDirs)
file(
GLOB_RECURSE ${PROJECT_NAME}_Sources
RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
${PROJECT_NAME}/*.cpp)
add_library(${PROJECT_NAME} ${${PROJECT_NAME}_Sources})
target_include_directories(${PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
target_link_libraries(${PROJECT_NAME} PUBLIC bts-http bts-json bts-system)
# curlpp
FetchContent_Declare(
curlpp
GIT_REPOSITORY git@github.com:jpbarrette/curlpp.git
GIT_TAG v0.8.1
# CMAKE_ARGS
SYSTEM
OVERRIDE_FIND_PACKAGE
)
FetchContent_MakeAvailable(curlpp)
target_include_directories(${PROJECT_NAME} PUBLIC ${curlpp_SOURCE_DIR}/include)
target_link_directories(${PROJECT_NAME} PUBLIC ${curlpp_BINARY_DIR})
# target_link_libraries(${PROJECT_NAME} PUBLIC curlpp)
@@ -0,0 +1,81 @@
#pragma once
#include <curlpp/Easy.hpp>
#include <curlpp/Options.hpp>
#include <iostream>
#include <list>
#include <nlohmann/detail/macro_scope.hpp>
#include "bts-http/http_request.h"
#include "bts-http/http_response.h"
#include "bts-system/UNUSED.h"
#include "bts-system/logging.h"
namespace bts::http {
/**
* @brief Sets boilerplate curl opts and callbacks for http requests.
*/
class CurlRequestor {
public:
explicit CurlRequestor(const HTTPRequest &request)
: request_(std::make_unique<curlpp::Easy>()) {
request_->setOpt<curlpp::options::Url>(request.url);
std::list<std::string> req_hdrs;
for (const auto &[k, v] : request.headers) {
req_hdrs.push_back(fmt::format("{}:{}", k, v));
}
request_->setOpt<curlpp::options::HttpHeader>(req_hdrs);
request_->setOpt<curlpp::options::FailOnError>(true);
}
CurlRequestor(const CurlRequestor &) = delete;
CurlRequestor(CurlRequestor &&) noexcept = default;
CurlRequestor &operator=(const CurlRequestor &) = delete;
CurlRequestor &operator=(CurlRequestor &&) noexcept = default;
curlpp::Easy &request();
const curlpp::Easy &request() const;
void perform(HTTPResponse &response);
private:
std::unique_ptr<curlpp::Easy> request_;
std::string errors_;
};
//////////////////////////////////////////////////
// Definition
//////////////////////////////////////////////////
inline curlpp::Easy &CurlRequestor::request() { return *request_; }
inline const curlpp::Easy &CurlRequestor::request() const { return *request_; }
inline void CurlRequestor::perform(HTTPResponse &response) {
request_->setOpt<curlpp::options::HeaderFunction>(
[&response](char *cstr, size_t sz, size_t n) {
std::string str{cstr, sz * n};
const auto colon_idx = str.find(':');
if (colon_idx >= str.size()) {
response.headers()[str] = {};
} else {
response.headers()[str.substr(0, colon_idx)] =
str.substr(colon_idx + 1, str.size() - colon_idx - 1);
}
return sz * n;
});
request_->setOpt<curlpp::options::WriteFunction>(
[&response](char *cstr, size_t sz, size_t n) {
response.body().append(cstr, sz * n);
return sz * n;
});
try {
request_->perform();
} catch (const std::exception &ex) {
LOG(Gen, Error, "CurlRequestor::perform threw an exception: {}",
std::string{ex.what()});
throw;
}
}
} // namespace bts::http
@@ -0,0 +1,28 @@
#include "http_client.h"
#include <curlpp/Options.hpp>
#include "bts-http-client/curl_requestor.h"
#include "bts-http/http_request.h"
#include "bts-http/http_response.h"
namespace bts::http {
HTTPResponse HTTPClient::get(const HTTPRequest &request) {
CurlRequestor requestor{request};
requestor.request().setOpt<curlpp::options::HttpGet>(true);
HTTPResponse response;
requestor.perform(response);
return response;
}
HTTPResponse HTTPClient::post(const HTTPRequest &request) {
CurlRequestor requestor{request};
requestor.request().setOpt<curlpp::options::Post>(true);
requestor.request().setOpt<curlpp::options::PostFields>(request.body);
HTTPResponse response;
requestor.perform(response);
return response;
}
} // namespace bts::http
@@ -0,0 +1,14 @@
#pragma once
namespace bts::http {
class HTTPRequest;
class HTTPResponse;
class HTTPClient {
public:
HTTPResponse get(const HTTPRequest &request);
HTTPResponse post(const HTTPRequest &request);
};
} // namespace bts::http
+10
View File
@@ -0,0 +1,10 @@
cmake_minimum_required(VERSION 3.23)
project(bts-http)
file(
GLOB_RECURSE ${PROJECT_NAME}_Sources
RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
${PROJECT_NAME}/*.cpp)
add_library(${PROJECT_NAME} ${${PROJECT_NAME}_Sources})
target_include_directories(${PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
target_link_libraries(${PROJECT_NAME} PUBLIC bts-json bts-system)
+18
View File
@@ -0,0 +1,18 @@
#include "QueryParams.h"
namespace bts::io {
std::string QueryParams::to_string() const {
std::string rv;
auto it = begin();
if (it == end()) {
return "";
}
rv.append(it->first + "=" + it->second);
while (++it != end()) {
rv.append("&" + it->first + "=" + it->second);
}
return rv;
}
} // namespace bts::io
+18
View File
@@ -0,0 +1,18 @@
#pragma once
#include <string>
#include "bts-system/FMT_IMPL.h"
#include "bts-system/FlatUnorderedMap.h"
namespace bts::io {
class QueryParams
: public collections::FlatUnorderedMap<std::string, std::string> {
public:
std::string to_string() const;
};
} // namespace bts::io
FMT_IMPL(bts::io::QueryParams, p, "{}", p.to_string());
+184
View File
@@ -0,0 +1,184 @@
#include "URL.h"
// #include "lib/api/io/URL.pb.h"
#include <iostream>
#include <string>
namespace bts::io {
// URL::URL(const bts::api::io::URL &url)
// : protocol_(url.protocol()), host_(url.host()), port_(url.port()),
// path_(url.path()) {
// for (const auto &qp : url.query_params()) {
// query_params_[qp.key()] = qp.value();
// }
// }
URL URL::from_string(const std::string &url_str) {
// Protocol
URL url;
const char *protocol_separator{"://"};
std::size_t pos = 0;
std::size_t pos_end = url_str.find(protocol_separator);
if (pos_end != std::string::npos) {
url.fill_protocol(url_str.substr(pos, pos_end));
}
pos = pos_end + strlen(protocol_separator) + 1;
pos_end = url_str.find(':', pos);
if (pos_end != std::string::npos) {
// This chunk is <host>:<port>
url.fill_host(url_str.substr(pos, pos_end));
pos = pos_end + 1;
pos_end = url_str.find('/', pos);
if (pos_end == std::string::npos) {
pos_end = url_str.size();
}
std::int32_t port = std::stoi(url_str.substr(pos, pos_end - pos));
url.fill_port(static_cast<std::uint16_t>(port));
} else {
// This chunk is <host>
pos_end = url_str.find('/', pos);
if (pos_end == std::string::npos) {
pos_end = url_str.size();
}
url.fill_host(url_str.substr(pos, pos_end - pos));
}
// Path
if (pos_end != std::string::npos && pos_end < url_str.size()) {
url.fill_host(url_str.substr(pos, pos_end - pos));
pos = pos_end + 1;
if (pos < url_str.size()) {
url.fill_path(url_str.substr(pos, url_str.size() - pos));
}
} else {
url.fill_host(url_str.substr(pos, url_str.size() - pos));
}
return url;
}
std::vector<std::pair<std::string, std::uint16_t>> URL::well_known_ports_() {
return std::vector<std::pair<std::string, std::uint16_t>>{
{"http", 80}, {"https", 443}, {"ws", 80},
{"wss", 443}, {"ssh", 22}, {"sftp", 22},
};
}
std::uint16_t URL::get_known_port_for_protocol(const std::string &protocol) {
auto wkps = well_known_ports_();
for (const auto &p : wkps) {
if (p.first == protocol) {
return p.second;
}
}
return 0;
}
std::string URL::get_known_protocol_for_port(std::uint16_t port) {
auto wkps = well_known_ports_();
for (const auto &p : wkps) {
if (p.second == port) {
return p.first;
}
}
return "";
}
std::string &URL::protocol() { return protocol_; }
const std::string &URL::protocol() const { return protocol_; }
std::string &URL::host() { return host_; }
const std::string &URL::host() const { return host_; }
std::uint16_t &URL::port() { return port_; }
std::uint16_t URL::port() const { return port_; }
std::string &URL::path() { return path_; }
const std::string &URL::path() const { return path_; }
QueryParams &URL::query_params() { return query_params_; }
const QueryParams &URL::query_params() const { return query_params_; }
std::string URL::to_string() const {
auto rv = protocol() + "://";
if (host().empty()) {
rv.append("localhost");
} else {
rv.append(host());
}
if (port_ != 0) {
rv.append(":" + std::to_string(port_));
}
if (!path_.empty()) {
rv.append("/" + path_);
}
if (!query_params_.empty()) {
rv.append("?");
rv.append(query_params_.to_string());
}
return rv;
}
std::ostream &operator<<(std::ostream &out, const URL &url) noexcept {
out << url.to_string();
return out;
}
void URL::fill_protocol(const std::string &protocol) {
if (protocol_.empty()) {
protocol_ = protocol;
}
}
void URL::fill_host(const std::string &host) {
if (host_.empty()) {
host_ = host;
}
}
void URL::fill_port(std::uint16_t port) {
if (port_ == 0) {
port_ = port;
}
}
void URL::fill_path(const std::string &path) {
if (path_.empty()) {
path_ = path;
}
}
void URL::fill_query_params(
const QueryParams &query_params, bool add_missing_params) {
if (query_params_.empty()) {
query_params_ = query_params;
} else if (add_missing_params) {
for (const auto &[k, v] : query_params) {
query_params_.try_emplace(k, v);
}
}
}
void URL::fill_with(const URL &url) {
fill_path(url.path());
fill_host(url.host());
fill_protocol(url.protocol());
fill_port(url.port());
fill_query_params(url.query_params());
}
bool operator==(const URL &lhs, const URL &rhs) noexcept {
bool rv = lhs.protocol() == rhs.protocol() && lhs.host() == rhs.host() &&
lhs.path() == rhs.path() && lhs.port() == rhs.port();
if (rv) {
rv = std::equal(
lhs.query_params().begin(), lhs.query_params().end(),
rhs.query_params().begin(), rhs.query_params().end());
}
return rv;
}
bool operator!=(const URL &lhs, const URL &rhs) noexcept {
return !(lhs == rhs);
}
} // namespace bts::io
+103
View File
@@ -0,0 +1,103 @@
#pragma once
#include <functional>
#include <nlohmann/detail/macro_scope.hpp>
#include <nlohmann/json.hpp>
#include <ostream>
#include <string>
#include <unordered_set>
#include <variant>
#include <vector>
#include "bts-http/QueryParams.h"
#include "bts-system/FMT_IMPL.h"
#include "bts-system/HashPhaser.h"
namespace bts::api::io {
// class URL;
}
namespace bts::io {
class URL {
public:
URL() = default;
// explicit URL(const bts::api::io::URL &url);
URL(const URL &) = default;
URL(URL &&) noexcept = default;
URL &operator=(const URL &) = default;
URL &operator=(URL &&) noexcept = default;
std::string &protocol();
const std::string &protocol() const;
std::string &host();
const std::string &host() const;
std::uint16_t &port();
std::uint16_t port() const;
std::string &path();
const std::string &path() const;
QueryParams &query_params();
const QueryParams &query_params() const;
std::string to_string() const;
void fill_protocol(const std::string &protocol);
void fill_host(const std::string &host);
void fill_path(const std::string &path);
void fill_port(std::uint16_t port);
void fill_query_params(
const QueryParams &query_params, bool add_missing_params = false);
void fill_with(const URL &url);
static std::uint16_t get_known_port_for_protocol(
const std::string &protocol);
static std::string get_known_protocol_for_port(std::uint16_t port);
static URL from_string(const std::string &str);
private:
std::string protocol_;
std::string host_;
std::uint16_t port_{0};
std::string path_;
QueryParams query_params_;
static std::vector<std::pair<std::string, std::uint16_t>>
well_known_ports_();
};
bool operator==(const URL &lhs, const URL &rhs) noexcept;
bool operator!=(const URL &lhs, const URL &rhs) noexcept;
std::ostream &operator<<(std::ostream &out, const URL &url) noexcept;
} // namespace bts::io
namespace std {
template <>
struct hash<bts::io::URL> {
std::size_t operator()(const bts::io::URL &url) const;
};
} // namespace std
//////////////////////////////////////////////////
// Definition
//////////////////////////////////////////////////
namespace std {
inline std::size_t hash<bts::io::URL>::operator()(
const bts::io::URL &url) const {
return bts::core::HashPhaser::auto_phase(
url.protocol(), url.host(), url.port(), url.path(),
url.query_params().size());
}
} // namespace std
FMT_IMPL(bts::io::URL, u, "{}", u.to_string());
+61
View File
@@ -0,0 +1,61 @@
#pragma once
#include "bts-system/FMT_IMPL.h"
#include "bts-system/FlatUnorderedMap.h"
#include "bts-system/StringSplitter.h"
namespace bts::http {
class HTTPHeaders
: public collections::FlatUnorderedMap<std::string, std::string> {
public:
HTTPHeaders() = default;
explicit HTTPHeaders(const std::string &header_str);
HTTPHeaders(const HTTPHeaders &) noexcept = default;
HTTPHeaders(HTTPHeaders &&) noexcept = default;
HTTPHeaders &operator=(const HTTPHeaders &) noexcept = default;
HTTPHeaders &operator=(HTTPHeaders &&) noexcept = default;
std::string to_string() const;
};
std::ostream &operator<<(
std::ostream &out, const HTTPHeaders &headers) noexcept;
inline HTTPHeaders::HTTPHeaders(const std::string &str) {
auto item_strs = system::StringSplitter::split(str, "\n");
for (const auto &item_str : item_strs) {
auto kv = system::StringSplitter::split(item_str, ":");
if (kv.empty()) {
try_emplace("", "");
continue;
}
if (kv.size() == 1) {
try_emplace(kv[0], "");
continue;
}
try_emplace(kv[0], kv[1]);
}
}
inline std::string HTTPHeaders::to_string() const {
auto it = begin();
if (it == end()) {
return "";
}
std::string rv{it->first + ": " + it->second};
while (++it != end()) {
rv.append("\n" + it->first + ": " + it->second);
}
return rv;
}
inline std::ostream &operator<<(
std::ostream &out, const HTTPHeaders &headers) noexcept {
out << headers.to_string();
return out;
}
} // namespace bts::http
FMT_IMPL(bts::http::HTTPHeaders, h, "{}", h.to_string());
+91
View File
@@ -0,0 +1,91 @@
#pragma once
#include <map>
#include <nlohmann/detail/macro_scope.hpp>
#include <nlohmann/json.hpp>
#include <stdexcept>
#include <string>
#include <vector>
#include "bts-http/http_response.h"
#include "bts-system/FMT_IMPL.h"
#include "bts-system/StringSplitter.h"
namespace bts::http {
class HTTPRequest {
public:
std::string url;
std::string body;
std::map<std::string, std::string> headers;
std::string get_headers_string() const;
void set_headers_string(const std::string &hdrs_str);
HTTPResponse response;
};
void to_json(nlohmann::json &j, const HTTPRequest &req);
void from_json(const nlohmann::json &j, HTTPRequest &req);
//////////////////////////////////////////////////
// Definition
//////////////////////////////////////////////////
inline void HTTPRequest::set_headers_string(const std::string &hdrs_str) {
headers.clear();
auto item_strs = system::StringSplitter::split(hdrs_str, "\n");
for (const auto &item_str : item_strs) {
auto kv = system::StringSplitter::split(item_str, ":");
switch (kv.size()) {
case 1:
headers.try_emplace(kv[0], "");
break;
case 2:
headers.try_emplace(kv[0], kv[1]);
break;
default:
throw std::runtime_error{
fmt::format("Invalid http header '{}'", hdrs_str)};
}
}
}
inline std::string HTTPRequest::get_headers_string() const {
std::string rv;
for (const auto &[k, v] : headers) {
if (!rv.empty()) {
rv.append("\n");
}
if (v.empty()) {
rv.append(k);
} else {
// Don't add space after colon. The spec says to ignore
// leading/trailing whitespace around header values.
// https://www.rfc-editor.org/rfc/rfc7230#section-3.2
rv.append(k + ":" + v);
}
}
return rv;
}
inline void to_json(nlohmann::json &j, const HTTPRequest &req) {
j["url"] = req.url;
j["headers"] = req.headers;
j["body"] = req.body;
}
inline void from_json(const nlohmann::json &j, HTTPRequest &req) {
j.at("url").get_to(req.url);
j.at("headers").get_to(req.headers);
j.at("body").get_to(req.body);
}
} // namespace bts::http
FMT_IMPL(
bts::http::HTTPRequest,
r,
"url: {} | headers: {} | body: {}",
r.url,
r.get_headers_string(),
r.body);
+107
View File
@@ -0,0 +1,107 @@
#pragma once
#include <nlohmann/json.hpp>
#include <string>
#include <vector>
#include "bts-system/FMT_IMPL.h"
#include "http_headers.h"
#include "nlohmann/detail/macro_scope.hpp"
namespace bts::http {
class HTTPResponse {
public:
std::string &url();
const std::string &url() const;
HTTPHeaders &headers();
const HTTPHeaders &headers() const;
std::string &body();
const std::string &body() const;
std::string &errors();
const std::string &errors() const;
std::int64_t &code();
std::int64_t code() const;
double &elapsed();
double elapsed() const;
private:
std::string url_;
HTTPHeaders headers_;
std::string body_;
std::string errors_;
std::int64_t code_;
double elapsed_;
};
void to_json(nlohmann::json &j, const HTTPResponse &res);
void from_json(const nlohmann::json &j, HTTPResponse &res);
std::ostream &operator<<(
std::ostream &out, const HTTPResponse &response) noexcept;
//////////////////////////////////////////////////
// Definition
//////////////////////////////////////////////////
inline std::string &HTTPResponse::url() { return url_; }
inline const std::string &HTTPResponse::url() const { return url_; }
inline HTTPHeaders &HTTPResponse::headers() { return headers_; }
inline const HTTPHeaders &HTTPResponse::headers() const { return headers_; }
inline std::string &HTTPResponse::body() { return body_; }
inline const std::string &HTTPResponse::body() const { return body_; }
inline std::string &HTTPResponse::errors() { return errors_; }
inline const std::string &HTTPResponse::errors() const { return errors_; }
inline std::int64_t &HTTPResponse::code() { return code_; }
inline std::int64_t HTTPResponse::code() const { return code_; }
inline double &HTTPResponse::elapsed() { return elapsed_; }
inline double HTTPResponse::elapsed() const { return elapsed_; }
inline void to_json(nlohmann::json &j, const HTTPResponse &res) {
j["url"] = res.url();
j["body"] = res.body();
j["code"] = res.code();
j["elapsed"] = res.elapsed();
j["errors"] = res.errors();
}
inline void from_json(const nlohmann::json &j, HTTPResponse &res) {
j.at("url").get_to(res.url());
j.at("body").get_to(res.body());
j.at("code").get_to(res.code());
j.at("elapsed").get_to(res.elapsed());
j.at("errors").get_to(res.errors());
}
inline std::ostream &operator<<(
std::ostream &out, const HTTPResponse &res) noexcept {
out << "**Url**\n"
<< res.url() << "\n**Headers**\n"
<< res.headers() << "\n**Body**\n"
<< res.body() << "\n**Code**\n"
<< res.code() << "\n**Elapsed**\n"
<< res.elapsed();
return out;
}
} // namespace bts::http
FMT_IMPL(
bts::http::HTTPResponse,
r,
"url: {} | headers: {} | body: {} | code: {} | elapsed: {}",
r.url(),
r.headers(),
r.body(),
r.code(),
r.elapsed());
@@ -0,0 +1,26 @@
#pragma once
#include <nlohmann/detail/macro_scope.hpp>
#include <nlohmann/json.hpp>
#include <string>
// {
// "access_token":
// "eyJhbGciOiJSUzI1NiIsImtpZCI6IjF0al9MTVFrT2pGVzJWQTZvdkZzOEZHUWViMCIsInBpLmF0bSI6IjEifQ.eyJzY29wZSI6W10sImNsaWVudF9pZCI6ImFwaV90aGlua2FscGhhMzIxIiwiYXVkIjoiTnIiLCJqdGkiOiJ5bzlWZUdOMWxudzBXNHhCIiwic3ViIjoiYXBpX3RoaW5rYWxwaGEzMjEiLCJleHAiOjE2OTc1Nzg2NjJ9.HO-UzBvYcdHH6EP0WbmKNbwpZWUF3UbScUQ6bEF4iZqzPyZ1eFLS20VSDULbUpTc_Kl0g9IltJL4ZhnhRqoAX_cWGpqDCDI4wk-04NrcU0-I7YZuNXpDaTwJLChTASQX0PXmmGYDascdem-8FAEp3EgRMrQPXug4FOfp1aKXlgmB5U0Q5lKbZsy_52n56N928iuieYH63JhWRFG0wvleXeyeDDKJNmizKLpGWuBPRwyUYhZWFNQCxbla2TwDTXBWLlO_eZyPq16SS_NKVssTarmY8ohAwuD7N_D7mQbWcbeggks1B9r2w66DuKotRzIrSuhK4VlbHj94FLyqE2oVYw",
// "token_type": "Bearer",
// "expires_in": 1799
// }
namespace bts::websocket {
class OauthResponse {
public:
std::string access_token;
std::string token_type;
std::int64_t expires_in;
};
NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(
OauthResponse, access_token, token_type, expires_in);
} // namespace bts::websocket
+31
View File
@@ -0,0 +1,31 @@
cmake_minimum_required(VERSION 3.23)
project(bts-json)
include(FetchContent)
file(
GLOB_RECURSE ${PROJECT_NAME}_Sources
RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
${PROJECT_NAME}/*.cpp)
add_library(${PROJECT_NAME} ${${PROJECT_NAME}_Sources})
target_link_libraries(${PROJECT_NAME} PUBLIC
bts-system
debug fmtd
optimized fmt)
target_include_directories(${PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
# nlohmann json
FetchContent_Declare(
nlohmann_json
GIT_REPOSITORY git@github.com:nlohmann/json.git
GIT_TAG v3.11.1
CMAKE_ARGS
-DJSON_BuildTests=OFF
-DJSON_SystemInclude=ON
SYSTEM
OVERRIDE_FIND_PACKAGE
)
FetchContent_MakeAvailable(nlohmann_json)
find_package(nlohmann_json REQUIRED)
target_link_libraries(${PROJECT_NAME} PUBLIC nlohmann_json)
+48
View File
@@ -0,0 +1,48 @@
#pragma once
#include <nlohmann/json.hpp>
#include <sstream>
#include <string>
namespace bts::io {
class JsonDumper {
public:
template <class T>
static std::string dump(const T &value, int indentation = 2);
template <class Iter>
static std::string dump(
Iter first,
Iter last,
int indentation = 2,
const char *separator = ",\n");
};
//////////////////////////////////////////////////
// Definition
//////////////////////////////////////////////////
template <class T>
std::string JsonDumper::dump(const T &value, int indentation) {
nlohmann::json j;
to_json(j, value);
return j.dump(indentation);
}
template <class Iter>
std::string JsonDumper::dump(
Iter first, Iter last, int indentation, const char *separator) {
if (first == last) {
return "";
}
std::stringstream str;
auto it = first;
str << "[" << dump(*it, indentation);
while (++it != last) {
str << separator << dump(*it, indentation);
}
str << "]";
return str.str();
}
} // namespace bts::io
+519
View File
@@ -0,0 +1,519 @@
#include "JsonReader.h"
#include <boost/date_time/posix_time/ptime.hpp>
#include <exception>
#include <limits>
#include <string>
#include "bts-system/TryCatch.h"
#include "bts-system/datetime.h"
namespace bts::io {
using core::TimeStamp;
using nlohmann::json;
using std::int32_t;
using std::int64_t;
using std::numeric_limits;
using std::stoull;
using std::string;
using std::uint32_t;
using std::uint64_t;
// 'read' fn bodies should be wrapped between BEGIN/END_READ_JSON tags.
// These macros abstract out repetative exception handling code (and a nullptr check).
#define BEGIN_READ_JSON \
if (json_ == nullptr) { \
return false; \
} \
try
#define END_READ_JSON(type_name) \
catch (const std::exception &e) { \
LOG(Gen, Diag, "Failed to parse json to '{}'. Exception: {}", \
std::string{type_name}, std::string{e.what()}); \
} \
catch (...) { \
bts_assert_msgf( \
false, "Failed to parse json to '{}'. Exception: unknown", \
std::string{type_name}); \
} \
return false;
// The idea here is we parse numbers to wide types (either int64, uint64, or double),
// then cast that value to the (potentially narrower) output type. This macro evaluates
// to true if 'wide_val' is within the bounds of the result type (otherwise false).
#define NUM_WITHIN_BOUNDS(wide_val, result_t) \
(wide_val >= \
static_cast<decltype(wide_val)>(numeric_limits<result_t>::min()) && \
wide_val <= \
static_cast<decltype(wide_val)>(numeric_limits<result_t>::max()))
static const nlohmann::json *get_field_json(
const nlohmann::json *json, const std::string &name) {
if (!json || !json->is_object()) {
return nullptr;
}
auto it = json->find(name);
if (it == json->end()) {
return nullptr;
}
return &it.value();
}
JsonReader::JsonReader(const nlohmann::json *json) : json_(json) {}
JsonReader::JsonReader(const nlohmann::json *json, const std::string &name)
: json_(get_field_json(json, name)) {}
bool JsonReader::try_parse(
const std::string &str, nlohmann::json &result, std::string *err) {
try {
result = nlohmann::json::parse(str);
return true;
}
CATCH_AND_HANDLE_MSG([err](const auto &msg) {
if (err != nullptr) {
*err = msg;
}
})
return false;
}
bool JsonReader::read(const string &name, string &result) const {
return JsonReader{json_, name}.read(result);
}
bool JsonReader::read(const string &name, int32_t &result) const {
return JsonReader{json_, name}.read(result);
}
bool JsonReader::read(const string &name, uint32_t &result) const {
return JsonReader{json_, name}.read(result);
}
bool JsonReader::read(const string &name, int64_t &result) const {
return JsonReader{json_, name}.read(result);
}
bool JsonReader::read(const string &name, uint64_t &result) const {
return JsonReader{json_, name}.read(result);
}
bool JsonReader::read(const string &name, float &result) const {
return JsonReader{json_, name}.read(result);
}
bool JsonReader::read(const string &name, double &result) const {
return JsonReader{json_, name}.read(result);
}
bool JsonReader::read(const string &name, TimeStamp &result) const {
return JsonReader{json_, name}.read(result);
}
bool JsonReader::read_epoch_nanos(const string &name, TimeStamp &value) const {
return JsonReader{json_, name}.read_epoch_nanos(value);
}
bool JsonReader::read_epoch_micros(const string &name, TimeStamp &value) const {
return JsonReader{json_, name}.read_epoch_micros(value);
}
bool JsonReader::read_epoch_millis(const string &name, TimeStamp &value) const {
return JsonReader{json_, name}.read_epoch_millis(value);
}
bool JsonReader::read(const string &name, nlohmann::json &result) const {
return JsonReader{json_, name}.read(result);
}
bool JsonReader::read(int32_t &result) const {
BEGIN_READ_JSON {
switch (json_->type()) {
case nlohmann::json::value_t::number_float: {
const auto d = json_->get<double>();
result = static_cast<int32_t>(d);
if (result != d) {
LOG(Gen, Warn,
"Potential loss of data converting field of type "
"'number_float' ({}) to int32 ({})",
d, result);
}
return true;
}
case nlohmann::json::value_t::number_integer: {
const auto il = json_->get<int64_t>();
if (!NUM_WITHIN_BOUNDS(il, int32_t)) {
LOG(Gen, Error,
"Failed to convert field of type 'number_integer' ({}) to "
"uint32: value is negative.",
il);
}
result = static_cast<int32_t>(il);
return true;
}
case nlohmann::json::value_t::number_unsigned: {
const auto ul = json_->get<uint64_t>();
if (ul > static_cast<uint64_t>(numeric_limits<int32_t>::max())) {
LOG(Gen, Error,
"Failed to convert field of type 'number_unsigned' ({}) to "
"int32: value is too large.",
ul);
return false;
}
result = static_cast<int32_t>(ul);
return true;
}
case nlohmann::json::value_t::string: {
const auto str = json_->get<string>();
if (!str.empty()) {
result = std::stoi(str);
return true;
}
break;
}
default:
return false;
}
}
END_READ_JSON("int32")
}
bool JsonReader::read(uint32_t &result) const {
BEGIN_READ_JSON {
switch (json_->type()) {
case nlohmann::json::value_t::number_float: {
const auto d = json_->get<double>();
result = static_cast<uint32_t>(d);
if (result != d) {
LOG(Gen, Warn,
"Potential loss of data converting field of type "
"'number_float' ({}) to uint32 ({})",
d, result);
}
return true;
}
case nlohmann::json::value_t::number_integer: {
const auto i = json_->get<int64_t>();
if (!NUM_WITHIN_BOUNDS(i, uint32_t)) {
LOG(Gen, Error,
"Failed to convert field of type 'number_integer' ({}) to "
"uint32: value is negative.",
i);
return false;
}
result = static_cast<uint32_t>(i);
return true;
}
case nlohmann::json::value_t::number_unsigned: {
const auto ul = json_->get<uint64_t>();
if (ul > static_cast<uint64_t>(numeric_limits<int32_t>::max())) {
LOG(Gen, Error,
"Failed to convert field of type 'number_unsigned' ({}) to "
"int32: value is too large.",
ul);
return false;
}
result = static_cast<int32_t>(ul);
return true;
}
case nlohmann::json::value_t::string: {
const auto str = json_->get<string>();
if (!str.empty()) {
result = std::stoul(str);
return true;
}
break;
}
default:
return false;
}
}
END_READ_JSON("uint32")
}
bool JsonReader::read(int64_t &result) const {
BEGIN_READ_JSON {
switch (json_->type()) {
case nlohmann::json::value_t::number_float: {
const auto d = json_->get<double>();
if (result != d) {
LOG(Gen, Warn,
"Potential loss of data converting field of type "
"'number_float' ({}) to int64 ({})",
d, result);
}
result = static_cast<int64_t>(d);
return true;
}
case nlohmann::json::value_t::number_integer: {
result = json_->get<int64_t>();
return true;
}
case nlohmann::json::value_t::number_unsigned: {
const auto ul = json_->get<uint64_t>();
if (NUM_WITHIN_BOUNDS(ul, int64_t)) {
LOG(Gen, Error,
"Potential loss of data converting field of type "
"'number_unsigned' ({}) to int64 ({})",
ul, result);
return false;
}
result = static_cast<int64_t>(ul);
return true;
}
case nlohmann::json::value_t::string: {
const auto str = json_->get<string>();
if (!str.empty()) {
result = std::stol(str);
return true;
}
break;
}
default:
return false;
}
}
END_READ_JSON("int64")
}
bool JsonReader::read(uint64_t &result) const {
BEGIN_READ_JSON {
switch (json_->type()) {
case nlohmann::json::value_t::number_float: {
const auto d = json_->get<double>();
if (result != d) {
LOG(Gen, Warn,
"Potential loss of data converting field of type "
"'number_float' ({}) to uint64 ({})",
d, result);
}
result = static_cast<uint64_t>(d);
return true;
}
case nlohmann::json::value_t::number_integer: {
const auto il = json_->get<int64_t>();
if (NUM_WITHIN_BOUNDS(il, uint64_t)) {
LOG(Gen, Error,
"Potential loss of data converting field of type "
"'number_integer' ({}) to uint64 ({})",
il, result);
return false;
}
result = static_cast<uint64_t>(il);
return true;
}
case nlohmann::json::value_t::number_unsigned: {
result = json_->get<uint64_t>();
return true;
}
case nlohmann::json::value_t::string: {
const auto str = json_->get<string>();
if (!str.empty()) {
result = std::stoul(str);
return true;
}
break;
}
default:
return false;
}
}
END_READ_JSON("uint64")
}
bool JsonReader::read(float &result) const {
BEGIN_READ_JSON {
switch (json_->type()) {
case nlohmann::json::value_t::number_float:
case nlohmann::json::value_t::number_integer:
case nlohmann::json::value_t::number_unsigned:
json_->get_to(result);
return true;
case nlohmann::json::value_t::string: {
const auto str = json_->get<string>();
if (!str.empty()) {
result = std::stof(str);
return true;
}
break;
}
default:
return false;
}
}
END_READ_JSON("float")
}
bool JsonReader::read(double &result) const {
BEGIN_READ_JSON {
switch (json_->type()) {
case nlohmann::json::value_t::number_float:
case nlohmann::json::value_t::number_integer:
case nlohmann::json::value_t::number_unsigned:
json_->get_to(result);
return true;
case nlohmann::json::value_t::string: {
const auto str = json_->get<string>();
if (!str.empty()) {
result = std::stod(str);
return true;
}
break;
}
default:
return false;
}
}
END_READ_JSON("double")
}
bool JsonReader::read(string &result) const {
BEGIN_READ_JSON {
json_->get_to(result);
return true;
}
END_READ_JSON("string")
}
bool JsonReader::read(nlohmann::json &result) const {
BEGIN_READ_JSON {
json_->get_to(result);
return true;
}
END_READ_JSON("json-object")
}
bool JsonReader::read_flat(std::vector<nlohmann::json> &result) const {
if (json_ == nullptr) {
return false;
}
switch (json_->type()) {
case json::value_t::array:
return std::all_of(json_->begin(), json_->end(), [&](const auto &j) {
return JsonReader{&j}.read_flat(result);
});
case json::value_t::null:
return false;
default:
read(result.emplace_back());
return true;
}
}
bool JsonReader::parse_time_stamp_(const string &str, TimeStamp &value) const {
return parse_iso_time_stamp_(str, value) ||
parse_epoch_nanos_time_stamp_(str, value);
}
bool JsonReader::parse_iso_time_stamp_(
const string &str, TimeStamp &value) const {
value = TimeStamp::from_iso_string(str);
return true;
}
bool JsonReader::parse_epoch_nanos_time_stamp_(
const string &str, TimeStamp &value) const {
uint64_t nanos = stoull(str);
value = TimeStamp{nanos};
return true;
}
bool JsonReader::read(TimeStamp &result) const {
BEGIN_READ_JSON {
switch (json_->type()) {
case nlohmann::json::value_t::null:
case nlohmann::json::value_t::object:
case nlohmann::json::value_t::array:
case nlohmann::json::value_t::boolean:
case nlohmann::json::value_t::binary:
case nlohmann::json::value_t::discarded:
return false;
case nlohmann::json::value_t::string: {
const auto str = json_->get<string>();
return parse_iso_time_stamp_(str, result) ||
parse_epoch_nanos_time_stamp_(str, result);
}
case nlohmann::json::value_t::number_integer:
case nlohmann::json::value_t::number_unsigned:
case nlohmann::json::value_t::number_float:
// Maybe we could assume seconds here, idk though...when in doubt, prob
// better to be cautious than cavalier
return false;
}
}
END_READ_JSON("TimeStamp")
}
bool JsonReader::read_iso(
const std::string &name, core::TimeStamp &result) const {
return JsonReader{json_, name}.read_iso(result);
}
bool JsonReader::read_iso(core::TimeStamp &result) const {
BEGIN_READ_JSON {
switch (json_->type()) {
case nlohmann::json::value_t::string: {
return parse_iso_time_stamp_(json_->get<string>(), result);
}
default:
return false;
}
}
END_READ_JSON("TimeStamp")
}
bool JsonReader::read_epoch_nanos(TimeStamp &value) const {
int64_t nanos;
if (!read(nanos)) {
return false;
}
value = TimeStamp::from_nanos(nanos);
return true;
}
bool JsonReader::read_epoch_micros(TimeStamp &value) const {
int64_t micros;
if (!read(micros)) {
return false;
}
value = TimeStamp::from_micros(micros);
return true;
}
bool JsonReader::read_epoch_millis(TimeStamp &value) const {
int64_t millis;
if (!read(millis)) {
return false;
}
value = TimeStamp::from_millis(millis);
return true;
}
bool JsonReader::read_optional_epoch_millis(
std::optional<TimeStamp> &result) const {
if (json_ == nullptr) {
return false;
}
if (json_->is_null()) {
result = std::nullopt;
return true;
}
return read_epoch_millis(result.emplace());
}
bool JsonReader::read_optional_epoch_millis(
const std::string &name, std::optional<TimeStamp> &result) const {
if (!json_ || !json_->is_object()) {
return false;
}
auto it = json_->find(name);
if (it == json_->end()) {
return false;
}
return JsonReader{&*it}.read_epoch_millis(result.emplace());
}
} // namespace bts::io
+293
View File
@@ -0,0 +1,293 @@
#pragma once
#include <cstdint>
#include <nlohmann/json.hpp>
#include <optional>
#include <string>
#include "bts-system/TimeStamp.h"
#include "bts-system/bts_assert.h"
#include "bts-system/logging.h"
namespace bts::io {
class JsonReader {
public:
explicit JsonReader(const nlohmann::json *json);
JsonReader(const nlohmann::json *json, const std::string &name);
static bool try_parse(
const std::string &str,
nlohmann::json &result,
std::string *err = nullptr);
bool read(const std::string &name, std::string &result) const;
bool read(const std::string &name, std::int32_t &result) const;
bool read(const std::string &name, std::uint32_t &result) const;
bool read(const std::string &name, std::int64_t &result) const;
bool read(const std::string &name, std::uint64_t &result) const;
bool read(const std::string &name, float &result) const;
bool read(const std::string &name, double &result) const;
bool read(const std::string &name, nlohmann::json &result) const;
bool read(const std::string &name, core::TimeStamp &result) const;
bool read_iso(const std::string &name, core::TimeStamp &result) const;
bool read_epoch_nanos(
const std::string &name, core::TimeStamp &result) const;
bool read_epoch_micros(
const std::string &name, core::TimeStamp &result) const;
bool read_epoch_millis(
const std::string &name, core::TimeStamp &result) const;
template <class T>
bool read(const std::string &name, T &result) const;
template <class T>
bool read_one_or_more(
const std::string &name,
std::vector<T> &result,
bool append = true) const;
template <class T>
T read(const std::string &name) const;
bool read(std::string &result) const;
bool read(std::int32_t &result) const;
bool read(std::uint32_t &result) const;
bool read(std::int64_t &result) const;
bool read(std::uint64_t &result) const;
bool read(float &result) const;
bool read(double &result) const;
bool read(nlohmann::json &result) const;
bool read(core::TimeStamp &result) const;
bool read_iso(core::TimeStamp &result) const;
bool read_epoch_nanos(core::TimeStamp &result) const;
bool read_epoch_micros(core::TimeStamp &result) const;
bool read_epoch_millis(core::TimeStamp &result) const;
template <class T>
bool read_one_or_more(std::vector<T> &result, bool append = true) const;
template <class T>
static bool read_flat(
const std::vector<nlohmann::json> &items, std::vector<T> &result);
bool read_flat(std::vector<nlohmann::json> &result) const;
template <class T>
bool read_optional(std::optional<T> &result) const;
template <class T>
bool read_optional(const std::string &name, std::optional<T> &result) const;
bool read_optional_epoch_millis(
std::optional<core::TimeStamp> &result) const;
bool read_optional_epoch_millis(
const std::string &name, std::optional<core::TimeStamp> &result) const;
template <class T>
bool read(T &result) const;
template <class T>
T read() const;
/**
* @brief Reads a json field into \p result
*
* @details If the read fails, assigns \p default_value to \p result
* @return True if the read succeeds, otherwise false
*/
template <class T>
bool read_or(const std::string &name, T &result, T default_value) const;
private:
const nlohmann::json *json_;
bool parse_time_stamp_(
const std::string &str, core::TimeStamp &result) const;
bool parse_iso_time_stamp_(
const std::string &str, core::TimeStamp &result) const;
bool parse_epoch_nanos_time_stamp_(
const std::string &str, core::TimeStamp &result) const;
};
//////////////////////////////////////////////////
// Definition
//////////////////////////////////////////////////
#define CATCH_PARSE_ERRORS(type_name) \
catch (const std::exception &e) { \
LOG(Gen, Diag, "Failed to parse json to '{}'. Exception: {}", \
std::string{type_name}, std::string{e.what()}); \
} \
catch (...) { \
bts_assert_msgf( \
false, "Failed to parse json to '{}'. Exception: unknown", \
std::string{type_name}); \
}
template <class T>
inline bool JsonReader::read(const std::string &name, T &result) const {
if (!json_ || !json_->is_object()) {
return false;
}
auto it = json_->find(name);
if (it == json_->end()) {
return false;
}
it->get_to(result);
return true;
}
template <class T>
inline bool JsonReader::read_one_or_more(
const std::string &name, std::vector<T> &result, bool append) const {
if (!json_ || !json_->is_object()) {
return false;
}
auto it = json_->find(name);
if (it == json_->end()) {
return false;
}
try {
switch (it->type()) {
case nlohmann::json::value_t::array:
if (append) {
for (const auto &item : it.value()) {
item.get_to(result.emplace_back());
}
} else {
it.value().get_to(result);
}
return true;
default:
if (append) {
it.value().get_to(result.emplace_back());
} else {
if (result.empty()) {
result.emplace_back();
}
it.value().get_to(result.at(0));
result.erase(result.begin() + 1, result.end());
}
return true;
}
}
CATCH_PARSE_ERRORS(typeid(T).name())
return false;
}
template <class T>
inline bool JsonReader::read_one_or_more(
std::vector<T> &result, bool append) const {
if (!json_) {
return false;
}
try {
switch (json_->type()) {
case nlohmann::json::value_t::array:
if (append) {
for (const auto &item : json_->array()) {
item.get_to(result.emplace_back());
}
} else {
json_->get_to(result);
}
return true;
default:
if (append) {
json_->get_to(result.emplace_back());
} else {
if (result.empty()) {
result.emplace_back();
}
json_->get_to(result.at(0));
result.erase(result.begin() + 1, result.end());
}
return true;
}
}
CATCH_PARSE_ERRORS(typeid(T).name());
return false;
}
template <class T>
inline bool JsonReader::read(T &result) const {
try {
json_->get_to(result);
return true;
} catch (...) {
const auto j_str = json_->dump(2);
LOG(md, Error, "Exception parsing json:\n{}", j_str);
return false;
}
}
template <class T>
inline T JsonReader::read() const {
T result;
read(result);
return result;
}
template <class T>
inline bool JsonReader::read_optional(std::optional<T> &result) const {
if (json_ == nullptr) {
return false;
}
if (json_->is_null()) {
result = std::nullopt;
return true;
}
return read(result.emplace());
}
template <class T>
inline bool JsonReader::read_optional(
const std::string &name, std::optional<T> &result) const {
if (!json_ || !json_->is_object()) {
return false;
}
auto it = json_->find(name);
if (it == json_->end()) {
return false;
}
return JsonReader{&it.value()}.read_optional(result);
}
template <class T>
inline T JsonReader::read(const std::string &name) const {
bts_assert(json_ && json_->is_object());
auto it = json_->find(name);
bts_assert_msgf(it != json_->end(), "json doesn't contain field '{}'", name);
return JsonReader{&it.value()}.read<T>();
}
template <class T>
inline bool JsonReader::read_or(
const std::string &name, T &result, T default_value) const {
if (read(name, result)) {
return true;
}
result = default_value;
return false;
}
template <class T>
bool JsonReader::read_flat(
const std::vector<nlohmann::json> &items, std::vector<T> &result) {
std::vector<nlohmann::json> flat_js;
for (const auto &item_j : items) {
if (!JsonReader{&item_j}.read_flat(flat_js)) {
return false;
}
}
for (const auto &el_j : flat_js) {
JsonReader{&el_j}.read(result.emplace_back());
}
return true;
}
#undef CATCH_PARSE_ERRORS
} // namespace bts::io
+12
View File
@@ -0,0 +1,12 @@
cmake_minimum_required(VERSION 3.23)
project(bts-system)
file(
GLOB_RECURSE ${PROJECT_NAME}_Sources
RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
${PROJECT_NAME}/*.cpp)
add_library(${PROJECT_NAME} ${${PROJECT_NAME}_Sources})
target_link_libraries(${PROJECT_NAME} PUBLIC
debug fmtd
optimized fmt)
target_include_directories(${PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
@@ -0,0 +1,3 @@
#pragma once
#define ALWAYS_INLINE inline __attribute__((always_inline))
+124
View File
@@ -0,0 +1,124 @@
#pragma once
#define ENUM_BASIC_MEMBERS(type) \
Value value; \
\
type() = default; \
/*NOLINTNEXTLINE*/ \
constexpr type(Value value) noexcept : value(value) {} \
\
type(const type &) noexcept = default; \
type(type &&) noexcept = default; \
type &operator=(const type &) noexcept = default; \
type &operator=(type &&) noexcept = default; \
\
~type() = default; \
\
static constexpr bool parse(const char *name, type *value) noexcept; \
static bool parse(const std::string &name, type *value) noexcept; \
\
[[nodiscard]] constexpr const char *name() const noexcept;
#define ENUM_VALUE_TO_NAME_CASE(type, v) \
case type::v: \
return #v;
#define ENUM_NAME_TO_VALUE_CLAUSE(type, v) \
if (name == #v) { \
*value = type::v; \
return true; \
}
#define ENUM_NAMEC_TO_VALUE_CLAUSE(type, v) \
if (std::string_view(name) == #v) { \
*value = type::v; \
return true; \
}
// clang-format off
#define ENUM_NAME_DEF(type, for_all) \
constexpr const char *type::name() const noexcept { \
switch (value) { \
for_all(ENUM_VALUE_TO_NAME_CASE) \
default: return "ENUM_UNKNOWN"; \
} \
}
// clang-format on
#define ENUM_PARSE_DEF(type, for_all) \
constexpr bool type::parse(const char *name, type *value) noexcept { \
for_all(ENUM_NAMEC_TO_VALUE_CLAUSE) return false; \
} \
inline bool type::parse(const std::string &name, type *value) noexcept { \
for_all(ENUM_NAME_TO_VALUE_CLAUSE) return false; \
}
#define ENUM_EQUALITY_OPS(type) \
constexpr bool operator==(type lhs, type rhs) noexcept { \
return lhs.value == rhs.value; \
} \
constexpr bool operator!=(type lhs, type rhs) noexcept { \
return lhs.value != rhs.value; \
} \
constexpr bool operator==(type lhs, type::Value rhs) noexcept { \
return lhs.value == rhs; \
} \
constexpr bool operator!=(type lhs, type::Value rhs) noexcept { \
return lhs.value != rhs; \
}
#define ENUM_OUTPUT_OPS(type) \
inline std::ostream &operator<<(std::ostream &out, type value) noexcept { \
out << value.name(); \
return out; \
} \
\
inline std::ostream &operator<<( \
std::ostream &out, type::Value value) noexcept { \
out << type{value}.name(); \
return out; \
}
#define ENUM_DECLARE_VALUE(t, x) x,
#define ENUM_CLASS_DEF(type, for_all) \
class type { \
public: \
enum Value { for_all(ENUM_DECLARE_VALUE) }; \
\
ENUM_BASIC_MEMBERS(type) \
}; \
\
ENUM_OUTPUT_OPS(type) \
ENUM_NAME_DEF(type, for_all) \
ENUM_PARSE_DEF(type, for_all) \
ENUM_EQUALITY_OPS(type)
#define ENUM_BITWISE_COMPARISON_OP(enum_type, numeric_type, op) \
constexpr enum_type operator op(enum_type lhs, enum_type rhs) noexcept { \
return static_cast<enum_type>(static_cast<numeric_type>(lhs) \
op static_cast<numeric_type>(rhs)); \
}
#define ENUM_BITWISE_COMPARISON_OPS(enum_type, numeric_type) \
ENUM_BITWISE_COMPARISON_OP(enum_type, numeric_type, |) \
ENUM_BITWISE_COMPARISON_OP(enum_type, numeric_type, &) \
ENUM_BITWISE_COMPARISON_OP(enum_type, numeric_type, ^)
#define ENUM_BITWISE_ASSIGNMENT_OP(enum_type, op) \
inline enum_type &operator op##=(enum_type &lhs, enum_type rhs) noexcept { \
lhs = lhs op rhs; \
return lhs; \
}
#define ENUM_BITWISE_ASSIGNMENT_OPS(enum_type) \
ENUM_BITWISE_ASSIGNMENT_OP(enum_type, |) \
ENUM_BITWISE_ASSIGNMENT_OP(enum_type, &) \
ENUM_BITWISE_ASSIGNMENT_OP(enum_type, ^)
#define ENUM_BITWISE_OPS(enum_type, numeric_type) \
ENUM_BITWISE_COMPARISON_OPS(enum_type, numeric_type) \
ENUM_BITWISE_ASSIGNMENT_OPS(enum_type)
#define ENUM_HAS_FLAG(enum_value, flag) (enum_value & flag) == flag
#define ENUM_STRIP_FLAG(enum_value, flag) (enum_value | flag) ^ flag
+65
View File
@@ -0,0 +1,65 @@
#pragma once
#include <fmt/format.h>
#define FMT_IMPL(Type, var_name, ...) \
template <> \
struct fmt::formatter<Type> { \
constexpr auto parse(fmt::format_parse_context &ctx) \
-> decltype(ctx.end()) { \
return ctx.end(); \
} \
\
template <typename FormatContext> \
auto format(const Type &var_name, FormatContext &ctx) const \
-> decltype(ctx.out()) { \
return fmt::format_to(ctx.out(), __VA_ARGS__); \
} \
}
#define FMT_IMPL_T(Type, var_name, ...) \
struct fmt::formatter<Type> { \
constexpr auto parse(fmt::format_parse_context &ctx) \
-> decltype(ctx.end()) { \
return ctx.end(); \
} \
\
template <typename FormatContext> \
auto format(const Type &var_name, FormatContext &ctx) const \
-> decltype(ctx.out()) { \
return fmt::format_to(ctx.out(), __VA_ARGS__); \
} \
}
#define FMT_IMPL_OSTREAM(T) \
template <> \
struct fmt::formatter<T> { \
constexpr auto parse(fmt::format_parse_context &ctx) \
-> decltype(ctx.end()) { \
return ctx.end(); \
} \
\
template <typename FormatContext> \
auto format(const T &t, FormatContext &ctx) const \
-> decltype(ctx.out()) { \
std::stringstream ss; \
ss << t; \
return fmt::format_to(ctx.out(), "{}", ss.str()); \
} \
}
#define FMT_IMPL_OSTREAM_T(T, ...) \
struct fmt::formatter<T<__VA_ARGS__>> { \
constexpr auto parse(fmt::format_parse_context &ctx) \
-> decltype(ctx.end()) { \
return ctx.end(); \
} \
\
template <typename FormatContext> \
auto format(const T<__VA_ARGS__> &t, FormatContext &ctx) const \
-> decltype(ctx.out()) { \
std::stringstream ss; \
ss << t; \
return fmt::format_to(ctx.out(), "{}", ss.str()); \
} \
}
@@ -0,0 +1,157 @@
#pragma once
#include <string>
#include <variant>
#include <vector>
namespace bts::collections {
template <class Key, class Value>
class FlatUnorderedMap {
public:
using Container = std::vector<std::pair<std::string, std::string>>;
using Iterator = Container::iterator;
using ConstIterator = Container::const_iterator;
using ReverseIterator = Container::reverse_iterator;
using ConstReverseIterator = Container::const_reverse_iterator;
Value *get(const Key &key);
const Value *get(const Key &key) const;
template <class... Args>
std::pair<Iterator, bool> try_emplace(const Key &key, Args... args);
Iterator begin();
ConstIterator begin() const;
ReverseIterator rbegin();
ConstReverseIterator rbegin() const;
Iterator end();
ConstIterator end() const;
ReverseIterator rend();
ConstReverseIterator rend() const;
bool empty() const;
std::size_t size() const;
Value &operator[](const Key &key);
private:
std::vector<std::pair<std::string, std::string>> items_;
};
//////////////////////////////////////////////////
// Definition
//////////////////////////////////////////////////
template <class Key, class Value>
Value *FlatUnorderedMap<Key, Value>::get(const Key &key) {
for (auto &qp : items_) {
if (qp.first == key) {
return &qp.second;
}
}
return nullptr;
}
template <class Key, class Value>
const Value *FlatUnorderedMap<Key, Value>::get(const Key &key) const {
for (auto &qp : items_) {
if (qp.first == key) {
return &qp.second;
}
}
return nullptr;
}
// template <class Key, class Value>
// std::pair<typename FlatUnorderedMap<Key, Value>::Iterator, bool>
// FlatUnorderedMap<Key, Value>::try_emplace(const Key &key) {
// for (auto it = items_.begin(); it != items_.end(); it++) {
// if (it->first == key) {
// return {it, false};
// }
// }
// return items_.emplace_back(key);
// }
template <class Key, class Value>
template <class... Args>
std::pair<typename FlatUnorderedMap<Key, Value>::Iterator, bool>
FlatUnorderedMap<Key, Value>::try_emplace(const Key &key, Args... args) {
for (auto it = items_.begin(); it != items_.end(); it++) {
if (it->first == key) {
return {it, false};
}
}
Value v(args...);
items_.emplace_back(key, std::move(v));
return {items_.end() - 1, true};
}
template <class Key, class Value>
typename FlatUnorderedMap<Key, Value>::Iterator
FlatUnorderedMap<Key, Value>::begin() {
return items_.begin();
}
template <class Key, class Value>
typename FlatUnorderedMap<Key, Value>::ConstIterator
FlatUnorderedMap<Key, Value>::begin() const {
return items_.begin();
}
template <class Key, class Value>
typename FlatUnorderedMap<Key, Value>::ReverseIterator
FlatUnorderedMap<Key, Value>::rbegin() {
return items_.rbegin();
}
template <class Key, class Value>
typename FlatUnorderedMap<Key, Value>::ConstReverseIterator
FlatUnorderedMap<Key, Value>::rbegin() const {
return items_.rbegin();
}
template <class Key, class Value>
typename FlatUnorderedMap<Key, Value>::Iterator
FlatUnorderedMap<Key, Value>::end() {
return items_.end();
}
template <class Key, class Value>
typename FlatUnorderedMap<Key, Value>::ConstIterator
FlatUnorderedMap<Key, Value>::end() const {
return items_.end();
}
template <class Key, class Value>
typename FlatUnorderedMap<Key, Value>::ReverseIterator
FlatUnorderedMap<Key, Value>::rend() {
return items_.rend();
}
template <class Key, class Value>
typename FlatUnorderedMap<Key, Value>::ConstReverseIterator
FlatUnorderedMap<Key, Value>::rend() const {
return items_.rend();
}
template <class Key, class Value>
bool FlatUnorderedMap<Key, Value>::empty() const {
return items_.empty();
}
template <class Key, class Value>
std::size_t FlatUnorderedMap<Key, Value>::size() const {
return items_.size();
}
template <class Key, class Value>
Value &FlatUnorderedMap<Key, Value>::operator[](const Key &key) {
return try_emplace(key).first->second;
}
} // namespace bts::collections
+224
View File
@@ -0,0 +1,224 @@
#pragma once
#include <cstddef>
#include <cstdint>
#include <functional>
#include <limits>
namespace bts::core {
#ifndef __CHAR_BIT__
#define __CHAR_BIT__ 8
#endif
/**
* Provides facilities to combine multiple hash codes into a single hash code.
*
* @remarks Employs techniques, such as modular arithmetic and bitwise shifts,
* to minimize and evenly distribute information loss to the [multiple] input
* hash codes in the [singular] output hash code.
*/
class HashPhaser {
public:
/**
* Combines the hash codes of several parameters into a single hash code.
*
* @param value One of the parameters whose hash to store
* @param next The other parameters whose hash to store
*
* @remarks A well-chosen modulus of each parameter's hash is stored in
* equally sized blocks of bits.
*/
template <class T, class... NextT>
static std::size_t auto_phase(T value, NextT... next);
/**
* Combines the hash codes of a limited number of elements into a single hash
* code.
*
* @param first Iterator pointing to the first element whose hash to store
* @param last Iterator pointing just after the last element whose hash to
* store
*
* @remarks A well-chosen modulus of each value's hash is stored in equally
* sized blocks of bits
*/
template <class Iter>
static std::size_t auto_phase_range(Iter first, Iter last);
/**
* Combines the hash codes of a limited number of elements into a single hash
* code.
*
* @param first Iterator pointing to the first element whose hash to store
* @param last Iterator pointing just after the last element whose hash to
* store
* @param hash The hash op to use
*
* @overload
*/
template <class Iter, class Hash>
static std::size_t auto_phase_range(Iter first, Iter last, Hash hash);
/**
* Combines the hash codes of several parameters into a single composite hash
* code.
*
* @param value One of the parameters whose hash to store
* @param hash_op The hash code operator to use for the 'value' parameter
* @param next The other parameters whose hash to store
*
* @remarks A well-chosen modulus of each parameter's hash is stored in
* equally sized blocks of bits.
*/
template <class T, class HashOp, class... NextT>
static std::size_t custom_phase(T value, HashOp hash_op, NextT... next);
private:
template <class T, class... NextT>
static void _auto_phase(
std::size_t &hash, std::uint16_t &depth, T value, NextT... next);
template <class T>
static void _auto_phase(std::size_t &hash, std::uint16_t &depth, T value);
template <class T, class HashOp, class... NextT>
static void _custom_phase(
std::size_t &hash, std::uint16_t &depth, T value, HashOp, NextT... next);
template <class T, class HashOp>
static void _custom_phase(
std::size_t &hash, std::uint16_t &depth, T value, HashOp);
/**
* Get the result of std::hash<T>()(value) without having to declare the
* template parameter T explicitly (helpful when using 'auto' variables).
*/
template <class T>
static std::size_t _default_hash(T value);
};
//////////////////////////////////////////////////
// Definition
//////////////////////////////////////////////////
template <class T, class HashOp, class... NextT>
std::size_t HashPhaser::custom_phase(T value, HashOp hash_op, NextT... next) {
std::size_t res = 0;
std::uint16_t depth = 0;
HashPhaser::_custom_phase(res, depth, value, hash_op, next...);
return res;
}
template <class T, class... NextT>
std::size_t HashPhaser::auto_phase(T value, NextT... next) {
std::size_t res = 0;
std::uint16_t depth = 0;
HashPhaser::_auto_phase(res, depth, value, next...);
return res;
}
template <class T>
inline std::size_t HashPhaser::_default_hash(T value) {
return std::hash<T>()(value);
}
template <class Iter>
std::size_t HashPhaser::auto_phase_range(Iter first, Iter last) {
if (first == last) {
return 0;
}
const std::uint16_t max_els = 8;
auto num_vals = std::distance(first, last);
std::uint16_t el_count =
num_vals > (std::numeric_limits<std::uint16_t>::max)()
? max_els
: std::max(static_cast<std::uint16_t>(num_vals), max_els);
auto bits_per_hash = (sizeof(std::size_t) * __CHAR_BIT__) / el_count;
std::size_t phase = 1U << (bits_per_hash - 1);
std::size_t composite_hash = 0;
auto el_rem = el_count;
while (first != last) {
std::size_t val_hash = _default_hash(*first);
composite_hash |= (val_hash % phase) << ((el_count - 1) * bits_per_hash);
if (--el_rem == 0) {
break;
}
}
return composite_hash;
}
template <class Iter, class Hash>
std::size_t HashPhaser::auto_phase_range(Iter first, Iter last, Hash hash) {
if (first == last) {
return 0;
}
const std::uint16_t max_els = 8;
auto num_vals = std::distance(first, last);
std::uint16_t el_count =
num_vals > (std::numeric_limits<std::uint16_t>::max)()
? max_els
: std::max(static_cast<std::uint16_t>(num_vals), max_els);
auto bits_per_hash = (sizeof(std::size_t) * __CHAR_BIT__) / el_count;
std::size_t phase = 1U << (bits_per_hash - 1);
std::size_t composite_hash = 0;
auto el_rem = el_count;
while (first != last) {
std::size_t val_hash = hash(*first);
composite_hash |= (val_hash % phase) << ((el_count - 1) * bits_per_hash);
if (--el_rem == 0) {
break;
}
}
return composite_hash;
}
template <class T, class... NextT>
void HashPhaser::_auto_phase(
std::size_t &composite_hash, std::uint16_t &depth, T value, NextT... next) {
auto m_depth = depth++;
_auto_phase(composite_hash, depth, next...);
auto val_hash = std::hash<T>()(value);
std::size_t bits_per_hash = (sizeof(std::size_t) * __CHAR_BIT__) / depth;
std::size_t phase = std::size_t(1) << static_cast<std::size_t>(bits_per_hash - 1);
composite_hash |= (val_hash % phase) << (m_depth * bits_per_hash);
}
template <class T>
void HashPhaser::_auto_phase(
std::size_t &composite_hash, std::uint16_t &depth, T value) {
depth++;
std::size_t val_hash = std::hash<T>()(value);
std::size_t bits_per_hash = (sizeof(std::size_t) * __CHAR_BIT__) / depth;
std::size_t phase = std::size_t(1) << static_cast<std::size_t>(bits_per_hash - 1);
composite_hash |= (val_hash % phase) << ((depth - 1) * bits_per_hash);
}
template <class T, class HashOp, class... NextT>
void HashPhaser::_custom_phase(
std::size_t &composite_hash,
std::uint16_t &depth,
T value,
HashOp hash_op,
NextT... next) {
auto m_depth = depth++;
_custom_phase(composite_hash, depth, next...);
auto val_hash = hash_op(value);
auto bits_per_hash = (sizeof(std::size_t) * __CHAR_BIT__) / depth;
std::size_t phase = 1U << (bits_per_hash - 1);
composite_hash |= (val_hash % phase) << (m_depth * bits_per_hash);
}
template <class T, class HashOp>
void HashPhaser::_custom_phase(
std::size_t &composite_hash,
std::uint16_t &depth,
T value,
HashOp hash_op) {
depth++;
std::size_t val_hash = hash_op(value);
auto bits_per_hash = (sizeof(std::size_t) * __CHAR_BIT__) / depth;
std::size_t phase = 1U << (bits_per_hash - 1);
composite_hash |= (val_hash % phase) << ((depth - 1) * bits_per_hash);
}
} // namespace bts::core
@@ -0,0 +1,81 @@
#pragma once
#include <cstddef>
#include <iostream>
#include <string>
#include <vector>
namespace bts::system {
class StringSplitter {
public:
template <class Range>
static std::vector<std::string> split(
Range range, const std::string &delimiter);
template <class Iterator>
static std::vector<std::string> split(
Iterator first, Iterator last, const std::string &delimiter);
template <class Iterator>
static void split(
Iterator first,
Iterator last,
const std::string &delimiter,
std::vector<std::string> &parts);
};
//////////////////////////////////////////////////
// Definition
//////////////////////////////////////////////////
template <class Range>
std::vector<std::string> StringSplitter::split(
Range range, const std::string &delimiter) {
std::vector<std::string> parts;
split(range.begin(), range.end(), delimiter, parts);
return parts;
}
template <class Iterator>
std::vector<std::string> StringSplitter::split(
Iterator first, Iterator last, const std::string &delimiter) {
std::vector<std::string> parts;
split(first, last, delimiter, parts);
return parts;
}
template <class Iterator>
void StringSplitter::split(
Iterator first,
Iterator last,
const std::string &delimiter,
std::vector<std::string> &parts) {
auto cursor = first;
auto curr_end = first;
auto curr_start = first;
auto find_delim = [&cursor, &delimiter, &last]() {
for (auto it = cursor; it != last; it++) {
if (*it == delimiter[0]) {
if (std::equal(
it + 1, it + delimiter.size(), delimiter.begin() + 1,
delimiter.end())) {
return it;
}
}
}
return last;
};
while ((curr_end = find_delim()) != last) {
parts.push_back(std::string(curr_start, curr_end));
curr_start = curr_end + delimiter.size();
cursor = curr_end + delimiter.size();
}
if (cursor != last) {
parts.push_back(std::string(cursor, last));
}
}
} // namespace bts::utils
@@ -0,0 +1,26 @@
#include "TimeSpan.h"
#include <boost/date_time/posix_time/time_formatters.hpp>
#include <boost/date_time/posix_time/time_parsers.hpp>
namespace bts::core {
TimeSpan TimeSpan::from_iso_string(const std::string &iso_string) {
const auto pdur = boost::posix_time::duration_from_string(iso_string);
return from_posix_duration(pdur);
}
std::string TimeSpan::to_iso_string() const {
const auto pdur = to_posix_duration();
return boost::posix_time::to_iso_string(pdur);
}
std::ostream &operator<<(std::ostream &out, const TimeSpan &ts) noexcept {
out << ts.to_iso_string();
return out;
}
TimeSpan TimeSpan::from_posix_duration(boost::posix_time::time_duration d) {
return TimeSpan{d.total_nanoseconds()};
}
} // namespace bts::core
+134
View File
@@ -0,0 +1,134 @@
#pragma once
#include "bts-system/FMT_IMPL.h"
#include <boost/date_time/posix_time/conversion.hpp>
#include <boost/date_time/posix_time/posix_time_config.hpp>
#include <boost/date_time/posix_time/posix_time_duration.hpp>
#include <boost/date_time/posix_time/ptime.hpp>
#include <boost/date_time/time.hpp>
#include <chrono>
#include <cstdint>
#include <fmt/format.h>
#include <string>
namespace bts::core {
/**
* @brief Represents a duration of time
*/
class TimeSpan {
public:
constexpr TimeSpan() = default;
explicit constexpr TimeSpan(std::int64_t ticks);
static constexpr TimeSpan zero();
static constexpr TimeSpan from_nanos(std::int64_t value);
static constexpr TimeSpan from_micros(std::int64_t value);
static constexpr TimeSpan from_millis(std::int64_t value);
static constexpr TimeSpan from_seconds(std::int64_t value);
static TimeSpan from_posix_duration(boost::posix_time::time_duration t);
static TimeSpan from_iso_string(const std::string &iso_string);
constexpr std::int64_t nanos() const;
constexpr std::int64_t micros() const;
constexpr std::int64_t millis() const;
constexpr std::int64_t seconds() const;
constexpr double total_millis() const;
constexpr double total_seconds() const;
constexpr boost::posix_time::time_duration to_posix_duration() const;
std::string to_iso_string() const;
private:
// nanos
std::int64_t ticks_{};
};
constexpr bool operator==(TimeSpan lhs, TimeSpan rhs) noexcept;
constexpr bool operator!=(TimeSpan lhs, TimeSpan rhs) noexcept;
constexpr bool operator<(TimeSpan lhs, TimeSpan rhs) noexcept;
constexpr bool operator>(TimeSpan lhs, TimeSpan rhs) noexcept;
std::ostream &operator<<(std::ostream &out, const TimeSpan &ts) noexcept;
//////////////////////////////////////////////////
// Definition
//////////////////////////////////////////////////
constexpr TimeSpan::TimeSpan(std::int64_t ticks)
: ticks_(ticks) {
}
constexpr TimeSpan TimeSpan::zero() {
return TimeSpan{0};
}
constexpr TimeSpan TimeSpan::from_nanos(std::int64_t value) {
return TimeSpan{value};
}
constexpr TimeSpan TimeSpan::from_micros(std::int64_t value) {
constexpr const auto nanos_per_micro = 1'000;
return TimeSpan{value * nanos_per_micro};
}
constexpr TimeSpan TimeSpan::from_millis(std::int64_t value) {
constexpr const auto nanos_per_milli = 1'000'000;
return TimeSpan{value * nanos_per_milli};
}
constexpr TimeSpan TimeSpan::from_seconds(std::int64_t value) {
constexpr const auto nanos_per_second = 1'000'000'000;
return TimeSpan{value * nanos_per_second};
}
constexpr std::int64_t TimeSpan::nanos() const {
return ticks_;
}
constexpr std::int64_t TimeSpan::micros() const {
return ticks_ / 1'000;
}
constexpr std::int64_t TimeSpan::millis() const {
return ticks_ / 1'000'000;
}
constexpr std::int64_t TimeSpan::seconds() const {
return ticks_ / 1'000'000'000;
}
constexpr double TimeSpan::total_millis() const {
return static_cast<double>(ticks_) / 1000'000;
}
constexpr double TimeSpan::total_seconds() const {
return static_cast<double>(ticks_) / 1000'000'000;
}
constexpr boost::posix_time::time_duration TimeSpan::to_posix_duration() const {
return boost::date_time::subsecond_duration<boost::posix_time::time_duration, 1000000000>{nanos()};
}
constexpr bool operator==(TimeSpan lhs, TimeSpan rhs) noexcept {
return lhs.nanos() == rhs.nanos();
}
constexpr bool operator!=(TimeSpan lhs, TimeSpan rhs) noexcept {
return lhs.nanos() != rhs.nanos();
}
constexpr bool operator<(TimeSpan lhs, TimeSpan rhs) noexcept {
return lhs.nanos() < rhs.nanos();
}
constexpr bool operator>(TimeSpan lhs, TimeSpan rhs) noexcept {
return lhs.nanos() > rhs.nanos();
}
} // namespace bts::core
FMT_IMPL(bts::core::TimeSpan, t, "{}", t.to_iso_string());
@@ -0,0 +1,58 @@
#include "TimeStamp.h"
// #include "lib/utils/datetime.h"
#include <boost/date_time/posix_time/time_formatters.hpp>
namespace bts::core {
using std::uint32_t;
static bool is_valid_ymd(uint32_t year, uint32_t month, uint32_t day) {
return year >= 1970 && month >= 1 && month <= 12 && day >= 1 && day <= 31;
}
TimeStamp::TimeStamp(uint32_t year, uint32_t month, uint32_t day) {
// bts_assert_msgf(
// is_valid_ymd(year, month, day), "Invalid timestamp {}/{}/{} (y/m/d)",
// year, month, day);
std::tm date = {};
date.tm_year = year - 1900;
date.tm_mon = month - 1;
date.tm_mday = day;
auto time = std::chrono::system_clock::from_time_t(mktime(&date));
auto duration = time.time_since_epoch();
value_ =
std::chrono::duration_cast<std::chrono::nanoseconds>(duration).count();
}
bool TimeStamp::from_ymd(
std::uint32_t year, std::uint32_t month, std::uint32_t day, TimeStamp *result) {
if (!is_valid_ymd(year, month, day)) {
return false;
}
*result = TimeStamp{year, month, day};
return true;
}
TimeStamp TimeStamp::from_iso_string(const std::string &iso_string) {
auto ptime = datetime::parse_iso_date_time_string(iso_string);
return from_ptime(ptime);
}
std::string TimeStamp::to_iso_string() const {
return boost::posix_time::to_iso_string(to_ptime());
}
std::ostream &operator<<(std::ostream &out, const TimeStamp &ts) noexcept {
out << ts.to_iso_string();
return out;
}
TimeStamp TimeStamp::from_ptime(boost::posix_time::ptime t) {
// time_t is Unix time: number of seconds since epoch Jan 1, 1970
auto epoch_pt =
t - boost::posix_time::ptime(boost::gregorian::date(1970, 1, 1));
auto epoch_nanos = epoch_pt.total_nanoseconds();
return TimeStamp{static_cast<std::uint64_t>(epoch_nanos)};
}
} // namespace bts::core
+212
View File
@@ -0,0 +1,212 @@
#pragma once
#include "bts-system/FMT_IMPL.h"
#include "bts-system/TimeSpan.h"
#include "bts-system/datetime.h"
// #include "lib/utils/bts_assert.h"
// #include "lib/utils/datetime.h"
#include <boost/date_time/posix_time/conversion.hpp>
#include <boost/date_time/posix_time/posix_time_duration.hpp>
#include <boost/date_time/posix_time/ptime.hpp>
#include <boost/date_time/time.hpp>
#include <chrono>
#include <cstdint>
#include <fmt/format.h>
#include <limits>
#include <string>
namespace bts::core {
/**
* @brief Represents time as nano-seconds since the unix epoch (Jan 1, 1970)
*/
class TimeStamp {
public:
constexpr TimeStamp() = default;
explicit constexpr TimeStamp(std::uint64_t value);
// constructs a TimeStamp from a UTC date
explicit TimeStamp(uint32_t year, uint32_t month, uint32_t day);
static constexpr TimeStamp min();
static constexpr TimeStamp max();
static constexpr TimeStamp from_int64(std::int64_t value);
static constexpr TimeStamp from_nanos(std::int64_t value);
static constexpr TimeStamp from_micros(std::int64_t value);
static constexpr TimeStamp from_millis(std::int64_t value);
static constexpr TimeStamp from_seconds(std::int64_t value);
static TimeStamp from_ptime(boost::posix_time::ptime t);
static TimeStamp from_iso_string(const std::string &iso_string);
static bool from_ymd(
std::uint32_t year,
std::uint32_t month,
std::uint32_t day,
TimeStamp *result);
constexpr std::uint64_t nanos() const;
constexpr std::uint64_t micros() const;
constexpr std::uint64_t millis() const;
constexpr std::uint64_t seconds() const;
constexpr double total_millis() const;
constexpr double total_seconds() const;
constexpr std::int64_t to_int64();
inline void to_date(uint32_t &year, uint32_t &month, uint32_t &day);
constexpr boost::posix_time::ptime to_ptime() const;
std::string to_iso_string() const;
// current epoch ns
static uint64_t now_ns() {
#ifndef _WIN32
return datetime::unix_nano_now();
#else
auto now = std::chrono::system_clock::now();
auto ns = std::chrono::duration_cast<std::chrono::nanoseconds>(
now.time_since_epoch())
.count();
return ns;
#endif
}
static TimeStamp now() { return from_nanos(now_ns()); }
private:
// posix time
std::uint64_t value_{};
};
constexpr bool operator==(TimeStamp lhs, TimeStamp rhs) noexcept;
constexpr bool operator!=(TimeStamp lhs, TimeStamp rhs) noexcept;
constexpr bool operator<(TimeStamp lhs, TimeStamp rhs) noexcept;
constexpr bool operator<=(TimeStamp lhs, TimeStamp rhs) noexcept;
constexpr bool operator>(TimeStamp lhs, TimeStamp rhs) noexcept;
constexpr bool operator>=(TimeStamp lhs, TimeStamp rhs) noexcept;
constexpr TimeSpan operator-(TimeStamp lhs, TimeStamp rhs) noexcept;
constexpr TimeStamp operator-(TimeStamp lhs, TimeSpan rhs) noexcept;
constexpr TimeStamp operator+(TimeStamp lhs, TimeSpan rhs) noexcept;
std::ostream &operator<<(std::ostream &out, const TimeStamp &ts) noexcept;
//////////////////////////////////////////////////
// Definition
//////////////////////////////////////////////////
constexpr TimeStamp::TimeStamp(std::uint64_t value) : value_(value) {}
constexpr TimeStamp TimeStamp::min() { return TimeStamp{0}; }
constexpr TimeStamp TimeStamp::max() {
return TimeStamp{std::numeric_limits<std::uint64_t>::max()};
}
constexpr TimeStamp TimeStamp::from_int64(std::int64_t value) {
// bts_assert(value >= 0);
return TimeStamp{static_cast<std::uint64_t>(value)};
}
constexpr TimeStamp TimeStamp::from_nanos(std::int64_t value) {
// bts_assert(value >= 0);
return TimeStamp{static_cast<std::uint64_t>(value)};
}
constexpr TimeStamp TimeStamp::from_micros(std::int64_t value) {
// bts_assert(value >= 0);
constexpr const auto nanos_per_micro = 1'000;
return TimeStamp{static_cast<std::uint64_t>(value * nanos_per_micro)};
}
constexpr TimeStamp TimeStamp::from_millis(std::int64_t value) {
// bts_assert(value >= 0);
constexpr const auto nanos_per_milli = 1'000'000;
return TimeStamp{static_cast<std::uint64_t>(value * nanos_per_milli)};
}
constexpr TimeStamp TimeStamp::from_seconds(std::int64_t value) {
// bts_assert(value >= 0);
constexpr const auto nanos_per_second = 1'000'000'000;
return TimeStamp{static_cast<std::uint64_t>(value * nanos_per_second)};
}
constexpr std::uint64_t TimeStamp::nanos() const { return value_; }
constexpr std::uint64_t TimeStamp::micros() const { return value_ / 1'000; }
constexpr std::uint64_t TimeStamp::millis() const { return value_ / 1'000'000; }
constexpr std::uint64_t TimeStamp::seconds() const {
return value_ / 1'000'000'000;
}
constexpr double TimeStamp::total_millis() const {
return static_cast<double>(value_) / 1000'000;
}
constexpr double TimeStamp::total_seconds() const {
return static_cast<double>(value_) / 1000'000'000;
}
constexpr std::int64_t TimeStamp::to_int64() {
// bts_assert(
// value_ <=
// static_cast<std::int64_t>(std::numeric_limits<std::int64_t>::max()));
return static_cast<std::int64_t>(value_);
}
void TimeStamp::to_date(uint32_t &year, uint32_t &month, uint32_t &day) {
std::uint64_t epoch_secs = value_ / (1000 * 1000 * 1000);
time_t ts_tt(epoch_secs);
struct tm *ptm = gmtime(&ts_tt);
year = ptm->tm_year + 1900;
month = ptm->tm_mon + 1;
day = ptm->tm_mday;
}
constexpr boost::posix_time::ptime TimeStamp::to_ptime() const {
constexpr const auto nanos_per_sec = 1'000'000'000;
constexpr const auto nanos_per_micro = 1'000;
// time_t is Unix time: number of seconds since epoch Jan 1, 1970
std::time_t ts = value_ / nanos_per_sec;
const auto nanos_rem = value_ % nanos_per_sec;
return boost::posix_time::ptime(boost::gregorian::date(1970, 1, 1)) +
boost::posix_time::seconds(static_cast<long>(ts)) +
boost::posix_time::microseconds(nanos_rem / nanos_per_micro);
}
constexpr bool operator==(TimeStamp lhs, TimeStamp rhs) noexcept {
return lhs.nanos() == rhs.nanos();
}
constexpr bool operator!=(TimeStamp lhs, TimeStamp rhs) noexcept {
return lhs.nanos() != rhs.nanos();
}
constexpr bool operator<(TimeStamp lhs, TimeStamp rhs) noexcept {
return lhs.nanos() < rhs.nanos();
}
constexpr bool operator<=(TimeStamp lhs, TimeStamp rhs) noexcept {
return lhs.nanos() <= rhs.nanos();
}
constexpr bool operator>(TimeStamp lhs, TimeStamp rhs) noexcept {
return lhs.nanos() > rhs.nanos();
}
constexpr bool operator>=(TimeStamp lhs, TimeStamp rhs) noexcept {
return lhs.nanos() >= rhs.nanos();
}
constexpr TimeSpan operator-(TimeStamp lhs, TimeStamp rhs) noexcept {
return TimeSpan::from_nanos(lhs.nanos() - rhs.nanos());
}
constexpr TimeStamp operator-(TimeStamp lhs, TimeSpan rhs) noexcept {
return TimeStamp{lhs.nanos() - rhs.nanos()};
}
constexpr TimeStamp operator+(TimeStamp lhs, TimeSpan rhs) noexcept {
return TimeStamp{lhs.nanos() + rhs.nanos()};
}
} // namespace bts::core
FMT_IMPL(bts::core::TimeStamp, t, "{}", t.to_iso_string());
+28
View File
@@ -0,0 +1,28 @@
#pragma once
#define CATCH_AND_LOG(subsys, level, label) \
catch (const std::exception &ex) { \
LOG(subsys, level, label ": {}", std::string{ex.what()}); \
} \
catch (...) { \
LOG(subsys, level, label ": Unknown exception"); \
}
#define CATCH_AND_HANDLE(err_var_name, impl) \
catch (const std::exception &err_var_name##_ex) { \
const auto &err_var_name = err_var_name##_ex.what(); \
impl; \
} \
catch (...) { \
const std::string err_var_name{"Unknown exception"}; \
impl; \
}
// Normalizes 'std::exception' and '...' handlers into single callback
#define CATCH_AND_HANDLE_MSG(impl) \
catch (const std::exception &ex) { \
impl(std::string{ex.what()}); \
} \
catch (...) { \
impl(std::string{"Unknown exception"}); \
}
+4
View File
@@ -0,0 +1,4 @@
#pragma once
#define UNUSED(x) (void)(x)
#define UNUSED_PARAM __attribute__((unused))
@@ -0,0 +1,46 @@
#pragma once
#include <chrono>
#include <csignal>
#include <iostream>
#include <thread>
// #include "lib/logging/logging.h"
#include "bts_debugger.h"
#ifdef _WIN32
#define TERMINATE ::_exit(-1);
#else
#define TERMINATE abort();
#endif
#define bts_assert_msg(EXP, msg) \
do { \
if (!(EXP)) { \
std::cerr << fmt::format("Assert failure: {} {}", std::string(#EXP), \
std::string(msg)) << std::endl; \
std::this_thread::sleep_for(std::chrono::seconds(1)); \
if (is_debugger_present()) \
debug_break(); \
TERMINATE; \
} \
} while (0)
#define bts_assert(EXP) bts_assert_msg(EXP, "")
#define bts_assert_msgf(EXP, msg_template, ...) \
do { \
if (!(EXP)) { \
std::cerr << fmt::format("Assert failure: {} {}", std::string(#EXP), \
fmt::format(msg_template, __VA_ARGS__)) << std::endl; \
std::this_thread::sleep_for(std::chrono::seconds(1)); \
if (is_debugger_present()) \
debug_break(); \
TERMINATE; \
} \
} while (0)
#ifndef NDEBUG
#define bts_assert_d bts_assert
#else
#define bts_assert_d(EXP)
#endif
@@ -0,0 +1,43 @@
#pragma once
// #include "windows_wrapper.h"
#include <csignal>
#include <cstdlib>
#include <cstring>
#include <fcntl.h>
#include <sys/stat.h>
inline bool is_debugger_present() {
#ifdef _WIN32
return IsDebuggerPresent();
#else
char buf[1024];
int debugger_present = 0;
int status_fd = open("/proc/self/status", O_RDONLY);
if (status_fd == -1)
return 0;
ssize_t num_read = read(status_fd, buf, sizeof(buf) - 1);
if (num_read > 0) {
static const char TracerPid[] = "TracerPid:";
char *tracer_pid;
buf[num_read] = 0;
tracer_pid = strstr(buf, TracerPid);
if (tracer_pid)
debugger_present = !!atoi(tracer_pid + sizeof(TracerPid) - 1);
}
return debugger_present;
#endif
}
inline void debug_break() {
#ifdef _WIN32
__debugbreak();
#else
std::raise(SIGINT);
#endif
}
+546
View File
@@ -0,0 +1,546 @@
#include "datetime.h"
#include "TimeStamp.h"
#include "bts-system/TimeSpan.h"
#include "bts_assert.h"
#include <boost/date_time/gregorian/gregorian.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/date_time/posix_time/posix_time_duration.hpp>
#include <sstream>
#include <time.h>
namespace bts {
namespace datetime {
const boost::gregorian::date anchor(1970, boost::gregorian::Jan, 1);
const uint64_t anchor_ticks = 621355968000000000;
const uint64_t micros_per_day = 86400000000;
const uint64_t ticks_per_micro = 10;
const uint64_t ticks_per_day = micros_per_day * ticks_per_micro;
const uint64_t ticks_mask = 0x3FFFFFFFFFFFFFFF;
// DateTimeKinds
const uint64_t KindUnspecified = 0x0000000000000000;
const uint64_t KindUtc = 0x4000000000000000;
const uint64_t KindLocal = 0x8000000000000000;
unsigned long long ptime_to_ll(PTime const &t, uint64_t const &kind) {
uint64_t days = (t.date() - anchor).days();
uint64_t usecs = t.time_of_day().total_microseconds();
uint64_t ticks =
anchor_ticks + usecs * ticks_per_micro + days * ticks_per_day;
return (ticks & ticks_mask) | kind;
}
unsigned long long ptime_to_ll(PTime const &t) {
return ptime_to_ll(t, KindUnspecified);
}
LLDateTime ll_now() {
return ptime_to_ll(
boost::posix_time::microsec_clock::universal_time(), KindUtc);
}
LLDateTime ll_local_now() {
return ptime_to_ll(
boost::posix_time::microsec_clock::local_time(), KindLocal);
}
long unix_now() {
return (boost::posix_time::microsec_clock::universal_time() - PTime(anchor))
.total_microseconds() /
(long)1E6;
}
std::chrono::system_clock::time_point utc_ll_to_timepoint(
unsigned long long ll) {
auto us_since_epoch = ((ll & ticks_mask) - anchor_ticks) / ticks_per_micro;
return std::chrono::system_clock::time_point(
std::chrono::microseconds(us_since_epoch));
}
long long ll_diff_in_us(unsigned long long ll1, unsigned long long ll2) {
#ifndef NO_CPP0X
auto p1 = ll_to_ptime(ll1);
auto p2 = ll_to_ptime(ll2); // NOLINT
return (p2 - p1).total_microseconds();
#else
return 0;
#endif
}
long long ll_diff_in_seconds(unsigned long long ll1, unsigned long long ll2) {
#ifndef NO_CPP0X
auto p1 = ll_to_ptime(ll1);
auto p2 = ll_to_ptime(ll2); // NOLINT
return (p2 - p1).total_seconds();
#else
return 0;
#endif
}
long long ptime_diff_in_us(PTime const &t1, PTime const &t2) {
return (t1 - t2).total_microseconds();
}
long long ptime_diff_in_ms(PTime const &t1, PTime const &t2) {
return (t1 - t2).total_milliseconds();
}
long long ptime_diff_in_secs(PTime const &t1, PTime const &t2) {
return (t1 - t2).total_seconds();
}
PTime timestamp_to_ptime(core::TimeStamp const &t) {
auto now_ts = core::TimeStamp::now();
auto now = datetime::local_now();
auto delta = (now_ts - t).micros();
return now - boost::posix_time::microseconds(delta);
}
core::TimeStamp ptime_to_timestamp(PTime const &t) {
auto now_ts = core::TimeStamp::now();
auto now = datetime::now();
auto delta = (now - t).total_milliseconds();
auto delta_tspan = core::TimeSpan::from_millis(delta);
return now_ts - delta_tspan;
}
long long usecs_since(PTime const &t1) {
return (boost::posix_time::microsec_clock::universal_time() - t1)
.total_microseconds();
}
long long msecs_since(PTime const &t1) {
return (boost::posix_time::microsec_clock::universal_time() - t1)
.total_milliseconds();
}
PTime now() { return boost::posix_time::microsec_clock::universal_time(); }
PTime local_now() { return boost::posix_time::microsec_clock::local_time(); }
PTime make_ptime(int year, int month, int day) {
// January=1
bts_assert_d(month > 0);
boost::gregorian::date dt(year, boost::gregorian::greg_month(month), day);
return PTime(dt);
}
PTime make_ptime(
int year,
int month,
int day,
int hour,
int minute,
int second,
int millisecond) {
boost::gregorian::date dt(year, boost::gregorian::greg_month(month), day);
return PTime(
dt, boost::posix_time::time_duration(hour, minute, second) +
boost::posix_time::milliseconds(millisecond));
}
PTime ll_to_ptime(LLDateTime ll) {
ll &= ticks_mask;
uint64_t ticks_part = ll % ticks_per_day;
uint64_t days_part = (ll - anchor_ticks) / ticks_per_day;
return PTime(
anchor + boost::gregorian::date_duration(days_part),
boost::posix_time::time_duration(
boost::posix_time::microseconds(ticks_part / ticks_per_micro)));
}
extern "C" BTS_EXPORT int ll_to_cstr(
LLDateTime ll, char *buffer, int buffer_sz) {
const int str_sz = sizeof("20121204-14:44:02.000");
bts_assert(buffer_sz >= str_sz);
auto str = FIX_timestamp(ll_to_ptime(ll));
bts_assert(str.size() == str_sz - 1);
memcpy(buffer, &str[0], str.size());
buffer[str.size()] = '\0';
return str.size();
}
std::string time_string(PTime const &t) {
int hours = t.time_of_day().hours();
int minutes = t.time_of_day().minutes();
int seconds = t.time_of_day().seconds();
int whole_ms = seconds * 1000 + minutes * 1000 * 60 + hours * 1000 * 60 * 60;
int frac_ms = t.time_of_day().total_milliseconds() - whole_ms;
std::ostringstream out;
out << std::setw(2) << std::setfill('0') << hours << ":" << std::setw(2)
<< std::setfill('0') << minutes << ":" << std::setw(2)
<< std::setfill('0') << seconds << "." << std::setw(3)
<< std::setfill('0') << frac_ms;
return out.str();
}
std::string date_string(PTime const &t) {
std::string result(10, ' ');
sprintf(
&result[0], "%02d/%02d/%04d", t.date().month().as_number(),
t.date().day().as_number(), (unsigned short)t.date().year());
return result;
}
std::string iso_date_time_string(PTime const &t) {
return boost::posix_time::to_iso_extended_string(t);
}
PTime parse_iso_date_time_tz(const std::string &date) {
// example 1) 2022-10-27T09:30-5:00
// example 2) 2022-10-27T09:30+5:00
#ifdef _WIN32
struct tm tt = {0, 0, 0, 0, 0, 0, 0, 0, 0};
#else
struct tm tt = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
#endif
int tz_hours;
int tz_minutes;
int num_scanned = sscanf(
date.c_str(), "%4d-%2d-%2dT%2d:%2d:%2d%3d:%2d", &tt.tm_year, &tt.tm_mon,
&tt.tm_mday, &tt.tm_hour, &tt.tm_min, &tt.tm_sec, &tz_hours,
&tz_minutes);
bts_assert_msgf(
num_scanned == 8,
"Failed to parse iso8601 date from string '{}' (format must be "
"YYYY-MM-DDThh:mm:ss<+/->hh:ss)",
date);
tt.tm_mon -= 1;
tt.tm_year -= 1900;
tt.tm_isdst = -1;
return boost::posix_time::ptime_from_tm(tt) +
boost::posix_time::time_duration{tz_hours, tz_minutes, 0, 0};
}
PTime parse_iso_date_time_string(std::string const &t) {
constexpr const std::size_t time_idx = sizeof("YYYY-MM-DD") - 1;
auto actual_time_idx = t.find('T', time_idx);
if (actual_time_idx != std::string::npos) {
constexpr const std::size_t time_zone_idx =
time_idx + sizeof("HH:MM") - 1;
// time zone must be after time
bts_assert(actual_time_idx < time_zone_idx);
if (t.find('+', time_zone_idx) != std::string::npos ||
t.find('-', time_zone_idx) != std::string::npos) {
// date, time, and time zone
return parse_iso_date_time_tz(t);
}
// date and time (no time zone)
return boost::posix_time::from_iso_extended_string(t);
}
// date (no time or time zone)
return PTime{boost::gregorian::from_simple_string(t)};
}
std::string simple_date_time_string(PTime const &t) {
return boost::posix_time::to_simple_string(t);
}
PTime parse_simple_date_time_string(std::string const &t) {
if (t.find(' ') == t.npos)
return boost::posix_time::time_from_string(t + " 00:00:00");
else
return boost::posix_time::time_from_string(t);
}
PDuration parse_duration(std::string const &time_str) {
try {
return boost::posix_time::duration_from_string(time_str);
} catch (boost::bad_lexical_cast &) {
bts_assert(false);
return boost::posix_time::time_duration();
}
}
std::string FIX_date_time_string(PTime const &t) {
std::string result(strlen("20121204-14:44:02"), ' ');
sprintf(
&result[0], "%d%02d%02d-%02d:%02d:%02d", (unsigned short)t.date().year(),
t.date().month().as_number(), t.date().day().as_number(),
(int)t.time_of_day().hours(), (int)t.time_of_day().minutes(),
(int)t.time_of_day().seconds());
return result;
}
void FIX_timestamp(PTime const &t, std::string *out) {
int hours = t.time_of_day().hours();
int minutes = t.time_of_day().minutes();
int seconds = t.time_of_day().seconds();
int whole_ms = seconds * 1000 + minutes * 1000 * 60 + hours * 1000 * 60 * 60;
int frac_ms = t.time_of_day().total_milliseconds() - whole_ms;
out->resize(sizeof("20121204-14:44:02.000"));
#ifdef _WIN32
_snprintf(
&(*out)[0], out->size(), "%04d%02d%02d-%02d:%02d:%02d.%03d",
(int)t.date().year(), t.date().month().as_number(),
t.date().day().as_number(), hours, minutes, seconds, frac_ms);
#else
snprintf(
&(*out)[0], out->size(), "%04d%02d%02d-%02d:%02d:%02d.%03d",
(int)t.date().year(), t.date().month().as_number(),
t.date().day().as_number(), hours, minutes, seconds, frac_ms);
#endif
out->resize(out->size() - 1);
}
std::string FIX_timestamp(PTime const &t) {
std::string result;
FIX_timestamp(t, &result);
return result;
}
bool is_from_today(PTime const &time) {
return (
time.date() ==
boost::posix_time::microsec_clock::universal_time().date());
}
bool is_at_least_msecs_old(PTime const &time, uint64_t ms) {
PTime now = boost::posix_time::microsec_clock::universal_time();
return (now - time).total_milliseconds() >= (int64_t)ms;
}
bool is_at_least_secs_old(PTime const &time, uint64_t sec) {
PTime now = boost::posix_time::microsec_clock::universal_time();
return (now - time).total_seconds() >= (int64_t)sec;
}
bool is_at_least_mins_old(PTime const &time, uint64_t mins) {
PTime now = boost::posix_time::microsec_clock::universal_time();
return ((now - time).total_seconds() / 60) >= (int64_t)mins;
}
bool is_at_least_hours_old(PTime const &time, uint64_t hours) {
PTime now = boost::posix_time::microsec_clock::universal_time();
int64_t secs = (int64_t)((now - time).total_seconds());
return (secs / 60 / 60) >= (int64_t)hours;
}
bool is_at_least_days_old(PTime const &time, uint64_t days) {
return is_at_least_hours_old(time, days * 24);
}
LLDateTime ll_from_unix_epoch(long seconds) {
PTime result(anchor, boost::posix_time::seconds(seconds));
return ptime_to_ll(result, KindUnspecified);
}
LLDateTime ll_from_unix_epoch_ms(long long milliseconds) {
PTime result(anchor, boost::posix_time::millisec(milliseconds));
return ptime_to_ll(result, KindUnspecified);
}
void ll_to_parts(
LLDateTime ll_time,
int &year,
int &month,
int &day,
int &hour,
int &minute,
int &second,
int &millisecond) {
PTime t = ll_to_ptime(ll_time);
year = t.date().year();
month = t.date().month();
day = t.date().day();
hour = t.time_of_day().hours();
minute = t.time_of_day().minutes();
second = t.time_of_day().seconds();
int whole_ms = second * 1000 + minute * 1000 * 60 + hour * 1000 * 60 * 60;
millisecond = t.time_of_day().total_milliseconds() - whole_ms;
}
LLDateTime ll_from_parts(
int year,
int month,
int day,
int hour,
int minute,
int second,
int millisecond) {
return ptime_to_ll(make_ptime(
year, month, day, hour, minute, second, millisecond)); // NOLINT
}
LLDateTime ll_from_date(const Date &date) {
if (date.year == 0 && date.day == 0 && date.month == 0) {
return 0;
}
return ll_from_parts(date.year, date.month, date.day, 0, 0, 0, 0);
}
Date ll_to_date(LLDateTime time) {
Date date;
int year, month, day, unused;
ll_to_parts(time, year, month, day, unused, unused, unused, unused);
date.year = year;
date.month = month;
date.day = day;
return date;
}
bool is_local_time_sunday() {
auto now = local_now();
return now.date().day_of_week() == boost::date_time::Sunday;
}
bool is_local_time_between(int hh_start, int mm_start, int hh_end, int mm_end) {
using namespace boost::posix_time;
auto now = local_now();
auto start = ptime(now.date(), hours(hh_start) + minutes(mm_start));
auto end = ptime(now.date(), hours(hh_end) + minutes(mm_end));
return (now >= start && now <= end);
}
struct UtcTimeStamp {
int hour;
int min;
int sec;
int msec;
int day;
int month;
int year;
};
struct UtcTimeStampConvertor {
static UtcTimeStamp convert(const std::string &value) {
bool haveMilliseconds = false;
switch (value.size()) {
case 21:
haveMilliseconds = true;
case 17:
break;
default:
bts_assert(false);
}
int i = 0;
int c = 0;
for (c = 0; c < 8; ++c)
if (!isdigit(value[i++]))
bts_assert(false);
if (value[i++] != '-')
bts_assert(false);
for (c = 0; c < 2; ++c)
if (!isdigit(value[i++]))
bts_assert(false);
if (value[i++] != ':')
bts_assert(false);
for (c = 0; c < 2; ++c)
if (!isdigit(value[i++]))
bts_assert(false);
if (value[i++] != ':')
bts_assert(false);
for (c = 0; c < 2; ++c)
if (!isdigit(value[i++]))
bts_assert(false);
if (haveMilliseconds) {
if (value[i++] != '.')
bts_assert(false);
for (c = 0; c < 3; ++c)
if (!isdigit(value[i++]))
bts_assert(false);
}
int year, mon, mday, hour, min, sec, millis;
i = 0;
year = value[i++] - '0';
year = 10 * year + value[i++] - '0';
year = 10 * year + value[i++] - '0';
year = 10 * year + value[i++] - '0';
mon = value[i++] - '0';
mon = 10 * mon + value[i++] - '0';
if (mon < 1 || 12 < mon)
bts_assert(false);
mday = value[i++] - '0';
mday = 10 * mday + value[i++] - '0';
if (mday < 1 || 31 < mday)
bts_assert(false);
++i; // skip '-'
hour = value[i++] - '0';
hour = 10 * hour + value[i++] - '0';
// No check for >= 0 as no '-' are converted here
if (23 < hour)
bts_assert(false);
++i; // skip ':'
min = value[i++] - '0';
min = 10 * min + value[i++] - '0';
// No check for >= 0 as no '-' are converted here
if (59 < min)
bts_assert(false);
++i; // skip ':'
sec = value[i++] - '0';
sec = 10 * sec + value[i++] - '0';
// No check for >= 0 as no '-' are converted here
if (60 < sec)
bts_assert(false);
if (haveMilliseconds) {
millis =
(100 * (value[i + 1] - '0') + 10 * (value[i + 2] - '0') +
(value[i + 3] - '0'));
} else
millis = 0;
return UtcTimeStamp{hour, min, sec, millis, mday, mon, year};
}
};
PTime parse_FIX_timestamp(const std::string &ts_str) {
auto ts = UtcTimeStampConvertor::convert(ts_str);
boost::gregorian::date dt(ts.year, ts.month, ts.day);
// fucking boost. unbelieavable.
auto ticks_per_second =
boost::posix_time::time_duration::rep_type::res_adjust();
boost::posix_time::time_duration td(
ts.hour, ts.min, ts.sec, ts.msec * (ticks_per_second / 1000));
return PTime(dt, td);
}
#ifndef NO_CPP0X
extern "C" BTS_EXPORT LLDateTime ll_today() {
return datetime::ll_from_date(today());
}
BTS_EXPORT Date today() {
auto now = datetime::now();
Date date;
date.year = now.date().year();
date.month = now.date().month();
date.day = now.date().day();
return date;
}
BTS_EXPORT Date add_days(Date indate, int days) {
boost::gregorian::date dt(indate.year, indate.month, indate.day);
auto adjusted_dt = dt + boost::gregorian::days(days);
Date date(adjusted_dt.year(), adjusted_dt.month(), adjusted_dt.day());
return date;
}
extern "C" BTS_EXPORT LLDateTime ll_yesterday() {
auto now = datetime::now() - boost::gregorian::days(1);
return datetime::ll_from_parts(
now.date().year(), now.date().month(), now.date().day(), 0, 0, 0, 0);
}
#endif
} // namespace datetime
} // namespace bts
+168
View File
@@ -0,0 +1,168 @@
#pragma once
// #include "bts_export.h"
#include <chrono>
#include <string>
// #include "windows_wrapper.h" // tick_count.h includes windows.h
namespace boost {
namespace posix_time {
class ptime;
}
} // namespace boost
namespace boost:: posix_time {
class time_duration;
} // namespace boost
namespace bts::core {
class TimeStamp;
}
namespace bts {
namespace datetime {
typedef boost::posix_time::ptime PTime;
typedef boost::posix_time::time_duration PDuration;
#ifndef BTS_EXPORT
#define BTS_EXPORT
#endif
typedef unsigned long long LLDateTime;
// Simple Date structure
struct Date {
Date() : year(0), month(0), day(0) {}
Date(uint16_t y, uint8_t m, uint8_t d) : year(y), month(m), day(d) {}
Date(uint16_t date)
: year((date >> 9) + 1970), month(date >> 5 & 15), day(date & 31) {}
uint16_t year;
uint8_t month;
uint8_t day;
bool operator<(const Date &other) const {
if (year < other.year)
return true;
if (year == other.year && month < other.month)
return true;
if (year == other.year && month == other.month && day < other.day)
return true;
return false;
}
bool operator>(const Date &other) const {
return !(*this == other) && !(*this < other);
}
bool operator==(const Date &other) const {
return day == other.day && month == other.month && year == other.year;
}
bool operator!=(const Date &other) const { return !(*this == other); }
uint16_t to_short() {
return ((year - 1970) << 9) + (month << 5) + day;
} // NOLINT
};
// extern "C" BTS_EXPORT LLDateTime ll_now();
extern "C" LLDateTime ll_local_now();
extern "C" double OA_date_from_ll(LLDateTime ll);
extern "C" LLDateTime ll_from_OA_date(double oa_date);
extern "C" long unix_now();
#ifndef _WIN32
inline uint64_t unix_nano_now() {
struct timespec ts;
// CLOCK_REALTIME is already anchored at the unix epoch
clock_gettime(CLOCK_REALTIME, &ts);
return static_cast<int64_t>(1000000000UL) * static_cast<int64_t>(ts.tv_sec) +
static_cast<int64_t>(ts.tv_nsec);
}
#endif
// BTS_EXPORT std::chrono::system_clock::time_point
// utc_ll_to_timepoint(unsigned long long ll);
BTS_EXPORT PTime now();
BTS_EXPORT PTime local_now();
// BTS_EXPORT PTime make_ptime(int year, int month, int day);
// BTS_EXPORT PTime make_ptime(
// int year,
// int month,
// int day,
// int hour,
// int minute,
// int second,
// int millisecond);
LLDateTime ptime_to_ll(PTime const &t);
PTime ll_to_ptime(LLDateTime ll);
// extern "C" BTS_EXPORT int
// ll_to_cstr(LLDateTime ll, char *buffer, int buffer_sz);
// BTS_EXPORT long long
// ll_diff_in_us(unsigned long long start, unsigned long long stop);
// BTS_EXPORT long long
// ll_diff_in_seconds(unsigned long long start, unsigned long long stop);
long long ptime_diff_in_us(PTime const &t1, PTime const &t2);
long long ptime_diff_in_ms(PTime const &t1, PTime const &t2);
long long ptime_diff_in_secs(PTime const &t1, PTime const &t2);
PTime timestamp_to_ptime(core::TimeStamp const &t);
core::TimeStamp ptime_to_timestamp(PTime const &t);
long long usecs_since(PTime const &t1);
long long msecs_since(PTime const &t1);
std::string time_string(PTime const &t);
std::string date_string(PTime const &t);
std::string iso_date_time_string(PTime const &t);
PTime parse_iso_date_time_string(std::string const &t);
PTime parse_iso_date_time_tz(const std::string &date);
std::string simple_date_time_string(PTime const &t);
PTime parse_simple_date_time_string(std::string const &t);
PDuration parse_duration(std::string const &time_str);
std::string FIX_date_time_string(PTime const &t);
PTime parse_FIX_timestamp(const std::string &ts);
std::string FIX_timestamp(PTime const &t);
void FIX_timestamp(PTime const &t, std::string *out);
bool is_from_today(PTime const &time);
bool is_at_least_msecs_old(PTime const &time, uint64_t ms);
bool is_at_least_secs_old(PTime const &time, uint64_t sec);
bool is_at_least_mins_old(PTime const &time, uint64_t min);
bool is_at_least_hours_old(PTime const &time, uint64_t hour);
bool is_at_least_hours_old(PTime const &time, uint64_t hour);
bool is_at_least_days_old(PTime const &time, uint64_t days);
LLDateTime ll_from_unix_epoch(long);
LLDateTime ll_from_unix_epoch_ms(long long);
// extern "C" BTS_EXPORT void ll_to_parts(
// LLDateTime,
// int &year,
// int &month,
// int &day,
// int &hour,
// int &minute,
// int &second,
// int &millisecond);
// BTS_EXPORT Date ll_to_date(LLDateTime);
// extern "C" BTS_EXPORT LLDateTime ll_from_parts(
// int year,
// int month,
// int day,
// int hour,
// int minute,
// int second,
// int millisecond);
// BTS_EXPORT LLDateTime ll_from_date(const Date &date);
bool is_local_time_sunday();
bool is_local_time_between(int hh_start, int mm_start, int hh_end, int mm_end);
#ifndef NO_CPP0X
// extern "C" BTS_EXPORT LLDateTime ll_today();
BTS_EXPORT Date today();
// BTS_EXPORT Date add_days(Date date, int days);
// extern "C" BTS_EXPORT LLDateTime ll_yesterday();
#endif
} // namespace datetime
} // namespace bts
// namespace std {
// template <>
// struct numeric_limits<bts::datetime::Date> {
// static bts::datetime::Date min() { return
// bts::datetime::Date(1970,1,1); } static bts::datetime::Date max() {
// return bts::datetime::Date(2097,12,31); }
// };
// }
+10
View File
@@ -0,0 +1,10 @@
#pragma once
#include <fmt/format.h>
#include <iomanip>
#include <iostream>
#define LOG(subsys, level, msg_template, ...) \
std::cerr << std::setw(8) << #subsys << " | " << std::setw(8) << #level \
<< " | " << fmt::format(msg_template, __VA_ARGS__) << std::endl
@@ -0,0 +1,176 @@
#pragma once
#include <cstring>
#include <functional>
#include <iomanip>
#include <ostream>
#include <tuple>
#include <vector>
namespace bts::system {
class TableFormatter {
public:
template <class T>
using Schema =
std::vector<std::tuple<std::string, int, std::function<std::string(T)>>>;
template <class T, class Range>
static std::ostream &format(
std::ostream &out, const Range &range, const Schema<T> &schema);
template <class T, class TIter>
static std::ostream &format(
std::ostream &out, TIter first, TIter last, const Schema<T> &schema);
template <class T>
static std::ostream &format_record(
std::ostream &out,
const T &record,
const Schema<T> &schema,
bool headers = false);
template <class TRow>
class SchemaBuilder {
public:
Schema<TRow> result;
template <class GetCell>
void add(std::string name, GetCell get_cell, int width = 0);
};
};
//////////////////////////////////////////////////
// Definition
//////////////////////////////////////////////////
template <class TRow>
template <class GetCell>
inline void TableFormatter::SchemaBuilder<TRow>::add(
std::string name, GetCell get_cell, int width) {
std::function<std::string(TRow)> get_cell_str = [&get_cell](const TRow &r) {
std::stringstream ss;
ss << get_cell(r);
return ss.str();
};
result.emplace_back(std::move(name), width, get_cell_str);
}
template <class T, class Range>
std::ostream &TableFormatter::format(
std::ostream &out, const Range &range, const Schema<T> &schema) {
return format(out, range.begin(), range.end(), schema);
}
template <class T, class TIter>
inline std::ostream &TableFormatter::format(
std::ostream &out,
TIter first,
TIter last,
const typename TableFormatter::Schema<T> &schema) {
if (first == last || schema.size() == 0) return out;
int total_width = 0;
for (auto col : schema) {
total_width += std::get<1>(col);
}
// top border of table
for (int i = 0; i < total_width + static_cast<int>(schema.size()); i++) {
out << "-";
}
out << std::endl;
// column headers themselves
out << "|";
for (auto col : schema) {
out << std::setw(std::get<1>(col)) << std::get<0>(col) << "|";
}
// line between column headers and rows
out << std::endl;
for (int i = 0; i < total_width + static_cast<int>(schema.size()); i++) {
out << "-";
}
// rows
while (first != last) {
out << std::endl;
out << "|";
for (uint32_t i = 0; i < schema.size(); i++) {
out << std::setw(std::get<1>(schema[i]))
<< std::get<2>(schema[i])(*first) << "|";
}
first++;
}
// bottom border of table
out << std::endl;
for (int i = 0; i < total_width + static_cast<int>(schema.size()); i++)
out << "-";
return out;
}
template <class T>
inline std::ostream &TableFormatter::format_record(
std::ostream &out,
const T &record,
const typename TableFormatter::Schema<T> &schema,
bool headers) {
constexpr const char *const field_header = "Field";
constexpr const char *const value_header = "Value";
int ulabel_width = headers ? strlen(field_header) : 0;
for (const auto &field : schema) {
auto label_width = std::get<1>(field);
if (label_width == 0) {
label_width = static_cast<int>(std::get<0>(field).size());
}
if (label_width > ulabel_width) {
ulabel_width = label_width;
}
}
std::vector<std::string> field_vals;
for (const auto &field : schema) {
field_vals.push_back(std::get<2>(field)(record));
}
int uvalue_width = headers ? strlen(value_header) : 0;
for (const auto &v : field_vals) {
auto value_width = static_cast<int>(v.size());
if (value_width > uvalue_width) {
uvalue_width = value_width;
}
}
int table_width = ulabel_width + uvalue_width + 4;
if (headers) {
// top border of table
for (int i = 0; i < table_width + 3; i++) {
out << "-";
}
out << std::endl;
// column headers
out << "| " << std::setw(ulabel_width) << field_header << " | "
<< std::setw(uvalue_width) << value_header << " |\n";
}
// border between col headers and rows (or top border of table, if 'headers'
// is false)
for (int i = 0; i < table_width + 3; i++) {
out << "-";
}
// rows
for (std::size_t i = 0; i < field_vals.size(); i++) {
out << "\n";
const auto &label = std::get<0>(schema.at(i));
const auto &val = field_vals.at(i);
out << "| " << std::setw(ulabel_width) << label << " | "
<< std::setw(uvalue_width) << val << " |";
}
out << "\n";
// bottom border of table
for (int i = 0; i < table_width + 3; i++) {
out << "-";
}
return out;
}
} // namespace bts::core