Book.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 <OnixS/SgxTitan/MarketData/Itch/OrderBook.h>
#include "BookImpl.h"

#include <algorithm> 
#include <sstream>

#include <boost/format.hpp>
#include <boost/foreach.hpp>

#include "NamespaceHelper.h"

ONIXS_HANDLER_NAMESPACE_BEGIN

namespace
{

void bestBid2string(std::stringstream& ss, Price price, Quantity quantity)
{
    ss << boost::format("     -     | %9d | %20d |") % quantity % price.value();
}

void bestAsk2string(std::stringstream& ss, Price price, Quantity quantity)
{
      ss << boost::format("%20d | %9d |     -      |") % price.value() % quantity ;
}

void bid2string(std::stringstream& ss, const PriceLevel& bid)
{
    ss << boost::format(" %9d | %9d | %20d |") % bid.numberOfOrders() % bid.quantity() % bid.price().value();
}

void ask2string(std::stringstream& ss, const PriceLevel& ask)
{
    ss << boost::format("%20d | %9d | %9d  |") % ask.price().value() % ask.quantity() % ask.numberOfOrders();
}

void printLevels(std::stringstream& presentation, const PriceLevels& levels)
{
    if (!levels.empty())
    {
        PriceLevelsConstEntry lastLevel = --levels.end();

        for (PriceLevelsConstEntry level = levels.begin(); 
            level != levels.end(); 
            ++level)
        {
            presentation << level->toString();

            if (level != lastLevel)
                presentation << ", ";
        }
    }
}

} // namespace


OrderInfo::OrderInfo() :
    orderId_(0), 
    quantity_(0)
{
}

OrderInfo::OrderInfo(OrderId orderId, Quantity quantity) :
    orderId_(orderId), 
    quantity_(quantity)
{
}

PriceLevel::PriceLevel (const Price& price, Quantity quantity, Quantity numberOfOrders, const OrderInfos& orders) : 
    price_(price),
    qty_(quantity), 
    orders_(orders)
{
    (void) numberOfOrders;
}

const size_t OrderIdsDefaultSize = 10;

PriceLevel::PriceLevel() : 
    price_(),
    qty_(0)
{
    orders_.reserve(OrderIdsDefaultSize); // \todo:
}

PriceLevel&
PriceLevel::operator=(
    const PriceLevel& other)
{
    if (this == &other)
        return *this;

    PriceLevel tmp(other);
    tmp.swap(*this);
    return *this;
}

PriceLevel::PriceLevel(const PriceLevel& other)
    : price_(other.price_)
    , qty_(other.qty_)
    , orders_(other.orders_)
{
}

#if defined(ONIXS_SGXTITAN_ITCH_COMPILER_CXX_RVALUE_REFERENCES) && ONIXS_SGXTITAN_ITCH_COMPILER_CXX_RVALUE_REFERENCES

PriceLevel::PriceLevel(PriceLevel&& other)
ONIXS_SGXTITAN_ITCH_NOTHROW
    : price_(std::move(other.price_))
    , qty_(std::move(other.qty_))
    , orders_(std::move(other.orders_))
{
}

PriceLevel&
    PriceLevel::operator=(
            PriceLevel&& other)
    ONIXS_SGXTITAN_ITCH_NOTHROW
{
    if (this == &other)
        return *this;

    other.swap(*this);
    return *this;
}

#endif

 
const Price& PriceLevel::price() const
{
    return price_;
}

void PriceLevel::price(const Price& value)
{
    price_ = value;
}

Quantity PriceLevel::quantity() const
{
    return qty_;
}

void PriceLevel::quantity (Quantity value)
{
    qty_ = value;
}

Quantity PriceLevel::numberOfOrders() const
{
    return static_cast<Quantity>(orders_.size());
}

const OrderInfos& PriceLevel::orders() const
{
    return orders_;
}

void PriceLevel::swap(PriceLevel &obj) ONIXS_SGXTITAN_ITCH_NOTHROW
{
    std::swap(price_, obj.price_);
    std::swap(qty_,   obj.qty_);
    std::swap(orders_, obj.orders_);
}

void PriceLevel::addOrderId(OrderId id, Quantity quantity)
{
    BOOST_ASSERT(id != 0);
    BOOST_ASSERT(quantity != 0);

    orders_.push_back(OrderInfo(id, quantity));
}

struct FindById : public std::binary_function<OrderInfo, OrderId, bool>
{
    bool operator()(const OrderInfo& oInf, OrderId id) const
    {
        BOOST_ASSERT(id != 0);
        BOOST_ASSERT(oInf.orderId_ != 0);
        BOOST_ASSERT(oInf.quantity_ != 0);

        return (oInf.orderId_ == id);
    }
};

void PriceLevel::removeOrderId(OrderId id)
{
    BOOST_ASSERT(std::find_if(orders_.begin(), orders_.end(), std::bind2nd(FindById(), id)) != orders_.end());
    orders_.erase(std::remove_if(orders_.begin(), orders_.end(), std::bind2nd(FindById(), id)), orders_.end());
}

const Price& getPrice (const PriceLevel& level)
{
    return level.price();
}

bool isValid (const PriceLevel& level) ONIXS_SGXTITAN_ITCH_NOTHROW
{
    BOOST_ASSERT(level.quantity() >= level.numberOfOrders());
    BOOST_ASSERT(level.numberOfOrders() == level.orders().size());

    return (level.quantity() != 0);
}

std::string PriceLevel::toString() const
{
    std::string str;
    toString (str);
    return str;
}

void PriceLevel::toString (std::string& str) const 
{
    std::stringstream ss;

    ss << "PriceLevel [price="
        << price_/*.toString()*/
        << ", quantity="
        << qty_
        << ", numberOfOrders="
        << numberOfOrders()
        << ", orders= [";

        BOOST_FOREACH(OrderInfo info, orders_)
        {
            ss << info.orderId_ << " - " << info.quantity_ << ", ";
        }

        ss << "] ]";

    str = ss.str();
};

std::ostream& operator << (std::ostream& stream, const PriceLevel& value)
{
    stream << value.toString();
    return stream;
}

OrderBook::OrderBook () :
    userPointer_(nullptr)
{
}

OrderBook::~OrderBook ()
{
}

void OrderBook::setUserPointer(void* pointer)
{
    userPointer_ = pointer;
}

void* OrderBook::getUserPointer() const
{
    return userPointer_;
}

bool OrderBook::bestAsk (Price& price, Quantity& quantity) const
{
    return doBestAsk(price, quantity);
}

bool OrderBook::bestBid (Price& price, Quantity& quantity) const
{
    return doBestBid(price, quantity);
}
 
size_t OrderBook::depth() const
{
    return doDepth();
}
 
OrderBookId OrderBook::orderBookId() const
{
    return doOrderBookId();
}
 
bool OrderBook::empty() const
{
    return doAsks().empty() && doBids().empty();
}
 
const PriceLevels& OrderBook::asks() const
{
    return doAsks();
}
 
const PriceLevels& OrderBook::bids() const
{
    return doBids();
}

std::string OrderBook::toString() const
{
    std::string str;

    toString(str);

    return str;
}

void OrderBook::toString (std::string& str) const
{
    std::stringstream ss;
    ss 
        << "Book [securityId="
        << orderBookId()
        << ", depth="
        << depth();

    ss << ", bids: ";
    printLevels(ss, bids());

    ss << ", asks: ";
    printLevels(ss, asks());

    ss << ']';

    str = ss.str();
}

std::string OrderBook::toShortString() const
{
    std::string str;

    toShortString(str);

    return str;
}

void OrderBook::toShortString (std::string& str) const
{
    std::stringstream ss;
    ss << "Book [" 
        << orderBookId() 
        << ", depth=" << depth() << "]";
    str = ss.str();
}

std::string OrderBook::toFormattedString() const
{
    std::string str;

    toFormattedString (str);

    return str;
}

void OrderBook::toFormattedString (std::string& str) const
{
    std::stringstream ss;

    const std::string briefInfo = toShortString();

    ss << briefInfo << "\n";


    ss << "    |-------------------------------------------------------------------------------------------------|\n";
    ss << "    |                      BID                      | |                       ASC                     |\n";
    ss << "    |-----------------------------------------------+-+-----------------------------------------------|\n";
    ss << "    | OrderCount | Quantity  |         Price        | |        Price         |  Quantity | OrderCount |\n";
    ss << "    |------------+-----------+----------------------+-+----------------------+-----------+------------|\n";

    Price bestBidPrice(0);
    Quantity bestBidQuantity = 0;
    bool bestBidAvailable = bestBid(bestBidPrice, bestBidQuantity);

    Price bestAskPrice(0);
    Quantity bestAskQuantity = 0;
    bool bestAskAvailable = bestAsk(bestAskPrice, bestAskQuantity);                  

    if( bestBidAvailable || bestAskAvailable )
    {
        ss 
            << "  "
            << "b"
            << " | ";

        bestBid2string(ss, bestBidPrice, bestBidQuantity);

        ss << " | ";

        bestAsk2string(ss, bestAskPrice, bestAskQuantity);

        ss << "\n";

        ss 
            << "  "
            << "-"
            << " |";

        ss << "------------+-----------+----------------------+-+----------------------+-----------+------------|\n";
    }

    static const PriceLevel zeroPriceLevel(Price(0), 0, 0);

    using namespace std;

    const size_t depth = max(bids().size(), asks().size());

    for (size_t level = 0; level < depth; ++level)
    {
        ss 
            << ((level < 9) ? "  " : " ")
            << level + 1
            << " | ";

        bid2string(
            ss,
            level < bids().size() 
            ? bids().at(level) : zeroPriceLevel);

        ss << " | ";


        ask2string(
            ss, 
            level < asks().size() 
            ? asks().at(level) : zeroPriceLevel);


        if (level + 1 != depth)
            ss << "\n";
    }

    ss << "\n";
    ss << "    |-------------------------------------------------------------------------------------------------|\n";

    str = ss.str();
}


void checkSanity(const OrderBook& book)
{
    static_cast<const OrderBookInternal&>(book).checkSanity();
}


ONIXS_HANDLER_NAMESPACE_END