options.h

Go to the documentation of this file.

#ifndef PRESSIO_OPTIONS_CPP
#define PRESSIO_OPTIONS_CPP
 
#include <cwchar>
#include <string>
#include <map>
#include <type_traits>
#include <utility>
#include <vector>
#include <initializer_list>
#include "pressio_options.h"
#include "pressio_option.h"
#include "pressio_compressor.h"
#include "userptr.h"
#include "libpressio_ext/cpp/data.h"
#include "std_compat/string_view.h"
#include "std_compat/optional.h"
#include "std_compat/variant.h"
#include "std_compat/functional.h"
#include "std_compat/language.h"
#include <algorithm>
 
namespace {
using option_type = compat::variant<compat::monostate,
      compat::optional<bool>,
      compat::optional<int8_t>,
      compat::optional<uint8_t>,
      compat::optional<int16_t>,
      compat::optional<uint16_t>,
      compat::optional<int32_t>,
      compat::optional<uint32_t>,
      compat::optional<int64_t>,
      compat::optional<uint64_t>,
      compat::optional<float>,
      compat::optional<double>,
      compat::optional<std::string>,
      compat::optional<userdata>,
      compat::optional<std::vector<std::string>>,
      compat::optional<pressio_data>,
      compat::optional<pressio_dtype>,
      compat::optional<pressio_thread_safety>
      >;
 
 
}
 
template <class T>
constexpr enum pressio_option_type pressio_type_to_enum() {
  return 
    std::is_same<T, bool>() ? pressio_option_bool_type :
    std::is_same<T, int8_t>() ? pressio_option_int8_type :
    std::is_same<T,uint8_t>() ? pressio_option_uint8_type :
    std::is_same<T, int16_t>() ? pressio_option_int16_type :
    std::is_same<T,uint16_t>() ? pressio_option_uint16_type :
    std::is_same<T, int32_t>() ? pressio_option_int32_type :
    std::is_same<T,uint32_t>() ? pressio_option_uint32_type :
    std::is_same<T, int64_t>() ? pressio_option_int64_type :
    std::is_same<T,uint64_t>() ? pressio_option_uint64_type :
    std::is_same<T,float>() ? pressio_option_float_type :
    std::is_same<T,double>() ? pressio_option_double_type :
    std::is_same<T,std::string>() ? pressio_option_charptr_type :
    std::is_same<T,const char*>() ? pressio_option_charptr_type :
    std::is_same<T,const char**>() ? pressio_option_charptr_array_type :
    std::is_same<T,std::vector<std::string>>() ? pressio_option_charptr_array_type :
    std::is_same<T,pressio_data>() ? pressio_option_data_type :
    std::is_same<T,pressio_dtype>() ? pressio_option_dtype_type :
    pressio_option_userptr_type;
    ;
}
 
struct pressio_option final {
  pressio_option()=default;
 
  template<class T, typename = typename std::enable_if<
    !std::is_same<T, pressio_conversion_safety>::value &&
    !std::is_same<T, pressio_option>::value &&
    !std::is_same<T, const char*>::value &&
    !std::is_same<T, void*>::value &&
    !std::is_same<T, compat::monostate>::value
    >::type>
  pressio_option(compat::optional<T> const& value): option(value) {}
 
  template<class T, typename = typename std::enable_if<
    !std::is_same<T, pressio_conversion_safety>::value &&
    !std::is_same<T, pressio_option>::value &&
    !std::is_same<T, const char*>::value &&
    !std::is_same<T, void*>::value &&
    !std::is_same<T, compat::monostate>::value
    >::type>
  pressio_option(compat::optional<T> && value): option(value) {}
 
  template<class T, typename = typename std::enable_if<
    !std::is_same<T, pressio_conversion_safety>::value &&
    !std::is_same<T, pressio_option>::value &&
    !std::is_same<T, const char*>::value &&
    !std::is_same<T, compat::monostate>::value
    >::type>
  pressio_option(T const& value): option(compat::optional<T>(value)) {}
 
  pressio_option(void* value): option(compat::optional<userdata>(userdata(value))) {}
 
  pressio_option(compat::monostate value): option(value) { }
 
  pressio_option(const char* value): option(std::string(value)) { }
 
  template<class T>
  pressio_option(std::initializer_list<T> ul): option(ul) {}
 
  pressio_option as(const enum pressio_option_type type, const enum pressio_conversion_safety safety = pressio_conversion_implicit) const;
 
  enum pressio_option_type type() const;
 
  template <class T, typename std::enable_if<!(std::is_same<T,compat::monostate>::value || std::is_same<T,void*>::value),int>::type = 0>
  bool holds_alternative() const {
    return compat::holds_alternative<compat::optional<T>>(option);
  }
 
  template <class T, typename std::enable_if<std::is_same<T,void*>::value,int>::type = 0>
  bool holds_alternative() const {
    return compat::holds_alternative<compat::optional<userdata>>(option);
  }
 
  template <class T, typename std::enable_if<std::is_same<T,compat::monostate>::value,int>::type = 0>
  bool holds_alternative() const {
    return compat::holds_alternative<compat::monostate>(option);
  }
 
  template <class T>
  compat::optional<T> const& get() const{
    return compat::get<compat::optional<T>>(option);
  }
 
  template <class T, typename std::enable_if<std::is_same<T, void*>::value, int>::type = 0>
  void* get_value() const{
    return get<userdata>()->get();
  }
 
  template <class T, typename std::enable_if<!std::is_same<T, void*>::value, int>::type = 0>
  T const& get_value() const{
    return *get<T>();
  }
 
  bool has_value() const {
    if (holds_alternative<compat::monostate>()) return false;
    else {
      switch(type())
      {
        case pressio_option_bool_type:
          return (bool)get<bool>();
        case pressio_option_int8_type:
          return (bool)get<int8_t>();
        case pressio_option_uint8_type:
          return (bool)get<uint8_t>();
        case pressio_option_int16_type:
          return (bool)get<int16_t>();
        case pressio_option_uint16_type:
          return (bool)get<uint16_t>();
        case pressio_option_int32_type:
          return (bool)get<int32_t>();
        case pressio_option_uint32_type:
          return (bool)get<uint32_t>();
        case pressio_option_int64_type:
          return (bool)get<int64_t>();
        case pressio_option_uint64_type:
          return (bool)get<uint64_t>();
        case pressio_option_float_type:
          return (bool)get<float>();
        case pressio_option_double_type:
          return (bool)get<double>();
        case pressio_option_charptr_type:
          return (bool)get<std::string>();
        case pressio_option_userptr_type:
          return (bool)get<userdata>();
        case pressio_option_charptr_array_type:
          return (bool)get<std::vector<std::string>>();
        case pressio_option_data_type:
          return (bool)get<pressio_data>();
        case pressio_option_dtype_type:
          return (bool)get<pressio_dtype>();
        case pressio_option_threadsafety_type:
          return (bool)get<pressio_thread_safety>();
        case pressio_option_unset_type:
        default:
          return false;
      }
    }
  }
 
  template <class T, typename std::enable_if<!std::is_same<T, void*>::value, bool>::type = false>
  void set(T v) {
    option = compat::optional<T>(v);
  }
 
  void set(void* v) {
    option = compat::optional<userdata>(userdata(v));
  }
 
  void set_type(pressio_option_type type) {
    switch(type)
    {
      case pressio_option_charptr_type:
        option = compat::optional<std::string>();
        break;
      case pressio_option_userptr_type:
        option = compat::optional<userdata>();
        break;
      case pressio_option_bool_type:
        option = compat::optional<bool>();
        break;
      case pressio_option_int8_type:
        option = compat::optional<int8_t>();
        break;
      case pressio_option_uint8_type:
        option = compat::optional<uint8_t>();
        break;
      case pressio_option_int16_type:
        option = compat::optional<int16_t>();
        break;
      case pressio_option_uint16_type:
        option = compat::optional<uint16_t>();
        break;
      case pressio_option_int32_type:
        option = compat::optional<int32_t>();
        break;
      case pressio_option_uint32_type:
        option = compat::optional<uint32_t>();
        break;
      case pressio_option_int64_type:
        option = compat::optional<int64_t>();
        break;
      case pressio_option_uint64_type:
        option = compat::optional<uint64_t>();
        break;
      case pressio_option_float_type:
        option = compat::optional<float>();
        break;
      case pressio_option_double_type:
        option = compat::optional<double>();
        break;
      case pressio_option_unset_type:
        option = compat::monostate{};
        break;
      case pressio_option_charptr_array_type:
        option = compat::optional<std::vector<std::string>>();
        break;
      case pressio_option_data_type:
        option = compat::optional<pressio_data>();
        break;
      case pressio_option_threadsafety_type:
        option = compat::optional<pressio_thread_safety>();
        break;
      case pressio_option_dtype_type:
        option = compat::optional<pressio_dtype>();
        break;
    }
  }
 
  bool operator==(pressio_option const& rhs) const {
    return option == rhs.option;
  }
 
  enum pressio_options_key_status cast_set(struct pressio_option const& rhs, enum pressio_conversion_safety safety = pressio_conversion_implicit) { 
    auto casted = rhs.as(type(), safety);
    if (casted.has_value()) {
      *this = std::move(casted);
      return pressio_options_key_set;
    } else {
      return pressio_options_key_exists; 
    }
  }
 
  private:
  option_type option;
};
 
 
struct pressio_options final {
 
  using key_type = std::string;
  using mapped_type = pressio_option;
 
  pressio_options()=default;
  pressio_options(pressio_options const& rhs)=default;
  pressio_options(pressio_options && rhs) DEFAULTED_NOEXCEPT =default;
  pressio_options& operator=(pressio_options const& rhs)=default;
  pressio_options& operator=(pressio_options && rhs) DEFAULTED_NOEXCEPT =default;
 
  pressio_options(std::initializer_list<std::pair<const std::string, pressio_option>> opts): options(opts) {}
 
  pressio_options_key_status key_status(std::string const& key) const {
    auto it = options.find(key);
    if(it == options.end()) {
      return pressio_options_key_does_not_exist;
    } else if (it->second.has_value()) {
      return pressio_options_key_set;
    } else { 
      return pressio_options_key_exists;
    }
  }
 
  template <class StringType>
  pressio_options_key_status key_status(StringType const& name, std::string const& key) const {
    return key_status(format_name(name, key));
  }
 
  template <class StringType>
  void set(StringType&& key,  pressio_option const& value) {
    options[std::forward<StringType>(key)] = value;
  }
 
  template <class StringType, class StringType2>
  void set(StringType const& name, StringType2 const& key,  pressio_option const& value) {
    set(format_name(name, key), value);
  }
 
 
  template <class StringType>
  enum pressio_options_key_status cast_set(StringType && key,  pressio_option const& value, enum pressio_conversion_safety safety= pressio_conversion_implicit) {
    switch(key_status(key))
    {
      case pressio_options_key_set:
      case pressio_options_key_exists:
        return options[std::forward<StringType>(key)].cast_set(value, safety);
      default:
        return pressio_options_key_does_not_exist;
    }
 
  }
 
  template <class StringType, class StringType2>
  enum pressio_options_key_status cast_set(StringType const& name, StringType2 const& key,  pressio_option const& value, enum pressio_conversion_safety safety= pressio_conversion_implicit) {
    return cast_set(format_name(name, key), value, safety);
  }
 
  template <class StringType>
  void set_type(StringType && key, pressio_option_type type) {
    options[std::forward<StringType>(key)].set_type(type);
  }
 
  template <class StringType, class StringType2>
  void set_type(StringType const& name, StringType2 const& key, pressio_option_type type) {
    set_type(format_name(name, key), type);
  }
 
  template<class StringType>
  pressio_option const& get(StringType const& key) const {
    return options.find(key)->second;
  }
 
  template <class StringType, class StringType2>
  pressio_option const& get(compat::string_view const& name, StringType2 const& key) const {
    std::string prefix_key;
    for (auto path : search(name)) {
      prefix_key = format_name(path, key);
      if(options.find(prefix_key) != options.end()) {
        return get(prefix_key);
      }
    }
    return get(key);
  }
 
  template <class PointerType, class StringType>
  enum pressio_options_key_status get(StringType const& key, compat::optional<PointerType>* value) const {
    switch(key_status(key)){
      case pressio_options_key_set:
        {
          auto variant = get(key);
          if (variant.template holds_alternative<PointerType>()) { 
            *value = variant.template get<PointerType>();
            return pressio_options_key_set;
          } else {
            return pressio_options_key_exists;
          }
        }
        break;
      default:
        //value does not exist
        return pressio_options_key_does_not_exist;
    }
  }
 
  template <class PointerType, class StringType>
  enum pressio_options_key_status get(StringType const& key, PointerType value) const {
    using ValueType = typename std::remove_pointer<PointerType>::type;
    switch(key_status(key)){
      case pressio_options_key_set:
        {
          auto variant = get(key);
          if (variant.template holds_alternative<ValueType>()) { 
            *value = variant.template get_value<ValueType>();
            return pressio_options_key_set;
          } else {
            return pressio_options_key_exists;
          }
        }
        break;
      default:
        //value does not exist
        return pressio_options_key_does_not_exist;
    }
  }
 
  template <class PointerType, class StringType, class StringType2>
  enum pressio_options_key_status get(StringType const& name, StringType2 const& key, PointerType value) const {
    std::string prefix_key;
    for (auto path : search(name)) {
      prefix_key = format_name(std::string(path), key);
      if(options.find(prefix_key) != options.end()) {
        return get(prefix_key, value);
      }
    }
    return get(key, value);
  }
 
  template <class PointerType, class StringType>
  enum pressio_options_key_status cast(StringType const& key, PointerType value, enum pressio_conversion_safety safety) const {
    using ValueType = typename std::remove_pointer<PointerType>::type;
    switch(key_status(key)){
      case pressio_options_key_set:
        {
          auto variant = get(key);
          auto converted = pressio_option(variant).as(pressio_type_to_enum<ValueType>(), safety);
          if(converted.has_value()) {
            *value = converted.template get_value<ValueType>();
            return pressio_options_key_set;
          } else {
            return pressio_options_key_exists;
          }
        }
        break;
      default:
        //value does not exist
        return pressio_options_key_does_not_exist;
    }
  }
 
  template <class PointerType, class StringType, class StringType2>
  enum pressio_options_key_status cast(StringType const& name, StringType2 const& key, PointerType value, enum pressio_conversion_safety safety) const {
    std::string prefix_key;
    for (auto path : search(name)) {
      prefix_key = format_name(path, key);
      if(options.find(prefix_key) != options.end()) {
        return cast(prefix_key, value, safety);
      }
    }
    return cast(key, value, safety);
  }
 
  static std::vector<compat::string_view> search(compat::string_view const& value);
 
  void clear() noexcept {
    options.clear();
  }
 
  void copy_from(pressio_options const& o, bool ignore_empty=false) {
    insert_or_assign(o.begin(), o.end(), ignore_empty);
  }
 
  private:
 
  std::string format_name(std::string const& name, std::string const& key) const {
    if(name == "") return key;
    else return '/' + name + ':' + key;
  }
 
  std::map<std::string, pressio_option, compat::less<>> options;
 
 
  public:
  using iterator = typename decltype(options)::iterator;
  using const_iterator = typename decltype(options)::const_iterator;
  using value_type = typename decltype(options)::value_type;
 
  iterator insert(const_iterator it, value_type const& value) {
    return options.insert(it, value);
  }
 
  template <class InputIt>
  void insert(InputIt begin, InputIt end){
    options.insert(begin, end);
  }
 
  template <class InputIt>
  void insert_or_assign(InputIt begin, InputIt end, bool ignore_empty){
    std::for_each(begin, end, [this, ignore_empty](decltype(options)::const_reference it) {
        if(ignore_empty && not it.second.has_value()) return;
        options[it.first] = it.second;
    });
  }
 
 
 
  auto begin() const -> decltype(std::begin(options)) {
    return std::begin(options);
  }
  auto end() const -> decltype(std::end(options)) {
    return std::end(options);
  }
 
  auto begin() -> decltype(std::begin(options)){
    return std::begin(options);
  }
  auto end() -> decltype(std::end(options)){
    return std::end(options);
  }
 
  size_t size() const {
    return options.size();
  }
 
  iterator find(key_type const& key) {
    return options.find(key);
  }
 
  const_iterator find(key_type const& key) const {
    return options.find(key);
  }
 
  size_t erase(key_type const& key) {
    return options.erase(key);
  }
 
  auto insert(value_type const& value) -> decltype(options.insert(value)) {
    return options.insert(value);
  }
 
  bool operator==(pressio_options const& rhs) const {
    return options == rhs.options;
  }
 
  size_t num_set() const {
    return std::count_if(std::begin(options), std::end(options), [](decltype(options)::value_type const& key_option){
          return key_option.second.has_value();
        });
  }
};
 
 
#endif