OrderBookHolder.cpp

Go to the documentation of this file.

/*
* Copyright Onix Solutions Limited [OnixS]. All rights reserved.
*
* This software owned by Onix Solutions Limited [OnixS] and is protected by copyright law
* and international copyright treaties.
*
* Access to and use of the software is governed by the terms of the applicable ONIXS Software
* Services Agreement (the Agreement) and Customer end user license agreements granting
* a non-assignable, non-transferable and non-exclusive license to use the software
* for it's own data processing purposes under the terms defined in the Agreement.
*
* Except as otherwise granted within the terms of the Agreement, copying or reproduction of any part
* of this source code or associated reference material to any other location for further reproduction
* or redistribution, and any amendments to this copyright notice, are expressly prohibited.
*
* Any reproduction or redistribution for sale or hiring of the Software not in accordance with
* the terms of the Agreement is a violation of copyright law.
*/

#include "OrderBookHolder.h"

#include <util/String.h>

#include <OnixS/SgxTitan/MarketData/Itch/Messages.h>
#include <OnixS/SgxTitan/MarketData/Itch/Exception.h>

#include <boost/foreach.hpp>

ONIXS_HANDLER_NAMESPACE_BEGIN

OrderBookCreator::OrderBookCreator(size_t bookDepth, OrderBookAllocator* bookAllocator) :
    bookDepth_(bookDepth), 
    bookAllocator_(bookAllocator)
{
    BOOST_ASSERT(bookAllocator_!= nullptr);
}

OrderBookCreator::OrderBookCreator(const OrderBookCreator& other) :
    FullOrderDepthBookCreator(other),
    bookDepth_(other.bookDepth_), 
    bookAllocator_(other.bookAllocator_)
{
    BOOST_ASSERT(bookAllocator_!= nullptr);
};

boost::shared_ptr<OrderBookInternal> OrderBookCreator::operator()(const OrderBookId& id) const
{
    BOOST_ASSERT(bookAllocator_!= nullptr);
    void* location = bookAllocator_->alloc();
    BOOST_ASSERT(location != nullptr);

    if(location == nullptr)
        throw std::logic_error("book memory exhausted.");

    return boost::shared_ptr<OrderBookInternal>(new(location) OrderBookInternal(id, bookDepth_, bookDepth_));
}

void OrderBookCreator::reset()
{
    OnixS::HandlerCore::MarketData::FullOrderDepthBookCreator<OrderBookInternal, false>::reset();
}

OrderBookHolder::OrderBookHolder(const OnOrderBookUpdatedCallback& onOrderBookUpdated, OrderBookAllocator* bookAllocator, size_t bookDepth) :
    impl_(new BookRegistry(OrderBookCreator(bookDepth, bookAllocator))), 
    onOrderBookUpdated_(onOrderBookUpdated),
    snapshotRecoveryInProgress_(false)
{
    BOOST_ASSERT(bookAllocator != nullptr);
    BOOST_ASSERT(bookDepth > 0);
}

void OrderBookHolder::snapshotRecoveryStarted()
{
    snapshotRecoveryInProgress_ = true;
}

void OrderBookHolder::snapshotRecoveryFinished()
{
    snapshotRecoveryInProgress_ = false;

    BOOST_FOREACH(BookPtr ptr, books_)
    {
        BOOST_ASSERT(ptr);
        onOrderBookUpdated_(*ptr);
    }
}

void OrderBookHolder::onOrderAdd(const AddOrderMsg& message)
{
    BOOST_ASSERT(impl_.get() != nullptr);

    BookPtr bookPtr = impl_->get(message.orderBookId());
    
    if(!bookPtr)
        throw OperationException (__FUNCTION__, OnixS::Util::format("Unknown security id: %d", message.orderBookId()).c_str());

    if(message.side() == Side::Sell)
    {
        BOOST_ASSERT(checkOrderExistence(bookPtr->askOrders().orders(), message.orderId(), false));
        bookPtr->askOrders().update(Order(message.orderId(), message.price(), message.quantity()));
    }
    else if(message.side() == Side::Buy)
    {
        BOOST_ASSERT(checkOrderExistence(bookPtr->bidOrders().orders(), message.orderId(), false));
        bookPtr->bidOrders().update(Order(message.orderId(), message.price(), message.quantity()));
    }
    else
        throw OperationException (__FUNCTION__, OnixS::Util::format("Unknown side, %d", message.side()).c_str());

    books_.insert(bookPtr);

    onBookChanged(*bookPtr);
}


namespace {
    struct FindById : public std::binary_function<const Order*, OrderId, bool>
    {
        bool operator()(const Order* order, OrderId id) const
        {
            BOOST_ASSERT(order != nullptr);
            return (order->id_ == id);
        }
    };
}

template <typename OrderList>
bool OrderBookHolder::checkOrderExistence(const OrderList& list, OrderId orderId, bool shouldExist)
{
    typename OrderList::const_iterator pos = std::find_if(list.begin(), list.end(), std::bind2nd(FindById(), orderId));

    if(shouldExist)
        if(pos == list.end())
            throw OperationException (__FUNCTION__, OnixS::Util::format("Order does not exist, %llu", orderId).c_str());

    if(!shouldExist)
        if(pos != list.end())
            throw OperationException (__FUNCTION__, OnixS::Util::format("Order already exists, %llu", orderId).c_str());

    return true;
}


Side::Enum OrderBookHolder::getOrderSide(BookPtr bookPtr, OrderId orderId)
{
    if(std::find_if(bookPtr->askOrders().orders().begin(), bookPtr->askOrders().orders().end(), std::bind2nd(FindById(), orderId)) != bookPtr->askOrders().orders().end())
        return Side::Sell;
    else if(std::find_if(bookPtr->bidOrders().orders().begin(), bookPtr->bidOrders().orders().end(), std::bind2nd(FindById(), orderId)) != bookPtr->bidOrders().orders().end())
        return Side::Buy;
    else 
        throw OperationException (__FUNCTION__, OnixS::Util::format("Unknown side for order, %llu", orderId).c_str());
}

void OrderBookHolder::onOrderExecuted(const OrderExecutedMsg& message)
{
    BOOST_ASSERT(!snapshotRecoveryInProgress_);

    BOOST_ASSERT(impl_.get() != nullptr);

    BookPtr bookPtr = impl_->get(message.orderBookId());

    if(!bookPtr)
        throw OperationException (__FUNCTION__, OnixS::Util::format("Unknown book id: %d", message.orderBookId()).c_str());

    const OrderId orderId = message.orderId();

    if(message.side() == Side::Sell)
    {
        BOOST_ASSERT(checkOrderExistence(bookPtr->askOrders().orders(), orderId, true));

        const Order& order = bookPtr->askOrders().find(orderId);
        const Price price = order.price_;
        const Quantity oldQuantity = order.quantity_;

        bookPtr->askOrders().remove(orderId);

        const Quantity newQuantity = oldQuantity - message.executedQuantity();

        if(newQuantity != 0)
            bookPtr->askOrders().update(Order(orderId, price, newQuantity));
    }
    else if(message.side() == Side::Buy)
    {
        BOOST_ASSERT(checkOrderExistence(bookPtr->bidOrders().orders(), orderId, true));

        const Order& order = bookPtr->bidOrders().find(orderId);
        const Price price = order.price_;
        const Quantity oldQuantity = order.quantity_;

        bookPtr->bidOrders().remove(orderId);

        const Quantity newQuantity = oldQuantity - message.executedQuantity();

        if(newQuantity != 0)
            bookPtr->bidOrders().update(Order(orderId, price, newQuantity));
    }
    else
        throw OperationException (__FUNCTION__, OnixS::Util::format("Unknown side, %d", message.side()).c_str());

    onBookChanged(*bookPtr);
}

void OrderBookHolder::onOrderExecutedWithPrice(const OrderExecutedWithPriceMsg& message)
{
    BOOST_ASSERT(!snapshotRecoveryInProgress_);
    BOOST_ASSERT(impl_.get() != nullptr);

    if(!message.printable())
        return;

    BookPtr bookPtr = impl_->get(message.orderBookId());

    if(!bookPtr)
        throw OperationException (__FUNCTION__, OnixS::Util::format("Unknown book id: %d", message.orderBookId()).c_str());

    const OrderId orderId = message.orderId();

    if(message.side() == Side::Sell)
    {
        BOOST_ASSERT(checkOrderExistence(bookPtr->askOrders().orders(), orderId, true));

        const Order& order = bookPtr->askOrders().find(orderId);
        const Price price = order.price_;
        const Quantity oldQuantity = order.quantity_;

        bookPtr->askOrders().remove(orderId);

        const Quantity newQuantity = oldQuantity - message.executedQuantity();

        if(newQuantity != 0)
            bookPtr->askOrders().update(Order(orderId, price, newQuantity));
    }
    else if(message.side() == Side::Buy)
    {
        BOOST_ASSERT(checkOrderExistence(bookPtr->bidOrders().orders(), orderId, true));

        const Order& order = bookPtr->bidOrders().find(orderId);
        const Price price = order.price_;
        const Quantity oldQuantity = order.quantity_;

        bookPtr->bidOrders().remove(orderId);

        const Quantity newQuantity = oldQuantity - message.executedQuantity();

        if(newQuantity != 0)
            bookPtr->bidOrders().update(Order(orderId, price, newQuantity));
    }
    else
        throw OperationException (__FUNCTION__, OnixS::Util::format("Unknown side, %d", message.side()).c_str());

    onBookChanged(*bookPtr);
}

void OrderBookHolder::onOrderReplace(const OrderReplaceMsg& message)
{
    BOOST_ASSERT(!snapshotRecoveryInProgress_);
    BOOST_ASSERT(impl_.get() != nullptr);

    BookPtr bookPtr = impl_->get(message.orderBookId());

    if (!bookPtr)
        throw OperationException(__FUNCTION__, OnixS::Util::format("Unknown book id: %d", message.orderBookId()).c_str());

    const OrderId orderId = message.orderId();
    const Side::Enum side = getOrderSide(bookPtr, orderId);

    if (side == Side::Sell)
    {
        const Price price =
            bookPtr->askOrders().find(orderId).price_;

        bookPtr->askOrders().remove(orderId);
        bookPtr->askOrders().update(Order(orderId, price, message.quantity()));
    }
    else if (side == Side::Buy)
    {
        const Price price =
            bookPtr->bidOrders().find(orderId).price_;

        bookPtr->bidOrders().remove(orderId);
        bookPtr->bidOrders().update(Order(orderId, price, message.quantity()));
    }

    onBookChanged(*bookPtr);
}

void OrderBookHolder::onOrderDelete(const OrderDeleteMsg& message)
{
    BOOST_ASSERT(!snapshotRecoveryInProgress_);
    BOOST_ASSERT(impl_.get() != nullptr);

    BookPtr bookPtr = impl_->get(message.orderBookId());

    if(!bookPtr)
        throw OperationException (__FUNCTION__, OnixS::Util::format("Unknown book id: %d", message.orderBookId()).c_str());

    const OrderId orderId = message.orderId();

    if(message.side() == Side::Sell)
    {
        BOOST_ASSERT(checkOrderExistence(bookPtr->askOrders().orders(), orderId, true));
        bookPtr->askOrders().remove(orderId);
    }
    else if(message.side() == Side::Buy)
    {
        BOOST_ASSERT(checkOrderExistence(bookPtr->bidOrders().orders(), orderId, true));
        bookPtr->bidOrders().remove(orderId);
    }
    else
        throw OperationException (__FUNCTION__, OnixS::Util::format("Unknown side, %d", message.side()).c_str());

    onBookChanged(*bookPtr);
}

void OrderBookHolder::reset()
{
    BOOST_ASSERT(impl_.get() != nullptr);

    BOOST_FOREACH(BookPtr ptr, books_)
    {
        BOOST_ASSERT(ptr);
        ptr->clear();
    }

    books_.clear();
}

void OrderBookHolder::onBookOutOfDate(const boost::function<void(const OrderBookInternal&)>& onOrderBookOutOfDate)
{
    BOOST_FOREACH(BookPtr ptr, books_)
    {
        BOOST_ASSERT(ptr);
        onOrderBookOutOfDate(*ptr);
    }
}

void OrderBookHolder::onBookChanged(const OrderBookInternal& book)
{
    if (!snapshotRecoveryInProgress_)
        onOrderBookUpdated_(book);
}

ONIXS_HANDLER_NAMESPACE_END