itch.hpp

#pragma once
 
#include <array>
#include <bit>
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <expected>
#include <string>
#include <string_view>
 
#include <order_book/feed.hpp>
 
namespace order_book {

enum class ItchKind : std::uint8_t {
    Add,     
    Execute, 
    Delete,  
    Replace, 
    Trade,   
    Skipped, 
};

struct ItchMessage {
    std::uint64_t time;        
    std::uint64_t order;       
    std::uint64_t replacement; 
    std::string_view stock;    
    Shares shares;             
    Price price;               
    std::uint16_t locate;      
    ItchKind kind;             
    Side side;                 
    friend bool operator==(const ItchMessage&, const ItchMessage&) = default;
};

struct ItchError {
    enum class Reason : std::uint8_t {
        Empty,       
        UnknownType, 
        WrongSize,   
        InvalidSide, 
    };
    Reason reason;    
    char type;        
    std::size_t size; 
    std::uint64_t value; 
    friend bool operator==(const ItchError&, const ItchError&) = default;
};

[[nodiscard]] std::string describe(const ItchError& error);
 
namespace itch_detail {
 
// Field offsets from the specification. Every message starts with its type, stock locate,
// tracking number, and timestamp, and every type the book uses then names an order.
constexpr std::size_t locate_offset = 1;
constexpr std::size_t time_offset = 5;
constexpr std::size_t order_offset = 11;
// A and F
constexpr std::size_t side_offset = 19;
constexpr std::size_t add_shares_offset = 20;
constexpr std::size_t stock_offset = 24;
constexpr std::size_t stock_size = 8;
constexpr std::size_t add_price_offset = 32;
// E, C, and X
constexpr std::size_t shares_offset = 19;
// U
constexpr std::size_t new_order_offset = 19;
constexpr std::size_t replace_shares_offset = 27;
constexpr std::size_t replace_price_offset = 31;
 
// The specification's message types the book does not use
constexpr std::string_view skipped_types = "SRHYLVWKJhBINO";
 
struct Size {
    char type;
    std::uint8_t size;
};
// Size of each message type the book uses
constexpr std::array sizes{
    Size{.type = 'A', .size = 36}, Size{.type = 'F', .size = 40}, Size{.type = 'E', .size = 31},
    Size{.type = 'C', .size = 36}, Size{.type = 'X', .size = 23}, Size{.type = 'D', .size = 19},
    Size{.type = 'U', .size = 35}, Size{.type = 'P', .size = 44}, Size{.type = 'Q', .size = 40},
};
// Sizes by type byte, so each message costs one lookup: 0 for a type the book does not use
constexpr auto size_by_type = [] {
    std::array<std::uint8_t, 256> table{};
    for (const auto& [type, size] : sizes) {
        table[static_cast<unsigned char>(type)] = size;
    }
    return table;
}();
 
constexpr std::size_t message_size(char type)
{
    return size_by_type[static_cast<unsigned char>(type)];
}
 
// Big-endian unsigned integer at `offset`, which the caller has checked lies within `message`
template <typename T> T read(std::string_view message, std::size_t offset)
{
    T value{};
    std::memcpy(&value, message.data() + offset, sizeof(T));
    if constexpr (std::endian::native == std::endian::little) {
        value = std::byteswap(value);
    }
    return value;
}
 
// The 6-byte timestamp
inline std::uint64_t read_time(std::string_view message)
{
    constexpr unsigned high_shift = 32;
    return (std::uint64_t{read<std::uint16_t>(message, time_offset)} << high_shift) |
           read<std::uint32_t>(message, time_offset + 2);
}
 
} // namespace itch_detail

template <typename Handler> decltype(auto) visit_itch(std::string_view message, Handler&& handler)
{
    using namespace itch_detail;
    if (message.empty()) {
        return handler.error(
            ItchError{.reason = ItchError::Reason::Empty, .type = 0, .size = 0, .value = 0});
    }
    const auto type = message.front();
    const auto size = message_size(type);
    if (size == 0) {
        if (skipped_types.contains(type)) {
            return handler.skipped();
        }
        return handler.error(ItchError{
            .reason = ItchError::Reason::UnknownType,
            .type = type,
            .size = 0,
            .value = 0,
        });
    }
    if (message.size() != size) {
        return handler.error(ItchError{
            .reason = ItchError::Reason::WrongSize,
            .type = type,
            .size = message.size(),
            .value = size,
        });
    }
 
    ItchMessage decoded{
        .time = read_time(message),
        .order = 0,
        .replacement = 0,
        .stock = {},
        .shares = 0,
        .price = 0,
        .locate = read<std::uint16_t>(message, locate_offset),
        .kind = ItchKind::Trade,
        .side = Side::Buy,
    };
    if (type == 'P' || type == 'Q') {
        // Trades, whose order field, if any, names no order on the book
        return handler.trade(decoded);
    }
    decoded.order = read<std::uint64_t>(message, order_offset);
    if (type == 'U') {
        decoded.replacement = read<std::uint64_t>(message, new_order_offset);
    }
    switch (type) {
    case 'A':
    case 'F': {
        const auto side = message[side_offset];
        if (side != 'B' && side != 'S') {
            return handler.error(ItchError{
                .reason = ItchError::Reason::InvalidSide,
                .type = side,
                .size = 0,
                .value = 0,
            });
        }
        decoded.kind = ItchKind::Add;
        decoded.stock = message.substr(stock_offset, stock_size);
        decoded.shares = read<std::uint32_t>(message, add_shares_offset);
        decoded.price = read<std::uint32_t>(message, add_price_offset);
        decoded.side = side == 'B' ? Side::Buy : Side::Sell;
        return handler.add(decoded);
    }
    case 'D':
        decoded.kind = ItchKind::Delete;
        return handler.remove(decoded);
    case 'U':
        decoded.kind = ItchKind::Replace;
        decoded.shares = read<std::uint32_t>(message, replace_shares_offset);
        decoded.price = read<std::uint32_t>(message, replace_price_offset);
        return handler.replace(decoded);
    default:
        // E, C, and X
        decoded.kind = ItchKind::Execute;
        decoded.shares = read<std::uint32_t>(message, shares_offset);
        return handler.execute(decoded);
    }
}

[[nodiscard]] std::expected<ItchMessage, ItchError> decode_itch(std::string_view message);

struct ItchPeek {
    std::uint64_t order = 0;  
    std::uint16_t locate = 0; 
    friend bool operator==(const ItchPeek&, const ItchPeek&) = default;
};

inline ItchPeek peek_itch(std::string_view message)
{
    using itch_detail::order_offset;
    if (message.size() < order_offset + sizeof(std::uint64_t) ||
        itch_detail::message_size(message.front()) == 0) {
        return {};
    }
    return {
        .order = itch_detail::read<std::uint64_t>(message, order_offset),
        .locate = itch_detail::read<std::uint16_t>(message, itch_detail::locate_offset),
    };
}
 
} // namespace order_book