overlay.hpp

Go to the documentation of this file.

#pragma once
 
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <functional>
#include <span>
#include <string_view>
 
#include "itch/detail/wire.hpp"
#include "itch/parser.hpp"
 
namespace itch::overlay {
 
namespace detail {
 
template <typename FieldType>
[[nodiscard]] inline auto read_field(const std::byte* base, std::size_t offset) noexcept
    -> FieldType {
    FieldType value {};
    std::memcpy(&value, base + offset, sizeof(FieldType));
    if constexpr (std::is_integral_v<FieldType> && sizeof(FieldType) > 1) {
        return utils::from_big_endian(value);
    } else {
        return value;
    }
}
 
[[nodiscard]] inline auto read_timestamp(const std::byte* base, std::size_t offset) noexcept
    -> std::uint64_t {
    const auto    high        = read_field<std::uint16_t>(base, offset);
    const auto    low         = read_field<std::uint32_t>(base, offset + 2);
    constexpr int LOWER_SHIFT = 32;
    return (static_cast<std::uint64_t>(high) << LOWER_SHIFT) | low;
}
 
[[nodiscard]] inline auto read_stock(const std::byte* base, std::size_t offset) noexcept
    -> std::string_view {
    const void* raw = base + offset;
    return std::string_view {static_cast<const char*>(raw), 8};
}
 
// Common field offsets shared by every message after the 1-byte type.
constexpr std::size_t STOCK_LOCATE_OFFSET    = 1;
constexpr std::size_t TRACKING_NUMBER_OFFSET = 3;
constexpr std::size_t TIMESTAMP_OFFSET       = 5;
 
}  // namespace detail
 
class MessageView {
   public:
    constexpr MessageView() noexcept = default;
 
    explicit MessageView(const std::byte* data, std::size_t size) noexcept
        : m_data {data}, m_size {size} {}
 
    [[nodiscard]] auto type() const noexcept -> char {
        return static_cast<char>(static_cast<unsigned char>(m_data[0]));
    }
 
    [[nodiscard]] auto stock_locate() const noexcept -> std::uint16_t {
        return detail::read_field<std::uint16_t>(m_data, detail::STOCK_LOCATE_OFFSET);
    }
 
    [[nodiscard]] auto tracking_number() const noexcept -> std::uint16_t {
        return detail::read_field<std::uint16_t>(m_data, detail::TRACKING_NUMBER_OFFSET);
    }
 
    [[nodiscard]] auto timestamp() const noexcept -> std::uint64_t {
        return detail::read_timestamp(m_data, detail::TIMESTAMP_OFFSET);
    }
 
    [[nodiscard]] auto size() const noexcept -> std::size_t { return m_size; }
 
    [[nodiscard]] auto data() const noexcept -> const std::byte* { return m_data; }
 
    template <typename FieldType>
    [[nodiscard]] auto read(std::size_t offset) const noexcept -> FieldType {
        return detail::read_field<FieldType>(m_data, offset);
    }
 
   protected:
    const std::byte* m_data {nullptr};
    std::size_t      m_size {0};
};
 
class AddOrderView : public MessageView {
   public:
    using MessageView::MessageView;
 
    [[nodiscard]] auto order_reference_number() const noexcept -> std::uint64_t {
        return read<std::uint64_t>(11);
    }
 
    [[nodiscard]] auto buy_sell_indicator() const noexcept -> char { return read<char>(19); }
 
    [[nodiscard]] auto shares() const noexcept -> std::uint32_t { return read<std::uint32_t>(20); }
 
    [[nodiscard]] auto stock() const noexcept -> std::string_view {
        return detail::read_stock(m_data, 24);
    }
 
    [[nodiscard]] auto price() const noexcept -> std::uint32_t { return read<std::uint32_t>(32); }
};
 
class OrderExecutedView : public MessageView {
   public:
    using MessageView::MessageView;
 
    [[nodiscard]] auto order_reference_number() const noexcept -> std::uint64_t {
        return read<std::uint64_t>(11);
    }
 
    [[nodiscard]] auto executed_shares() const noexcept -> std::uint32_t {
        return read<std::uint32_t>(19);
    }
 
    [[nodiscard]] auto match_number() const noexcept -> std::uint64_t {
        return read<std::uint64_t>(23);
    }
};
 
class OrderExecutedWithPriceView : public MessageView {
   public:
    using MessageView::MessageView;
 
    [[nodiscard]] auto order_reference_number() const noexcept -> std::uint64_t {
        return read<std::uint64_t>(11);
    }
 
    [[nodiscard]] auto executed_shares() const noexcept -> std::uint32_t {
        return read<std::uint32_t>(19);
    }
 
    [[nodiscard]] auto match_number() const noexcept -> std::uint64_t {
        return read<std::uint64_t>(23);
    }
 
    [[nodiscard]] auto printable() const noexcept -> char { return read<char>(31); }
 
    [[nodiscard]] auto execution_price() const noexcept -> std::uint32_t {
        return read<std::uint32_t>(32);
    }
};
 
class OrderCancelView : public MessageView {
   public:
    using MessageView::MessageView;
 
    [[nodiscard]] auto order_reference_number() const noexcept -> std::uint64_t {
        return read<std::uint64_t>(11);
    }
 
    [[nodiscard]] auto cancelled_shares() const noexcept -> std::uint32_t {
        return read<std::uint32_t>(19);
    }
};
 
class OrderDeleteView : public MessageView {
   public:
    using MessageView::MessageView;
 
    [[nodiscard]] auto order_reference_number() const noexcept -> std::uint64_t {
        return read<std::uint64_t>(11);
    }
};
 
class OrderReplaceView : public MessageView {
   public:
    using MessageView::MessageView;
 
    [[nodiscard]] auto original_order_reference_number() const noexcept -> std::uint64_t {
        return read<std::uint64_t>(11);
    }
 
    [[nodiscard]] auto new_order_reference_number() const noexcept -> std::uint64_t {
        return read<std::uint64_t>(19);
    }
 
    [[nodiscard]] auto shares() const noexcept -> std::uint32_t { return read<std::uint32_t>(27); }
 
    [[nodiscard]] auto price() const noexcept -> std::uint32_t { return read<std::uint32_t>(31); }
};
 
class NonCrossTradeView : public MessageView {
   public:
    using MessageView::MessageView;
 
    [[nodiscard]] auto order_reference_number() const noexcept -> std::uint64_t {
        return read<std::uint64_t>(11);
    }
 
    [[nodiscard]] auto buy_sell_indicator() const noexcept -> char { return read<char>(19); }
 
    [[nodiscard]] auto shares() const noexcept -> std::uint32_t { return read<std::uint32_t>(20); }
 
    [[nodiscard]] auto stock() const noexcept -> std::string_view {
        return detail::read_stock(m_data, 24);
    }
 
    [[nodiscard]] auto price() const noexcept -> std::uint32_t { return read<std::uint32_t>(32); }
 
    [[nodiscard]] auto match_number() const noexcept -> std::uint64_t {
        return read<std::uint64_t>(36);
    }
};
 
using ViewCallback = std::function<void(const MessageView&)>;
 
[[nodiscard]] consteval auto build_size_table() -> std::array<std::uint16_t, 256> {
    std::array<std::uint16_t, 256> table {};
    auto                           add = [&table]<typename MsgType>(char type) {
        table[static_cast<unsigned char>(type)] =
            static_cast<std::uint16_t>(itch::detail::WIRE_SIZE<MsgType>);
    };
    itch::detail::for_each_message_type(add);
    return table;
}
 
inline constexpr auto SIZE_TABLE = build_size_table();
 
inline auto for_each_message(std::span<const std::byte> data, const ViewCallback& callback)
    -> std::uint64_t {
    std::uint64_t delivered = 0;
    std::size_t   offset    = 0;
    while (offset + sizeof(std::uint16_t) <= data.size()) {
        std::uint16_t length {};
        std::memcpy(&length, data.data() + offset, sizeof(length));
        length = utils::from_big_endian(length);
        offset += sizeof(std::uint16_t);
        if (length == 0) {
            continue;
        }
        if (offset + length > data.size()) {
            break;
        }
        const std::byte* frame        = data.data() + offset;
        const auto       message_type = static_cast<unsigned char>(frame[0]);
        offset += length;
 
        const std::uint16_t expected = SIZE_TABLE[message_type];
        if (expected == 0 || length < expected) {
            continue;  // Unknown type or undersized frame.
        }
        callback(MessageView {frame, length});
        ++delivered;
    }
    return delivered;
}
 
}  // namespace itch::overlay