BookImpl.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/Exception.h>

#include "BookImpl.h"

ONIXS_HANDLER_NAMESPACE_BEGIN

Order::Order() : 
    id_(0), 
    price_(), 
    quantity_(0) 
{
}

Order::Order(const OrderId& inId, const Price& inPrice, Quantity inQuantity) :
    id_(inId), 
    price_(inPrice), 
    quantity_(inQuantity) 
{
}

void Order::addOrder(const Order& order, PriceLevel& level)
{
    BOOST_ASSERT(level.numberOfOrders() == level.orders().size());

    level.quantity(level.quantity() + order.quantity_);
    level.addOrderId(order.id_, order.quantity_);

    BOOST_ASSERT(level.quantity() >= level.numberOfOrders());
    BOOST_ASSERT(level.numberOfOrders() == level.orders().size());
}

void Order::removeOrder(const Order& order, PriceLevel& level)
{
    BOOST_ASSERT(level.quantity() >= order.quantity_);
    BOOST_ASSERT(level.numberOfOrders() > 0);
    BOOST_ASSERT(level.quantity() >= level.numberOfOrders());
    BOOST_ASSERT(level.numberOfOrders() == level.orders().size());

    level.quantity(level.quantity() - order.quantity_);
    level.removeOrderId(order.id_);

    BOOST_ASSERT(level.quantity() >= level.numberOfOrders());
    BOOST_ASSERT(level.numberOfOrders() == level.orders().size());
}

bool Order::isOrderAffectsPriceLevel(const Order&)
{
    return true;
}

void addOrder(const Order& order, PriceLevel& level)
{
    Order::addOrder(order, level);
}

void removeOrder(const Order& order, PriceLevel& level)
{
    Order::removeOrder(order, level);
}

bool isOrderAffectsPriceLevel(const Order& order)
{
    return Order::isOrderAffectsPriceLevel(order);
}
const OrderId& getOrderId(const Order& order) 
{ 
    return order.id_; 
}

const Price& getPrice(const Order& order) 
{ 
    return order.price_; 
}


OrderBookInternal::OrderBookInternal
(
     const OrderBookId& id, 
     size_t bookDepth,
     size_t maxAggregatedPriceLevelsCount,                         
     const PoolManagerPtr& poolManager
 ) :
    OrderDepthBook(maxAggregatedPriceLevelsCount, bookDepth, poolManager),
    bookDepth_(bookDepth), 
    id_(id)
{
}

OrderBookInternal::~OrderBookInternal()
{}

size_t OrderBookInternal::doDepth() const
{
    return bookDepth_;
}

const PriceLevels& OrderBookInternal::doAsks() const
{
    return OrderDepthBook::askOrders().levels().levels();
}

const PriceLevels& OrderBookInternal::doBids() const
{
    return OrderDepthBook::bidOrders().levels().levels();
}

bool OrderBookInternal::doBestAsk(Price& price, Quantity& quantity) const
{
    const PriceLevels& levels = doAsks();

    if(levels.empty())
    return false;

    price = levels[0].price();
    quantity = levels[0].quantity();

    return true;
}

bool OrderBookInternal::doBestBid(Price& price, Quantity& quantity) const
{
    const PriceLevels& levels = doBids();

    if(levels.empty())
        return false;

    price = levels[0].price();
    quantity = levels[0].quantity();

    return true;
}

OrderBookId OrderBookInternal::doOrderBookId() const
{
    return id_;
}

void* OrderBookInternal::operator new (std::size_t)
{
    throw std::bad_alloc();
}

void OrderBookInternal::operator delete (void*)
{
}

void* OrderBookInternal::operator new (std::size_t, void* p)
{
    return p;
}

void OrderBookInternal::operator delete (void*, void*)
{
}

void OrderBookInternal::checkSanity() const
{
    checkAsksSanity();
    checkBidsSanity();

    Price bestAskPrice;
    Quantity bestAskQuantity;
    const bool hasBestAsk = bestAsk(bestAskPrice, bestAskQuantity);

    Price bestBidPrice;
    Quantity bestBidQuantity;
    const bool hasBestBid = bestBid(bestBidPrice, bestBidQuantity);

    (void) hasBestAsk;
    (void) hasBestBid;
}

void OrderBookInternal::checkAsksSanity() const
{
    const PriceLevels& asksLevels = asks();

    Price bestAskPrice;
    Quantity bestAskQuantity;
    const bool hasBestAsk = bestAsk(bestAskPrice, bestAskQuantity);

    if(asksLevels.size() == 0)
        return;

    if(!hasBestAsk)
        throw OperationException (__FUNCTION__, "best ask does not exist");

    if(asksLevels.at(0).price() != bestAskPrice)
        throw OperationException (__FUNCTION__, "best ask is wrong");

    for(PriceLevels::const_iterator pos = asksLevels.begin(), end = asksLevels.end(); pos != end; ++pos)
    {
        if(pos->quantity() <= 0)
            throw OperationException (__FUNCTION__, "quantity is not positive number");
    }

    for(size_t i = 1; i < asksLevels.size(); ++i)
    {
        if(!isValid(asksLevels.at(i)))
            throw OperationException (__FUNCTION__, "invalid price level");
    }

    for(size_t i = 1; i < asksLevels.size(); ++i)
    {
        if(asksLevels.at(i).price() != Price(0))
        {
            if(asksLevels.at(i - 1).price() >=  asksLevels.at(i).price())
                throw OperationException (__FUNCTION__, "wrong price level order");
        }
    }
}

void OrderBookInternal::checkBidsSanity() const
{
    const PriceLevels& bidsLevels = bids();

    Price bestBidPrice;
    Quantity bestBidQuantity;
    const bool hasBestBid = bestBid(bestBidPrice, bestBidQuantity);

    if(bidsLevels.size() == 0)
        return;

    if(!hasBestBid)
        throw OperationException (__FUNCTION__, "best bid does not exist");

    if(bidsLevels.at(0).price() != bestBidPrice)
        throw OperationException (__FUNCTION__, "best bid is wrong");

    for(PriceLevels::const_iterator pos = bidsLevels.begin(), end = bidsLevels.end(); pos != end; ++pos)
    {
        if(pos->quantity() <= 0)
            throw OperationException (__FUNCTION__, "quantity is not positive number");
    }

    for(size_t i = 1; i < bidsLevels.size(); ++i)
    {
        if(!isValid(bidsLevels.at(i)))
            throw OperationException (__FUNCTION__, "invalid price level");
    }

    for(size_t i = 1; i < bidsLevels.size(); ++i)
    {
        if(bidsLevels.at(i).price() != Price(0))
        {
            if(bidsLevels.at(i - 1).price() <=  bidsLevels.at(i).price())
                throw OperationException (__FUNCTION__, "wrong price level order");
        }
    }
}

OrderBookInternal::AskFullOrderDepthMap& OrderBookInternal::askOrders() 
{
    return OrderDepthBook::askOrders();
}

const OrderBookInternal::AskFullOrderDepthMap& OrderBookInternal::askOrders() const 
{
    return OrderDepthBook::askOrders();
}

OrderBookInternal::BidFullOrderDepthMap& OrderBookInternal::bidOrders() 
{
    return OrderDepthBook::bidOrders();
}

const OrderBookInternal::BidFullOrderDepthMap& OrderBookInternal::bidOrders() const 
{
    return OrderDepthBook::bidOrders();
}

void OrderBookInternal::remove(const OrderId& orderId)
{
    return OrderDepthBook::remove(orderId);
}

void OrderBookInternal::clear() 
{ 
    OrderDepthBook::clear();
}


OrderBookAllocator::OrderBookAllocator(size_t objectsAmount) :
    poolSize_(objectsAmount * sizeof(OrderBookInternal)), 
    poolPtr_(poolSize_, 0), 
    allocator_(&poolPtr_.front(), poolSize_)
{
}

OrderBookAllocator::~OrderBookAllocator()
{
    allocator_.reset();
}

void* OrderBookAllocator::alloc()
{
    return allocator_.allocate(sizeof(OrderBookInternal));
}

void OrderBookAllocator::reset()
{
    allocator_.reset();
}

size_t hash_value(OrderBookInternal const& book)
{
    size_t seed = 0;

    const PriceLevels& asks = book.asks();
    for(PriceLevels::const_iterator i = asks.begin(), end = asks.end(); i < end; ++i)
    {
        boost::hash_combine(seed, i->quantity());
        boost::hash_combine(seed, i->numberOfOrders());
        boost::hash_combine(seed, (Int64)i->price().value());
    }

    const PriceLevels& bids = book.bids();
    for(PriceLevels::const_iterator i = bids.begin(), end = bids.end(); i < end; ++i)
    {
        boost::hash_combine(seed, i->quantity());
        boost::hash_combine(seed, i->numberOfOrders());
        boost::hash_combine(seed, (Int64)i->price().value());
    }

    return seed;
}


ONIXS_HANDLER_NAMESPACE_END