Files
spark/src/lib/orderman/orders/CompositeOrder.cpp
T

150 lines
4.4 KiB
C++

#include "lib/orderman/orders/CompositeOrder.h"
#include "lib/api/services/OrderService.pb.h"
#include "lib/orderman/actors/order_manager/ChildOrder.h"
#include "lib/orderman/actors/order_manager/OrderBuilder.h"
#include "lib/orderman/orders/PreActivationOrderServices.h"
#include "lib/utils/bts_assert.h"
namespace bts {
namespace orderman {
using namespace api::orderman;
struct CompositeOrder::PImpl {
ChildOrder child_order;
OrderBuilder order_builder;
OrderServices *services;
api::orderman::OrderState state;
};
CompositeOrder::CompositeOrder() : me(new PImpl()) {}
CompositeOrder::~CompositeOrder() {}
void CompositeOrder::on_init_new(api::orderman::OrderDefinition const &def,
const PreActivationOrderServices &serv) {
bts_assert(def.custom_def().has_composite());
api::orderman::OrderDefinition child_def = def;
*child_def.mutable_custom_def() = def.custom_def();
me->order_builder = OrderBuilder{key(), child_def, serv.order_factory, 1};
me->state.set_status(ORDER_STATUS_INACTIVE);
}
void CompositeOrder::on_init_recovered(OrderRecord const &rec,
const PreActivationOrderServices &) {
me->state = rec.state();
// Infer internal status from persisted external status
switch (me->state.status()) {
case ORDER_STATUS_WORKING:
case ORDER_STATUS_PENDING_WORKING:
case ORDER_STATUS_DISCONNECTED:
me->state.set_status(ORDER_STATUS_ERROR);
me->state.set_last_msg("System restarted with active composite order");
return;
// Terminal states
case ORDER_STATUS_ERROR:
case ORDER_STATUS_REJECTED_BY_SPARK:
case ORDER_STATUS_COMPLETED:
case ORDER_STATUS_CANCELED:
break;
// It should not be possible to reach these
case ORDER_STATUS_INACTIVE:
case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_:
case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_:
bts_assert(false);
break;
}
}
OrderOpResult CompositeOrder::on_activate(Price p, Quantity q,
OrderServices &services) {
me->services = &services;
switch (me->state.status()) {
case ORDER_STATUS_INACTIVE:
me->order_builder.activate(services);
me->child_order = me->order_builder.build();
me->child_order.activate(p, q);
services.subscribe_to_child_updates([this](auto const &u) {
this->on_child_order_update(u.key, u.quick_rebuild_state());
});
return {};
// Terminal states
case ORDER_STATUS_ERROR:
case ORDER_STATUS_REJECTED_BY_SPARK:
case ORDER_STATUS_COMPLETED:
case ORDER_STATUS_CANCELED:
return {};
// It should not be possible to reach these
case ORDER_STATUS_DISCONNECTED:
case ORDER_STATUS_WORKING:
case ORDER_STATUS_PENDING_WORKING:
case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_:
case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_:
bts_assert(false);
return {};
}
bts_assert(false);
return {};
}
OrderOpResult CompositeOrder::on_update(Price p, Quantity q) {
if (is_working())
me->child_order.update(p, q);
return {};
}
OrderOpResult CompositeOrder::on_update(api::orderman::Update const &u) {
if (is_working()) {
Update child_update;
child_update.set_price(u.price());
child_update.set_quantity(u.quantity());
child_update.set_order_key(me->child_order.key().value());
if (u.has_custom()) {
bts_assert(u.custom().has_composite());
auto const &cupdate = u.custom().composite().definition();
*child_update.mutable_custom()
->mutable_composite()
->mutable_definition() = cupdate;
}
me->child_order.update(child_update);
}
return {};
}
OrderOpResult CompositeOrder::on_detach() {
if (is_working())
me->child_order.detach();
return {};
}
OrderOpResult CompositeOrder::on_cancel() {
if (is_working())
me->child_order.cancel();
return {};
}
void CompositeOrder::on_child_order_update(
OrderKey, api::orderman::OrderState const &st) {
me->services->report_state(st);
}
bool CompositeOrder::is_working() const {
return
me->state.status() == ORDER_STATUS_WORKING ||
me->state.status() == ORDER_STATUS_PENDING_WORKING ||
me->state.status() == ORDER_STATUS_DISCONNECTED ;
}
void CompositeOrder::on_attached(api::orderman::OrderDefinition const &) {}
} // namespace orderman
} // namespace bts