1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #ifndef UI_BASE_L10N_L10N_UTIL_COLLATOR_H_
6 #define UI_BASE_L10N_L10N_UTIL_COLLATOR_H_
7
8 #include <algorithm>
9 #include <functional>
10 #include <string>
11 #include <vector>
12
13 #include "base/i18n/string_compare.h"
14 #include "base/memory/scoped_ptr.h"
15 #include "third_party/icu/source/i18n/unicode/coll.h"
16 #include "ui/base/ui_base_export.h"
17
18 namespace l10n_util {
19
20 // Used by SortStringsUsingMethod. Invokes a method on the objects passed to
21 // operator (), comparing the string results using a collator.
22 template <class T, class Method>
23 class StringMethodComparatorWithCollator
24 : public std::binary_function<const base::string16&,
25 const base::string16&,
26 bool> {
27 public:
StringMethodComparatorWithCollator(icu::Collator * collator,Method method)28 StringMethodComparatorWithCollator(icu::Collator* collator, Method method)
29 : collator_(collator),
30 method_(method) { }
31
32 // Returns true if lhs preceeds rhs.
operator()33 bool operator() (T* lhs_t, T* rhs_t) {
34 return base::i18n::CompareString16WithCollator(collator_,
35 (lhs_t->*method_)(), (rhs_t->*method_)()) == UCOL_LESS;
36 }
37
38 private:
39 icu::Collator* collator_;
40 Method method_;
41 };
42
43 // Used by SortStringsUsingMethod. Invokes a method on the objects passed to
44 // operator (), comparing the string results using <.
45 template <class T, class Method>
46 class StringMethodComparator
47 : public std::binary_function<const base::string16&,
48 const base::string16&,
49 bool> {
50 public:
StringMethodComparator(Method method)51 explicit StringMethodComparator(Method method) : method_(method) { }
52
53 // Returns true if lhs preceeds rhs.
operator()54 bool operator() (T* lhs_t, T* rhs_t) {
55 return (lhs_t->*method_)() < (rhs_t->*method_)();
56 }
57
58 private:
59 Method method_;
60 };
61
62 // Sorts the objects in |elements| using the method |method|, which must return
63 // a string. Sorting is done using a collator, unless a collator can not be
64 // found in which case the strings are sorted using the operator <.
65 template <class T, class Method>
SortStringsUsingMethod(const std::string & locale,std::vector<T * > * elements,Method method)66 void SortStringsUsingMethod(const std::string& locale,
67 std::vector<T*>* elements,
68 Method method) {
69 UErrorCode error = U_ZERO_ERROR;
70 icu::Locale loc(locale.c_str());
71 scoped_ptr<icu::Collator> collator(icu::Collator::createInstance(loc, error));
72 if (U_FAILURE(error)) {
73 sort(elements->begin(), elements->end(),
74 StringMethodComparator<T, Method>(method));
75 return;
76 }
77
78 std::sort(elements->begin(), elements->end(),
79 StringMethodComparatorWithCollator<T, Method>(collator.get(), method));
80 }
81
82 // Compares two elements' string keys and returns true if the first element's
83 // string key is less than the second element's string key. The Element must
84 // have a method like the follow format to return the string key.
85 // const base::string16& GetStringKey() const;
86 // This uses the locale specified in the constructor.
87 template <class Element>
88 class StringComparator : public std::binary_function<const Element&,
89 const Element&,
90 bool> {
91 public:
StringComparator(icu::Collator * collator)92 explicit StringComparator(icu::Collator* collator)
93 : collator_(collator) { }
94
95 // Returns true if lhs precedes rhs.
operator()96 bool operator()(const Element& lhs, const Element& rhs) {
97 const base::string16& lhs_string_key = lhs.GetStringKey();
98 const base::string16& rhs_string_key = rhs.GetStringKey();
99
100 return StringComparator<base::string16>(collator_)(lhs_string_key,
101 rhs_string_key);
102 }
103
104 private:
105 icu::Collator* collator_;
106 };
107
108 // Specialization of operator() method for base::string16 version.
109 template <> UI_BASE_EXPORT
110 bool StringComparator<base::string16>::operator()(const base::string16& lhs,
111 const base::string16& rhs);
112
113 // In place sorting of |elements| of a vector according to the string key of
114 // each element in the vector by using collation rules for |locale|.
115 // |begin_index| points to the start position of elements in the vector which
116 // want to be sorted. |end_index| points to the end position of elements in the
117 // vector which want to be sorted
118 template <class Element>
SortVectorWithStringKey(const std::string & locale,std::vector<Element> * elements,unsigned int begin_index,unsigned int end_index,bool needs_stable_sort)119 void SortVectorWithStringKey(const std::string& locale,
120 std::vector<Element>* elements,
121 unsigned int begin_index,
122 unsigned int end_index,
123 bool needs_stable_sort) {
124 DCHECK(begin_index < end_index &&
125 end_index <= static_cast<unsigned int>(elements->size()));
126 UErrorCode error = U_ZERO_ERROR;
127 icu::Locale loc(locale.c_str());
128 scoped_ptr<icu::Collator> collator(icu::Collator::createInstance(loc, error));
129 if (U_FAILURE(error))
130 collator.reset();
131 StringComparator<Element> c(collator.get());
132 if (needs_stable_sort) {
133 stable_sort(elements->begin() + begin_index,
134 elements->begin() + end_index,
135 c);
136 } else {
137 sort(elements->begin() + begin_index, elements->begin() + end_index, c);
138 }
139 }
140
141 template <class Element>
SortVectorWithStringKey(const std::string & locale,std::vector<Element> * elements,bool needs_stable_sort)142 void SortVectorWithStringKey(const std::string& locale,
143 std::vector<Element>* elements,
144 bool needs_stable_sort) {
145 SortVectorWithStringKey<Element>(locale, elements, 0, elements->size(),
146 needs_stable_sort);
147 }
148
149 } // namespace l10n_util
150
151 #endif // UI_BASE_L10N_L10N_UTIL_COLLATOR_H_
152