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/ConflatedUDP/Memory.h>
#include <OnixS/CME/ConflatedUDP/VectorOverArray.h>
#include <OnixS/CME/ConflatedUDP/BookAttributes.h>
 
ONIXS_CONFLATEDUDP_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=";
 
    toStr(error, newDepth);
 
    error += ",maxDepth=";
 
    toStr(error, maxDepth);
 
    error += "]. ";
 
    throw std::runtime_error(error);
}

template
<
    class EntryType,
    class DepthType
>
class 
MbpBook
{
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_.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&);
};

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

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 Byte [bookSize]);
    }

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

    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_CONFLATEDUDP_NAMESPACE_END