enum_object.hpp

Go to the documentation of this file.

#pragma once
#include "array.hpp"
#include "enum_attribute.hpp"
#include "enum_collection.hpp"
#include "enum_register.hpp"
#include "enum_set_attribute.hpp"
#include "format_exception.hpp"
#include "icomparable.hpp"
#include "iequatable.hpp"
#include "iformatable.hpp"
#include "number_styles.hpp"
#include "optional.hpp"
#include "static.hpp"
#include "string_comparison.hpp"
#include "string_split_options.hpp"

namespace xtd {
  
  template<class enum_t = std::nullptr_t>
  struct enum_object : xtd::object, xtd::icomparable<enum_object<enum_t>>, xtd::iequatable<enum_object<enum_t >>, xtd::iformatable {
    
    using enum_type = enum_t;
    using value_type = enum_t;
    
    
    enum_object() noexcept = default;
    explicit enum_object(enum_type value) : value(value) {}
    
    explicit enum_object(xtd::byte value) : value(to_enum(value)) {}
    explicit enum_object(sbyte value) : value(to_enum(value)) {}
    explicit enum_object(int16 value) : value(to_enum(value)) {}
    explicit enum_object(int32 value) : value(to_enum(value)) {}
    explicit enum_object(int64 value) : value(to_enum(value)) {}
    explicit enum_object(uint16 value) : value(to_enum(value)) {}
    explicit enum_object(uint32 value) : value(to_enum(value)) {}
    explicit enum_object(uint64 value) : value(to_enum(value)) {}
    enum_object(enum_object&&) noexcept = default;
    enum_object(const enum_object&) noexcept = default;
    enum_object& operator =(const enum_object&) noexcept = default;
    operator enum_type() const noexcept {return value;}
    
    
    bool has_flag(enum_type flag) const noexcept {return (to_int(value) & to_int(flag)) == to_int(flag);}
    
    enum_type value {};
    
    
    int32 compare_to(const enum_object& value) const noexcept override {
      if (to_int(this->value) == to_int(value.value)) return 0;
      if (to_int(this->value) < to_int(value.value)) return -1;
      return 1;
    }
    int32 compare_to(const enum_object& value) const noexcept override {…}
    
    bool equals(const object& obj) const noexcept override {return dynamic_cast<const enum_object*>(&obj) && equals(static_cast<const enum_object&>(obj));}
    bool equals(const enum_object& value) const noexcept override {return this->value == value.value;}
    bool equals(enum_type value) const noexcept {return this->value == value;}
    template<class attribute_t>
    bool equals(attribute_t value) const noexcept {return false;}
    
    xtd::size get_hash_code() const noexcept override {return hash_code::combine(value);}
    
    xtd::byte to_byte() const noexcept {return static_cast<xtd::byte>(value);}
    
    int16 to_int16() const noexcept {return static_cast<int16>(value);}
    
    int32 to_int32() const noexcept {return static_cast<int32>(value);}
    
    int64 to_int64() const noexcept {return static_cast<int64>(value);}
    
    sbyte to_sbyte() const noexcept {return static_cast<sbyte>(value);}
    
    uint16 to_uint16() const noexcept {return static_cast<uint16>(value);}
    
    uint32 to_uint32() const noexcept {return static_cast<uint32>(value);}
    
    uint64 to_uint64() const noexcept {return static_cast<uint64>(value);}
    
    xtd::string to_string() const noexcept override {
      init();
      if (attribute() == xtd::enum_attribute::flags) return to_string_flags();
      
      auto iterator = std::find_if(entries().begin(), entries().end(), [&](auto value)->bool {return value.first == this->value;});
      if (iterator == entries().end()) return string::format("{}", to_int(value));
      
      return iterator->second;
    }
    xtd::string to_string() const noexcept override  {…}
    
    xtd::string to_string(const xtd::string& format) const {return to_string(format, std::locale {});}
    
    xtd::string to_string(const xtd::string& format, const std::locale& loc) const override;
    
    
    static enum_type parse(const xtd::string& str) {return parse(str, false);}
    static enum_type parse(const xtd::string& str, bool ignore_case) {
      enum_object<enum_type>().init();
      if (enum_object<enum_type>().attribute() == xtd::enum_attribute::flags) return parse_flags(str, ignore_case);
      
      for (auto item : enum_object<enum_type>().entries()) {
        if (xtd::string::compare(str, item.second, ignore_case) == 0)
          return static_cast<enum_type>(item.first);
      }
      
      return to_enum(xtd::parse<int64>(str));
    }
    
  private:
    friend struct enum_object<std::nullptr_t>;
    
    xtd::string get_name() const noexcept {
      auto iterator = std::find_if(entries().begin(), entries().end(), [&](auto value)->bool {return value.first == this->value;});
      if (iterator == entries().end()) return xtd::string::format("{}", to_int(value));
      return iterator->second;
    }
    
    static enum_type parse_flags(const xtd::string& value, bool ignore_case) {
      xtd::array<xtd::string> values = value.split(',');
      for (xtd::string& str : values)
        str = str.trim(' ');
        
      if (values.size() == 1) {
        for (auto item : enum_object<enum_type>().entries()) {
          if (xtd::string::compare(value, item.second, ignore_case) == 0)
            return to_enum(item.first);
        }
        return to_enum(xtd::parse<int64>(value));
      }
      
      int64 result = 0;
      for (xtd::string str : values) {
        bool found = false;
        for (auto item : enum_object<enum_type>().entries()) {
          if (xtd::string::compare(str, item.second, ignore_case) == 0) {
            found = true;
            result |= to_int(item.first);
            break;
          }
        }
        if (found == false)
          xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::format);;
      }
      
      return to_enum(result);
    }
    
    xtd::string to_string_flags() const noexcept {
      auto iterator = std::find_if(entries().begin(), entries().end(), [&](auto value)->bool {return value.first == this->value;});
      if (to_int(value) == 0 && iterator == entries().end()) return "0";
      
      iterator = std::find_if(entries().begin(), entries().end(), [&](auto value)->bool {return value.first == to_enum(0);});
      if (to_int(value) == 0) return iterator == entries().end() ? "0" : iterator->second;
      
      xtd::string str;
      int64 rest = to_int(value);
      enum_collection<enum_type> reversed_entries = entries();
      std::reverse(reversed_entries.begin(), reversed_entries.end());
      
      for (auto item : reversed_entries) {
        if (to_int(item.first) != 0 && (rest & to_int(item.first)) == to_int(item.first)) {
          rest -= to_int(item.first);
          if (!xtd::string::is_empty(str)) str = ", " + str;
          str = item.second + str;
        }
      }
      
      if (str.empty() || rest > 0) return  xtd::string::format("{}", to_int(value));
      
      return str;
    }
    
    template<class attribute_t>
    static enum_type to_enum(attribute_t value) noexcept {return static_cast<enum_type>(value);}
    static int64 to_int(enum_type value) noexcept {return static_cast<int64>(value);}
    
    static xtd::enum_attribute attribute() noexcept {
      if (attribute_.has_value()) return attribute_.value();
      attribute_ = xtd::enum_attribute(enum_set_attribute<enum_type>());
      return attribute_.value();
    }
    
    static enum_collection<enum_type>& entries() noexcept {
      if (entries_.has_value()) return entries_.value();
      entries_ = enum_collection<enum_type>(enum_register<enum_type>());
      return entries_.value();
    };
    
    static void init() noexcept {
      attribute();
      entries();
    }
    
    inline static std::optional<xtd::enum_attribute> attribute_;
    inline static std::optional<enum_collection<enum_type>> entries_;
  };
  
  template<>
  struct enum_object < std::nullptr_t > static_ {
    
    
    
    template < class enum_t >
    static const xtd::enum_collection < enum_t > & get_entries() noexcept {
      return enum_object < enum_t > ().entries();
    }
    
    template < class enum_t >
    static xtd::enum_collection < xtd::byte > get_entries_as_byte() noexcept {
      xtd::enum_collection < xtd::byte > entries;
      std::for_each(enum_object < enum_t > ().entries().begin(), enum_object < enum_t>().entries().end(), [&](auto entry) {entries.emplace_back(enum_object < enum_t > (entry.first).to_byte(), entry.second);});
      return entries;
    }
    
    template < class enum_t >
    static xtd::enum_collection < int16 > get_entries_as_int16() noexcept {
      xtd::enum_collection < int16 > entries;
      std::for_each(enum_object < enum_t > ().entries().begin(), enum_object < enum_t>().entries().end(), [&](auto entry) {entries.emplace_back(enum_object < enum_t > (entry.first).to_int16(), entry.second);});
      return entries;
    }
    
    template < class enum_t >
    static xtd::enum_collection < int32 > get_entries_as_int32() noexcept {
      xtd::enum_collection < int32 > entries;
      std::for_each(enum_object < enum_t > ().entries().begin(), enum_object < enum_t>().entries().end(), [&](auto entry) {entries.emplace_back(enum_object < enum_t > (entry.first).to_int32(), entry.second);});
      return entries;
    }
    
    template < class enum_t >
    static xtd::enum_collection < int64 > get_entries_as_int64() noexcept {
      xtd::enum_collection < int64 > entries;
      std::for_each(enum_object < enum_t > ().entries().begin(), enum_object < enum_t>().entries().end(), [&](auto entry) {entries.emplace_back(enum_object < enum_t > (entry.first).to_int64(), entry.second);});
      return entries;
    }
    
    template < class enum_t >
    static xtd::enum_collection < sbyte > get_entries_as_sbyte() noexcept {
      xtd::enum_collection < sbyte > entries;
      std::for_each(enum_object < enum_t > ().entries().begin(), enum_object < enum_t>().entries().end(), [&](auto entry) {entries.emplace_back(enum_object < enum_t > (entry.first).to_sbyte(), entry.second);});
      return entries;
    }
    
    template < class enum_t >
    static xtd::enum_collection < uint16 > get_entries_as_uint16() noexcept {
      xtd::enum_collection < uint16 > entries;
      std::for_each(enum_object < enum_t > ().entries().begin(), enum_object < enum_t>().entries().end(), [&](auto entry) {entries.emplace_back(enum_object < enum_t > (entry.first).to_uint16(), entry.second);});
      return entries;
    }
    
    template < class enum_t >
    static xtd::enum_collection < uint32 > get_entries_as_uint32() noexcept {
      xtd::enum_collection < uint32 > entries;
      std::for_each(enum_object < enum_t > ().entries().begin(), enum_object < enum_t>().entries().end(), [&](auto entry) {entries.emplace_back(enum_object < enum_t > (entry.first).to_uint32(), entry.second);});
      return entries;
    }
    
    template < class enum_t >
    static xtd::enum_collection < uint64 > get_entries_as_uint64() noexcept {
      xtd::enum_collection < uint64 > entries;
      std::for_each(enum_object < enum_t > ().entries().begin(), enum_object < enum_t>().entries().end(), [&](auto entry) {entries.emplace_back(enum_object < enum_t > (entry.first).to_uint64(), entry.second);});
      return entries;
    }
    
    template < class enum_t >
    static xtd::string get_name(enum_t value) noexcept {return enum_object < enum_t > (value).to_string();}
    template < class enum_t >
    static xtd::string get_name(enum_object < enum_t > value) noexcept {return enum_object < enum_t > (value).to_string();}
    template < class enum_t >
    static xtd::string get_name(int32 value) noexcept {return enum_object < enum_t > (value).to_string();}
    template < class enum_t >
    static xtd::string get_name(int64 value) noexcept {return enum_object < enum_t > (value).to_string();}
    
    template < class enum_t >
    static xtd::array < xtd::string > get_names() noexcept {
      auto names = xtd::array < xtd::string > {};
      std::for_each(enum_object < enum_t > ().entries().begin(), enum_object < enum_t > ().entries().end(), [&](auto entry) {names.resize(names.size() + 1, entry.second);});
      return names;
    }
    
    template < class enum_t >
    static xtd::array < enum_t > get_values() noexcept {
      auto values = xtd::array < enum_t > {};
      std::for_each(enum_object < enum_t > ().entries().begin(), enum_object < enum_t > ().entries().end(), [&](auto entry) {values.resize(values.size() + 1, entry.first);});
      return values;
    }
    
    template < class enum_t >
    static xtd::array < xtd::byte > get_values_as_byte() noexcept {
      auto values = xtd::array < xtd::byte > {};
      std::for_each(enum_object < enum_t > ().entries().begin(), enum_object < enum_t > ().entries().end(), [&](auto entry) {values.resize(values.size() + 1, enum_object < enum_t > (entry.first).to_byte());});
      return values;
    }
    
    template < class enum_t >
    static xtd::array < int16 > get_values_as_int16() noexcept {
      auto values = xtd::array < xtd::int16 > {};
      std::for_each(enum_object < enum_t > ().entries().begin(), enum_object < enum_t > ().entries().end(), [&](auto entry) {values.resize(values.size() + 1, enum_object < enum_t > (entry.first).to_int16());});
      return values;
    }
    
    template < class enum_t >
    static xtd::array < int32 > get_values_as_int32() noexcept {
      auto values = xtd::array < xtd::int32 > {};
      std::for_each(enum_object < enum_t > ().entries().begin(), enum_object < enum_t > ().entries().end(), [&](auto entry) {values.resize(values.size() + 1, enum_object < enum_t > (entry.first).to_int32());});
      return values;
    }
    
    template < class enum_t >
    static xtd::array < int64 > get_values_as_int64() noexcept {
      auto values = xtd::array < xtd::int64 > {};
      std::for_each(enum_object < enum_t > ().entries().begin(), enum_object < enum_t > ().entries().end(), [&](auto entry) {values.resize(values.size() + 1, enum_object < enum_t > (entry.first).to_int64());});
      return values;
    }
    
    template < class enum_t >
    static xtd::array < sbyte > get_values_as_sbyte() noexcept {
      auto values = xtd::array < xtd::sbyte > {};
      std::for_each(enum_object < enum_t > ().entries().begin(), enum_object < enum_t > ().entries().end(), [&](auto entry) {values.resize(values.size() + 1, enum_object < enum_t > (entry.first).to_sbyte());});
      return values;
    }
    
    template < class enum_t >
    static xtd::array < uint16 > get_values_as_uint16() noexcept {
      auto values = xtd::array < xtd::uint16 > {};
      std::for_each(enum_object < enum_t > ().entries().begin(), enum_object < enum_t > ().entries().end(), [&](auto entry) {values.resize(values.size() + 1, enum_object < enum_t > (entry.first).to_uint16());});
      return values;
    }
    
    template < class enum_t >
    static xtd::array < uint32 > get_values_as_uint32() noexcept {
      auto values = xtd::array < xtd::uint32 > {};
      std::for_each(enum_object < enum_t > ().entries().begin(), enum_object < enum_t > ().entries().end(), [&](auto entry) {values.resize(values.size() + 1, enum_object < enum_t > (entry.first).to_uint32());});
      return values;
    }
    
    template < class enum_t >
    static xtd::array < uint64 > get_values_as_uint64() noexcept {
      auto values = xtd::array < xtd::uint64 > {};
      std::for_each(enum_object < enum_t > ().entries().begin(), enum_object < enum_t > ().entries().end(), [&](auto entry) {values.resize(values.size() + 1, enum_object < enum_t > (entry.first).to_uint64());});
      return values;
    }
    
    template < class enum_t >
    static bool is_defined(enum_t value) noexcept {return std::find_if(enum_object < enum_t > ().entries().begin(), enum_object < enum_t>().entries().end(), [&](auto item)->bool {return item.first == value;}) != enum_object < enum_t > ().entries().end();}
    template < class enum_t >
    static bool is_defined(enum_object < enum_t > value) noexcept {return std::find_if(enum_object < enum_t>().entries().begin(), enum_object<enum_t>().entries().end(), [&](auto item)->bool {return item.first == value;}) != enum_object < enum_t > ().entries().end();}
    
    template < class enum_t >
    static enum_t parse(const xtd::string & value) {return parse < enum_t > (value, false);}
    template < class enum_t >
    static enum_t parse(const xtd::string & str, bool ignore_case) {
      return enum_object < enum_t >::parse(str, ignore_case);
    }
    
    template < class enum_t >
    static xtd::byte to_byte(enum_t value) noexcept {return enum_object < enum_t > (value).to_byte();}
    
    template < class enum_t >
    static int16 to_int16(enum_t value) noexcept {return enum_object < enum_t > (value).to_int16();}
    
    template < class enum_t >
    static int32 to_int32(enum_t value) noexcept {return enum_object < enum_t > (value).to_int32();}
    
    template < class enum_t >
    static int64 to_int64(enum_t value) noexcept {return enum_object < enum_t > (value).to_int64();}
    
    template < class enum_t >
    static sbyte to_sbyte(enum_t value) noexcept {return enum_object < enum_t > (value).to_sbyte();}
    
    template < class enum_t >
    static xtd::string to_string(enum_t value) noexcept {return enum_object < enum_t > (value).to_string();}
    
    template < class enum_t >
    static uint16 to_uint16(enum_t value) noexcept {return enum_object < enum_t > (value).to_uint16();}
    
    template < class enum_t >
    static uint32 to_uint32(enum_t value) noexcept {return enum_object < enum_t > (value).to_uint32();}
    
    template < class enum_t >
    static uint64 to_uint64(enum_t value) noexcept {return enum_object < enum_t > (value).to_uint64();}
    
    template < class enum_t >
    static bool try_parse(const xtd::string & value, enum_t& result) noexcept {return try_parse < enum_t > (value, false, result);}
    
    template < class enum_t >
    static bool try_parse(const xtd::string & value, bool ignore_case, enum_t& result) noexcept {
      try {
        result = parse < enum_t > (value, ignore_case);
        return true;
      } catch (...) {
        return false;
      }
    }
  };
  struct enum_object : xtd::object, xtd::icomparable<enum_object<enum_t>>, xtd::iequatable<enum_object<enum_t >>, xtd::iformatable {…};

  
  template < class enum_t >
  xtd::string enum_object < enum_t >::to_string(const xtd::string& format, const std::locale& loc) const {
    init();
    auto fmt = format;
    if (fmt.empty()) fmt = "G";
    
    switch (fmt[0]) {
      case 'b':
      case 'B':
      case 'd':
      case 'D':
      case 'o':
      case 'O':
      case 'x':
      case 'X': return __numeric_formatter(fmt.chars(), static_cast < long long int > (value), std::locale());
      case 'f':
      case 'F':
      case 'g':
      case 'G': return xtd::enum_object < >::get_name(value);
    }
    xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::format);
  }
}

template < class enum_t >
inline std::string __enum_to_string__(enum_t value) noexcept {
  return xtd::enum_object < >::get_name(value);
}
 
template < class value_t >
value_t __parse_enum(const std::string& str) {
  return xtd::enum_object < >::parse < value_t > (str);
}