datafmt.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <vector>
#include <concepts>
#include <cstdint>
 
 
namespace itk::pixel::datafmt {
 
namespace concepts {
 
template<typename T>
concept Hit =
  std::constructible_from<T> and
  std::constructible_from<T, uint16_t, uint16_t, uint16_t> and // (col, row, tot)
  std::destructible<T> and
  requires(T a, T b) {
    a == b;
  } and
  requires(T self) {
    { self.clear() } -> std::same_as<void>;
    { self.get_col() } -> std::same_as<uint16_t>;
    { self.get_row() } -> std::same_as<uint16_t>;
    { self.get_tot() } -> std::same_as<uint16_t>;
  } and
  requires(T self, uint16_t col, uint16_t row, uint16_t tot) {
    { self.set_col(col) } -> std::same_as<void>;
    { self.set_row(row) } -> std::same_as<void>;
    { self.set_tot(row) } -> std::same_as<void>;
  };
 
 
template<typename T>
concept QCoreHit =
  std::constructible_from<T> and
  std::constructible_from<T, uint16_t, uint16_t, uint64_t> and // (qcol, qrow, qtot)
  std::destructible<T> and
  requires(T a, T b) {
    a == b;
  } and
  requires(T self) {
    { self.clear() } -> std::same_as<void>;
    { self.get_qcol() } -> std::same_as<uint16_t>;
    { self.get_qrow() } -> std::same_as<uint16_t>;
    { self.get_qtot() } -> std::same_as<uint64_t>;
  } and
  requires(T self, uint16_t qcol, uint16_t qrow, uint64_t qtot) {
    { self.set_qcol(qcol) } -> std::same_as<void>;
    { self.set_qrow(qrow) } -> std::same_as<void>;
    { self.set_qtot(qrow) } -> 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 col, uint16_t row, uint16_t tot) {
    { self.add_hit(col, row, tot) } -> std::same_as<void>;
  } and
  requires(T self, uint16_t qcol, uint16_t qrow, uint64_t qtot) {
    { self.add_qcore(qcol, qrow, qtot) } -> std::same_as<void>;
  };
 
 
 
template<typename T, typename PixVec, typename QCoreVec>
concept HitMap =
  std::constructible_from<T> and
  std::constructible_from<T, const PixVec&> and
  std::constructible_from<T, const QCoreVec&> and
  std::destructible<T> and
  requires(T self, uint16_t col, uint16_t row, uint16_t tot) {
    { self.clear() } -> std::same_as<void>;
    { self.get_status() } -> std::same_as<uint32_t>;
  } and
  requires(T self, uint16_t col, uint16_t row, uint16_t tot) {
    { self.get_hit(col, row) } -> std::same_as<uint16_t>;
    { self.set_hit(col, row, tot) } -> std::same_as<void>;
  } and
  requires(T self, uint16_t qcol, uint16_t qrow, uint64_t qtot) {
    { self.get_qcore(qcol, qrow) } -> std::same_as<uint64_t>;
    { self.set_qcore(qcol, qrow, qtot) } -> std::same_as<void>;
  };
 
 
 
template<typename T>
concept HitSum =
  std::constructible_from<T> and
  std::destructible<T> and
  requires(T self, uint16_t col, uint16_t row) {
     { self.add_hit(col, row) } -> std::same_as<void>;
     { self.get_sum(col, row) } -> std::same_as<typename T::sum_t>;
   } and
   requires(T self, uint16_t qcol, uint16_t qrow, uint16_t hitmap) {
     { self.add_qcore(qcol, qrow, hitmap) } -> std::same_as<void>;
   } and
   requires(T self) {
     { self.clear() } -> std::same_as<void>;
     { self.get_status() } -> std::same_as<uint32_t>;
   };
 
} // concepts
 
 
 
 
namespace concepts = itk::pixel::datafmt::concepts;
// using namespace itk::pixel::datafmt;
 
// static_assert(concepts::Hit<Hit>);
// static_assert(concepts::QCoreHit<QCoreHit>);
 
// static_assert(concepts::HitVec<PixelVec, HitMap>);
// static_assert(concepts::HitVec<QCoreVec, HitMap>);
 
// static_assert(concepts::HitMap<HitMap, PixelVec, QCoreVec>);
 
// static_assert(concepts::HitSum<HitSum16>);
// static_assert(concepts::HitSum<HitSum32>);
// static_assert(concepts::HitSum<HitSum64>);
 
 
} // itk::pixel::datafmt