pressio.h

Go to the documentation of this file.

 
#ifndef LIBPRESSIO_PRESSIO_IMPL_H
#define LIBPRESSIO_PRESSIO_IMPL_H
#include <map>
#include <memory>
#include <functional>
#include "compressor.h"
#include "metrics.h"
#include "io.h"
#include "std_compat/language.h"
 
template <class T>
struct pressio_registry {
  T build(std::string const& name) const {
    auto factory = factories.find(name);
    if ( factory != factories.end()) {
      return factory->second();
    } else {
      return nullptr;
    }
  }
 
  template <class Name, class Factory>
  void regsiter_factory(Name&& name, Factory&& factory) {
    factories.emplace(std::forward<Name>(name), std::forward<Factory>(factory));
  }
 
  private:
  std::map<std::string, std::function<T()>> factories;
 
  public:
  using value_type = T;
  using reference = T&;
  using const_reference = T const;
  auto begin() const -> decltype(factories.begin()) { return std::begin(factories); }
  auto end() const -> decltype(factories.end()) { return std::end(factories); }
 
  bool contains(std::string const& key) const {
    return factories.find(key) != factories.end();
  }
 
  auto find(std::string const& key) const -> decltype(factories.find(key)) {
    return factories.find(key);
  }
 
  auto find(std::string const& key) -> decltype(factories.find(key)) {
    return factories.find(key);
  }
 
  size_t size() const {
      return factories.size();
  }
 
};
 
class pressio_register{
  public:
  template <class RegistryType, class NameType, class Factory>
  pressio_register(pressio_registry<RegistryType>& registry, NameType&& name, Factory&& factory) {
    registry.regsiter_factory(name, factory);
  }
};
 
pressio_registry<std::shared_ptr<libpressio_compressor_plugin>>& compressor_plugins();
pressio_registry<std::unique_ptr<libpressio_metrics_plugin>>& metrics_plugins();
 
pressio_registry<std::unique_ptr<libpressio_io_plugin>>& io_plugins();
 
struct pressio {
  public:
 
  void set_error(int code, std::string const& msg) {
    error.code = code;
    error.msg = msg;
  }
 
  int err_code() const { return error.code; }
 
  std::string const& err_msg() const { return error.msg; }
 
  std::shared_ptr<libpressio_compressor_plugin> get_compressor(std::string const& compressor_id) {
    auto compressor = compressor_plugins().build(compressor_id);
    if (compressor) return compressor;
    else {
      set_error(1, std::string("invalid compressor id ") + compressor_id);
      return nullptr;
    }
  }
 
  std::shared_ptr<libpressio_io_plugin> get_io(std::string const& io_module_id)
  {
    auto io_module = io_plugins().build(io_module_id);
    if (io_module)
      return RVO_MOVE(io_module);
    else {
      set_error(1, std::string("invalid io_plugin id ") + io_module_id);
      return nullptr;
    }
  }
 
  template <class Str>
  std::unique_ptr<libpressio_metrics_plugin> get_metric(Str id) {
    auto ret = metrics_plugins().build(id);
    if(!ret) {
        set_error(2, std::string("failed to construct metrics plugin: ") + id);
        return nullptr;
    }
    return ret;
  }
 
  template <class ForwardIt>
  std::unique_ptr<libpressio_metrics_plugin> get_metrics(ForwardIt first, ForwardIt last) {
    std::vector<pressio_metrics> plugins;
 
    for (auto metric = first; metric != last; ++metric) {
      plugins.emplace_back(metrics_plugins().build(*metric));
      if(not plugins.back()) {
        set_error(2, std::string("failed to construct metrics plugin: ") + *metric);
        return nullptr;
      }
    }
 
    auto metrics = make_m_composite(std::move(plugins));
 
    if(metrics) return metrics;
    else {
      set_error(3, "failed to construct composite metric");
      return nullptr;
    };
  }
 
  static const char* version();
 
  static const char* features();
 
  static const char* supported_compressors();
 
  static const char* supported_metrics();
 
  static const char* supported_io();
 
  static unsigned int major_version();
 
  static unsigned int minor_version();
 
  static unsigned int patch_version();
 
  private:
  struct {
    int code;
    std::string msg;
  } error;
};
#endif