Files
spark/src/server/sparkd/exchange_sim/book/OrderMatcher.cpp
T

246 lines
6.6 KiB
C++

#include "OrderMatcher.h"
#include "lib/utils/bts_assert.h"
#include "server/sparkd/exchange_sim/book/Book.h"
#include "server/sparkd/exchange_sim/book/Order.h"
#include <set>
namespace bts {
namespace ex_sim {
struct OrderMatcher::PImpl {
PImpl()
: bids(OrderCmp(false)), asks(OrderCmp(true)) {}
OrdersSide bids;
OrdersSide asks;
std::vector<Trade> pending_trades;
};
OrderMatcher::OrderMatcher()
: me(new PImpl()) {}
OrderMatcher::~OrderMatcher() {}
struct OrderFinder {
OrderFinder(std::string const &clordid) : clordid(clordid) {}
bool operator()(Order const &o) const { return o.clordid() == clordid; }
std::string const &clordid;
};
Order const *OrderMatcher::get_order(std::string const &clordid) {
auto r =
std::find_if(me->bids.begin(), me->bids.end(), OrderFinder(clordid));
if (r != me->bids.end())
return &(*r);
r = std::find_if(me->asks.begin(), me->asks.end(), OrderFinder(clordid));
if (r != me->asks.end())
return &(*r);
return nullptr;
}
std::tuple<size_t,size_t,size_t> OrderMatcher::size() const
{
return std::make_tuple (me->bids.size(), me->bids.size(), me->pending_trades.size());
}
void OrderMatcher::add_new(Order const &o, std::vector<Order> *out) {
bts_assert(!get_order(o.clordid()));
if (o.side() == api::SIDE_BUY)
me->bids.insert(o);
else
me->asks.insert(o);
match(out);
}
std::pair<OrderMatcher::OrdersSide::iterator, OrderMatcher::OrdersSide::iterator>
OrderMatcher::find_level(OrdersSide &side, double level)
{
std::pair<OrdersSide::iterator, OrdersSide::iterator> result {side.end(), side.end()};
for (auto it = side.begin() ; it != side.end(); it++) {
if (it->price() == level) {
result.first = it;
for (;it != side.end(); it++) {
if (it->price() != level)
break;
}
result.second = it;
break;
}
}
return result;
}
void OrderMatcher::add_or_merge(Order const &o, std::vector<Order> *out) {
bts_assert(!get_order(o.clordid()));
OrdersSide *side = nullptr;
if (o.side() == api::SIDE_BUY)
side = &me->bids;
else
side = &me->asks;
auto range = find_level(*side,o.price());
for (auto it = range.first; it != range.second; it++)
if (it->owner() == o.owner()) {
auto no_const = const_cast<Order *>(&(*it));
no_const->set_open_quantity(it->open_quantity() + o.quantity());
match(out);
return;
}
add_new(o,out);
}
void OrderMatcher::update(std::string const &clordid, Price price, Quantity qty,
std::vector<Order> *out) {
auto order = get_order(clordid);
bts_assert(order);
auto order_cpy = *order;
order_cpy.set_price(price.value());
*order_cpy.mutable_last_update_time() = utils::pb::pb_now();
if (order_cpy.quantity() != qty.value()) {
order_cpy.set_quantity(qty.value());
order_cpy.set_open_quantity(qty.value());
}
if (order->side() == api::SIDE_BUY) {
me->bids.erase(
std::find_if(me->bids.begin(), me->bids.end(), OrderFinder(clordid)));
me->bids.insert(order_cpy);
} else {
me->asks.erase(
std::find_if(me->asks.begin(), me->asks.end(), OrderFinder(clordid)));
me->asks.insert(order_cpy);
}
match(out);
}
void OrderMatcher::cancel(std::string const &clordid) {
auto order = get_order(clordid);
bts_assert(order);
if (order->side() == api::SIDE_BUY)
me->bids.erase(
std::find_if(me->bids.begin(), me->bids.end(), OrderFinder(clordid)));
else
me->asks.erase(
std::find_if(me->asks.begin(), me->asks.end(), OrderFinder(clordid)));
}
void OrderMatcher::try_reduce_quantity_at_level(
api::Side side, Price level, Quantity by_quantity,
std::string const &order_owner) {
std::pair<OrdersSide::iterator, OrdersSide::iterator> range;
if (side == api::SIDE_BUY)
range = find_level(me->bids,level.value());
else
range = find_level(me->asks,level.value());
std::vector<std::string> orders_to_cancel;
for (auto it = range.first; it != range.second && by_quantity.value();
it++) {
if (it->owner() == order_owner) {
if (it->open_quantity() >= by_quantity.value()) {
auto no_const = const_cast<Order *>(&(*it));
no_const->set_open_quantity(it->open_quantity() -
by_quantity.value());
by_quantity.value() = 0;
} else {
by_quantity.value() -= it->open_quantity();
auto no_const = const_cast<Order *>(&(*it));
no_const->set_open_quantity(0);
}
if (it->open_quantity() == 0)
orders_to_cancel.push_back(it->clordid());
}
}
for (auto const &clordid : orders_to_cancel)
cancel(clordid);
}
void OrderMatcher::match(std::vector<Order> *out) {
for (;;) {
if (me->bids.empty() || me->asks.empty())
break;
auto iBid = me->bids.begin();
auto iAsk = me->asks.begin();
if (iBid->price() >= iAsk->price()) {
Order bid = *iBid;
Order ask = *iAsk;
match(&bid, &ask);
out->push_back(bid);
out->push_back(ask);
me->bids.erase(iBid);
me->asks.erase(iAsk);
if (bid.open_quantity())
me->bids.insert(bid);
if (ask.open_quantity())
me->asks.insert(ask);
} else
break;
}
}
void OrderMatcher::match(Order *bid, Order *ask) {
Price price(0);
if (utils::pb::greater(bid->last_update_time(), ask->last_update_time()))
price = Price(ask->price());
else
price = Price(bid->price());
Quantity quantity;
if (bid->open_quantity() > ask->open_quantity())
quantity = Quantity(ask->open_quantity());
else
quantity = Quantity(bid->open_quantity());
me->pending_trades.push_back(Trade{price, quantity});
execute(bid, price, quantity);
execute(ask, price, quantity);
}
std::vector<OrderMatcher::Trade> OrderMatcher::get_new_trades() {
return std::move(me->pending_trades);
}
Book OrderMatcher::get_book() const {
Book result;
for (auto &b : me->bids)
result.bids[Price(b.price())].value() += b.open_quantity();
for (auto &a : me->asks)
result.asks[Price(a.price())].value() += a.open_quantity();
return result;
}
OrderBook OrderMatcher::get_order_book(std::string const&exclude_owner) const
{
OrderBook result;
for (auto &b : me->bids)
if (b.owner() != exclude_owner)
*result.add_order() = b;
for (auto &a : me->asks)
if (a.owner() != exclude_owner)
*result.add_order() = a;
return result;
}
}
}