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 T>
  34 struct ValueMatch
  35 {
  36         const T &value;
  37
  38         bool operator()(const T &v) { return v==value; }
  39 };
  40
  41 template<typename Container, typename T>
  42 inline bool any_equals(Container &cont, const T &value)
  43 {
  44         return std::any_of(cont.begin(), cont.end(), ValueMatch<T>{value});
  45 }
  46
  47 template<typename Container, typename T>
  48 inline typename Container::iterator lower_bound(Container &cont, const T &value)
  49 {
  50         return std::lower_bound(cont.begin(), cont.end(), value);
  51 }
  52
  53 template<typename Container, typename T>
  54 inline typename Container::const_iterator lower_bound(const Container &cont, const T &value)
  55 {
  56         return std::lower_bound(cont.begin(), cont.end(), value);
  57 }
  58
  59 template<typename Container, typename T, typename Predicate>
  60 inline typename Container::iterator lower_bound(Container &cont, const T &value, Predicate pred)
  61 {
  62         return std::lower_bound(cont.begin(), cont.end(), value, pred);
  63 }
  64
  65 template<typename Container, typename T, typename Predicate>
  66 inline typename Container::const_iterator lower_bound(const Container &cont, const T &value, Predicate pred)
  67 {
  68         return std::lower_bound(cont.begin(), cont.end(), value, pred);
  69 }
  70
  71 template<typename Container, typename T>
  72 inline typename Container::iterator upper_bound(Container &cont, const T &value)
  73 {
  74         return std::upper_bound(cont.begin(), cont.end(), value);
  75 }
  76
  77 template<typename Container, typename T>
  78 inline typename Container::const_iterator upper_bound(const Container &cont, const T &value)
  79 {
  80         return std::upper_bound(cont.begin(), cont.end(), value);
  81 }
  82
  83 template<typename Container, typename T, typename Predicate>
  84 inline typename Container::iterator upper_bound(Container &cont, const T &value, Predicate pred)
  85 {
  86         return std::upper_bound(cont.begin(), cont.end(), value, pred);
  87 }
  88
  89 template<typename Container, typename T, typename Predicate>
  90 inline typename Container::const_iterator upper_bound(const Container &cont, const T &value, Predicate pred)
  91 {
  92         return std::upper_bound(cont.begin(), cont.end(), value, pred);
  93 }
  94
  95 template<typename Container>
  96 inline void sort(Container &cont)
  97 {
  98         std::sort(cont.begin(), cont.end());
  99 }
 100
 101 template<typename Container, typename Predicate>
 102 inline void sort(Container &cont, Predicate pred)
 103 {
 104         std::sort(cont.begin(), cont.end(), pred);
 105 }
 106
 107 template<typename Container>
 108 inline void stable_sort(Container &cont)
 109 {
 110         std::stable_sort(cont.begin(), cont.end());
 111 }
 112
 113 template<typename Container, typename Predicate>
 114 inline void stable_sort(Container &cont, Predicate pred)
 115 {
 116         std::stable_sort(cont.begin(), cont.end(), pred);
 117 }
 118
 119 template<typename C, typename T>
 120 struct MemberMatch
 121 {
 122         const T &value;
 123         T C::*mem_ptr;
 124
 125         bool operator()(const C &obj) { return obj.*mem_ptr==value; }
 126 };
 127
 128 template<typename Container, typename T>
 129 inline typename Container::iterator find_member(Container &cont, const T &value, T Container::value_type::*mp)
 130 {
 131         return find_if(cont, MemberMatch<typename Container::value_type, T>{ value, mp });
 132 }
 133
 134 template<typename Container, typename T>
 135 inline typename Container::const_iterator find_member(const Container &cont, const T &value, T Container::value_type::*mp)
 136 {
 137         return find_if(cont, MemberMatch<typename Container::value_type, T>{ value, mp });
 138 }
 139
 140 template<typename C, typename T, typename P=std::less<T>>
 141 struct MemberCompare
 142 {
 143         T C::*mem_ptr;
 144         P pred;
 145
 146         MemberCompare(T C::*p): mem_ptr(p) { }
 147
 148         bool operator()(const C &obj, const T &v) { return pred(obj.*mem_ptr, v); }
 149         bool operator()(const T &v, const C &obj) { return pred(v, obj.*mem_ptr); }
 150         bool operator()(const C &obj1, const C &obj2) { return pred(obj1.*mem_ptr, obj2.*mem_ptr); }
 151 };
 152
 153 template<typename Container, typename T>
 154 inline typename Container::iterator lower_bound_member(Container &cont, const T &value, T Container::value_type::*mp)
 155 {
 156         return lower_bound(cont, value, MemberCompare<typename Container::value_type, T>(mp));
 157 }
 158
 159 template<typename Container, typename T>
 160 inline typename Container::const_iterator lower_bound_member(const Container &cont, const T &value, T Container::value_type::*mp)
 161 {
 162         return lower_bound(cont, value, MemberCompare<typename Container::value_type, T>(mp));
 163 }
 164
 165 template<typename Container, typename T>
 166 inline typename Container::iterator upper_bound_member(Container &cont, const T &value, T Container::value_type::*mp)
 167 {
 168         return upper_bound(cont, value, MemberCompare<typename Container::value_type, T>(mp));
 169 }
 170
 171 template<typename Container, typename T>
 172 inline typename Container::const_iterator upper_bound_member(const Container &cont, const T &value, T Container::value_type::*mp)
 173 {
 174         return upper_bound(cont, value, MemberCompare<typename Container::value_type, T>(mp));
 175 }
 176
 177 template<typename Container, typename T>
 178 inline void sort_member(Container &cont, T Container::value_type::*mp)
 179 {
 180         sort(cont, MemberCompare<typename Container::value_type, T>(mp));
 181 }
 182
 183 template<typename Container, typename T>
 184 inline void stable_sort_member(Container &cont, T Container::value_type::*mp)
 185 {
 186         stable_sort(cont, MemberCompare<typename Container::value_type, T>(mp));
 187 }
 188
 189 template<typename Container, typename Predicate>
 190 inline void transform(Container &cont, Predicate pred)
 191 {
 192         transform(cont.begin(), cont.end(), cont.begin(), pred);
 193 }
 194
 195 } // namespace Msp
 196
 197 #endif