diff options
Diffstat (limited to 'boost/container/detail/algorithm.hpp')
-rw-r--r-- | boost/container/detail/algorithm.hpp | 122 |
1 files changed, 122 insertions, 0 deletions
diff --git a/boost/container/detail/algorithm.hpp b/boost/container/detail/algorithm.hpp index 67e7876345..11844220e1 100644 --- a/boost/container/detail/algorithm.hpp +++ b/boost/container/detail/algorithm.hpp @@ -29,6 +29,128 @@ namespace container { using boost::intrusive::algo_equal; using boost::intrusive::algo_lexicographical_compare; +template<class Func> +class binder1st +{ + public: + typedef typename Func::second_argument_type argument_type; + typedef typename Func::result_type result_type; + + binder1st(const Func& func, const typename Func::first_argument_type& arg) + : op(func), value(arg) + {} + + result_type operator()(const argument_type& arg) const + { return op(value, arg); } + + result_type operator()(argument_type& arg) const + { return op(value, arg); } + + private: + Func op; + typename Func::first_argument_type value; +}; + +template<class Func, class T> +inline binder1st<Func> bind1st(const Func& func, const T& arg) +{ return boost::container::binder1st<Func>(func, arg); } + +template<class Func> +class binder2nd +{ + public: + typedef typename Func::first_argument_type argument_type; + typedef typename Func::result_type result_type; + + binder2nd(const Func& func, const typename Func::second_argument_type& arg) + : op(func), value(arg) + {} + + result_type operator()(const argument_type& arg) const + { return op(arg, value); } + + result_type operator()(argument_type& arg) const + { return op(arg, value); } + + private: + Func op; + typename Func::second_argument_type value; +}; + +template<class Func, class T> +inline binder2nd<Func> bind2nd(const Func& func, const T& arg) +{ + return (boost::container::binder2nd<Func>(func, arg)); +} + +template<class Func> +class unary_negate +{ + public: + typedef typename Func::argument_type argument_type; + typedef typename Func::result_type result_type; + + explicit unary_negate(const Func& func) + : m_func(func) + {} + + bool operator()(const typename Func::argument_type& arg) const + { return !m_func(arg); } + + private: + Func m_func; +}; + +template<class Func> inline +unary_negate<Func> not1(const Func& func) +{ + return boost::container::unary_negate<Func>(func); +} + +template<class InputIt, class UnaryPredicate> +InputIt find_if(InputIt first, InputIt last, UnaryPredicate p) +{ + for (; first != last; ++first) { + if (p(*first)) { + return first; + } + } + return last; +} + +template<class InputIt, class ForwardIt, class BinaryPredicate> +InputIt find_first_of(InputIt first1, InputIt last1, ForwardIt first2, ForwardIt last2, BinaryPredicate p) +{ + for (; first1 != last1; ++first1) { + for (ForwardIt it = first2; it != last2; ++it) { + if (p(*first1, *it)) { + return first1; + } + } + } + return last1; +} + +template<class ForwardIt1, class ForwardIt2, class BinaryPredicate> +ForwardIt1 search(ForwardIt1 first1, ForwardIt1 last1, + ForwardIt2 first2, ForwardIt2 last2, BinaryPredicate p) +{ + for (; ; ++first1) { + ForwardIt1 it = first1; + for (ForwardIt2 it2 = first2; ; ++it, ++it2) { + if (it2 == last2) { + return first1; + } + if (it == last1) { + return last1; + } + if (!p(*it, *it2)) { + break; + } + } + } +} + } //namespace container { } //namespace boost { |