datafmt.hpp

// Data Formats for ITkPix
 
#pragma once
 
#include <vector>
#include <concepts>
#include <cstdint>
 
 
namespace itk::strip::datafmt {
 
namespace concepts {
 
template<typename T>
concept Hit =
  std::constructible_from<T> and
  std::constructible_from<T, uint8_t> and // (idx)
  std::constructible_from<T, uint8_t, uint8_t> and // (col, row)
  std::destructible<T> and
  requires(T a, T b) {
    a == b;
  } and
  requires(T self) {
    { self.clear() } -> std::same_as<void>;
    { self.get_idx() } -> std::same_as<uint8_t>;
    { self.get_col() } -> std::same_as<uint8_t>;
    { self.get_row() } -> std::same_as<uint8_t>;
  } and
  requires(T self, uint8_t col, uint8_t row) {
    { self.set(col, row) } -> std::same_as<void>;
  } and
  requires(T self, uint8_t idx) {
    { self.set(idx) } -> std::same_as<void>;
  };
 
 
 
template<typename T, typename HitMap>
concept HitVec =
  std::constructible_from<T> and
  std::constructible_from<T, const HitMap&> and
  std::destructible<T> and
  requires(T self) {
    typename T::hit_t;
    { self.hits } -> std::same_as<std::vector<typename T::hit_t>&>;
    { self.clear() } -> std::same_as<void>;
    { self.get_status() } -> std::same_as<uint32_t>;
  } and
  requires(T self, const typename T::hit_t& hit) {
    { self.add_hit(hit) } -> std::same_as<void>;
  } and
  requires(T self, uint16_t idx, uint8_t next) {
    { self.add_hit(idx) } -> std::same_as<void>;
    { self.add_hit_next(idx, next) } -> std::same_as<void>;
  };
 
 
 
template<typename T, typename HitVec>
concept HitMap =
  std::constructible_from<T> and
  std::constructible_from<T, const HitVec&> and
  std::destructible<T> and
  requires(T self) {
    { self.clear() } -> std::same_as<void>;
    { self.get_status() } -> std::same_as<uint32_t>;
  } and
  requires(T self, uint8_t idx, uint8_t val) {
    { self.get_hit(idx) } -> std::same_as<uint8_t>;
    { self.set_hit(idx, val) } -> std::same_as<void>;
  } and
  requires(T self, uint8_t col, uint8_t row, uint8_t val) {
    { self.get_hit(col, row) } -> std::same_as<uint8_t>;
    { self.set_hit(col, row, val) } -> std::same_as<void>;
  };
 
 
 
template<typename T>
concept HitSum =
  std::constructible_from<T> and
  std::destructible<T> and
  requires(T self) {
    { self.clear() } -> std::same_as<void>;
    { self.get_status() } -> std::same_as<uint32_t>;
  } and
  requires(T self, uint8_t idx, typename T::sum_t cnt) {
    { self.add_hit(idx) } -> std::same_as<void>;
    { self.add_hits(idx, cnt) } -> std::same_as<void>;
  } and
  requires(T self, uint8_t col, uint8_t row, typename T::sum_t cnt) {
    { self.add_hit(col, row) } -> std::same_as<void>;
    { self.add_hits(col, row, cnt) } -> std::same_as<void>;
  } and
  requires(T self, uint8_t addr, uint32_t cntreg) {
    { self.add_cntreg(addr, cntreg) } -> std::same_as<void>;
  } and
  requires(T self, uint8_t idx) {
    { self.get_sum(idx) } -> std::same_as<typename T::sum_t>;
  } and
  requires(T self, uint8_t col, uint8_t row) {
    { self.get_sum(col, row) } -> std::same_as<typename T::sum_t>;
  };
 
} // concepts
 
 
 
 
 
namespace concepts = itk::strip::datafmt::concepts;
using namespace itk::strip::datafmt;
 
// static_assert(concepts::Hit<Hit>);
 
// static_assert(concepts::HitVec<StripVec, HitMap>);
 
// static_assert(concepts::HitMap<HitMap, StripVec>);
 
// static_assert(concepts::HitSum<HitSum16>);
// static_assert(concepts::HitSum<HitSum32>);
// static_assert(concepts::HitSum<HitSum64>);
 
 
} // itk::strip::datafmt