time_tagged_events.hpp

/*
 * This file is part of libtcspc
 * Copyright 2019-2026 Board of Regents of the University of Wisconsin System
 * SPDX-License-Identifier: MIT
 */
 
#pragma once
 
#include "numeric_traits.hpp"
 
#include <array>
#include <ostream>
#include <type_traits>
 
namespace tcspc {

template <typename NumericTraits = default_numeric_traits>
struct time_reached_event {
    NumericTraits::abstime_type abstime;
    static_assert(std::is_integral_v<decltype(abstime)>);

    friend auto operator==(time_reached_event const &lhs,
                           time_reached_event const &rhs) noexcept
        -> bool = default;

    friend auto operator<<(std::ostream &s, time_reached_event const &e)
        -> std::ostream & {
        return s << "time_reached(" << e.abstime << ')';
    }
};

template <typename NumericTraits = default_numeric_traits>
struct data_lost_event {
    NumericTraits::abstime_type abstime;
    static_assert(std::is_integral_v<decltype(abstime)>);

    friend auto operator==(data_lost_event const &lhs,
                           data_lost_event const &rhs) noexcept
        -> bool = default;

    friend auto operator<<(std::ostream &s, data_lost_event const &e)
        -> std::ostream & {
        return s << "data_lost(" << e.abstime << ')';
    }
};

template <typename NumericTraits = default_numeric_traits>
struct begin_lost_interval_event {
    NumericTraits::abstime_type abstime;
    static_assert(std::is_integral_v<decltype(abstime)>);

    friend auto operator==(begin_lost_interval_event const &lhs,
                           begin_lost_interval_event const &rhs) noexcept
        -> bool = default;

    friend auto operator<<(std::ostream &s, begin_lost_interval_event const &e)
        -> std::ostream & {
        (void)e;
        return s << "begin_lost_interval()";
    }
};

template <typename NumericTraits = default_numeric_traits>
struct end_lost_interval_event {
    NumericTraits::abstime_type abstime;
    static_assert(std::is_integral_v<decltype(abstime)>);

    friend auto operator==(end_lost_interval_event const &lhs,
                           end_lost_interval_event const &rhs) noexcept
        -> bool = default;

    friend auto operator<<(std::ostream &s, end_lost_interval_event const &e)
        -> std::ostream & {
        (void)e;
        return s << "end_lost_interval()";
    }
};

template <typename NumericTraits = default_numeric_traits>
struct lost_counts_event {
    NumericTraits::abstime_type abstime;
    static_assert(std::is_integral_v<decltype(abstime)>);

    NumericTraits::channel_type channel;
    static_assert(std::is_integral_v<decltype(channel)>);

    NumericTraits::count_type count;
    static_assert(std::is_integral_v<decltype(count)>);

    friend auto operator==(lost_counts_event const &lhs,
                           lost_counts_event const &rhs) noexcept
        -> bool = default;

    friend auto operator<<(std::ostream &s, lost_counts_event const &e)
        -> std::ostream & {
        return s << "lost_counts(" << e.abstime << ", " << e.channel << ", "
                 << e.count << ')';
    }
};

template <typename NumericTraits = default_numeric_traits>
struct bulk_counts_event {
    NumericTraits::abstime_type abstime;
    static_assert(std::is_integral_v<decltype(abstime)>);

    NumericTraits::channel_type channel;
    static_assert(std::is_integral_v<decltype(channel)>);

    NumericTraits::count_type count;
    static_assert(std::is_integral_v<decltype(count)>);

    friend auto operator==(bulk_counts_event const &lhs,
                           bulk_counts_event const &rhs) noexcept
        -> bool = default;

    friend auto operator<<(std::ostream &s, bulk_counts_event const &e)
        -> std::ostream & {
        return s << "bulk_counts(" << e.abstime << ", " << e.channel << ", "
                 << e.count << ')';
    }
};

template <typename NumericTraits = default_numeric_traits>
struct detection_event {
    NumericTraits::abstime_type abstime;
    static_assert(std::is_integral_v<decltype(abstime)>);

    NumericTraits::channel_type channel;
    static_assert(std::is_integral_v<decltype(channel)>);

    friend auto operator==(detection_event const &lhs,
                           detection_event const &rhs) noexcept
        -> bool = default;

    friend auto operator<<(std::ostream &s, detection_event const &e)
        -> std::ostream & {
        return s << "detection(" << e.abstime << ", " << e.channel << ')';
    }
};

template <typename NumericTraits = default_numeric_traits>
struct time_correlated_detection_event {
    NumericTraits::abstime_type abstime;
    static_assert(std::is_integral_v<decltype(abstime)>);

    NumericTraits::channel_type channel;
    static_assert(std::is_integral_v<decltype(channel)>);

    NumericTraits::difftime_type difftime;
    static_assert(std::is_integral_v<decltype(difftime)>);

    friend auto operator==(time_correlated_detection_event const &lhs,
                           time_correlated_detection_event const &rhs) noexcept
        -> bool = default;

    friend auto operator<<(std::ostream &s,
                           time_correlated_detection_event const &e)
        -> std::ostream & {
        return s << "time_correlated_detection(" << e.abstime << ", "
                 << e.channel << ", " << e.difftime << ')';
    }
};

template <typename NumericTraits = default_numeric_traits>
struct marker_event {
    NumericTraits::abstime_type abstime;
    static_assert(std::is_integral_v<decltype(abstime)>);

    NumericTraits::channel_type channel;
    static_assert(std::is_integral_v<decltype(channel)>);

    friend auto operator==(marker_event const &lhs,
                           marker_event const &rhs) noexcept -> bool = default;

    friend auto operator<<(std::ostream &s, marker_event const &e)
        -> std::ostream & {
        return s << "marker(" << e.abstime << ", " << e.channel << ')';
    }
};

template <typename NumericTraits>
auto operator<<(std::ostream &s,
                std::array<detection_event<NumericTraits>, 2> const &e)
    -> std::ostream & {
    return s << "[" << e[0] << ", " << e[1] << ']';
}
 
} // namespace tcspc