deccore.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <span>
#include <functional>
 
#include "options.hpp"
#include "evtcallback.hpp"
 
 
namespace itk::itkpix::endec {
 
namespace intf {
 
class DecCore {
public:
 
  virtual ~DecCore() = default;
 
  virtual void initialize() = 0;
 
  virtual void finalize() = 0;
 
  virtual void decode(uint64_t data) = 0;
 
  virtual void decode(const std::span<const uint8_t> buff) = 0;
 
  virtual void decode(const std::span<const uint64_t> buff64) = 0;
 
  inline void decode(const uint8_t *buff, size_t size) { decode({ buff, size }); }
 
  inline void decode(const uint64_t *buff64, size_t size64) { decode({ buff64, size64 }); }
 
};
 
} // intf
 
namespace concepts {
 
template<typename T>
concept DecCore =
  std::constructible_from<T, Options, typename T::EventCallback&> and // (opt, cb_evt)
  std::destructible<T> and
  requires(T self) {
    { self.initialize() } -> std::same_as<void>;
    { self.finalize() } -> std::same_as<void>;
  } and
  requires(T self, uint64_t data) {
    { self.decode(data) } -> std::same_as<void>;
  } and
  requires(T self, const uint8_t *buff, size_t size) {
    { self.decode(buff, size) } -> std::same_as<void>;
  } and
  requires(T self, const uint64_t *buff, size_t size) {
    { self.decode(buff, size) } -> std::same_as<void>;
  } and
  requires(T self, const std::span<const uint8_t> buff) {
    { self.decode(buff) } -> std::same_as<void>;
  } and
  requires(T self, const std::span<const uint64_t> buff) {
    { self.decode(buff) } -> std::same_as<void>;
  };
 
} // concepts
 
 
namespace factory {
 
struct DecCore {
 
  inline auto operator()(Options opt, intf::EventCallback& cb_evt, int cb_type = 0) {
    return func(opt, cb_evt, cb_type);
  }
 
  template<template <int> class T>
  static inline DecCore make() {
    DecCore maker;
    maker.func = [](Options opt, intf::EventCallback& cb_evt, int cb_type) -> auto {
      if (cb_type == 0) return static_cast<intf::DecCore*>(new T<0>(opt, cb_evt));
      if (cb_type == 1) return static_cast<intf::DecCore*>(new T<1>(opt, cb_evt));
      if (cb_type == 2) return static_cast<intf::DecCore*>(new T<2>(opt, cb_evt));
      return static_cast<intf::DecCore*>(nullptr);
    };
    return maker;
  }
 
  std::function<intf::DecCore* (Options opt, intf::EventCallback& cb_evt, int cb_type)> func;
};
 
} // factory
 
namespace wrap {
 
template<typename T>
class DecCore : public intf::DecCore {
public:
 
  using EventCallback = T::EventCallback;
 
  DecCore(Options opt, EventCallback& cb_evt) : impl(opt, cb_evt) {}
 
  void initialize() override { impl.initialize(); }
  void finalize() override { impl.finalize(); }
  void decode(uint64_t data) override { impl.decode(data); }
  // void decode(const uint8_t *buff, size_t size) override { impl.decode(buff, size); }
  // void decode(const uint64_t *buff64, size_t size64) override { impl.decode(buff64, size64); }
  void decode(const std::span<const uint8_t> buff) override { impl.decode(buff.data(), buff.size()); }
  void decode(const std::span<const uint64_t> buff64) override { impl.decode(buff64.data(), buff64.size()); }
 
  T impl;
};
 
} // libso
 
} // itk::itkpix::decoder