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>
 
#ifdef ONIXS_B3_UMDF_MD_CXX20
# include <compare>
# include <ranges>
#endif
 
ONIXS_B3_UMDF_MD_NAMESPACE_BEGIN
struct OrderBookPoolSettings
{
    size_t orderBooksAmount = 500;

    size_t chunksAmount = 1000;

    size_t chunkLength = 512 * 1024;

    bool preferHugePage = false;

    struct GrowthPolicy
    {
        enum Policy
        {
            Addition,

            Multiplication
        };
 
        Policy policy;

        double arg;
    };
 
    GrowthPolicy growthPolicy = {GrowthPolicy::Addition, 1.0f};
};

class ONIXS_B3_UMDF_MD_API OrderBookPool
{
public:
    explicit OrderBookPool(const OrderBookPoolSettings&);

    ~OrderBookPool();
 
    struct Statistic
    {
        int64_t maxChunksCountInUse_ = 0;
    };

    const Statistic& statistic() const noexcept
    {
        return statistic_;
    }
 
private:
    OrderBookPool(const OrderBookPool&) = delete;
    OrderBookPool& operator=(const OrderBookPool&) = delete;
 
    friend struct OrderBookPoolHelper;
    Statistic statistic_;
    void* const impl_;
 
    // for testing only
    OrderBookPool(const OrderBookPoolSettings& settings, NoCheck);
    friend struct TestOrdBookPoolCreator;
};

typedef UInt64 InstrumentId;

typedef UInt64 OrderId;

typedef Int64 Quantity;

typedef Messaging::PriceOptional Price;

struct Order
{
    Order(OrderId orderId, Price price, Quantity quantity) noexcept;

    std::string toString() const;

    ONIXS_B3_UMDF_MD_API
    void toString(std::string&) const;

    OrderId orderId() const noexcept { return orderId_; };

    Price price() const noexcept { return price_; };

    Quantity quantity() const noexcept { return quantity_; };

    bool marketOrder() const { return price_.isNull(); }
 
private:
    OrderId orderId_;
    Price price_;
    Quantity quantity_;
};

bool operator==(const Order& l, const Order& r) noexcept;

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

namespace Implementation
{
    class InstrumentRepository;
    class OrderStorage;
    struct alignas(1) BookOrderId { char _[3]; };
    typedef const BookOrderId* OrdersIterator;
};

class OrdersIterator
{
public:
    using iterator_concept = std::random_access_iterator_tag;
    using iterator_category = std::random_access_iterator_tag;
    using value_type = Order;
    using pointer = const Order*;
    using reference = const Order&;
    using difference_type = ptrdiff_t;

    OrdersIterator() noexcept = default;

    OrdersIterator(const OrdersIterator& r) noexcept = default;

    OrdersIterator& operator=(const OrdersIterator&) noexcept = default;

    void swap(OrdersIterator& other) noexcept
    {
        std::swap(storage_, other.storage_);
        std::swap(pos_, other.pos_);
    }

    bool valid() const noexcept
    {
        return storage_ != nullptr;
    }

    reference operator*() const noexcept
    {
        assert(valid());
 
        return *dereference();
    }

    pointer operator->() const noexcept
    {
        assert(valid());
 
        return dereference();
    }

    reference operator[] (difference_type n) const noexcept
    {
        assert(valid());
 
        return *dereference(n);
    }

    OrdersIterator operator++(int) noexcept
    {
        assert(valid());
 
        OrdersIterator tmp(*this);
        ++(*this);
        return tmp;
    }

    OrdersIterator& operator++() noexcept
    {
        assert(valid());
 
        ++pos_;
        return *this;
    }

    OrdersIterator operator+(difference_type v) const noexcept
    {
        assert(valid());
 
        return {storage_, pos_ + v};
    }

    OrdersIterator& operator+=(difference_type v) noexcept
    {
        assert(valid());
 
        pos_ += v;
        return *this;
    }

    OrdersIterator operator--(int) noexcept
    {
        assert(valid());
 
        OrdersIterator tmp(*this);
        --(*this);
        return tmp;
    }

    OrdersIterator& operator--() noexcept
    {
        assert(valid());
 
        --pos_;
        return *this;
    }

    OrdersIterator operator-(difference_type v) const noexcept
    {
        assert(valid());
 
        return {storage_, pos_ - v};
    }

    OrdersIterator& operator-=(difference_type v) noexcept
    {
        assert(valid());
 
        pos_ -= v;
        return *this;
    }

    friend OrdersIterator operator+(difference_type v, OrdersIterator it) noexcept
    {
        assert(it.valid());
 
        it += v;
        return it;
    }

    friend bool operator==(const OrdersIterator& l, const OrdersIterator& r) noexcept
    {
        assert(r.valid());
        assert(l.valid());
        assert(l.storage_ == r.storage_);
 
        return l.pos_ == r.pos_;
    }

    friend bool operator!=(const OrdersIterator& l, const OrdersIterator& r) noexcept
    {
        assert(r.valid());
        assert(l.valid());
        assert(l.storage_ == r.storage_);
 
        return l.pos_ != r.pos_;
    }
 
#ifdef ONIXS_B3_UMDF_MD_CXX20
    friend std::strong_ordering operator<=>(const OrdersIterator& l, const OrdersIterator& r) noexcept
    {
        assert(r.valid());
        assert(l.valid());
        assert(l.storage_ == r.storage_);
 
        if (l.pos_ < r.pos_)
            return std::strong_ordering::less;
 
        if (r.pos_ < l.pos_)
            return std::strong_ordering::greater;
 
        return std::strong_ordering::equal;
    }
#endif

    friend OrdersIterator::difference_type operator-(const OrdersIterator& l, const OrdersIterator& r) noexcept
    {
        assert(r.valid());
        assert(l.valid());
        assert(l.storage_ == r.storage_);
 
        return l.pos_ - r.pos_;
    }
 
private:
    friend class ConstOrdersRange;
    OrdersIterator(const Implementation::OrderStorage* storage, Implementation::OrdersIterator pos) noexcept
      : storage_(storage)
      , pos_(pos)
    {
    }
 
    ONIXS_B3_UMDF_MD_API pointer dereference(difference_type n = 0) const noexcept;
 
private:
    const Implementation::OrderStorage* storage_{};
    Implementation::OrdersIterator pos_{};
};

class ConstOrdersRange
#ifdef ONIXS_B3_UMDF_MD_CXX20
    : public std::ranges::view_interface<ConstOrdersRange>
#endif
{
public:
    OrdersIterator begin() const noexcept
    {
        assert(valid());
        return cbegin();
    }

    OrdersIterator end() const noexcept
    {
        assert(valid());
        return cend();
    }

    OrdersIterator cbegin() const noexcept
    {
        assert(valid());
        return {storage_, begin_};
    }

    OrdersIterator cend() const noexcept
    {
        assert(valid());
        return {storage_, end_};
    }

    bool empty() const noexcept
    {
        assert(valid());
        return begin_ == end_;
    }

    size_t size() const noexcept
    {
        assert(valid());
        return static_cast<size_t>(std::distance(begin_, end_));
    }

    const Order& operator[](size_t idx) const noexcept
    {
        assert(valid());
        assert(idx < size());
        return begin().operator[](idx);
    }

    ConstOrdersRange() noexcept = default;

    bool valid() const noexcept
    {
        return storage_ != nullptr;
    }
 
private:
    friend class OrderBook;
    ConstOrdersRange(Implementation::OrdersIterator begin, Implementation::OrdersIterator end, const Implementation::OrderStorage* storage) noexcept
      : begin_(begin)
      , end_(end)
      , storage_(storage)
    {}
 
private:
    Implementation::OrdersIterator begin_{};
    Implementation::OrdersIterator end_{};
    const Implementation::OrderStorage* storage_{};
};

class ONIXS_B3_UMDF_MD_API OrderBook
{
public:
    bool empty() const noexcept;

    ConstOrdersRange asks() const noexcept;

    ConstOrdersRange bids() const noexcept;

    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;

    OrderBook(const OrderBook&) = delete;
    OrderBook(OrderBook&&) = delete;
    OrderBook& operator=(const OrderBook&) = delete;
 
protected:
    OrderBook(size_t depth, const Implementation::InstrumentRepository* instrumentRepository) noexcept;
    ~OrderBook();
 
    const size_t depth_;
    const Implementation::InstrumentRepository* const instrumentRepository_;
 
private:
    const Implementation::OrderStorage* getStorage() const noexcept;
    InstrumentId instrumentId() const noexcept;
};

ONIXS_B3_UMDF_MD_API
void validate(const OrderBook&);
 
inline Order::Order(OrderId orderId, Price price, Quantity quantity) noexcept
  : orderId_(orderId)
  , price_(price)
  , quantity_(quantity)
{
}
 
inline bool operator==(const Order& l, const Order& r) noexcept
{
    return (l.orderId() == r.orderId()) && (l.price().mantissa() == r.price().mantissa()) && (l.quantity() == r.quantity());
}
 
inline std::string Order::toString() const
{
    std::string str;
    toString(str);
    return str;
}

struct BookAtomicChangeAction
{
    typedef UInt8 Base;

    enum Enum
    {
        New = 0,

        Change = 1,

        Delete = 2,

        Clean = 3,
    };
};

class BookAtomicChange
{
public:
    constexpr BookAtomicChange(
            Messaging::Side::Enum side, BookAtomicChangeAction::Enum action, const Order* previous, const Order* current) noexcept
        : side_(side)
        , action_(action)
        , previous_(previous)
        , current_(current)
    {
    }

    Messaging::Side::Enum side() const noexcept { return side_; }

    BookAtomicChangeAction::Enum action() const noexcept { return action_; }

    const Order* previous() const noexcept { return previous_; }

    const Order* current() const noexcept { return current_; }
 
private:
    Messaging::Side::Enum side_;
    BookAtomicChangeAction::Enum action_;
    const Order* previous_;
    const Order* current_;
};
 
ONIXS_B3_UMDF_MD_NAMESPACE_END
 
#ifdef ONIXS_B3_UMDF_MD_CXX20
namespace std::ranges { template <> inline constexpr bool enable_borrowed_range<OnixS::B3::MarketData::UMDF::ConstOrdersRange> = true; }
#endif