Adds a method to sort the elements of a vector by invoking a method on...

chrome/common/l10n_util.h

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // This file contains utility functions for dealing with localized
 // content.
 
 #ifndef CHROME_COMMON_L10N_UTIL_H_
 #define CHROME_COMMON_L10N_UTIL_H_
 
 #include "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 #include <algorithm>
 #include <functional>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/scoped_ptr.h"
 #include "base/string16.h"
 #include "base/string_util.h"
-#include "third_party/icu38/public/common/unicode/ubidi.h"
 #include "unicode/coll.h"
 #include "unicode/locid.h"
+#include "unicode/rbbi.h"
+#include "unicode/ubidi.h"
+#include "unicode/uchar.h"
 
 class FilePath;
 class PrefService;
 
 namespace l10n_util {
 
 const char16 kRightToLeftMark = 0x200f;
 const char16 kLeftToRightMark = 0x200e;
 const char16 kLeftToRightEmbeddingMark = 0x202A;
 const char16 kRightToLeftEmbeddingMark = 0x202B;
@@ skipping 152 matching lines @@
 int DefaultCanvasTextAlignment();
 
 #if defined(OS_WIN)
 // Give an HWND, this function sets the WS_EX_LAYOUTRTL extended style for the
 // underlying window. When this style is set, the UI for the window is going to
 // be mirrored. This is generally done for the UI of right-to-left languages
 // such as Hebrew.
 void HWNDSetRTLLayout(HWND hwnd);
 #endif
 
+// Compares the two strings using the specified collator.
+UCollationResult CompareStringWithCollator(const Collator* collator,
+                                           const std::wstring& lhs,
+                                           const std::wstring& rhs);
+
+// Used by SortStringsUsingMethod. Invokes a method on the objects passed to
+// operator (), comparing the string results using a collator.
+template <class T, class Method>
+class StringMethodComparatorWithCollator :
+    public std::binary_function<const std::wstring&,
+                                const std::wstring&,
+                                bool> {
+ public:
+  StringMethodComparatorWithCollator(Collator* collator, Method method)
+      : collator_(collator),
+        method_(method) { }
+
+  // Returns true if lhs preceeds rhs.
+  bool operator() (T* lhs_t, T* rhs_t) {
+    return CompareStringWithCollator(collator_, (lhs_t->*method_)(),
+                                     (rhs_t->*method_)()) == UCOL_LESS;
+  }
+
+ private:
+  Collator* collator_;
+  Method method_;
+};
+
+// Used by SortStringsUsingMethod. Invokes a method on the objects passed to
+// operator (), comparing the string results using <.
+template <class T, class Method>
+class StringMethodComparator : public std::binary_function<const std::wstring&,
+                                                           const std::wstring&,
+                                                           bool> {
+ public:
+  explicit StringMethodComparator(Method method) : method_(method) { }
+
+  // Returns true if lhs preceeds rhs.
+  bool operator() (T* lhs_t, T* rhs_t) {
+    return (lhs_t->*method_)() < (rhs_t->*method_)();
+  }
+
+ private:
+  Method method_;
+};
+
+// Sorts the objects in |elements| using the method |method|, which must return
+// a string. Sorting is done using a collator, unless a collator can not be
+// found in which case the strings are sorted using the operator <.
+template <class T, class Method>
+void SortStringsUsingMethod(const std::wstring& locale,
+                            std::vector<T*>* elements,
+                            Method method) {
+  UErrorCode error = U_ZERO_ERROR;
+  Locale loc(WideToUTF8(locale).c_str());
+  scoped_ptr<Collator> collator(Collator::createInstance(loc, error));
+  if (U_FAILURE(error)) {
+    sort(elements->begin(), elements->end(),
+         StringMethodComparator<T,Method>(method));
+    return;
+  }
+  
+  std::sort(elements->begin(), elements->end(),
+      StringMethodComparatorWithCollator<T,Method>(collator.get(), method));
+}
+
 // Compares two elements' string keys and returns true if the first element's
 // string key is less than the second element's string key. The Element must
 // have a method like the follow format to return the string key.
 // const std::wstring& GetStringKey() const;
 // This uses the locale specified in the constructor.
 template <class Element>
 class StringComparator : public std::binary_function<const Element&,
                                                      const Element&,
                                                      bool> {
  public:
@@ skipping 85 matching lines @@
 
  private:
   UBiDi* bidi_;
 
   DISALLOW_COPY_AND_ASSIGN(BiDiLineIterator);
 };
 
 }
 
 #endif  // CHROME_COMMON_L10N_UTIL_H_