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/B3/MarketData/UMDF/ABI.h>
#include <OnixS/B3/MarketData/UMDF/Defines.h>
#include <OnixS/B3/MarketData/UMDF/messaging/Composites.h>

#include <vector>
#include <memory>

namespace OnixS
{
    namespace B3
    {
        namespace MarketData
        {
            namespace UMDF
            {
                /// Alias for Instrument Id type.
                typedef UInt64 InstrumentId;

                /// Alias for Order Id type.
                typedef UInt64 OrderId;

                /// Alias for Quantity type.
                typedef Int64 Quantity;

                /// Alias for Price type (4 decimal places)
                typedef Messaging::PriceOptional Price;


                /// Order information
                struct Order
                {
                    /// Initializes the instances according to specified attributes.
                    Order(OrderId orderId, Price price, Quantity quantity) ONIXS_B3_UMDF_MD_NOTHROW;

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

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

                    /// Order Id
                    OrderId orderId() const ONIXS_B3_UMDF_MD_NOTHROW { return orderId_; };

                    /// Price
                    Price price() const ONIXS_B3_UMDF_MD_NOTHROW { return price_; };

                    /// Quantity
                    Quantity quantity() const ONIXS_B3_UMDF_MD_NOTHROW { return quantity_; };

                    /// Indicates whether the order is the market order.
                    bool marketOrder() const { return price_.isNull(); }

                private:
                    OrderId orderId_;
                    Price price_;
                    Quantity quantity_;
                };

                /// compare
                bool operator==(const Order& l, const Order& r) ONIXS_B3_UMDF_MD_NOTHROW;

                ///
                ONIXS_B3_UMDF_MD_API
                std::ostream& operator<<(std::ostream& stream, const Order& value);

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

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

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

                /// Sequence of price levels.
                typedef OrderCollections::Array Orders;

                /// Iterator to access price levels with write permissions.
                typedef OrderCollections::ArrayEntry OrderEntry;

                /// Iterator over read-only collection of price levels.
                typedef OrderCollections::ArrayConstEntry OrderConstEntry;

                /// Order Book.
                /// A set of bid and ask orders for the given
                /// security (bids are descending and asks are ascending).
                /// The quantity is provided at each price level.
                class ONIXS_B3_UMDF_MD_API OrderBook
                {
                    public:
                        // Base initialization.
                        OrderBook ();

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

                        /// Instrument Id
                        InstrumentId instrumentId() const;

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

                        /// 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;

                        /// Returns a set of descending bid prices for the given security.
                        const Orders& asks() const;

                        /// Returns a set of ascending ask prices for the given security.
                        const Orders& bids() const;

                        /// Returns the last processed packet sequence number of the incremental channel
                        Messaging::SeqNum lastMessageSeqNumApplied() const;

                        /// Returns the last processed RptSeq (sequence number per instrument update) for this instrument.
                        Messaging::RptSeq lastRptSeq() const;

                    private:
                        virtual const Orders& doAsks() const = 0;
                        virtual const Orders& doBids() const = 0;
                        virtual InstrumentId doInstrumentID() const = 0;
                        virtual Messaging::SeqNum doLastMessageSeqNumApplied() const = 0;
                        virtual Messaging::RptSeq doLastRptSeq() const = 0;
                };

                /// For testing only.
                void validate(const OrderBook&);

                inline Order::Order(OrderId orderId, Price price, Quantity quantity) ONIXS_B3_UMDF_MD_NOTHROW
                  : orderId_(orderId)
                  , price_(price)
                  , quantity_(quantity)
                {
                }

                inline bool operator==(const Order& l, const Order& r) ONIXS_B3_UMDF_MD_NOTHROW
                {
                    return (l.orderId() == r.orderId()) && (l.price().mantissa() == r.price().mantissa()) && (l.quantity() == r.quantity());
                }

                inline const Orders& OrderBook::asks() const
                {
                    return doAsks();
                }

                inline const Orders& OrderBook::bids() const
                {
                    return doBids();
                }

                inline InstrumentId OrderBook::instrumentId() const
                {
                    return doInstrumentID();
                }

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

                inline Messaging::SeqNum OrderBook::lastMessageSeqNumApplied() const
                {
                    return doLastMessageSeqNumApplied();
                }

                inline Messaging::RptSeq OrderBook::lastRptSeq() const
                {
                    return doLastRptSeq();
                }

                inline std::string Order::toString() const
                {
                    std::string str;
                    toString(str);
                    return str;
                }
            }
        }
    }
}