source/core/algorithm.h

   1 #ifndef MSP_CORE_ALGORITHM_H_
   2 #define MSP_CORE_ALGORITHM_H_
   3
   4 #include <algorithm>
   5 #include <functional>
   6
   7 namespace Msp {
   8
   9 template<typename Container, typename T>
  10 inline typename Container::iterator find(Container &cont, const T &value)
  11 {
  12         return std::find(cont.begin(), cont.end(), value);
  13 }
  14
  15 template<typename Container, typename T>
  16 inline typename Container::const_iterator find(const Container &cont, const T &value)
  17 {
  18         return std::find(cont.begin(), cont.end(), value);
  19 }
  20
  21 template<typename Container, typename Predicate>
  22 inline typename Container::iterator find_if(Container &cont, Predicate pred)
  23 {
  24         return std::find_if(cont.begin(), cont.end(), pred);
  25 }
  26
  27 template<typename Container, typename Predicate>
  28 inline typename Container::const_iterator find_if(const Container &cont, Predicate pred)
  29 {
  30         return std::find_if(cont.begin(), cont.end(), pred);
  31 }
  32
  33 template<typename Container, typename T>
  34 inline typename Container::iterator lower_bound(Container &cont, const T &value)
  35 {
  36         return std::lower_bound(cont.begin(), cont.end(), value);
  37 }
  38
  39 template<typename Container, typename T>
  40 inline typename Container::const_iterator lower_bound(const Container &cont, const T &value)
  41 {
  42         return std::lower_bound(cont.begin(), cont.end(), value);
  43 }
  44
  45 template<typename Container, typename T, typename Predicate>
  46 inline typename Container::iterator lower_bound(Container &cont, const T &value, Predicate pred)
  47 {
  48         return std::lower_bound(cont.begin(), cont.end(), value, pred);
  49 }
  50
  51 template<typename Container, typename T, typename Predicate>
  52 inline typename Container::const_iterator lower_bound(const Container &cont, const T &value, Predicate pred)
  53 {
  54         return std::lower_bound(cont.begin(), cont.end(), value, pred);
  55 }
  56
  57 template<typename Container, typename T>
  58 inline typename Container::iterator upper_bound(Container &cont, const T &value)
  59 {
  60         return std::upper_bound(cont.begin(), cont.end(), value);
  61 }
  62
  63 template<typename Container, typename T>
  64 inline typename Container::const_iterator upper_bound(const Container &cont, const T &value)
  65 {
  66         return std::upper_bound(cont.begin(), cont.end(), value);
  67 }
  68
  69 template<typename Container, typename T, typename Predicate>
  70 inline typename Container::iterator upper_bound(Container &cont, const T &value, Predicate pred)
  71 {
  72         return std::upper_bound(cont.begin(), cont.end(), value, pred);
  73 }
  74
  75 template<typename Container, typename T, typename Predicate>
  76 inline typename Container::const_iterator upper_bound(const Container &cont, const T &value, Predicate pred)
  77 {
  78         return std::upper_bound(cont.begin(), cont.end(), value, pred);
  79 }
  80
  81 template<typename Container>
  82 inline void sort(Container &cont)
  83 {
  84         std::sort(cont.begin(), cont.end());
  85 }
  86
  87 template<typename Container, typename Predicate>
  88 inline void sort(Container &cont, Predicate pred)
  89 {
  90         std::sort(cont.begin(), cont.end(), pred);
  91 }
  92
  93 template<typename Container>
  94 inline void stable_sort(Container &cont)
  95 {
  96         std::stable_sort(cont.begin(), cont.end());
  97 }
  98
  99 template<typename Container, typename Predicate>
 100 inline void stable_sort(Container &cont, Predicate pred)
 101 {
 102         std::stable_sort(cont.begin(), cont.end(), pred);
 103 }
 104
 105 template<typename C, typename T>
 106 struct MemberMatch
 107 {
 108         const T &value;
 109         T C::*mem_ptr;
 110
 111         MemberMatch(const T &v, T C::*p): value(v), mem_ptr(p) { }
 112
 113         bool operator()(const C &obj) { return obj.*mem_ptr==value; }
 114 };
 115
 116 template<typename Container, typename T>
 117 inline typename Container::iterator find_member(Container &cont, const T &value, T Container::value_type::*mp)
 118 {
 119         return find_if(cont, MemberMatch<typename Container::value_type, T>(value, mp));
 120 }
 121
 122 template<typename Container, typename T>
 123 inline typename Container::const_iterator find_member(const Container &cont, const T &value, T Container::value_type::*mp)
 124 {
 125         return find_if(cont, MemberMatch<typename Container::value_type, T>(value, mp));
 126 }
 127
 128 template<typename C, typename T, typename P=std::less<T>>
 129 struct MemberCompare
 130 {
 131         T C::*mem_ptr;
 132         P pred;
 133
 134         MemberCompare(T C::*p): mem_ptr(p) { }
 135
 136         bool operator()(const C &obj, const T &v) { return pred(obj.*mem_ptr, v); }
 137         bool operator()(const T &v, const C &obj) { return pred(v, obj.*mem_ptr); }
 138         bool operator()(const C &obj1, const C &obj2) { return pred(obj1.*mem_ptr, obj2.*mem_ptr); }
 139 };
 140
 141 template<typename Container, typename T>
 142 inline typename Container::iterator lower_bound_member(Container &cont, const T &value, T Container::value_type::*mp)
 143 {
 144         return lower_bound(cont, value, MemberCompare<typename Container::value_type, T>(mp));
 145 }
 146
 147 template<typename Container, typename T>
 148 inline typename Container::const_iterator lower_bound_member(const Container &cont, const T &value, T Container::value_type::*mp)
 149 {
 150         return lower_bound(cont, value, MemberCompare<typename Container::value_type, T>(mp));
 151 }
 152
 153 template<typename Container, typename T>
 154 inline typename Container::iterator upper_bound_member(Container &cont, const T &value, T Container::value_type::*mp)
 155 {
 156         return upper_bound(cont, value, MemberCompare<typename Container::value_type, T>(mp));
 157 }
 158
 159 template<typename Container, typename T>
 160 inline typename Container::const_iterator upper_bound_member(const Container &cont, const T &value, T Container::value_type::*mp)
 161 {
 162         return upper_bound(cont, value, MemberCompare<typename Container::value_type, T>(mp));
 163 }
 164
 165 template<typename Container, typename T>
 166 inline void sort_member(Container &cont, T Container::value_type::*mp)
 167 {
 168         sort(cont, MemberCompare<typename Container::value_type, T>(mp));
 169 }
 170
 171 template<typename Container, typename T>
 172 inline void stable_sort_member(Container &cont, T Container::value_type::*mp)
 173 {
 174         stable_sort(cont, MemberCompare<typename Container::value_type, T>(mp));
 175 }
 176
 177 template<typename Container, typename Predicate>
 178 inline void transform(Container &cont, Predicate pred)
 179 {
 180         transform(cont.begin(), cont.end(), cont.begin(), pred);
 181 }
 182
 183 } // namespace Msp
 184
 185 #endif