Files
spark/src/lib/orderman/OrderBuilder.cpp
T
John Colvin d433919f1b refactor: Move OrderBuilder defs to cpp file
So impl deps don't leak into the sdk through headers
2024-04-01 10:09:35 -04:00

137 lines
4.1 KiB
C++

#include "OrderBuilder.h"
namespace bts::orderman {
using bts::api::orderman::OrderDefinition;
using std::size_t;
std::atomic<size_t> 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 *> 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<PImpl>()) {}
OrderBuilder::OrderBuilder(
OrderKey parent_key,
OrderDefinition const &def,
IOrderFactory &factory,
size_t reserve_sz)
: me_(std::make_unique<PImpl>(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<PImpl>(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