configurable.h

Go to the documentation of this file.

#ifndef LIBPRESSIO_CONFIGURABLE_H
#define LIBPRESSIO_CONFIGURABLE_H
#include <string>
#include <utility>
#include "options.h"
#include "pressio_compressor.h"
#include "errorable.h"
 
class pressio_configurable : public pressio_errorable {
  public:
  virtual ~pressio_configurable()=default;
  pressio_configurable()=default;
 
  virtual const char* prefix() const=0;
 
  std::string const& get_name() const {
    return name;
  }
 
  virtual void set_name(std::string const& new_name) {
    this->set_name_impl(new_name);
    this->name = new_name;
  }
 
  virtual void set_name_impl(std::string const& new_name) {
    (void)new_name;
  }
 
  virtual struct pressio_options get_configuration() const;
 
  virtual struct pressio_options get_documentation() const;
 
  virtual int check_options(struct pressio_options const&);
 
  virtual struct pressio_options get_options() const;
 
  virtual int set_options(struct pressio_options const& options);
 
  protected:
  template <class StringType>
  void set(pressio_options& options, StringType const& key, pressio_option const& value) const {
    if(name.empty()) options.set(key, value);
    else options.set(name, key, value);
  }
 
 
  template <class StringType>
  void set_type(pressio_options& options, StringType const& key, pressio_option_type type) const {
    if(name.empty()) options.set_type(key, type);
    else options.set_type(name, key, type);
  }
 
 
  template <class StringType, class PointerType>
  enum pressio_options_key_status 
  get(pressio_options const& options, StringType && key, PointerType value) const {
    if(name.empty()) return options.get(std::forward<StringType>(key), value); 
    return options.get(name, std::forward<StringType>(key), value);
  }
 
  template<class StringType, class Wrapper, class... Args>
  void
  set_meta(pressio_options& options, StringType&& key, std::string const& current_id, Wrapper const& current_value, Args&&... args) const {
    set(options, std::forward<StringType>(key), current_id);
    options.copy_from(current_value->get_options(std::forward<Args>(args)...));
  }
 
  template<class StringType, class Wrapper, class... Args>
  void
  set_meta_docs(pressio_options& options, StringType&& key, std::string const& docstring, Wrapper const& current_value, Args&&... args) const {
    set(options, std::forward<StringType>(key), docstring);
    options.copy_from(current_value->get_documentation(std::forward<Args>(args)...));
  }
 
  template<class StringType, class Wrapper, class Registry, class... Args>
  void
  set_meta_configuration(pressio_options& options, StringType&& key, Registry const& registry, Wrapper const& current_value) const {
    std::vector<std::string> plugins;
    plugins.reserve(registry.size());
    for (auto const& i : registry) {
        plugins.emplace_back(i.first);
    }
    set(options, std::forward<StringType>(key), plugins);
    options.copy_from(current_value->get_configuration());
  }
 
  template<class StringType, class Wrapper, class Registry, class... Args>
  void
  set_meta_many_configuration(pressio_options& options, StringType&& key, Registry const& registry, std::vector<Wrapper> const& current_values) const {
    std::vector<std::string> plugins;
    plugins.reserve(registry.size());
    for (auto const& i : registry) {
        plugins.emplace_back(i.first);
    }
    set(options, std::forward<StringType>(key), plugins);
    for (auto const& current_value : current_values) {
        options.copy_from(current_value->get_configuration());
    }
  }
 
 
  template<class StringType, class Wrapper, class... Args>
  void
  set_meta_many_docs(pressio_options& options, StringType&& key, std::string const& docstring, std::vector<Wrapper> const& current_values, Args&&... args) const {
    set(options, std::forward<StringType>(key), docstring);
    for (auto const& wrapper : current_values) {
      options.copy_from(wrapper->get_documentation(std::forward<Args>(args)...));
    }
  }
 
  template<class StringType, class Wrapper, class... Args>
  void
  set_meta_many(pressio_options& options, StringType&& key, std::vector<std::string> const& current_ids, std::vector<Wrapper> const& current_values, Args&&... args) const {
    set(options, std::forward<StringType>(key), current_ids);
    for (auto const& wrapper : current_values) {
      options.copy_from(wrapper->get_options(std::forward<Args>(args)...));
    }
  }
 
  template <class StringType, class Registry, class Wrapper>
  pressio_options_key_status
  get_meta(pressio_options const& options,
      StringType && key,
      Registry const& registry,
      std::string& current_id,
      Wrapper& current_value) {
    std::string new_id;
    auto ret = pressio_options_key_exists;
    if(get(options, std::forward<StringType>(key), &new_id) == pressio_options_key_set) {
      if (new_id != current_id) {
        auto new_value = registry.build(new_id);
        if(new_value) {
          current_id = std::move(new_id);
          current_value = std::move(new_value);
          ret = pressio_options_key_set;
        } else {
          return pressio_options_key_does_not_exist;
        }
        if(not get_name().empty()) {
          set_name(get_name());
        }
      }
    }
    current_value->set_options(options);
    return ret;
  }
 
  template <class StringType, class Registry, class Wrapper>
  pressio_options_key_status
  get_meta_many(pressio_options const& options,
      StringType && key,
      Registry const& registry,
      std::vector<std::string>& current_ids,
      std::vector<Wrapper>& current_values) {
    std::vector<std::string> new_ids;
    auto ret = pressio_options_key_exists;
    if(get(options, std::forward<StringType>(key), &new_ids) == pressio_options_key_set) {
      if (new_ids != current_ids) {
        std::vector<Wrapper> new_values;
        bool all_built = true;
        for (auto const& new_id : new_ids) {
          new_values.emplace_back(registry.build(new_id));
          all_built &= new_values.back();
          if(not all_built) break;
        }
        if(all_built) {
          current_ids = std::move(new_ids);
          current_values = std::move(new_values);
          ret = pressio_options_key_set;
        } else {
          return pressio_options_key_does_not_exist;
        }
        if(not get_name().empty()) {
          set_name(get_name());
        }
      }
    }
    for (auto& current_value : current_values) {
      current_value->set_options(options);
    }
    return ret;
  }
 
  template <class T>
  void set_names_many(std::string const& name, std::vector<T>& plugins, std::vector<std::string> const& names) const {
    if(name.empty()) {
      for (auto & plugin : plugins) {
        plugin->set_name(name);
      }
    } else {
      if(not names.empty()) {
        for (size_t i = 0; i < std::min(plugins.size(), names.size()); ++i) {
          plugins[i]->set_name(name + "/" + names[i]);
        }
      } else {
        for (auto & plugin : plugins) {
          plugin->set_name(name + "/" + plugin->prefix());
        }
      }
    }
  }
 
  public:
  int cast_options(pressio_options const& early_config, pressio_options const& config) {
        set_options(early_config);
        auto types = get_options();
        pressio_options casted;
 
        for (auto const& i : config) {
            auto status = types.key_status(i.first);
            switch(status) {
                case pressio_options_key_does_not_exist:
                {
                    return set_error(1, "option " + i.first + " does not exist");
                }
                default:
                {
                    casted.set(i.first, types.get(i.first));
                    auto cast_status = casted.cast_set(i.first, i.second, pressio_conversion_special);
                    if(cast_status != pressio_options_key_set) {
                        return set_error(1, "option " + i.first + " could not be converted");
 
                    }
                }
            }
        }
        return set_options(casted);
    }
 
 
 
  protected:
 
  static pressio_thread_safety get_threadsafe(pressio_configurable const& c) {
    pressio_thread_safety thread_safe = pressio_thread_safety_single;
    c.get_configuration().get("pressio:thread_safe", &thread_safe);
    return pressio_thread_safety(thread_safe);
  }
 
  std::string get_metrics_key_name() const {
    return std::string(prefix()) + ":metric";
  }
 
  std::string name;
};
 
#endif /* end of include guard: LIBPRESSIO_CONFIGURABLE_H */