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 "argument_exception.hpp"
#include "as.hpp"
#include "is.hpp"
#include "not_implemented_exception.hpp"
#include "string_comparison.hpp"
#include "basic_string.hpp"
 
namespace xtd {
  template<class 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:
    
    static basic_string_comparer current_culture() {
      xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::not_implemented);
      //return create(culture_info::current_culture);
    }
 
    static basic_string_comparer current_culture_ignore_case() {
      xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::not_implemented);
      //return create(culture_info::current_culture, true);
    }
 
    static basic_string_comparer invariant_culture() {
      xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::not_implemented);
      //return create(culture_info::invariant_culture);
    }
    
    static basic_string_comparer invariant_culture_ignore_case() {
      xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::not_implemented);
      //return create(culture_info::invariant_culture, true);
    }
    
    static const basic_string_comparer& ordinal() {
      static auto result = from_comparison(string_comparison::ordinal);
      return result;
    }
 
    static const basic_string_comparer& ordinal_ignore_case() {
      static auto result = from_comparison(string_comparison::ordinal_ignore_case);
      return result;
    }
    
    
    template <class object_t>
    int32 compare(const object_t& x, const object_t& y) const  {
      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);;
    }
    int32 compare(const char_t* x, const char_t* y) const {
      if (x == y) return 0;
      return compare(basic_string<char_t> {x}, basic_string<char_t> {y});
    }
    int32 compare(const basic_string<char_t>& x, const char_t* y) const {return compare(x, basic_string<char_t> {y});}
    int32 compare(const char_t* x, const basic_string<char_t>& y) const {return compare(basic_string<char_t> {x}, y);}
    int32 compare(const xtd::basic_string<char_t>& x, const xtd::basic_string<char_t>& y) const noexcept 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);
      }
    }
 
    bool equals(const object& obj) const noexcept override {
      return is<basic_string_comparer>(obj) && reinterpret_cast<const basic_string_comparer&>(obj).comparison_ == comparison_;
    }
 
    template <class object_t>
    bool equals(const object_t& x, const object_t& y) const  {
      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);;
    }
    bool equals(const char_t* x, const char_t* y) const {
      if (x == y) return true;
      return equals(basic_string<char_t> {x}, basic_string<char_t> {y});}
    bool equals(const basic_string<char_t>& x, const char_t* y) const {return equals(x, basic_string<char_t> {y});}
    bool equals(const char_t* x, const basic_string<char_t>& y) const {return equals(basic_string<char_t> {x}, y);}
    bool equals(const xtd::basic_string<char_t>& x, const xtd::basic_string<char_t>& y) const noexcept 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 <class object_t>
    xtd::size get_hash_code(const object_t& obj) const  {
      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);
    }
    xtd::size get_hash_code(const char_t* obj) const {return get_hash_code(basic_string<char_t> {obj});}
    xtd::size get_hash_code(const xtd::basic_string<char_t>& obj) const noexcept 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();
      }
    }
 
    
    static basic_string_comparer from_comparison(xtd::string_comparison comparison) {
      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;
    } */
    
    static bool is_well_known_ordinal_comparer(const xtd::collections::generic::iequality_comparer<xtd::basic_string<char_t>>& comparer, bool& ignore_case) {
      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;
  };
}