Add xtd::string_comparer properties and methods

Author: gammasoft71

src/xtd.core/include/xtd/string_comparer.hpp

@@ -24,12 +24,51 @@ namespace xtd {
   /// xtd
   /// @par Library
   /// xtd.core
-  /// @ingroup xtd_core
+  /// @ingroup xtd_core system
   class string_comparer : public xtd::object, public xtd::collections::generic::icomparer<xtd::string>, public xtd::collections::generic::iequality_comparer<xtd::string> {
   public:
     /// @name Public Static Properties
 
     /// @{
+    /// @brief Gets a xtd::string_comparer object that performs a case-sensitive string comparison using the word comparison rules of the current culture.
+    /// @return A xtd::string_comparer object.
+    /// @remarks The xtd::string_comparer returned by the xtd::string_comparer::current_culture property can be used when strings are linguistically relevant. For example, if strings are displayed to the user, or if strings are the result of user interaction, culture-sensitive string comparison should be used to order the string data.
+    /// @remarks The current culture is the xtd::globalization::culture_info object associated with the current thread.
+    /// @remarks The xtd::::string_comparer::current_culture property actually returns an instance of an anonymous class derived from the ::string_comparer class.
+    /// @remarks Each call to the ::string_comparer::current_culture property get accessor returns a new ::string_comparer object, as the following code shows.
+    /// ```
+    /// void compare_current_culture_string_comparer() {
+    ///   string_comparer string_comparer1 = string_comparer::current_culture;
+    ///   string_comparer string_comparer2 = string_comparer::current_culture;
+    ///   // Displays false
+    ///   console::write_line(string_comparer::reference_equals(string_comparer1, string_comparer2));
+    /// }
+    /// ```
+    /// @remarks To improve performance, you can store the xtd::string_comparer object in a local variable rather than retrieve the value of the xtd::string_comparer::current_culture property multiple times.
+    static string_comparer current_culture();
+
+    /// @brief Gets a xtd::string_comparer object that performs case-insensitive string comparisons using the word comparison rules of the current culture.
+    /// @return A xtd::string_comparer object.
+    /// @remarks The current culture is the xtd::globalization::culture_info object associated with the current thread; it is returned by the xtd::globalization::culture_info::current_culture property.
+    /// @remarks The xtd::string_comparer returned by the xtd::string_comparer::current_culture_ignore_case property can be used when strings are linguistically relevant but their case is not. For example, if strings are displayed to the user but case is unimportant, culture-sensitive, case-insensitive string comparison should be used to order the string data.
+    /// @note xtd running on Linux and macOS systems only: The collation behavior for the C and Posix cultures is always case-sensitive because these cultures do not use the expected Unicode collation order. We recommend that you use a culture other than C or Posix for performing culture-sensitive, case-insensitive sorting operations.
+    /// @remarks The xtd::string_comparer::current_culture_ignore_case property actually returns an instance of an anonymous class derived from the xtd::string_comparer class.
+    /// @remarks Each call to the xtd::string_comparer::current_culture_ignore_case property get accessor returns a new xtd::string_comparer object, as the following code shows.
+    /// ```
+    /// void compare_current_culture_string_comparer() {
+    ///   string_comparer string_comparer1 = string_comparer::current_culture_ignore_case;
+    ///   string_comparer string_comparer2 = string_comparer::current_culture_ignore_case;
+    ///   // Displays false
+    ///   console::write_line(string_comparer::reference_equals(string_comparer1, string_comparer2));
+    /// }
+    /// ```
+    /// @remarks To improve performance, you can store the xtd::string_comparer object in a local variable rather than retrieve the value of the xtd::string_comparer::current_culture_ignore_case property multiple times.
+    static string_comparer current_culture_ignore_case();
+
+    static string_comparer invariant_culture();
+    
+    static string_comparer invariant_culture_ignore_case();
+    
     /// @brief Gets a xtd::string_comparer object that performs a case-sensitive ordinal string comparison.
     /// @return A xtd::string_comparer object.
     /// @remarks The xtd::string_comparer returned by the xtd::string_comparer::ordinal property performs a simple byte comparison that is independent of language. This is most appropriate when comparing strings that are generated programmatically or when comparing case-sensitive resources such as passwords.
@@ -84,7 +123,14 @@ namespace xtd {
     /// @remarks The xtd::string_comparer::compare(const string&, const string&) method is slightly more efficient than the xtd::string_comparer::compare(const object_t&, consy object_t&) method because no conversion of the `x` and `y` arguments is needed to perform the comparison.
     int32 compare(const xtd::string& x, const xtd::string& y) const noexcept override;
 
-    using xtd::object::equals;
+    /// @brief Determines whether the specified object is equal to the current object.
+    /// @param obj The object to compare with the current object.
+    /// @return true if the specified object is equal to the current object. otherwise, false.
+    /// @par Examples
+    /// The following code example compares the current instance with another object.
+    /// @include object_equals.cpp
+    bool equals(const object& obj) const noexcept override;
+
     /// @brief When overridden in a derived class, indicates whether two objects are equal.
     /// @param x An object to compare to `y`.
     /// @param y An object to compare to `x`.
@@ -111,7 +157,7 @@ namespace xtd {
     /// @return `true` if `x` and `y`  refer to the same object, or `x` and `y` are both the same type of object and those objects are equal; otherwise, `false`.
     /// @remarks The xtd::string_comparer::equals(const string&, const string&) method is slightly more efficient than the xtd::string_comparer::equals(const object_t&, consy object_t&) method because no conversion of the `x` and `y` arguments is needed to perform the comparison.
     bool equals(const xtd::string& x, const xtd::string& y) const noexcept override;
-    
+        
     using xtd::object::get_hash_code;
     /// @brief When overridden in a derived class, gets the hash code for the specified object.
     /// @param obj An object.
@@ -133,17 +179,48 @@ namespace xtd {
     xtd::size get_hash_code(const xtd::string& obj) const noexcept override;
     /// @}
 
+    /// @name Public Static Methods
+    
+    /// @{
+    /// @brief Converts the specified xtd::string_comparison instance to a StringComparer instance.
+    /// @param comparison A string comparer instance to convert.
+    /// @return A xtd::string_comparer instance representing the equivalent value of the specified xtd::string_comparison instance.
+    /// @exception xtd::argument_exception The specified string comparison is not supported.
+    static string_comparer from_comparison(xtd::string_comparison comparison);
+    /// @}
+
   protected:
     /// @name Protected Constructors
 
     /// @{
+    /// @todo Uncomment following lines when xtd::globalization::culture_info and xtd::globalization::compare_options are developped.
+    /*
+    /// @brief Creates a xtd::string_comparer object that compares strings according to the rules of a specified culture.
+    /// @param culture A culture whose linguistic rules are used to perform a string comparison.
+    /// @param ignore_case `true` to specify that comparison operations be case-insensitive; `false` to specify that comparison operations be case-sensitive.
+    /// @return A new xtd::string_comparer object that performs string comparisons according to the comparison rules used by the `culture` parameter and the case rule specified by the `ignore_case` parameter.
+    string_comparer create(const xtd::globalization::culture_info& culture, bool ignore_case);
+    
+    /// @brief Creates a xtd::string_comparer object that compares strings according to the rules of a specified culture and string options.
+    /// @param culture A culture whose linguistic rules are used to perform a string comparison.
+    /// @param options A bitwise combination of the xtd::globalization::compare_options values.
+    /// @exception xtd::argument_exception `options` has invalid flags.
+    string_comparer create(const xtd::globalization::culture_info& culture, xtd::globalization::compare_options options);
+     */
+
     /// @brief Initializes a new instance of the xtd::string_comparer class.
     string_comparer() = default;
     /// @}
 
 
   private:
-    explicit string_comparer(xtd::string_comparison comparison) : comparison_ {comparison} {}
+    explicit string_comparer(xtd::string_comparison comparison);
+    /// @todo Uncomment following lines when xtd::globalization::culture_info and xtd::globalization::compare_options are developped.
+    /*
+    string_comparer(const xtd::globalization::culture_info& culture, xtd::globalization::compare_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;
   };
 }

src/xtd.core/src/xtd/string_comparer.cpp

@@ -1,37 +1,114 @@
 #include "../../include/xtd/argument_exception.hpp"
 #include "../../include/xtd/is.hpp"
 #include "../../include/xtd/string_comparer.hpp"
+#include "../../include/xtd/not_implemented_exception.hpp"
 
 using namespace xtd;
+/// @todo Uncomment following lines when xtd::globalization::culture_info and xtd::globalization::compare_options are developped.
+//using namespace xtd::globalization;
+
+string_comparer string_comparer::current_culture() {
+  throw not_implemented_exception {};
+  //return create(culture_info::current_culture);
+}
+
+string_comparer string_comparer::current_culture_ignore_case() {
+  /// @todo Uncomment following lines when xtd::globalization::culture_info and xtd::globalization::compare_options are developped.
+  throw not_implemented_exception {};
+  //return create(culture_info::current_culture, true);
+}
+
+string_comparer string_comparer::invariant_culture() {
+  /// @todo Uncomment following lines when xtd::globalization::culture_info and xtd::globalization::compare_options are developped.
+  throw not_implemented_exception {};
+  //return create(culture_info::invariant_culture);
+}
+
+string_comparer string_comparer::invariant_culture_ignore_case() {
+  /// @todo Uncomment following lines when xtd::globalization::culture_info and xtd::globalization::compare_options are developped.
+  throw not_implemented_exception {};
+  //return create(culture_info::invariant_culture, true);
+}
 
 const string_comparer& string_comparer::ordinal() {
-  static auto result = string_comparer(string_comparison::ordinal);
+  static auto result = from_comparison(string_comparison::ordinal);
   return result;
 }
 
 const string_comparer& string_comparer::ordinal_ignore_case() {
-  static auto result = string_comparer(string_comparison::ordinal_ignore_case);
+  static auto result =  from_comparison(string_comparison::ordinal_ignore_case);
   return result;
 }
 
 int32 string_comparer::compare(const xtd::string& x, const xtd::string& y) const noexcept {
+  /// @todo Uncomment following lines when xtd::globalization::culture_info and xtd::globalization::compare_options are developped.
   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());
   }
 }
 
 bool string_comparer::equals(const string& x, const string& y) const noexcept {
   if (&x == &y) return true;
+  /// @todo Uncomment following lines when xtd::globalization::culture_info and xtd::globalization::compare_options are developped.
   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());
   }
 }
 
+bool string_comparer::equals(const object& obj) const noexcept {
+  return is<string_comparer>(obj) && reinterpret_cast<const string_comparer&>(obj).comparison_ == comparison_;
+}
+
 xtd::size string_comparer::get_hash_code(const string& obj) const noexcept {
+  /// @todo Uncomment following lines when xtd::globalization::culture_info and xtd::globalization::compare_options are developped.
   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();
   }
 }
+
+/// @todo Uncomment following lines when xtd::globalization::culture_info and xtd::globalization::compare_options are developped.
+/*
+string_comparer string_comparer::create(const culture_info& culture, bool ignore_case) {
+  return create {culture, compare_options::ignore_case};
+}
+
+string_comparer string_comparer::create(const culture_info& culture, compare_options options) {
+  return string_comparer {culture, options};
+}*/
+
+string_comparer string_comparer::from_comparison(xtd::string_comparison comparison) {
+  return string_comparer {comparison};
+}
+
+string_comparer::string_comparer(string_comparison comparison) : comparison_ {comparison} {
+  /// @todo Remove following lines when xtd::globalization::culture_info and xtd::globalization::compare_options are developped.
+  if (comparison == string_comparison::current_culture) throw not_implemented_exception {};
+  if (comparison == string_comparison::current_culture_ignore_case) throw not_implemented_exception {};
+  if (comparison == string_comparison::invariant_culture) throw not_implemented_exception {};
+  if (comparison == string_comparison::invariant_culture_ignore_case) throw not_implemented_exception {};
+
+  if (!enum_object<>::is_defined(comparison)) throw argument_exception {};
+}
+
+/// @todo Uncomment following lines when xtd::globalization::culture_info and xtd::globalization::compare_options are developped.
+/*
+string_comparer::string_comparer(const culture_info& culture, compare_options options) {
+  culture_ = culture;
+  options_ = options;
+}
+*/