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/HKEX/MarketData/Omdc/ABI.h>
#include <OnixS/HKEX/MarketData/Omdc/Defines.h>
#include <OnixS/HKEX/MarketData/Omdc/String.h>
 
#include <vector>
#include <memory>
 
namespace OnixS
{
    namespace HKEX
    {
        namespace MarketData
        {
            namespace Omdc
            {
                struct ONIXS_HKEX_OMDC_API OrderInfo
                {
                    OrderInfo() ONIXS_HKEX_OMDC_NOTHROW;
                    OrderInfo (OrderId orderId, Quantity quantity) ONIXS_HKEX_OMDC_NOTHROW;
 
                    OrderId orderId_;
                    Quantity quantity_;
                };
 
                typedef std::vector<OrderInfo> OrderInfos;

                struct ONIXS_HKEX_OMDC_API PriceLevel
                {
                    PriceLevel();

                    explicit
                    PriceLevel (const Price& price,
                        Quantity quantity = 0,
                        Quantity numberOfOrders = 0,
                        const OrderInfos& orders = OrderInfos() );
 
#if defined(ONIXS_HKEX_OMDC_COMPILER_CXX_RVALUE_REFERENCES) && ONIXS_HKEX_OMDC_COMPILER_CXX_RVALUE_REFERENCES
 
                        PriceLevel(PriceLevel&&)
                        ONIXS_HKEX_OMDC_NOTHROW;
 
                        PriceLevel&
                        operator=(PriceLevel&& other)
                        ONIXS_HKEX_OMDC_NOTHROW;
#endif
 
#if defined(ONIXS_HKEX_OMDC_COMPILER_CXX_DEFAULTED_FUNCTIONS) && ONIXS_HKEX_OMDC_COMPILER_CXX_DEFAULTED_FUNCTIONS
                    PriceLevel(const PriceLevel&) = default;
#else
                    PriceLevel(const PriceLevel&);
#endif
 
                    PriceLevel&
                    operator=(const PriceLevel& other);

                    const Price& getPrice() const
                    ONIXS_HKEX_OMDC_NOTHROW;

                    void setPrice (const Price& value)
                    ONIXS_HKEX_OMDC_NOTHROW;

                    Quantity quantity() const
                    ONIXS_HKEX_OMDC_NOTHROW;

                    void quantity (Quantity value)
                    ONIXS_HKEX_OMDC_NOTHROW;

                    Quantity numberOfOrders() const
                    ONIXS_HKEX_OMDC_NOTHROW;

                    void numberOfOrders (Quantity value)
                    ONIXS_HKEX_OMDC_NOTHROW;

                    std::string toString() const;

                    void toString (std::string&) const;

                    void swap (PriceLevel&)
                    ONIXS_HKEX_OMDC_NOTHROW;

                    const OrderInfos& orders() const
                    ONIXS_HKEX_OMDC_NOTHROW;

                    void addOrderId(OrderId id, Quantity quantity);

                    void removeOrderId (OrderId id);

                    void updateOrderId(OrderId id, Quantity quantity);
 
                private:
                    Price price_;
                    Quantity qty_;
                    Quantity ordersQty_;
                    OrderInfos orders_;
                };

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

                bool isValid (const PriceLevel& level)
                ONIXS_HKEX_OMDC_NOTHROW;

                const Price& getPrice (const PriceLevel& level)
                ONIXS_HKEX_OMDC_NOTHROW;
 
                ONIXS_HKEX_OMDC_API
                std::ostream& operator << (std::ostream& stream, const PriceLevel& value);
 

                struct ONIXS_HKEX_OMDC_API PriceLevelCollections
                {
                    typedef std::vector<PriceLevel> Array;

                    typedef Array::iterator ArrayEntry;

                    typedef Array::const_iterator ArrayConstEntry;
                };

                typedef PriceLevelCollections::Array PriceLevels;

                typedef PriceLevelCollections::ArrayEntry PriceLevelsEntry;

                typedef PriceLevelCollections::ArrayConstEntry PriceLevelsConstEntry;

                class ONIXS_HKEX_OMDC_API OrderBook
                {
                    public:
                        // Base initialization.
                        OrderBook ();

                        virtual ~OrderBook() {};

                        InstrumentId instrumentId() const;

                        bool empty() const
                        ONIXS_HKEX_OMDC_NOTHROW;
 
                        bool bestAsk (Price& price, Quantity& quantity) const;
 
                        bool bestBid (Price& price, Quantity& quantity) const;

                        std::string toString() const;

                        void toString (std::string&) const;

                        std::string toShortString() const;

                        void toShortString (std::string&) const;

                        std::string toFormattedString() const;

                        void toFormattedString (std::string&) const;

                        const PriceLevels& asks() const;

                        const PriceLevels& bids() const;

                        UInt64 lastMessageSeqNumApplied() const;
 
 
                    private:
                        virtual const PriceLevels& doAsks() const = 0;
                        virtual const PriceLevels& doBids() const = 0;
                        virtual bool doBestAsk (Price& price, Quantity& quantity) const = 0;
                        virtual bool doBestBid (Price& price, Quantity& quantity) const = 0;
                        virtual InstrumentId doInstrumentID() const = 0;
                        virtual UInt64 doLastMessageSeqNumApplied() const = 0;
                };
 
                inline const Price& PriceLevel::getPrice() const
                ONIXS_HKEX_OMDC_NOTHROW
                {
                    return price_;
                }
 
                inline void PriceLevel::setPrice (const Price& value)
                ONIXS_HKEX_OMDC_NOTHROW
                {
                    price_ = value;
                }
 
                inline Quantity PriceLevel::quantity() const
                ONIXS_HKEX_OMDC_NOTHROW
                {
                    return qty_;
                }
 
                inline void PriceLevel::quantity (Quantity value)
                ONIXS_HKEX_OMDC_NOTHROW
                {
                    qty_ = value;
                }
 
                inline Quantity PriceLevel::numberOfOrders() const
                ONIXS_HKEX_OMDC_NOTHROW
                {
                    return ordersQty_;
                }
 
                inline void PriceLevel::numberOfOrders (Quantity value)
                ONIXS_HKEX_OMDC_NOTHROW
                {
                    ordersQty_ = value;
                }
 
                inline const Price& getPrice (const PriceLevel& level)
                ONIXS_HKEX_OMDC_NOTHROW
                {
                    return level.getPrice();
                }
 
                inline bool isValid (const PriceLevel& level)
                ONIXS_HKEX_OMDC_NOTHROW
                {
                    return (level.quantity() != 0);
                }
 
                inline bool operator== (const PriceLevel& l, const PriceLevel& r)
                ONIXS_HKEX_OMDC_NOTHROW
                {
                    return (l.quantity() == r.quantity() ) && (l.numberOfOrders() == r.numberOfOrders() ) && (l.getPrice() == r.getPrice() );
                }
 
                inline const PriceLevels& OrderBook::asks() const
                {
                    return doAsks();
                }
 
                inline const PriceLevels& OrderBook::bids() const
                {
                    return doBids();
                }
 
                inline bool OrderBook::bestAsk (Price& price, Quantity& quantity ) const
                {
                    return doBestAsk (price, quantity);
                }
 
                inline bool OrderBook::bestBid (Price& price, Quantity& quantity ) const
                {
                    return doBestBid (price, quantity);
                }
 
                inline InstrumentId OrderBook::instrumentId() const
                {
                    return doInstrumentID();
                }
 
                inline bool OrderBook::empty() const
                ONIXS_HKEX_OMDC_NOTHROW
                {
                    return bids().empty() && asks().empty();
                }
 
                inline UInt64 OrderBook::lastMessageSeqNumApplied() const
                {
                    return doLastMessageSeqNumApplied();
                }
            }
        }
    }
}