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 "data_types.hpp"
 
#include <array>
#include <ostream>
#include <type_traits>
 
namespace tcspc {

template <typename DataTypes = default_data_types> struct time_reached_event {
    typename DataTypes::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 DataTypes = default_data_types> struct data_lost_event {
    typename DataTypes::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 DataTypes = default_data_types>
struct begin_lost_interval_event {
    typename DataTypes::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 DataTypes = default_data_types>
struct end_lost_interval_event {
    typename DataTypes::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 DataTypes = default_data_types> struct lost_counts_event {
    typename DataTypes::abstime_type abstime;
    static_assert(std::is_integral_v<decltype(abstime)>);

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

    typename DataTypes::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 DataTypes = default_data_types> struct bulk_counts_event {
    typename DataTypes::abstime_type abstime;
    static_assert(std::is_integral_v<decltype(abstime)>);

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

    typename DataTypes::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 DataTypes = default_data_types> struct detection_event {
    typename DataTypes::abstime_type abstime;
    static_assert(std::is_integral_v<decltype(abstime)>);

    typename DataTypes::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 DataTypes = default_data_types>
struct time_correlated_detection_event {
    typename DataTypes::abstime_type abstime;
    static_assert(std::is_integral_v<decltype(abstime)>);

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

    typename DataTypes::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 DataTypes = default_data_types> struct marker_event {
    typename DataTypes::abstime_type abstime;
    static_assert(std::is_integral_v<decltype(abstime)>);

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