histogram_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 "bucket.hpp"
#include "numeric_traits.hpp"
 
#include <cstddef>
#include <ostream>
 
namespace tcspc {

template <typename NumericTraits = default_numeric_traits>
struct datapoint_event {
    using datapoint_type = NumericTraits::datapoint_type;

    datapoint_type value;

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

    friend auto operator<<(std::ostream &s, datapoint_event const &e)
        -> std::ostream & {
        return s << "datapoint(" << e.value << ')';
    }
};

template <typename NumericTraits = default_numeric_traits>
struct bin_increment_event {
    NumericTraits::bin_index_type bin_index;

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

    friend auto operator<<(std::ostream &s, bin_increment_event const &e)
        -> std::ostream & {
        return s << "bin_increment(" << e.bin_index << ')';
    }
};

template <typename NumericTraits = default_numeric_traits>
struct bin_increment_cluster_event {
    bucket<typename NumericTraits::bin_index_type> bin_indices;

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

    friend auto operator<<(std::ostream &s,
                           bin_increment_cluster_event const &e)
        -> std::ostream & {
        return s << "bin_increment_cluster(" << e.bin_indices << ')';
    }
};

template <typename NumericTraits = default_numeric_traits>
struct histogram_event {
    bucket<typename NumericTraits::bin_type> data_bucket;

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

    friend auto operator<<(std::ostream &s, histogram_event const &e)
        -> std::ostream & {
        return s << "histogram(" << e.data_bucket << ')';
    }
};

template <typename NumericTraits = default_numeric_traits>
struct concluding_histogram_event {
    bucket<typename NumericTraits::bin_type> data_bucket;

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

    friend auto operator<<(std::ostream &s,
                           concluding_histogram_event const &e)
        -> std::ostream & {
        return s << "concluding_histogram(" << e.data_bucket << ')';
    }
};

template <typename NumericTraits = default_numeric_traits>
struct histogram_array_event {
    bucket<typename NumericTraits::bin_type> data_bucket;

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

    friend auto operator<<(std::ostream &s, histogram_array_event const &e)
        -> std::ostream & {
        return s << "histogram_array(" << e.data_bucket << ')';
    }
};

template <typename NumericTraits = default_numeric_traits>
struct histogram_array_progress_event {
    std::size_t valid_size;

    bucket<typename NumericTraits::bin_type> data_bucket;

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

    friend auto operator<<(std::ostream &s,
                           histogram_array_progress_event const &e)
        -> std::ostream & {
        return s << "histogram_array_progress(" << e.valid_size << ", "
                 << e.data_bucket << ')';
    }
};

template <typename NumericTraits = default_numeric_traits>
struct concluding_histogram_array_event {
    bucket<typename NumericTraits::bin_type> data_bucket;

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

    friend auto operator<<(std::ostream &s,
                           concluding_histogram_array_event const &e)
        -> std::ostream & {
        return s << "concluding_histogram_array(" << e.data_bucket << ')';
    }
};
 
} // namespace tcspc