246 lines
6.6 KiB
C++
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;
|
|
}
|
|
|
|
|
|
|
|
}
|
|
}
|
|
|