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<typename 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;}
    
    
    [[nodiscard]] auto has_flag(enum_type flag) const noexcept -> bool {return (to_int(value) & to_int(flag)) == to_int(flag);}
    
    enum_type value {};
    
    
    [[nodiscard]] auto compare_to(const enum_object& value) const noexcept -> xtd::int32 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;
    }
    
    [[nodiscard]] auto equals(const object& obj) const noexcept -> bool override {return dynamic_cast<const enum_object*>(&obj) && equals(static_cast<const enum_object&>(obj));}
    [[nodiscard]] auto equals(const enum_object& value) const noexcept -> bool override {return this->value == value.value;}
    [[nodiscard]] auto equals(enum_type value) const noexcept -> bool {return this->value == value;}
    template<typename attribute_t>
    [[nodiscard]] auto equals(attribute_t value) const noexcept -> bool {return false;}
    
    [[nodiscard]] auto get_hash_code() const noexcept -> xtd::usize override {return hash_code::combine(value);}
    
    [[nodiscard]] auto to_byte() const noexcept -> xtd::byte {return static_cast<xtd::byte>(value);}
    
    [[nodiscard]] auto to_int16() const noexcept -> xtd::int16 {return static_cast<int16>(value);}
    
    [[nodiscard]] auto to_int32() const noexcept -> xtd::int32 {return static_cast<int32>(value);}
    
    [[nodiscard]] auto to_int64() const noexcept -> xtd::int64 {return static_cast<int64>(value);}
    
    [[nodiscard]] auto to_sbyte() const noexcept -> xtd::sbyte {return static_cast<sbyte>(value);}
    
    [[nodiscard]] auto to_uint16() const noexcept -> xtd::uint16 {return static_cast<uint16>(value);}
    
    [[nodiscard]] auto to_uint32() const noexcept -> xtd::uint32 {return static_cast<uint32>(value);}
    
    [[nodiscard]] auto to_uint64() const noexcept -> xtd::uint64 {return static_cast<uint64>(value);}
    
    [[nodiscard]] auto to_string() const noexcept -> xtd::string 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;
    }
    
    [[nodiscard]] auto to_string(const xtd::string& format) const -> xtd::string {return to_string(format, std::locale {});}
    
    [[nodiscard]] auto to_string(const xtd::string& format, const globalization::culture_info& culture) const -> xtd::string override;
    
    
    [[nodiscard]] static auto parse(const xtd::string& str) -> enum_type {return parse(str, false);}
    [[nodiscard]] static auto parse(const xtd::string& str, bool ignore_case) -> enum_type {
      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));
    }
    
    
    friend auto operator << (std::ostream& os, const enum_object& value) -> std::ostream& {return os << value.to_string();}
    
  private:
    friend struct enum_object<std::nullptr_t>;
    
    [[nodiscard]] auto get_name() const noexcept -> xtd::string {
      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;
    }
    
    [[nodiscard]] static auto parse_flags(const xtd::string& value, bool ignore_case) -> enum_type {
      auto values = value.split(',');
      for (auto& str : values)
        str = str.trim(' ');
        
      if (values.length() == 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));
      }
      
      auto result = xtd::int64 {0};
      for (const auto& str : values) {
        auto 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);
    }
    
    [[nodiscard]] auto to_string_flags() const noexcept -> xtd::string {
      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;
      
      auto str = xtd::string::empty_string;
      auto rest = to_int(value);
      auto 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 (xtd::string::is_empty(str) || rest > 0) return  xtd::string::format("{}", to_int(value));
      return str;
    }
    
    template<typename attribute_t>
    static auto to_enum(attribute_t value) noexcept -> enum_type {return static_cast<enum_type>(value);}
    
    [[nodiscard]] static auto to_int(enum_type value) noexcept -> xtd::int64 {return static_cast<int64>(value);}
    
    [[nodiscard]] static auto attribute() noexcept -> xtd::enum_attribute {
      if (attribute_.has_value()) return attribute_.value();
      attribute_ = xtd::enum_attribute(enum_set_attribute<enum_type>());
      return attribute_.value();
    }
    
    [[nodiscard]] static auto entries() noexcept -> enum_collection<enum_type>& {
      if (entries_.has_value()) return entries_.value();
      entries_ = enum_collection<enum_type>(enum_register<enum_type>());
      return entries_.value();
    };
    
    static auto init() noexcept -> void {
      [[maybe_unused]] auto a = attribute();
      [[maybe_unused]] auto e = 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>
    [[nodiscard]] static auto get_entries() noexcept -> const xtd::enum_collection<enum_t>& {
      return enum_object<enum_t>().entries();
    }
    
    template<class enum_t>
    [[nodiscard]] static auto get_entries_as_byte() noexcept -> xtd::enum_collection<xtd::byte> {
      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>
    [[nodiscard]] static auto get_entries_as_int16() noexcept -> xtd::enum_collection<xtd::int16> {
      xtd::enum_collection<xtd::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>
    [[nodiscard]] static auto get_entries_as_int32() noexcept -> xtd::enum_collection<xtd::int32> {
      xtd::enum_collection<xtd::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>
    [[nodiscard]] static auto get_entries_as_int64() noexcept -> xtd::enum_collection<xtd::int64> {
      xtd::enum_collection<xtd::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>
    [[nodiscard]] static auto get_entries_as_sbyte() noexcept -> xtd::enum_collection<xtd::sbyte> {
      xtd::enum_collection<xtd::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>
    [[nodiscard]] static auto get_entries_as_uint16() noexcept -> xtd::enum_collection<xtd::uint16> {
      xtd::enum_collection<xtd::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>
    [[nodiscard]] static auto get_entries_as_uint32() noexcept -> xtd::enum_collection<xtd::uint32> {
      xtd::enum_collection<xtd::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>
    [[nodiscard]] static auto get_entries_as_uint64() noexcept -> xtd::enum_collection<xtd::uint64> {
      xtd::enum_collection<xtd::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>
    [[nodiscard]] static auto get_name(enum_t value) noexcept -> xtd::string {return enum_object<enum_t>(value).to_string();}
    template<class enum_t>
    [[nodiscard]] static auto get_name(enum_object<enum_t> value) noexcept -> xtd::string {return enum_object<enum_t>(value).to_string();}
    template<class enum_t>
    [[nodiscard]] static auto get_name(int32 value) noexcept -> xtd::string {return enum_object<enum_t>(value).to_string();}
    template<class enum_t>
    [[nodiscard]] static auto get_name(int64 value) noexcept -> xtd::string {return enum_object<enum_t>(value).to_string();}
    
    template<class enum_t>
    [[nodiscard]] static auto get_names() noexcept -> xtd::array<xtd::string> {
      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.length() + 1, entry.second);});
      return names;
    }
    
    template<class enum_t>
    [[nodiscard]] static auto get_values() noexcept -> xtd::array<enum_t> {
      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.length() + 1, entry.first);});
      return values;
    }
    
    template<class enum_t>
    [[nodiscard]] static auto get_values_as_byte() noexcept -> xtd::array<xtd::byte> {
      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.length() + 1, enum_object<enum_t>(entry.first).to_byte());});
      return values;
    }
    
    template<class enum_t>
    [[nodiscard]] static auto get_values_as_int16() noexcept -> xtd::array<xtd::int16> {
      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.length() + 1, enum_object<enum_t>(entry.first).to_int16());});
      return values;
    }
    
    template<class enum_t>
    [[nodiscard]] static auto get_values_as_int32() noexcept -> xtd::array<xtd::int32> {
      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.length() + 1, enum_object<enum_t>(entry.first).to_int32());});
      return values;
    }
    
    template<class enum_t>
    [[nodiscard]] static auto get_values_as_int64() noexcept -> xtd::array<xtd::int64> {
      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.length() + 1, enum_object<enum_t>(entry.first).to_int64());});
      return values;
    }
    
    template<class enum_t>
    [[nodiscard]] static auto get_values_as_sbyte() noexcept -> xtd::array<xtd::sbyte> {
      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.length() + 1, enum_object<enum_t>(entry.first).to_sbyte());});
      return values;
    }
    
    template<class enum_t>
    [[nodiscard]] static auto get_values_as_uint16() noexcept -> xtd::array<xtd::uint16> {
      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.length() + 1, enum_object<enum_t>(entry.first).to_uint16());});
      return values;
    }
    
    template<class enum_t>
    [[nodiscard]] static auto get_values_as_uint32() noexcept -> xtd::array<xtd::uint32> {
      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.length() + 1, enum_object<enum_t>(entry.first).to_uint32());});
      return values;
    }
    
    template<class enum_t>
    [[nodiscard]] static auto get_values_as_uint64() noexcept -> xtd::array<xtd::uint64> {
      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.length() + 1, enum_object<enum_t>(entry.first).to_uint64());});
      return values;
    }
    
    template<class enum_t>
    [[nodiscard]] static auto is_defined(enum_t value) noexcept -> bool {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>
    [[nodiscard]] static auto is_defined(enum_object<enum_t>value) noexcept -> bool {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>
    [[nodiscard]] static auto parse(const xtd::string & value) -> enum_t {return parse<enum_t>(value, false);}
    template<class enum_t>
    [[nodiscard]] static auto parse(const xtd::string & str, bool ignore_case) -> enum_t {
      return enum_object<enum_t>::parse(str, ignore_case);
    }
    
    template<class enum_t>
    [[nodiscard]] static auto to_byte(enum_t value) noexcept -> xtd::byte {return enum_object<enum_t>(value).to_byte();}
    
    template<class enum_t>
    [[nodiscard]] static auto to_int16(enum_t value) noexcept -> xtd::int16 {return enum_object<enum_t>(value).to_int16();}
    
    template<class enum_t>
    [[nodiscard]] static auto to_int32(enum_t value) noexcept -> xtd::int32 {return enum_object<enum_t>(value).to_int32();}
    
    template<class enum_t>
    [[nodiscard]] static auto to_int64(enum_t value) noexcept -> xtd::int64 {return enum_object<enum_t>(value).to_int64();}
    
    template<class enum_t>
    [[nodiscard]] static auto to_sbyte(enum_t value) noexcept -> xtd::sbyte {return enum_object<enum_t>(value).to_sbyte();}
    
    template<class enum_t>
    [[nodiscard]] static auto to_string(enum_t value) noexcept -> xtd::string {return enum_object<enum_t>(value).to_string();}
    
    template<class enum_t>
    [[nodiscard]] static auto to_uint16(enum_t value) noexcept -> xtd::uint16 {return enum_object<enum_t>(value).to_uint16();}
    
    template<class enum_t>
    [[nodiscard]] static auto to_uint32(enum_t value) noexcept -> xtd::uint32 {return enum_object<enum_t>(value).to_uint32();}
    
    template<class enum_t>
    [[nodiscard]] static auto to_uint64(enum_t value) noexcept -> xtd::uint64 {return enum_object<enum_t>(value).to_uint64();}
    
    template<class enum_t>
    [[nodiscard]] static auto try_parse(const xtd::string & value, enum_t& result) noexcept -> bool {return try_parse<enum_t>(value, false, result);}
    
    template<class enum_t>
    [[nodiscard]] static auto try_parse(const xtd::string & value, bool ignore_case, enum_t& result) noexcept -> bool {
      try {
        result = parse<enum_t>(value, ignore_case);
        return true;
      } catch (...) {
        return false;
      }
    }

  };

}

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