bars.hpp

Go to the documentation of this file.

#pragma once
 
 
#include <algorithm>
#include <cstdint>
#include <functional>
#include <utility>
 
#include "itch/price.hpp"
#include "itch/tape.hpp"
 
namespace itch::analytics {
 
struct Bar {
    std::uint64_t bucket {0};           
    std::uint64_t start_timestamp {0};  
    std::uint64_t end_timestamp {0};    
    StandardPrice open {};              
    StandardPrice high {};              
    StandardPrice low {};               
    StandardPrice close {};             
    std::uint64_t volume {0};           
    std::uint64_t trade_count {0};      
};
 
using BarCallback = std::function<void(const Bar&)>;
 
struct TimeClock {
    std::uint64_t interval_ns {1};
 
    [[nodiscard]] auto bucket(const Trade& trade, std::uint64_t, std::uint64_t) const noexcept
        -> std::uint64_t {
        return trade.timestamp / interval_ns;
    }
};
 
struct TickClock {
    std::uint64_t ticks_per_bar {1};
 
    [[nodiscard]] auto bucket(const Trade&, std::uint64_t, std::uint64_t tick_index) const noexcept
        -> std::uint64_t {
        return tick_index / ticks_per_bar;
    }
};
 
struct VolumeClock {
    std::uint64_t volume_per_bar {1};
 
    [[nodiscard]] auto bucket(const Trade&, std::uint64_t cumulative_volume, std::uint64_t)
        const noexcept -> std::uint64_t {
        return cumulative_volume / volume_per_bar;
    }
};
 
template <typename Clock>
class BarBuilder {
   public:
    BarBuilder(Clock clock, BarCallback callback)
        : m_clock {std::move(clock)}, m_callback {std::move(callback)} {}
 
    auto add(const Trade& trade) -> void {
        const std::uint64_t bucket = m_clock.bucket(trade, m_cumulative_volume, m_tick_index);
        if (m_has_bar && bucket != m_bar.bucket) {
            emit();
        }
        if (!m_has_bar) {
            m_bar                 = Bar {};
            m_bar.bucket          = bucket;
            m_bar.start_timestamp = trade.timestamp;
            m_bar.open            = trade.price;
            m_bar.high            = trade.price;
            m_bar.low             = trade.price;
            m_has_bar             = true;
        }
        m_bar.high          = std::max(m_bar.high, trade.price);
        m_bar.low           = std::min(m_bar.low, trade.price);
        m_bar.close         = trade.price;
        m_bar.end_timestamp = trade.timestamp;
        m_bar.volume += trade.shares;
        ++m_bar.trade_count;
 
        m_cumulative_volume += trade.shares;
        ++m_tick_index;
    }
 
    auto flush() -> void {
        if (m_has_bar) {
            emit();
        }
    }
 
   private:
    auto emit() -> void {
        if (m_callback) {
            m_callback(m_bar);
        }
        m_has_bar = false;
    }
 
    Clock         m_clock;
    BarCallback   m_callback;
    Bar           m_bar {};
    bool          m_has_bar {false};
    std::uint64_t m_cumulative_volume {0};
    std::uint64_t m_tick_index {0};
};
 
}  // namespace itch::analytics