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 <OnixS/CME/MDH/Memory.h>
#include <OnixS/CME/MDH/VectorOverArray.h>
#include <OnixS/CME/MDH/BookAttributes.h>

ONIXS_CMEMDH_NAMESPACE_BEGIN

/// Raises exception on book re-depth failure. 
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=";

    toStr(error, newDepth);

    error += ",maxDepth=";

    toStr(error, maxDepth);

    error += "]. ";

    throw std::runtime_error(error);
}

/// Base attributes of order book.
/// 
/// A set of bids and offers data for the given security 
/// (bids are descending and offers are ascending). 
template
<
    class EntryType,
    class DepthType
>
class 
MbpBook
{
public:
    /// Indicates price level data type.
    typedef 
    EntryType
    Entry;

    /// Aliases book dimension type. 
    typedef 
    DepthType 
    Depth;

    /// Collection of price levels allowing modifications.
    typedef 
    VectorOverArray
    <
        Entry,
        Depth
    >
    Entries;

    /// Iterator over bids and offers. 
    typedef 
    typename 
    Entries::ConstIterator
    EntryIterator;

    /// Initializes instance with given attributes.
    ///
    /// Bids and offers are stored in given segments of 
    /// plain arrays. Book constructs vectors over input 
    /// arrays of fixed size. That provides more flexibility 
    /// on memory layout for internally used data.
    MbpBook(
        Depth capacity, 
        Entry* bids,
        Entry* offers)
        : depth_(0)
        , state_(
            BookState::Constructed)
        , bids_(
            bids, 
            capacity)
        , offers_(
            offers, 
            capacity)
    {
    }

    // Cleans everything up. 
    ~MbpBook()
    {
    }

    /// Returns the maximal number of price levels.
    Depth depth() const
    {
        return depth_;
    }

    /// Indicates book capacity which is 
    /// maximal value of book depth allowed. 
    Depth capacity() const
    {
        return bids_.capacity();
    }

    /// Updates the maximal number of price levels.
    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;
    }

    /// List of descending bid prices.
    Entries& bids()
    {
        return bids_;
    }

    /// List of descending bid prices.
    Entries& 
    operator [](
        const Bids&)
    {
        return bids_;
    }

    /// List of descending bid prices.
    const 
    Entries& 
    bids() const
    {
        return bids_;
    }

    /// List of descending bid prices.
    const 
    Entries&
    operator [](
        const Bids&) const
    {
        return bids_;
    }
                
    /// List of ascending offer prices.
    Entries& offers()
    {
        return offers_;
    }

    /// List of ascending offer prices.
    Entries& 
    operator [](
        const Offers&)
    {
        return offers_;
    }

    /// List of ascending offer prices.
    const 
    Entries&
    offers() const
    {
        return offers_;
    }

    /// List of ascending offer prices.
    const 
    Entries&
    operator [](
        const Offers&) const
    {
        return offers_;
    }

    /// Indicates current state of book.
    BookState::Enum state() const
    {
        return state_;
    }

    /// Updates state of book.
    void 
    state(
        BookState::Enum state)
    {
        state_ = state;
    }

    /// Wipes out all bids and offers and other 
    /// data associated with book (like instance 
    /// of last applied FIX message).
    void 
    reset(
        BookState::Enum bookState)
    {
        state(bookState);

        bids_.resize(0);
        offers_.resize(0);
    }

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&);
};

/// Copies content of one book to another.
/// 
/// Source and destination books are not required
/// to be of same type, just compatible by price levels.
/// For example, content of direct book can be copied to implied book, 
/// or content of consolidated book can be copied to implied book,
/// however, implied book can't be copied to direct book as far as
/// direct price level has more attributes rather than implied one. 
template
<
    class TargetPriceLevel,
    class SourcePriceLevel,
    class Depth
>
void 
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());
}

/// Serves as a factory for book of given type. 
template
<
    class PriceLevelType,
    class DepthType
>
class 
MbpBookFactory
{
public:
    /// Type of book constructed by given factory. 
    typedef 
    MbpBook
    <
        PriceLevelType, 
        DepthType
    >
    Book; 

    /// Book entry type. 
    typedef 
    typename Book::Entry 
    Entry;

    /// Book depth type. 
    typedef
    typename Book::Depth
    Depth;

    /// Calculates size of memory required 
    /// to keep in memory book of given depth. 
    static 
    size_t
    calcSize(
        Depth maxDepth)
    {
        return (
            sizeof(Book) + 
            2 * 
            maxDepth * 
            sizeof(Entry)
        );
    }

    /// Constructs book instance of given capacity. 
    /// 
    /// Book depth can be changed in bounds of specified capacity.
    static 
    Book*
    construct(
        Depth maxDepth)
    {
        const 
        size_t 
        bookSize = 
            calcSize(maxDepth);

        return 
            inplaceConstruct(
                maxDepth, 
                new Byte [bookSize]);
    }

    /// Destructs previously constructed book.
    static 
    void 
    destruct(
        Book* book)
    {
        if (book)
        {
            book->~Book();

            delete [] reinterpret_cast<Byte*>(book);
        }
    }

    /// Constructs book on a given memory block. 
    static
    Book*
    inplaceConstruct(
        Depth maxDepth, 
        void* block)
    {
        Entry* 
        const 
        entries = 
            reinterpret_cast<Entry*>
            (
                reinterpret_cast<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