arg_wrappers.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 <cstddef>

namespace tcspc::arg {
 
// Function argument wrappers for strong typing (avoiding mistakes with
// otherwise easily swappable parameters). Each has a constructor for two
// reasons: (1) To avoid default-constructing without initializing the value
// and (2) so that CTAD works.
// Ordered alphabetically.

template <typename T> struct append {
    T value;
    explicit constexpr append(T arg) : value(arg) {}
};

template <typename T> struct abstime {
    T value;
    explicit constexpr abstime(T arg) : value(arg) {}
};

template <typename T = std::size_t> struct batch_size {
    T value;
    explicit constexpr batch_size(T arg) : value(arg) {}
};

template <typename T> struct bin_width {
    T value;
    explicit constexpr bin_width(T arg) : value(arg) {}
};

template <typename T = std::size_t> struct bucket_size {
    T value;
    explicit constexpr bucket_size(T arg) : value(arg) {}
};

template <typename T> struct channel {
    T value;
    explicit constexpr channel(T arg) : value(arg) {}
};

template <typename T> struct clamp {
    T value;
    explicit constexpr clamp(T arg) : value(arg) {}
};

template <typename T> struct count {
    T value;
    explicit constexpr count(T arg) : value(arg) {}
};

template <typename T = std::size_t> struct count_threshold {
    T value;
    explicit constexpr count_threshold(T arg) : value(arg) {}
};

template <typename T> struct delay {
    T value;
    explicit constexpr delay(T arg) : value(arg) {}
};

template <typename T> struct delta {
    T value;
    explicit constexpr delta(T arg) : value(arg) {}
};

template <typename T> struct fraction {
    T value;
    explicit constexpr fraction(T arg) : value(arg) {}
};

template <typename T = std::size_t> struct granularity {
    T value;
    explicit constexpr granularity(T arg) : value(arg) {}
};

template <typename T> struct initially_open {
    T value;
    explicit constexpr initially_open(T arg) : value(arg) {}
};

template <typename T> struct initial_count {
    T value;
    explicit constexpr initial_count(T arg) : value(arg) {}
};

template <typename T> struct interval {
    T value;
    explicit constexpr interval(T arg) : value(arg) {}
};

template <typename T> struct interval_threshold {
    T value;
    explicit constexpr interval_threshold(T arg) : value(arg) {}
};

template <typename T> struct length {
    T value;
    explicit constexpr length(T arg) : value(arg) {}
};

template <typename T> struct limit {
    T value;
    explicit constexpr limit(T arg) : value(arg) {}
};

template <typename T> struct max_bin_index {
    T value;
    explicit constexpr max_bin_index(T arg) : value(arg) {}
};

template <typename T = std::size_t> struct max_bucket_count {
    T value;
    explicit constexpr max_bucket_count(T arg) : value(arg) {}
};

template <typename T = std::size_t> struct max_buffered {
    T value;
    explicit constexpr max_buffered(T arg) : value(arg) {}
};

template <typename T> struct max_count {
    T value;
    explicit constexpr max_count(T arg) : value(arg) {}
};

template <typename T> struct max_interval {
    T value;
    explicit constexpr max_interval(T arg) : value(arg) {}
};

template <typename T> struct max_length {
    T value;
    explicit constexpr max_length(T arg) : value(arg) {}
};

template <typename T> struct max_mse {
    T value;
    explicit constexpr max_mse(T arg) : value(arg) {}
};

template <typename T> struct max_per_bin {
    T value;
    explicit constexpr max_per_bin(T arg) : value(arg) {}
};

template <typename T = std::size_t> struct max_recycled_size {
    T value;
    explicit constexpr max_recycled_size(T arg) : value(arg) {}
};

template <typename T> struct max_time_shift {
    T value;
    explicit constexpr max_time_shift(T arg) : value(arg) {}
};

template <typename T> struct min_interval {
    T value;
    explicit constexpr min_interval(T arg) : value(arg) {}
};

template <typename T = std::size_t> struct num_bins {
    T value;
    explicit constexpr num_bins(T arg) : value(arg) {}
};

template <typename T = std::size_t> struct num_elements {
    T value;
    explicit constexpr num_elements(T arg) : value(arg) {}
};

template <typename T> struct offset {
    T value;
    explicit constexpr offset(T arg) : value(arg) {}
};

template <typename T> struct start {
    T value;
    explicit constexpr start(T arg) : value(arg) {}
};

template <typename T> struct start_channel {
    T value;
    explicit constexpr start_channel(T arg) : value(arg) {}
};

template <typename T> struct start_offset {
    T value;
    explicit constexpr start_offset(T arg) : value(arg) {}
};

template <typename T> struct stop {
    T value;
    explicit constexpr stop(T arg) : value(arg) {}
};

template <typename T> struct threshold {
    T value;
    explicit constexpr threshold(T arg) : value(arg) {}
};

template <typename T> struct tick_index {
    T value;
    explicit constexpr tick_index(T arg) : value(arg) {}
};

template <typename T> struct time_window {
    T value;
    explicit constexpr time_window(T arg) : value(arg) {}
};

template <typename T> struct truncate {
    T value;
    explicit constexpr truncate(T arg) : value(arg) {}
};
 
} // namespace tcspc::arg