#include "OrderBuilder.h" namespace bts::orderman { using bts::api::orderman::OrderDefinition; using std::size_t; std::atomic OrderBuilder::_current_builder_id(0); struct OrderBuilder::PImpl { PImpl() : parent_key(null_order_key()), definition(), reserve_sz(0), order_stash(), builder_id(), order_services(nullptr) {} PImpl( OrderKey parent_key, const api::orderman::OrderDefinition &def, IOrderFactory &factory, std::size_t reserve_sz = 1) : parent_key(parent_key), definition(def), reserve_sz(reserve_sz), order_stash(), builder_id(++_current_builder_id), order_services(nullptr) { bts_assert(parent_key != null_order_key()); while (order_stash.size() != reserve_sz) order_stash.push_back(&factory.create(parent_key, definition)); } PImpl( OrderKey parent_key, const api::orderman::OrderDefinition &def, std::size_t reserve_sz = 1) : parent_key(parent_key), definition(def), reserve_sz(reserve_sz), order_stash(), builder_id(++_current_builder_id), order_services(nullptr) { bts_assert(parent_key != null_order_key()); } PImpl &operator=(PImpl &&src) { move_here(src); return *this; } PImpl(PImpl &&src) { operator=(std::move(src)); } OrderKey parent_key; bts::api::orderman::OrderDefinition definition; std::size_t reserve_sz; std::vector order_stash; std::size_t builder_id; OrderServices *order_services; ChildOrder build() { bts_assert_msg( order_services != nullptr, "OrderBuilder::activate() must be called before orders can be built"); ChildOrder result; if (order_stash.size()) { result = ChildOrder(*order_stash.back(), *order_services); order_stash.pop_back(); } else { LOG(OrderMan, Warn, "Ran out of pre-allocated child orders for order {}. Will " "allocate directly. " "This will have an impact on performance", parent_key); result = ChildOrder( order_services->order_factory().create(parent_key, definition), *order_services); } if (reserve_sz > order_stash.size()) { auto need = reserve_sz - order_stash.size(); order_services->send_order_create_req( builder_id, parent_key, definition, need); } return result; } void move_here(PImpl &src) { order_services = src.order_services; parent_key = src.parent_key; definition = src.definition; reserve_sz = src.reserve_sz; order_stash = src.order_stash; builder_id = src.builder_id; src.order_stash.clear(); src.builder_id = 0; src.order_services = nullptr; bts_assert(parent_key != null_order_key()); } }; OrderBuilder::OrderBuilder() : me_(std::make_unique()) {} OrderBuilder::OrderBuilder( OrderKey parent_key, OrderDefinition const &def, IOrderFactory &factory, size_t reserve_sz) : me_(std::make_unique(parent_key, def, factory, reserve_sz)) {} OrderBuilder::OrderBuilder( OrderKey parent_key, bts::api::orderman::OrderDefinition const &def, std::size_t reserve_sz) : me_(std::make_unique(parent_key, def, reserve_sz)) {} OrderBuilder::OrderBuilder(OrderBuilder &&src) = default; OrderBuilder &OrderBuilder::operator=(OrderBuilder &&rhs) = default; OrderBuilder::~OrderBuilder() = default; bool OrderBuilder::is_activated() const { return me_->order_services != nullptr; } void OrderBuilder::activate(OrderServices &order_services) { bts_assert(!me_->order_services); me_->order_services = &order_services; me_->order_services->subscribe_to_order_creation_reply( me_->builder_id, [this](auto const &order_ev) { me_->order_stash.insert( me_->order_stash.end(), order_ev.orders.begin(), order_ev.orders.end()); }); } ChildOrder OrderBuilder::build() { return me_->build(); } OrderServices &OrderBuilder::services() { bts_assert(me_->order_services != nullptr); return *me_->order_services; } } // namespace bts::orderman