diff --git a/src/lib/orderman/orderman_utils/Formatter.h b/src/lib/orderman/orderman_utils/Formatter.h new file mode 100644 index 000000000..4fab06f1d --- /dev/null +++ b/src/lib/orderman/orderman_utils/Formatter.h @@ -0,0 +1,300 @@ +#pragma once +#include "lib/api/services/OrderService.pb.h" +#include "lib/config/protos/MarketData.pb.h" +#include "lib/domain_model/common.h" +#include "lib/md/PriceSize.h" +#include "lib/orderman/orderman_utils/Book.h" +#include "lib/orderman/orders/algo/IAlgoOrder.h" +#include "lib/utils/PBUtils.h" +#include +#include +#include +#include + +namespace bts { +namespace orderman { +struct Formatter { + using Side = bts::api::Side; + // this is a placeholder for other book formats down the road. + enum class BookFormat { BBO = 1 }; + enum class Tense { + Present, + Preterite + }; + + template + inline static void concat(std::ostream& ostr, T v) { + ostr << v; + } + + template + inline static void concat(std::ostream& ostr, T first, Args... args) { + ostr << first; + (concat(ostr, args), ...); + } + + template + inline static std::string fmt(T curr) { + std::stringstream str; + str << curr; + return str.str(); + } + + template + inline static std::string fmt(T curr, Args... next) { + std::stringstream str; + concat(str, curr, next...); + return str.str(); + } + + template + static std::string fmt_values(const std::map& map) { + if (map.empty()) + return "None"; + std::stringstream str; + auto it = map.begin(); + str << it->second; + while (++it != map.end()) { + str << ", " << it->second; + } + return str.str(); + } + + template + static std::string fmt_values(const std::vector& values) { + if (values.empty()) + return "None"; + std::stringstream str; + auto it = values.begin(); + str << *it; + while (++it != values.end()) { + str << ", " << *it; + } + return str.str(); + } + + static std::string fmt_fill(Side side, uint32_t qty, double price) { + std::stringstream ostr; + ostr << to_string(side, Tense::Preterite) << " " << qty << " @ " << price; + return ostr.str(); + } + + static std::string fmt_order(Side side, uint32_t qty, double price) { + std::stringstream ostr; + ostr << to_string(side) << " " << qty << " @ " << price; + return ostr.str(); + } + + static std::string fmt_order(OrderKey key, uint32_t qty, double price, const api::orderman::OrderDefinition& def) { + std::stringstream ostr; + ostr << key << " " << to_string(def.side()) << " " << qty << " @ " + << price << std::endl << "[Def]" << utils::pb::to_string(def); + return ostr.str(); + } + + static std::string fmt_order(OrderKey key, Side side, uint32_t qty, double price, ChildState state) { + std::stringstream ostr; + ostr << key << " " << to_string(side) << " " << qty << " @ " << price + << " " << to_string(state); + return ostr.str(); + } + +private: + template + inline static void join_next(std::stringstream&, std::string) { } + + template + inline static void join_next(std::stringstream&, std::function) { } + + template + inline static void join_next(std::stringstream& str, std::string separator, T curr) { + str << separator << curr; + } + + template + inline static void join_next(std::stringstream& str, std::function get_separator, T curr) { + str << get_separator() << curr; + } + + template + inline static void join_next(std::stringstream& str, std::string separator, T curr, Args... next) { + str << separator << curr; + (join_next(str, separator, next), ...); + } + + template + inline static void join_next(std::stringstream& str, std::function get_separator, T curr, Args... next) { + str << get_separator() << curr; + (join_next(str, get_separator, next), ...); + } + +public: + template + inline static std::string join(std::string separator, T curr) { + std::stringstream str; + str << curr; + return str.str(); + } + + template + inline static std::string join(std::string separator, T curr, Next... next) { + std::stringstream str; + str << curr; + join_next(str, separator, next...); + return str.str(); + } + + template + inline static std::string join(std::function get_separator, T curr, Next... next) { + std::stringstream str; + str << curr; + join_next(str, get_separator, next...); + return str.str(); + } + + template + static std::string to_string(const T& value) { + std::stringstream str; + str << value; + return str.str(); + } + + static std::string to_string(bool value) { + return value ? "true" : "false"; + } + + static std::string to_string(Side side, Tense tense = Tense::Present) { + switch (side) { + case bts::api::SIDE_BUY: + switch (tense) { + case Tense::Preterite: + return "Bought"; + case Tense::Present: + default: + return "Buy"; + } + case bts::api::SIDE_SELL: + switch (tense) { + case Tense::Preterite: + return "Sold"; + case Tense::Present: + default: + return "Sell"; + } + default: + return fmt("Side_", static_cast(side)); + } + } + + static std::string to_string(ChildStatus value) { + switch (value) { + case ChildStatus::WORKING: return "Working"; + case ChildStatus::COMPLETED: return "Completed"; + case ChildStatus::CANCELED: return "Canceled"; + default: return fmt("ChildStatus_", static_cast(value)); + } + } + + static std::string to_string(ChildState value) { + std::stringstream ostr; + ostr << "[" << to_string(value.status) << "] " + << value.quantity.value() << " @ " << value.price.value() + << "(total filled " << value.total_fills.value() << " @[avg] " + << value.avg_price.value() << ", last filled " + << value.last_fills.value() << " @ " + << value.last_price.value() << ")"; + return ostr.str(); + } + + static std::string to_string(const Book &book) { + return to_string(book, BookFormat::BBO); + } + + static std::string to_string(const Book &book, BookFormat format) { + // add other impls as needed + std::stringstream ostr; + switch (format) { + case BookFormat::BBO: + if (book.bid().size() > 0 && !book.bid().at(0).is_nan()) { + auto best_bid = book.bid().at(0); + ostr << best_bid.size() << "@" << best_bid.price(); + } else { + ostr << "N/A"; + } + ostr << " <> "; + if (book.ask().size() > 0 && !book.ask().at(0).is_nan()) { + auto best_ask = book.ask().at(0); + ostr << best_ask.size() << "@" << best_ask.price(); + } else { + ostr << "N/A"; + } + break; + default: + break; + } + return ostr.str(); + } + + static std::string to_string(api::orderman::OrderError error) { + switch (error) { + case api::orderman::ORDER_ERROR_UNDEFINED: return "ORDER_ERROR_UNDEFINED"; + case api::orderman::ORDER_ERROR_UNSUPPORTED_ORDER_TYPE: return "ORDER_ERROR_UNSUPPORTED_ORDER_TYPE"; + case api::orderman::ORDER_ERROR_GATEWAY_NOT_READY: return "ORDER_ERROR_GATEWAY_NOT_READY"; + case api::orderman::ORDER_ERROR_UNKNOWN_ORDER: return "ORDER_ERROR_UNKNOWN_ORDER"; + case api::orderman::ORDER_ERROR_UNKNOWN_SECURITY: return "ORDER_ERROR_UNKNOWN_SECURITY"; + case api::orderman::ORDER_ERROR_ORDER_NOT_ACK: return "ORDER_ERROR_ORDER_NOT_ACK"; + case api::orderman::ORDER_ERROR_SERVER_NOT_READY: return "ORDER_ERROR_SERVER_NOT_READY"; + case api::orderman::ORDER_ERROR_OK: return "ORDER_ERROR_OK"; + case api::orderman::ORDER_ERROR_OP_NOT_SUPPORTED: return "ORDER_ERROR_OP_NOT_SUPPORTED"; + case api::orderman::ORDER_ERROR_INVALID_OP: return "ORDER_ERROR_INVALID_OP"; + case api::orderman::ORDER_ERROR_LIMIT_BREACH: return "ORDER_ERROR_LIMIT_BREACH"; + case api::orderman::ORDER_ERROR_MESSAGING_LIMIT_BREACH: return "ORDER_ERROR_MESSAGING_LIMIT_BREACH"; + case api::orderman::ORDER_ERROR_UNAUTHORIZED: return "ORDER_ERROR_UNAUTHORIZED"; + case api::orderman::ORDER_ERROR_INVALID_ORDER_DEFINITON: return "ORDER_ERROR_INVALID_ORDER_DEFINITON"; + case api::orderman::ORDER_ERROR_UNEXPECTED_CHILD_STATE: return "ORDER_ERROR_UNEXPECTED_CHILD_STATE"; + case api::orderman::ORDER_ERROR_INVALID_PARAMETER: return "ORDER_ERROR_INVALID_PARAMETER"; + default: return fmt("OrderError_", static_cast(error)); + } + } + + static std::string to_string(api::orderman::CustomOrderDefinition::CustomCase algo_type) { + switch (algo_type) { + case api::orderman::CustomOrderDefinition::CustomCase::kLimit: return "Limit"; + case api::orderman::CustomOrderDefinition::CustomCase::kOffset: return "Offset"; + case api::orderman::CustomOrderDefinition::CustomCase::kCover: return "Cover"; + case api::orderman::CustomOrderDefinition::CustomCase::kIceberg: return "Iceberg"; + default: return fmt("AlgoType_", static_cast(algo_type)); + } + } +}; + +// << operators +inline std::ostream &operator<<(std::ostream &ostr, const api::Side &side) { + ostr << Formatter::to_string(side); + return ostr; +} + +inline std::ostream &operator<<(std::ostream &ostr, const ChildStatus &child_status) { + ostr << Formatter::to_string(child_status); + return ostr; +} + +inline std::ostream &operator<<(std::ostream &ostr, const ChildState &child_state) { + ostr << "[" << child_state.status << "] " << child_state.quantity.value() + << " @ " << child_state.price.value() << "(filled " + << child_state.total_fills.value() << " @avg " + << child_state.avg_price.value() << ")"; + return ostr; +} + +inline std::ostream& operator<<(std::ostream& ostr, const bts::Price& price) { + ostr << price.value(); + return ostr; +} + +inline std::ostream& operator<<(std::ostream& ostr, const bts::Quantity& quantity) { + ostr << quantity.value(); + return ostr; +} +} // namespace orderman +} // namespace bts