compressor.h

Go to the documentation of this file.

#ifndef LIBPRESSIO_COMPRESSOR_IMPL_H
#define LIBPRESSIO_COMPRESSOR_IMPL_H
#include <string>
#include <memory>
#include "metrics.h"
#include "configurable.h"
#include "versionable.h"
#include "errorable.h"
#include <std_compat/span.h>
 
struct pressio_data;
struct pressio_options;
class libpressio_metrics_plugin;
 
class libpressio_compressor_plugin :public pressio_configurable, public pressio_versionable {
  public:
 
  libpressio_compressor_plugin() noexcept;
  libpressio_compressor_plugin(libpressio_compressor_plugin const& plugin):
    pressio_configurable(plugin),
    metrics_plugin((plugin.metrics_plugin)?plugin.metrics_plugin->clone(): nullptr)
  {}
  libpressio_compressor_plugin& operator=(libpressio_compressor_plugin const& plugin)
  {
    pressio_configurable::operator=(plugin);
    metrics_plugin = plugin.metrics_plugin->clone();
    return *this;
  }
  libpressio_compressor_plugin(libpressio_compressor_plugin&& plugin) noexcept:
    pressio_configurable(plugin),
    metrics_plugin(std::move(plugin.metrics_plugin))
    {}
  libpressio_compressor_plugin& operator=(libpressio_compressor_plugin&& plugin) noexcept
  {
    pressio_configurable::operator=(plugin);
    metrics_plugin = std::move(plugin.metrics_plugin);
    return *this;
  }
 
 
  virtual ~libpressio_compressor_plugin();
 
  struct pressio_options get_metrics_options() const;
 
  struct pressio_options get_options() const override final;
 
  int check_options(struct pressio_options const& options) override final;
 
  struct pressio_options get_configuration() const override final;
 
  struct pressio_options get_documentation() const override final;
 
  int set_options(struct pressio_options const& options) override final;
 
  int set_metrics_options(struct pressio_options const& options);
 
  int compress(struct pressio_data const*input, struct pressio_data* output);
  int decompress(struct pressio_data const*input, struct pressio_data* output);
 
  template <class InputRandomAccessIterator,
            class InputRandomAccessIteratorEnd,
            class OutputRandomAccessIterator,
            class OutputRandomAccessIteratorEnd
           >
  int compress_many(InputRandomAccessIterator in_begin, InputRandomAccessIteratorEnd in_end,
                    OutputRandomAccessIterator out_begin, OutputRandomAccessIteratorEnd out_end) {
    clear_error();
    compat::span<const pressio_data* const> inputs(in_begin, in_end);
    compat::span<pressio_data*> outputs(out_begin, out_end);
    if(metrics_plugin) {
      if(metrics_plugin->begin_compress_many(inputs, outputs) != 0 && metrics_errors_fatal) {
        set_error(metrics_plugin->error_code(), metrics_plugin->error_msg());
        return error_code();
      }
    }
    auto ret = compress_many_impl(inputs, outputs);
    if(metrics_plugin) {
      if(metrics_plugin->end_compress_many(inputs, outputs, ret) != 0 && metrics_errors_fatal) {
        set_error(metrics_plugin->error_code(), metrics_plugin->error_msg());
        return error_code();
      }
    }
    return ret;
  }
  template <class InputRandomAccessIterator,
            class InputRandomAccessIteratorEnd,
            class OutputRandomAccessIterator,
            class OutputRandomAccessIteratorEnd
           >
  int decompress_many(InputRandomAccessIterator in_begin, InputRandomAccessIteratorEnd in_end,
                      OutputRandomAccessIterator out_begin, OutputRandomAccessIteratorEnd out_end) {
    clear_error();
    compat::span<const pressio_data* const> inputs(in_begin, in_end);
    compat::span<pressio_data*> outputs(out_begin, out_end);
    if(metrics_plugin) {
      if(metrics_plugin->begin_decompress_many(inputs, outputs) != 0 && metrics_errors_fatal) {
        set_error(metrics_plugin->error_code(), metrics_plugin->error_msg());
        return error_code();
      }
    }
    auto ret = decompress_many_impl(inputs, outputs);
    if(metrics_plugin) {
      if(metrics_plugin->end_decompress_many(inputs, outputs, ret) != 0 && metrics_errors_fatal) {
        set_error(metrics_plugin->error_code(), metrics_plugin->error_msg());
        return error_code();
      }
    }
    return ret;
  }
 
  struct pressio_options get_metrics_results() const;
  struct pressio_metrics&& get_metrics() &&;
  struct pressio_metrics get_metrics() const&;
  void set_metrics(struct pressio_metrics& plugin);
  void set_metrics(struct pressio_metrics&& plugin);
 
 
  virtual std::shared_ptr<libpressio_compressor_plugin> clone()=0;
 
 
  void set_name(std::string const& new_name) override final;
 
 
  protected:
  virtual struct pressio_options get_options_impl() const=0;
  virtual struct pressio_options get_documentation_impl() const=0;
  virtual struct pressio_options get_configuration_impl() const=0;
  virtual int set_options_impl(struct pressio_options const& options)=0;
  virtual int compress_impl(const pressio_data *input, struct pressio_data* output)=0;
  virtual int decompress_impl(const pressio_data *input, struct pressio_data* output)=0;
 
  virtual int check_options_impl(struct pressio_options const&);
 
  virtual struct pressio_options get_metrics_results_impl() const;
 
  virtual int decompress_many_impl(compat::span<const pressio_data* const> const& inputs, compat::span<pressio_data* >& outputs);
 
  virtual int compress_many_impl(compat::span<const pressio_data* const> const& inputs, compat::span<pressio_data*> & outputs);
 
  private:
  pressio_metrics metrics_plugin;
  std::string metrics_id;
  int32_t metrics_errors_fatal = 1;
  int32_t metrics_copy_impl_results = 1;
};
 
struct pressio_compressor {
  pressio_compressor(std::shared_ptr<libpressio_compressor_plugin>&& impl): plugin(std::forward<std::shared_ptr<libpressio_compressor_plugin>>(impl)) {}
  pressio_compressor()=default;
  pressio_compressor(pressio_compressor const& compressor):
    plugin(compressor->clone()) {}
  pressio_compressor& operator=(pressio_compressor const& compressor) {
    if(&compressor == this) return *this;
    plugin = compressor->clone();
    return *this;
  }
  pressio_compressor& operator=(pressio_compressor&& compressor) noexcept=default;
  pressio_compressor(pressio_compressor&& compressor)=default;
 
  operator bool() const {
    return bool(plugin);
  }
 
  libpressio_compressor_plugin& operator*() const noexcept {
    return *plugin;
  }
 
  libpressio_compressor_plugin* operator->() const noexcept {
    return plugin.get();
  }
 
  std::shared_ptr<libpressio_compressor_plugin> plugin;
};
 
#endif