enum_object.h

Go to the documentation of this file.

 
#pragma once
#include "enum_attribute.h"
#include "enum_collection.h"
#include "enum_register.h"
#include "enum_set_attribute.h"
#include "format_exception.h"
#include "icomparable.h"
#include "iequatable.h"
#include "iformatable.h"
#include "literals.h"
#include "number_styles.h"
#include "optional.h"
#include "static.h"
#include "string_comparison.h"
#include "string_split_options.h"
 
namespace xtd {
  
  template<typename enum_t = std::nullptr_t>
  class enum_object : public xtd::object, public xtd::icomparable<enum_object<enum_t>>, public xtd::iequatable<enum_object<enum_t>>, public xtd::iformatable {
  public:
    
    using enum_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() const noexcept {return value_;}
    enum_object& value(enum_type value) {
      value_ = value;
      return *this;
    }
    
    
    int32 compare_to(const enum_object& value) const noexcept override {
      if (to_int(value_) == to_int(value.value_)) return 0;
      if (to_int(value_) < to_int(value.value_)) return -1;
      return 1;
    }
    
    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 == value_;});
      if (iterator == entries().end()) return string::format("{}", to_int(value_));
      
      return iterator->second;
    }
    
    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;
    
    using object::equals;
    bool equals(const enum_object& value) const noexcept override {return value_ == value.value_;}
    bool equals(enum_type value) const noexcept {return value_ == value;}
    template<typename attribute_t>
    bool equals(attribute_t value) const noexcept {return false;}
    
    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));
    }
    
    static enum_type parse_flags(const xtd::string& value, bool ignore_case) {
      std::vector<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)
          throw xtd::format_exception {};
      }
      
      return to_enum(result);
    }
    
  private:
    friend class 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 == value_;});
      if (iterator == entries().end()) return xtd::string::format("{}", to_int(value_));
      return iterator->second;
    }
    
    xtd::string to_string_flags() const noexcept {
      auto iterator = std::find_if(entries().begin(), entries().end(), [&](auto value)->bool {return value.first == 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<typename 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_;
    enum_type value_ {};
  };
  
  template<>
  class enum_object<std::nullptr_t> static_ {
  public:
    
    template<typename enum_t>
    static const xtd::enum_collection<enum_t>& get_entries() noexcept {
      return enum_object<enum_t>().entries();
    }
    
    template<typename 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<typename 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<typename 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<typename 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<typename 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<typename 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<typename 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<typename 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<typename enum_t>
    static xtd::string get_name(enum_t value) noexcept {return enum_object<enum_t>(value).to_string();}
    template<typename enum_t>
    static xtd::string get_name(enum_object<enum_t> value) noexcept {return enum_object<enum_t>(value).to_string();}
    template<typename enum_t>
    static xtd::string get_name(int32 value) noexcept {return enum_object<enum_t>(value).to_string();}
    template<typename enum_t>
    static xtd::string get_name(int64 value) noexcept {return enum_object<enum_t>(value).to_string();}
    
    template<typename enum_t>
    static std::vector<xtd::string> get_names() noexcept {
      std::vector<xtd::string> names;
      std::for_each(enum_object<enum_t>().entries().begin(), enum_object<enum_t>().entries().end(), [&](auto entry) {names.push_back(entry.second);});
      return names;
    }
    
    template<typename enum_t>
    static std::vector<enum_t> get_values() noexcept {
      std::vector<enum_t> values;
      std::for_each(enum_object<enum_t>().entries().begin(), enum_object<enum_t>().entries().end(), [&](auto entry) {values.push_back(entry.first);});
      return values;
    }
    
    template<typename enum_t>
    static std::vector<xtd::byte> get_values_as_byte() noexcept {
      std::vector<xtd::byte> values;
      std::for_each(enum_object<enum_t>().entries().begin(), enum_object<enum_t>().entries().end(), [&](auto entry) {values.push_back(enum_object<enum_t>(entry.first).to_byte());});
      return values;
    }
    
    template<typename enum_t>
    static std::vector<int16> get_values_as_int16() noexcept {
      std::vector<int16> values;
      std::for_each(enum_object<enum_t>().entries().begin(), enum_object<enum_t>().entries().end(), [&](auto entry) {values.push_back(enum_object<enum_t>(entry.first).to_int16());});
      return values;
    }
    
    template<typename enum_t>
    static std::vector<int32> get_values_as_int32() noexcept {
      std::vector<int32> values;
      std::for_each(enum_object<enum_t>().entries().begin(), enum_object<enum_t>().entries().end(), [&](auto entry) {values.push_back(enum_object<enum_t>(entry.first).to_int32());});
      return values;
    }
    
    template<typename enum_t>
    static std::vector<int64> get_values_as_int64() noexcept {
      std::vector<int64> values;
      std::for_each(enum_object<enum_t>().entries().begin(), enum_object<enum_t>().entries().end(), [&](auto entry) {values.push_back(enum_object<enum_t>(entry.first).to_int64());});
      return values;
    }
    
    template<typename enum_t>
    static std::vector<sbyte> get_values_as_sbyte() noexcept {
      std::vector<sbyte> values;
      std::for_each(enum_object<enum_t>().entries().begin(), enum_object<enum_t>().entries().end(), [&](auto entry) {values.push_back(enum_object<enum_t>(entry.first).to_sbyte());});
      return values;
    }
    
    template<typename enum_t>
    static std::vector<uint16> get_values_as_uint16() noexcept {
      std::vector<uint16> values;
      std::for_each(enum_object<enum_t>().entries().begin(), enum_object<enum_t>().entries().end(), [&](auto entry) {values.push_back(enum_object<enum_t>(entry.first).to_uint16());});
      return values;
    }
    
    template<typename enum_t>
    static std::vector<uint32> get_values_as_uint32() noexcept {
      std::vector<uint32> values;
      std::for_each(enum_object<enum_t>().entries().begin(), enum_object<enum_t>().entries().end(), [&](auto entry) {values.push_back(enum_object<enum_t>(entry.first).to_uint32());});
      return values;
    }
    
    template<typename enum_t>
    static std::vector<uint64> get_values_as_uint64() noexcept {
      std::vector<uint64> values;
      std::for_each(enum_object<enum_t>().entries().begin(), enum_object<enum_t>().entries().end(), [&](auto entry) {values.push_back(enum_object<enum_t>(entry.first).to_uint64());});
      return values;
    }
    
    template<typename 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<typename 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<typename enum_t>
    static enum_t parse(const xtd::string& value) {return parse<enum_t>(value, false);}
    template<typename enum_t>
    static enum_t parse(const xtd::string& str, bool ignore_case) {
      return enum_object<enum_t>::parse(str, ignore_case);
    }
    
    template<typename enum_t>
    static xtd::byte to_byte(enum_t value) noexcept {return enum_object<enum_t>(value).to_byte();}
    
    template<typename enum_t>
    static int16 to_int16(enum_t value) noexcept {return enum_object<enum_t>(value).to_int16();}
    
    template<typename enum_t>
    static int32 to_int32(enum_t value) noexcept {return enum_object<enum_t>(value).to_int32();}
    
    template<typename enum_t>
    static int64 to_int64(enum_t value) noexcept {return enum_object<enum_t>(value).to_int64();}
    
    template<typename enum_t>
    static sbyte to_sbyte(enum_t value) noexcept {return enum_object<enum_t>(value).to_sbyte();}
    
    template<typename enum_t>
    static xtd::string to_string(enum_t value) noexcept {return enum_object<enum_t>(value).to_string();}
    
    template<typename enum_t>
    static uint16 to_uint16(enum_t value) noexcept {return enum_object<enum_t>(value).to_uint16();}
    
    template<typename enum_t>
    static uint32 to_uint32(enum_t value) noexcept {return enum_object<enum_t>(value).to_uint32();}
    
    template<typename enum_t>
    static uint64 to_uint64(enum_t value) noexcept {return enum_object<enum_t>(value).to_uint64();}
    
    template<typename enum_t>
    static bool try_parse(const xtd::string& value, enum_t& result) noexcept {return try_parse<enum_t>(value, false, result);}
    
    template<typename 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;
      }
    }
  };
  
  template<typename 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_);
    }
    throw format_exception("Invalid format"_t);
  }
}
 
template<typename enum_t>
inline std::string __enum_to_string(enum_t value) noexcept {
  return xtd::enum_object<>::get_name(value);
}
 
template<typename value_t>
value_t __parse_enum(const std::string& str) {
  return xtd::enum_object<>::parse<value_t>(str);
}