OrderBook.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/Eurex/MarketData/Defines.h>

#include <vector>

namespace OnixS
{
    namespace Eurex
    {
        namespace MarketData
        {
            /// Encapsulates price level concept.
            struct ONIXS_EUREX_EMDI_API PriceLevel
            {
                public:
                    /// Default initialization.
                    PriceLevel();

                    /// Initializes the instances according to specified attributes.
                    PriceLevel (Decimal price, Quantity quantity, Quantity numberOfOrders);

                    /// Price value.
                    Decimal price() const;

                    /// Updates price value.
                    void price (Decimal value);

                    /// Quantify for the given price.
                    Quantity quantity() const;

                    /// Updates quantity value.
                    void quantity (Quantity value);

                    /// Total number of orders of given price.
                    Quantity numberOfOrders() const;

                    /// Updates total number of orders.
                    void numberOfOrders (Quantity value);

                    /// Returns string representation of the instance.
                    std::string toString() const;

                    /// Appends representation of the instance to the string.
                    void toString (std::string&) const;

                protected:
                    Decimal price_;

                    Quantity qty_;
                    Quantity ordersQty_;
            };

            ///
            bool operator ==(const PriceLevel& l, const PriceLevel& r);

            ///
            std::ostream& operator<< (std::ostream& s, const PriceLevel& lvl);


            inline Decimal PriceLevel::price() const
            {
                return price_;
            }

            inline void PriceLevel::price (Decimal value)
            {
                price_ = value;
            }

            inline Quantity PriceLevel::quantity() const
            {
                return qty_;
            }

            inline void PriceLevel::quantity (Quantity value)
            {
                qty_ = value;
            }

            inline Quantity PriceLevel::numberOfOrders() const
            {
                return ordersQty_;
            }

            inline void PriceLevel::numberOfOrders (Quantity value)
            {
                ordersQty_ = value;
            }

            inline std::string PriceLevel::toString() const
            {
                std::string str;

                toString (str);

                return str;
            }

            bool isValid (const PriceLevel& level);

            /// Miscellaneous traits for PriceLevel class.
            struct ONIXS_EUREX_EMDI_API PriceLevelCollections
            {
                /// Sequential collection of price levels.
                typedef std::vector<PriceLevel> Array;

                /// Mutable entry iterator.
                typedef Array::iterator ArrayEntry;

                /// Iterator for read-only access.
                typedef Array::const_iterator ArrayConstEntry;
            };

            /// Sequence of price levels.
            typedef PriceLevelCollections::Array PriceLevels;

            /// Iterator to access price levels with write permissions.
            typedef PriceLevelCollections::ArrayEntry PriceLevelsEntry;

            /// Iterator over read-only collection of price levels.
            typedef PriceLevelCollections::ArrayConstEntry PriceLevelsConstEntry;

            /// Order Book.
            ///
            /// A set of bid prices and ask prices for the given
            /// security (bids are descending and asks are ascending).
            /// The quantity is provided at each price level.
            class ONIXS_EUREX_EMDI_API OrderBook
            {
                public:
                    typedef PriceLevels PriceLevelsType;

                    /// Destruction interface.
                    virtual ~OrderBook();

                    /// Unique instrument Id (tag 48) as qualified
                    /// by the exchange per tag 22-SecurityIDSource.
                    SecurityId securityId() const;

                    /// Sequence number of the last processed message
                    virtual UInt32 lastMsgSeqNumProcessed() const = 0;

                    /// Returns the maximum book depth.
                    size_t depth() const;

                    /// Indicates whether book has no bids & asks.
                    bool empty() const;

                    /// Returns a set of descending bid prices for the given security.
                    virtual const PriceLevels& asks() const = 0;

                    /// Returns a set of ascending ask prices for the given security.
                    virtual const PriceLevels& bids() const = 0;

                    /// Returns best implied ask
                    virtual bool bestAsk (Decimal& price, Quantity& quantity) const = 0;

                    /// Returns best implied bid
                    virtual bool bestBid (Decimal& price, Quantity& quantity) const = 0;

                    /// For bids and offers the official time of book entry, for trades official time of execution (all in nanoseconds).
                    virtual UInt64 mdEntryTime () const = 0;

                    /// String presentation of the book.
                    std::string toString() const;

                    /// String presentation of the book.
                    void toString (std::string&) const;

                    /// Returns brief book info.
                    std::string toShortString() const;

                    /// Appends brief book info to the string.
                    void toShortString (std::string&) const;

                    /// Returns formatted presentation of the book.
                    std::string toFormattedString() const;

                    /// Appends Formatted presentation of the book.
                    void toFormattedString (std::string&) const;

                    /// Creates immutable snapshot of the book.
                    OrderBook* snapshot() const;

                    /// Allocation operator to avoid runtime collision.
                    /// Primarily designed for snapshot/cloning.
                    void* operator new (size_t bookSize);

                    /// De-allocating operator to avoid runtime collision.
                    /// Primarily designed for snapshot/cloning.
                    void operator delete (void* book);

                protected:
                    // Security id.
                    SecurityId securityId_;

                    // Depth (max num. of price levels) of book.
                    size_t depth_;

                    // Base initialization.
                    OrderBook (SecurityId securityId, size_t bookDepth);

                private:
                    // No public copies are allowed.
                    // Snapshot creation is exposed instead.

                    OrderBook (const OrderBook& book);
                    OrderBook& operator= (const OrderBook& book);
            };

            /// checks whether the given book is properly built
            void checkSanity (const OrderBook& book);

            inline SecurityId OrderBook::securityId() const
            {
                return securityId_;
            }

            inline size_t OrderBook::depth() const
            {
                return depth_;
            }

            inline bool OrderBook::empty() const
            {
                return bids().empty() && asks().empty();
            }

            inline std::string OrderBook::toString() const
            {
                std::string str;

                toString (str);

                return str;
            }

            inline std::string OrderBook::toShortString() const
            {
                std::string str;

                toShortString (str);

                return str;
            }

            inline std::string OrderBook::toFormattedString() const
            {
                std::string str;

                toFormattedString (str);

                return str;
            }
        }
    }
}