BookImpl.h

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.
*/

#pragma once

#include <OnixS/SgxTitan/MarketData/Itch/Enumerations.h>
#include <OnixS/SgxTitan/MarketData/Itch/OrderBook.h>

#include <OnixS/HandlerCore/OrderBook.h>

#include <OnixS/Core/Memory/FixedBlockAllocator.h>

#include "NamespaceHelper.h"

ONIXS_HANDLER_NAMESPACE_BEGIN

struct Order
{
    OrderId id_;
    Price price_;
    Quantity quantity_;

    Order();
    Order(const OrderId& inId, const Price& inPrice, Quantity inQuantity);
    static void addOrder(const Order& order, PriceLevel& level);
    static void removeOrder(const Order& order, PriceLevel& level);
    static bool isOrderAffectsPriceLevel(const Order& order);
};

void addOrder(const Order& order, PriceLevel& level);
void removeOrder(const Order& order, PriceLevel& level);
bool isOrderAffectsPriceLevel(const Order& order);
const OrderId& getOrderId(const Order& order);
const Price& getPrice(const Order& order);

static const size_t DefaultMaxBooksAmount = 500;

struct BaseFullOrderDepthBook
{
    typedef OnixS::HandlerCore::MarketData::DefaultBaseFullOrderDepthBook::BaseAskMap BaseAskMap;
    typedef OnixS::HandlerCore::MarketData::DefaultBaseFullOrderDepthBook::BaseBidMap BaseBidMap;
};

typedef OnixS::HandlerCore::MarketData::FullOrderDepthBook<PriceLevel, Order, OrderId, Price, BaseFullOrderDepthBook> OrderDepthBook;

class OrderBookInternal : public OrderBook, public OrderDepthBook
{
public:
    typedef OrderDepthBook::AskFullOrderDepthMap    AskFullOrderDepthMap;
    typedef OrderDepthBook::BidFullOrderDepthMap    BidFullOrderDepthMap;
    typedef OrderDepthBook::PoolManager             PoolManager;
    typedef OrderDepthBook::PoolManagerPtr          PoolManagerPtr;
    typedef OrderDepthBook::OrderIdMap              OrderIdMap;
    typedef OrderIdMap::Map                         BookSide;

    using OrderBook::asks;
    using OrderBook::bids;
    using OrderBook::depth;
    using OrderBook::empty;

public:
    OrderBookInternal
        (
            const OrderBookId& id, 
            size_t bookDepth,
            size_t maxAggregatedPriceLevelsCount = (size_t)-1,                         
            const PoolManagerPtr& poolManager = PoolManagerPtr()
        );

    virtual ~OrderBookInternal();

    AskFullOrderDepthMap& askOrders();
    const AskFullOrderDepthMap& askOrders() const;
    BidFullOrderDepthMap& bidOrders();
    const BidFullOrderDepthMap& bidOrders() const;

    void remove(const OrderId& orderId);
    void clear();
    void checkSanity() const;

    static void* operator new (std::size_t);
    static void operator delete (void*);

    static void* operator new (std::size_t, void*);
    static void operator delete (void*, void*);

private:
    size_t doDepth() const;
    const PriceLevels& doAsks() const;
    const PriceLevels& doBids() const;
    bool doBestAsk (Price& price, Quantity& quantity) const;
    bool doBestBid (Price& price, Quantity& quantity) const;
    OrderBookId doOrderBookId() const;

    void checkAsksSanity() const;
    void checkBidsSanity() const;

private:
    OrderBookInternal(const OrderBookInternal&);
    const OrderBookInternal& operator=(const OrderBookInternal&);

private:
    const size_t bookDepth_;
    OrderBookId id_;
};

class OrderBookAllocator : public boost::noncopyable
{
public:
    explicit
    OrderBookAllocator(size_t objectsAmount);
    ~OrderBookAllocator();
    void* alloc();
    void reset();

private:
    const size_t poolSize_;
    std::vector<unsigned char> poolPtr_;
    OnixS::FixedBlockAllocator allocator_;
};

size_t hash_value(OrderBookInternal const& book);

ONIXS_HANDLER_NAMESPACE_END

namespace OnixS {
namespace HandlerCore {
namespace MarketData {
namespace Detail{

inline 
size_t getHash(const HANDLER_NAMESPACE::OrderId& value)
{
    return boost::hash<HANDLER_NAMESPACE::OrderId>()(value);
}

}}}}