MbpBook.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 <cassert>
#include <memory>
#include <string>
#include <stdexcept>
#include <type_traits>
 
#include <OnixS/CME/MDH/messaging/Memory.h>
#include <OnixS/CME/MDH/VectorOverArray.h>
#include <OnixS/CME/MDH/BookAttributes.h>
 
ONIXS_CMEMDH_NAMESPACE_BEGIN

template <typename Depth>
inline void throwMbpBookRedepthFailure(Depth newDepth, Depth maxDepth)
{
    std::string error;
 
    error += "Cannot re-depth order book "
             "due to lack of capacity [newDepth=";
 
    Messaging::toStr(error, newDepth);
 
    error += ",maxDepth=";
 
    Messaging::toStr(error, maxDepth);
 
    error += "]. ";
 
    throw std::runtime_error(error);
}

template <class EntryType, class DepthType>
class MbpBook
{
    static_assert(std::is_trivially_destructible<EntryType>::value, "EntryType must be trivially destructible");
 
public:
    typedef EntryType Entry;

    typedef DepthType Depth;

    typedef VectorOverArray<Entry, Depth> Entries;

    typedef typename Entries::ConstIterator EntryIterator;

    MbpBook(Depth capacity, Entry* bids, Entry* offers)
        : depth_(0)
        , state_(BookState::Constructed)
        , bids_(bids, capacity)
        , offers_(offers, capacity)
    {
    }
 
    // Cleans everything up.
    ~MbpBook() {}

    Depth depth() const
    {
        return depth_;
    }

    Depth capacity() const
    {
        return bids_.capacity();
    }

    void depth(Depth depth)
    {
        if (depth > capacity())
        {
            throwMbpBookRedepthFailure(depth, capacity());
        }
 
        if (bids_.size() > depth)
            bids_.resize(depth);
 
        if (offers_.size() > depth)
            offers_.resize(depth);
 
        depth_ = depth;
    }

    Entries& bids()
    {
        return bids_;
    }

    Entries& operator[](const Bids&)
    {
        return bids_;
    }

    const Entries& bids() const
    {
        return bids_;
    }

    const Entries& operator[](const Bids&) const
    {
        return bids_;
    }

    Entries& offers()
    {
        return offers_;
    }

    Entries& operator[](const Offers&)
    {
        return offers_;
    }

    const Entries& offers() const
    {
        return offers_;
    }

    const Entries& operator[](const Offers&) const
    {
        return offers_;
    }

    BookState::Enum state() const
    {
        return state_;
    }

    void state(BookState::Enum state)
    {
        state_ = state;
    }

    void reset(BookState::Enum bookState)
    {
        state(bookState);
 
        bids_.clear();
        offers_.clear();
    }
 
private:
    // Book depth.
    Depth depth_;
 
    // Book state.
    BookState::Enum state_;
 
    // Bids.
    Entries bids_;
 
    // Asks.
    Entries offers_;
 
    // Copying is done the other way.
    MbpBook(const MbpBook&);
 
    // Copying is done the other way.
    MbpBook& operator=(const MbpBook&);
};

template <class TargetPriceLevel, class SourcePriceLevel, class Depth>
MbpBook<TargetPriceLevel, Depth>& copy(
    MbpBook<TargetPriceLevel, Depth>& target,
    const MbpBook<SourcePriceLevel, Depth>& source,
    Depth maxDepth = static_cast<Depth>(-1)
)
{
    if (maxDepth > source.depth())
    {
        maxDepth = source.depth();
    }
 
    target.depth(maxDepth);
 
    copy(target.bids(), source.bids(), maxDepth);
 
    copy(target.offers(), source.offers(), maxDepth);
 
    target.state(source.state());
 
    return target;
}

template <class PriceLevelType, class DepthType>
class MbpBookFactory
{
public:
    typedef MbpBook<PriceLevelType, DepthType> Book;

    typedef typename Book::Entry Entry;

    typedef typename Book::Depth Depth;

    static size_t calcSize(Depth maxDepth)
    {
        return (sizeof(Book) + 2 * maxDepth * sizeof(Entry));
    }

    static Book* construct(Depth maxDepth)
    {
        const size_t bookSize = calcSize(maxDepth);
 
        return inplaceConstruct(maxDepth, new Messaging::Byte[bookSize]);
    }

    static void destruct(Book* book)
    {
        if (book)
        {
            book->~Book();
 
            delete[] reinterpret_cast<Messaging::Byte*>(book);
        }
    }

    static Book* inplaceConstruct(Depth maxDepth, void* block)
    {
        Entry* const entries = reinterpret_cast<Entry*>(reinterpret_cast<Messaging::Byte*>(block) + sizeof(Book));
 
        inplaceConstruct(entries, entries + 2 * maxDepth);
 
        return new (block) Book(maxDepth, entries, entries + maxDepth);
    }
 
private:
    static void inplaceConstruct(Entry* first, Entry* last)
    {
        while (first != last)
            new (first++) Entry();
    }
};
 
ONIXS_CMEMDH_NAMESPACE_END