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         bool operator()(const C &obj) { return obj.*mem_ptr==value; }
 112 };
 113
 114 template<typename Container, typename T>
 115 inline typename Container::iterator find_member(Container &cont, const T &value, T Container::value_type::*mp)
 116 {
 117         return find_if(cont, MemberMatch<typename Container::value_type, T>{ value, mp });
 118 }
 119
 120 template<typename Container, typename T>
 121 inline typename Container::const_iterator find_member(const Container &cont, const T &value, T Container::value_type::*mp)
 122 {
 123         return find_if(cont, MemberMatch<typename Container::value_type, T>{ value, mp });
 124 }
 125
 126 template<typename C, typename T, typename P=std::less<T>>
 127 struct MemberCompare
 128 {
 129         T C::*mem_ptr;
 130         P pred;
 131
 132         bool operator()(const C &obj, const T &v) { return pred(obj.*mem_ptr, v); }
 133         bool operator()(const T &v, const C &obj) { return pred(v, obj.*mem_ptr); }
 134         bool operator()(const C &obj1, const C &obj2) { return pred(obj1.*mem_ptr, obj2.*mem_ptr); }
 135 };
 136
 137 template<typename Container, typename T>
 138 inline typename Container::iterator lower_bound_member(Container &cont, const T &value, T Container::value_type::*mp)
 139 {
 140         return lower_bound(cont, value, MemberCompare<typename Container::value_type, T>{ mp });
 141 }
 142
 143 template<typename Container, typename T>
 144 inline typename Container::const_iterator lower_bound_member(const Container &cont, const T &value, T Container::value_type::*mp)
 145 {
 146         return lower_bound(cont, value, MemberCompare<typename Container::value_type, T>{ mp });
 147 }
 148
 149 template<typename Container, typename T>
 150 inline typename Container::iterator upper_bound_member(Container &cont, const T &value, T Container::value_type::*mp)
 151 {
 152         return upper_bound(cont, value, MemberCompare<typename Container::value_type, T>{ mp });
 153 }
 154
 155 template<typename Container, typename T>
 156 inline typename Container::const_iterator upper_bound_member(const Container &cont, const T &value, T Container::value_type::*mp)
 157 {
 158         return upper_bound(cont, value, MemberCompare<typename Container::value_type, T>{ mp });
 159 }
 160
 161 template<typename Container, typename T>
 162 inline void sort_member(Container &cont, T Container::value_type::*mp)
 163 {
 164         sort(cont, MemberCompare<typename Container::value_type, T>{ mp });
 165 }
 166
 167 template<typename Container, typename T>
 168 inline void stable_sort_member(Container &cont, T Container::value_type::*mp)
 169 {
 170         stable_sort(cont, MemberCompare<typename Container::value_type, T>{ mp });
 171 }
 172
 173 template<typename Container, typename Predicate>
 174 inline void transform(Container &cont, Predicate pred)
 175 {
 176         transform(cont.begin(), cont.end(), cont.begin(), pred);
 177 }
 178
 179 } // namespace Msp
 180
 181 #endif