Documentation Overview Building ASL Documentation Library Wiki Docs Indices Browse Perforce More Info Release Notes Wiki Site Search License Success Stories Contributors Media Download Perforce Depots Support ASL SourceForge Home Mailing Lists Discussion Forums Report Bugs Suggest Features Contribute to ASL RSS Short-text news Full-text news File releases Other Adobe Projects Adobe Air Adobe GIL C++ Benchmarks Adobe Labs Adobe Media Gallery Adobe XMP Tamarin project (Mozilla Foundation) Other Resources Boost RIAForge SGI STL

functional.hpp Go to the documentation of this file. /* Copyright 2005-2007 Adobe Systems Incorporated Distributed under the MIT License (see accompanying file LICENSE_1_0_0.txt or a copy at http://stlab.adobe.com/licenses.html) */ /*************************************************************************************************/ #ifndef ADOBE_FUNCTIONAL_HPP #define ADOBE_FUNCTIONAL_HPP #include <adobe/config.hpp> #include <functional> #include <utility> #include <boost/compressed_pair.hpp> #include <boost/tuple/tuple.hpp> #include <adobe/functional/operator.hpp> #include <adobe/functional/is_member.hpp> #include <adobe/utility/pair.hpp> /*************************************************************************************************/ namespace adobe { /*************************************************************************************************/ /* REVISIT (sparent) : Documentation for delete_ptr moved to adobe/functional.hpp because doxygen 1.4.3 cannot handle the template specializations. */ template < typename F, // models UnaryFunction typename G> // models UnaryFunction -> argument_type(F) struct unary_compose { typedef typename F::result_type result_type; unary_compose() { } unary_compose(F f, G g) : data_m(f, g) { } template <typename U> // U models Regular result_type operator()(const U& x) const { return data_m.first()(data_m.second()(x)); } template <typename U> // U models Regular result_type operator()(U& x) const { return data_m.first()(data_m.second()(x)); } private: boost::compressed_pair<F, G> data_m; }; /*************************************************************************************************/ template < typename F, // models UnaryFunction typename G> // models UnaryFunction -> argument_type(F) unary_compose<F, G> compose(F f, G g) { return unary_compose<F, G>(f, g); } /*************************************************************************************************/ template < typename F, // models BinaryFunction typename G, // models UnaryFunction -> argument_type(F, 0); typename H = G> // models UnaryFunction -> argument_type(F, 1); struct binary_compose { typedef typename F::result_type result_type; template <typename T, typename U> // models Regular result_type operator()(const T& x, const U& y) const { return f(g(x), h(y)); } template <typename T, typename U> // models Regular result_type operator()(T& x, U& y) const { return f(g(x), h(y)); } F f; G g; H h; }; /*************************************************************************************************/ template <int N, typename T> // T is boost::tuple<> struct element { typedef typename boost::tuples::element<N, T>::type type; }; template <typename T1, typename T2> struct element<0, std::pair<T1, T2> > { typedef typename std::pair<T1, T2>::first_type type; }; template <typename T1, typename T2> struct element<1, std::pair<T1, T2> > { typedef typename std::pair<T1, T2>::second_type type; }; template <typename T1, typename T2> struct element<0, pair<T1, T2> > { typedef typename pair<T1, T2>::first_type type; }; template <typename T1, typename T2> struct element<1, pair<T1, T2> > { typedef typename pair<T1, T2>::second_type type; }; /*************************************************************************************************/ template <int N, typename T> // T is pair or tuple struct get_element : std::unary_function<T, typename element<N, T>::type> { typename element<N, T>::type& operator()(T& x) const { return boost::get<N>(x); } const typename element<N, T>::type& operator()(const T& x) const { return boost::get<N>(x); } }; /*************************************************************************************************/ template <typename T1, typename T2> // T is pair or tuple struct get_element<0, std::pair<T1, T2> > : std::unary_function<std::pair<T1, T2>, typename std::pair<T1, T2>::first_type> { typedef std::pair<T1, T2> argument_type; typedef typename argument_type::first_type result_type; result_type& operator()(argument_type& x) const { return x.first; } const result_type& operator()(const argument_type& x) const { return x.first; } }; /*************************************************************************************************/ template <typename T1, typename T2> // T is pair or tuple struct get_element<0, pair<T1, T2> > : std::unary_function<pair<T1, T2>, typename pair<T1, T2>::first_type> { typedef pair<T1, T2> argument_type; typedef typename argument_type::first_type result_type; result_type& operator()(argument_type& x) const { return x.first; } const result_type& operator()(const argument_type& x) const { return x.first; } }; /*************************************************************************************************/ template <typename T1, typename T2> // T is pair or tuple struct get_element<1, std::pair<T1, T2> > : std::unary_function<std::pair<T1, T2>, typename std::pair<T1, T2>::second_type> { typedef std::pair<T1, T2> argument_type; typedef typename argument_type::second_type result_type; result_type& operator()(argument_type& x) const { return x.second; } const result_type& operator()(const argument_type& x) const { return x.second; } }; /*************************************************************************************************/ template <typename T1, typename T2> // T is pair or tuple struct get_element<1, pair<T1, T2> > : std::unary_function<pair<T1, T2>, typename pair<T1, T2>::second_type> { typedef pair<T1, T2> argument_type; typedef typename argument_type::second_type result_type; result_type& operator()(argument_type& x) const { return x.second; } const result_type& operator()(const argument_type& x) const { return x.second; } }; /*************************************************************************************************/ template <typename T> struct always_true : std::unary_function<T, bool> { bool operator()(const T&) const { return true; } }; /*************************************************************************************************/ template <class Result> struct generator_t { typedef Result result_type; }; /*************************************************************************************************/ template <typename T> struct sequence_t #if !defined(ADOBE_NO_DOCUMENTATION) : generator_t<T> #endif { explicit sequence_t(const T& x) : data_m(x) { } T operator () () { return data_m++; } private: T data_m; }; /*************************************************************************************************/ template <class T, typename R, class Compare> struct compare_members_t : std::binary_function<T, T, bool> { compare_members_t(R T::* member, Compare compare) : compare_m(compare), member_m(member) { } bool operator () (const T& x, const T& y) const { return compare_m(x.*member_m, y.*member_m); } bool operator () (const T& x, const R& y) const { return compare_m(x.*member_m, y); } bool operator () (const R& x, const T& y) const { return compare_m(x, y.*member_m); } private: /* REVISIT (sparent) : This could probably use an empty member optimization. */ Compare compare_m; R T::* member_m; }; template <class T, typename R> compare_members_t<T, R, std::less<R> > compare_members(R T::* member) { return compare_members_t<T, R, std::less<R> >(member, std::less<R>() ); } template <class T, typename R, class Compare> compare_members_t<T, R, Compare> compare_members(R T::* member, Compare compare) { return compare_members_t<T, R, Compare>(member, compare); } /*************************************************************************************************/ template <class T, typename R> struct mem_data_t : std::unary_function<T, R&> { mem_data_t() { } explicit mem_data_t(R T::* member) : member_m(member) { } R& operator () (T& x) const { return x.*member_m; } const R& operator () (const T& x) const { return x.*member_m; } private: R T::* member_m; }; template <class T, typename R> struct mem_data_t<const T, R> : std::unary_function<T, const R&> { explicit mem_data_t(R T::* member) : member_m(member) { } const R& operator () (const T& x) const { return x.*member_m; } private: R T::* member_m; }; template <class T, typename R> mem_data_t<T, R> mem_data(R T::* member) { return mem_data_t<T, R>(member); } /*************************************************************************************************/ template <typename O> // O models StrictWeakOrdering struct equivalent : std::binary_function<typename O::first_argument_type, typename O::second_argument_type, bool> { public: explicit equivalent(const O& x) : o_m(x) { } bool operator()( const typename O::first_argument_type& x, const typename O::second_argument_type& y) const { return !o_m(x, y) && !o_m(y, x); } private: O o_m; }; /*************************************************************************************************/ template <class F> // F models a BinaryFunction struct transposer : std::binary_function<typename F::second_argument_type, typename F::first_argument_type, typename F::result_type> { typedef typename F::second_argument_type first_argument_type; typedef typename F::first_argument_type second_argument_type; typedef typename F::result_type result_type; F fun; transposer(const F& f) : fun(f) { } result_type operator()(const first_argument_type& x, const second_argument_type& y) const { return fun(y, x); } }; template <typename F> // F models BinaryFunction inline transposer<F> f_transpose(F f) { return transposer<F>(f); } /*************************************************************************************************/ } // namespace adobe /*************************************************************************************************/ #endif /*************************************************************************************************/

• Company | 
• Online Privacy Policy | 
• Terms of Use | 
• Contact Us | 
• Accessibility | 
• Report Piracy | 
• Permissions & Trademarks | 
• Product License Agreements | 
• Send Feedback

Copyright © 2006-2007 Adobe Systems Incorporated.

Use of this website signifies your agreement to the Terms of Use and Online Privacy Policy.

Search powered by Google