source/core/algorithm.h

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