auctions.hpp

Go to the documentation of this file.

#pragma once
 
 
#include <array>
#include <cstdint>
#include <functional>
#include <string>
#include <string_view>
#include <unordered_map>
#include <utility>
#include <variant>
 
#include "itch/analytics/imbalance.hpp"
#include "itch/indicators.hpp"
#include "itch/messages.hpp"
#include "itch/price.hpp"
 
namespace itch::analytics {
 
struct Auction {
    std::uint64_t timestamp {0};
    std::uint16_t stock_locate {0};
    std::string   stock;
    char          cross_type {'\0'};     
    StandardPrice cross_price {};        
    std::uint64_t cross_shares {0};      
    std::uint64_t paired_shares {0};     
    std::uint64_t imbalance_shares {0};  
    char          imbalance_direction {'\0'};
    bool          had_imbalance {false};  
};
 
[[nodiscard]] inline auto cross_type_name(char cross_type) -> std::string_view {
    constexpr indicators::FrozenMap types {std::to_array<std::pair<char, std::string_view>>({
        {'O', "Opening Cross"},
        {'C', "Closing Cross"},
        {'H', "Cross for halted/paused security"},
        {'I', "Intraday/IPO Cross"},
    })};
    return types.at_or(cross_type, "Unknown");
}
 
class AuctionTracker {
   public:
    using AuctionCallback = std::function<void(const Auction&)>;
 
    auto set_auction_callback(AuctionCallback callback) -> void {
        m_callback = std::move(callback);
    }
 
    auto process(const Message& message) -> void {
        if (const auto* noii = std::get_if<NOIIMessage>(&message)) {
            m_latest_imbalance[noii->stock_locate] = make_imbalance_info(*noii);
            return;
        }
        if (const auto* cross = std::get_if<CrossTradeMessage>(&message)) {
            Auction auction {};
            auction.timestamp    = cross->timestamp;
            auction.stock_locate = cross->stock_locate;
            auction.stock        = to_string(cross->stock, STOCK_LEN);
            auction.cross_type   = cross->cross_type;
            auction.cross_price  = StandardPrice {cross->cross_price};
            auction.cross_shares = cross->shares;
 
            const auto iter = m_latest_imbalance.find(cross->stock_locate);
            if (iter != m_latest_imbalance.end()) {
                auction.paired_shares       = iter->second.paired_shares;
                auction.imbalance_shares    = iter->second.imbalance_shares;
                auction.imbalance_direction = iter->second.imbalance_direction;
                auction.had_imbalance       = true;
            }
            if (m_callback) {
                m_callback(auction);
            }
            return;
        }
    }
 
   private:
    std::unordered_map<std::uint16_t, ImbalanceInfo> m_latest_imbalance;
    AuctionCallback                                  m_callback {};
};
 
}  // namespace itch::analytics