basic_string_comparer.hpp

Go to the documentation of this file.

#pragma once
#include "collections/generic/icomparer.hpp"
#include "collections/generic/iequality_comparer.hpp"
#include "as.hpp"
#include "is.hpp"
#include "string_comparison.hpp"
#include "basic_string.hpp"

namespace xtd {
  template<typename char_t>
  class basic_string_comparer : public xtd::object, public xtd::collections::generic::icomparer<xtd::basic_string<char_t>>, public xtd::collections::generic::iequality_comparer<xtd::basic_string<char_t >> {
  public:
    
    [[nodiscard]] static auto current_culture() -> basic_string_comparer {
      xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::not_implemented);
      //return create(culture_info::current_culture);
    }
    
    [[nodiscard]] static auto current_culture_ignore_case() -> basic_string_comparer {
      xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::not_implemented);
      //return create(culture_info::current_culture, true);
    }
    
    [[nodiscard]] static auto invariant_culture() -> basic_string_comparer {
      xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::not_implemented);
      //return create(culture_info::invariant_culture);
    }
    
    [[nodiscard]] static auto invariant_culture_ignore_case() -> basic_string_comparer {
      xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::not_implemented);
      //return create(culture_info::invariant_culture, true);
    }
    
    [[nodiscard]] static auto ordinal() -> const basic_string_comparer& {
      static auto result = from_comparison(string_comparison::ordinal);
      return result;
    }
    
    [[nodiscard]] static auto ordinal_ignore_case() -> const basic_string_comparer& {
      static auto result = from_comparison(string_comparison::ordinal_ignore_case);
      return result;
    }

    
    
    template<typename object_t>
    [[nodiscard]] auto compare(const object_t& x, const object_t& y) const -> xtd::int32 {
      if (is<basic_string<char_t>>(x) && is<basic_string<char_t>>(y)) return compare(as<basic_string<char_t >> (x), as<basic_string<char_t >> (y));
      if (is<icomparable<object_t>>(x) && is<icomparable<object_t>>(y)) return as<icomparable<object_t >> (x).compare_to(y);
      if (is<object>(x) && is<object>(y) && as<object>(x) == as<object>(y)) return 0;
      xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);
    }

    [[nodiscard]] auto compare(const char_t* x, const char_t* y) const -> xtd::int32 {
      if (x == y) return 0;
      return compare(basic_string<char_t> {x}, basic_string<char_t> {y});
    }
    [[nodiscard]] auto compare(const basic_string<char_t>& x, const char_t* y) const -> xtd::int32 {return compare(x, basic_string<char_t> {y});}
    [[nodiscard]] auto compare(const char_t* x, const basic_string<char_t>& y) const -> xtd::int32 {return compare(basic_string<char_t> {x}, y);}
    [[nodiscard]] auto compare(const xtd::basic_string<char_t>& x, const xtd::basic_string<char_t>& y) const noexcept -> xtd::int32 override {
      switch (comparison_) {
        case string_comparison::current_culture:
        case string_comparison::invariant_culture:
        case string_comparison::ordinal: return x.compare_to(y);
        case string_comparison::current_culture_ignore_case:
        case string_comparison::invariant_culture_ignore_case:
        case string_comparison::ordinal_ignore_case: return x.to_lower().compare_to(y.to_lower());
        default: return x.compare_to(y);
      }
    }
    
    [[nodiscard]] auto equals(const object& obj) const noexcept -> bool override {
      return is<basic_string_comparer>(obj) && reinterpret_cast<const basic_string_comparer&>(obj).comparison_ == comparison_;
    }
    
    template<typename object_t>
    [[nodiscard]] auto equals(const object_t& x, const object_t& y) const -> bool {
      if (&x == &y) return true;
      if (is<basic_string<char_t>>(x) && is<basic_string<char_t>>(y)) return equals(as<basic_string<char_t >> (x), as<basic_string<char_t >> (y));
      if (is<iequatable<object_t>>(x) && is<iequatable<object_t>>(y)) return as<iequatable<object_t >> (x).equals(y);
      if (is<object>(x) && is<object>(y) && as<object>(x) == as<object>(y)) return 0;
      xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);
    }

    [[nodiscard]] auto equals(const char_t* x, const char_t* y) const -> bool {
      if (x == y) return true;
      return equals(basic_string<char_t> {x}, basic_string<char_t> {y});
    }
    [[nodiscard]] auto equals(const basic_string<char_t>& x, const char_t* y) const -> bool {return equals(x, basic_string<char_t> {y});}
    [[nodiscard]] auto equals(const char_t* x, const basic_string<char_t>& y) const -> bool {return equals(basic_string<char_t> {x}, y);}
    [[nodiscard]] auto equals(const xtd::basic_string<char_t>& x, const xtd::basic_string<char_t>& y) const noexcept -> bool override {
      if (&x == &y) return true;
      switch (comparison_) {
        case string_comparison::current_culture:
        case string_comparison::invariant_culture:
        case string_comparison::ordinal: return x.equals(y);
        case string_comparison::current_culture_ignore_case:
        case string_comparison::invariant_culture_ignore_case:
        case string_comparison::ordinal_ignore_case: return x.to_lower().equals(y.to_lower());
        default : return x.equals(y);
      }
    }
    
    using xtd::object::get_hash_code;
    template<typename object_t>
    [[nodiscard]] auto get_hash_code(const object_t& obj) const -> xtd::usize {
      if (is<basic_string<char_t>>(obj)) return get_hash_code(as<basic_string<char_t >> (obj));
      if (is<object>(obj)) return as<object>(obj).get_hash_code();
      return xtd::hash_code::combine(obj);
    }

    [[nodiscard]] auto get_hash_code(const char_t* obj) const -> xtd::usize {return get_hash_code(basic_string<char_t> {obj});}
    [[nodiscard]] auto get_hash_code(const xtd::basic_string<char_t>& obj) const noexcept -> xtd::usize override {
      switch (comparison_) {
        case string_comparison::current_culture:
        case string_comparison::invariant_culture:
        case string_comparison::ordinal: return obj.get_hash_code();
        case string_comparison::current_culture_ignore_case:
        case string_comparison::invariant_culture_ignore_case:
        case string_comparison::ordinal_ignore_case: return obj.to_lower().get_hash_code();
        default: return obj.get_hash_code();
      }
    }

    
    
    [[nodiscard]] static auto from_comparison(xtd::string_comparison comparison) -> basic_string_comparer {
      return basic_string_comparer {comparison};
    }
    
    /*
    bool is_well_known_culture_aware_comparer(const xtd::collections::generic::iequality_comparer<xtd::basic_string<char_t>>& comparer, xtd::globalization::compare_info& compare_info, xtd::globalization::compare_options& compare_options) {
      if (xtd::is<>(comparer)) {
        compare_info = get_compare_info();
        compare_options = get_compare_options();
        return true;
      }
    
      compare_info = xtd::globalization::compare_info {};
      compare_options = xtd::globalization::compare_options::none;
      return false;
    } */
    
    [[nodiscard]] static auto is_well_known_ordinal_comparer(const xtd::collections::generic::iequality_comparer<xtd::basic_string<char_t>>& comparer, bool& ignore_case) -> bool {
      if (xtd::is<xtd::basic_string_comparer<char_t>>(comparer) && (xtd::as<xtd::basic_string_comparer<char_t>>(comparer).comparison_ == xtd::string_comparison::ordinal || xtd::as<xtd::basic_string_comparer<char_t >> (comparer).comparison_ == xtd::string_comparison::ordinal_ignore_case)) {
        ignore_case = xtd::is<xtd::basic_string_comparer<char_t>>(comparer) && xtd::as<xtd::basic_string_comparer<char_t >> (comparer).comparison_ == xtd::string_comparison::ordinal_ignore_case;
        return true;
      }
      
      ignore_case = false;
      return false;
    }

    
  protected:
    
    /*
    basic_string_comparer create(const xtd::globalization::culture_info& culture, bool ignore_case)  {
      return create {culture, ignore_case ? compare_options::ignore_case : compare_options::none};
    } */
    
    /*
    basic_string_comparer create(const xtd::globalization::culture_info& culture, xtd::globalization::compare_options options) {
      return basic_string_comparer {culture, options};
    } */
    
    basic_string_comparer() = default;
    
    
  private:
    explicit basic_string_comparer(xtd::string_comparison comparison) : comparison_ {comparison} {
      if (comparison == string_comparison::current_culture) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::not_implemented);
      if (comparison == string_comparison::current_culture_ignore_case) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::not_implemented);
      if (comparison == string_comparison::invariant_culture) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::not_implemented);
      if (comparison == string_comparison::invariant_culture_ignore_case) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::not_implemented);
      
      if (!enum_object<>::is_defined(comparison)) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);
    }
    /*
    basic_string_comparer(const xtd::globalization::culture_info& culture, xtd::globalization::compare_options options) : culture_ {culture}, options_ {options} {
    }
    xtd::globalization::culture_info culture_ = xtd::globalization::culture_info::empty;
    xtd::globalization::compare_options options_ = xtd::globalization::compare_options::none;
     */
    xtd::string_comparison comparison_ = xtd::string_comparison::ordinal;
  };
}