enccore.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <functional>
 
#include "options.hpp"
#include "outcallback.hpp"
 
namespace itk::itkpix::endec {
 
namespace intf {
 
class EncCore {
public:
  virtual ~EncCore() = default;
 
  virtual void initialize() = 0;
 
  virtual void finalize() = 0;
 
  virtual void evt_init(uint8_t tag) = 0;
 
  virtual void evt_next(uint8_t tag) = 0;
 
  virtual void evt_done() = 0;
 
  virtual void add_hit(uint16_t col, uint16_t row, uint16_t tot) = 0;
 
  virtual void add_hmap(uint8_t qcol, uint8_t qrow, uint16_t hmap, uint64_t tots) = 0;
 
  virtual void add_qcore(uint8_t qcol, uint8_t qrow, uint64_t qtot) = 0;
 
};
 
} // intf
 
 
namespace concepts {
 
template<typename T>
concept EncCore =
  std::constructible_from<T, Options, typename T::OutputCallback&> and // (opt, cb_out)
  std::destructible<T> and
  requires(T self) {
    { self.initialize() } -> std::same_as<void>;
    { self.finalize() } -> std::same_as<void>;
  } and
  requires(T self, uint8_t tag) {
    { self.evt_init(tag) } -> std::same_as<void>;
  } and
  requires(T self) {
    { self.evt_done() } -> 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, uint8_t qcol, uint8_t qrow, uint16_t hmap, uint64_t tots) {
    { self.add_hmap(qcol, qrow, hmap, tots) } -> std::same_as<void>;
  } and
  requires(T self, uint8_t qcol, uint8_t qrow, uint64_t qtot) {
    { self.add_qcore(qcol, qrow, qtot) } -> std::same_as<void>;
  };
 
} // concepts
 
 
namespace factory {
 
  struct EncCore {
  
    inline auto operator()(Options opt, intf::OutputCallback& cb_out) { return func(opt, cb_out); }
  
    template<typename T>
    static inline EncCore make() {
      EncCore maker;
      maker.func = [](Options opt, intf::OutputCallback& cb_out) -> auto { return new T(opt, cb_out); };
      return maker;
    }
  
    std::function<intf::EncCore* (Options opt, intf::OutputCallback& cb_out)> func;
  };
  
} // factory
  
 
namespace wrap {
 
template<typename T>
class EncCore : public intf::EncCore {
public:
  using OutputCallback = T::OutputCallback;
 
  EncCore(Options opt, OutputCallback& cb_out) : impl(opt, cb_out) {}
 
  void initialize() override { impl.initialize(); }
  void finalize() override { impl.finalize(); }
  void evt_init(uint8_t tag) override { impl.evt_init(tag); }
  void evt_next(uint8_t tag) override { impl.evt_next(tag); }
  void evt_done() override { impl.evt_done(); }
  void add_hit(uint16_t col, uint16_t row, uint16_t tot) override {
    impl.add_hit(col, row, tot);
  }
  void add_hmap(uint8_t qcol, uint8_t qrow, uint16_t hmap, uint64_t tots) override {
    impl.add_hmap(qcol, qrow, hmap, tots);
  }
  void add_qcore(uint8_t qcol, uint8_t qrow, uint64_t qtot) override {
    impl.add_qcore(qcol, qrow, qtot);
  }
 
  T impl;
};
 
} // wrap
 
 
} // itk::itkpix::encoder