137 lines
4.1 KiB
C++
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
|