1/************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22#ifndef SYSTEM_STL_FUNCTIONAL 23#define SYSTEM_STL_FUNCTIONAL 24 25#if defined(HAVE_STL_INCLUDE_PATH) 26 // TODO: use computed include file name 27 #include_next <functional> 28#elif defined(_MSC_VER) && (_MSC_VER >= 1900) 29 /* A modern MSVC keeps the standard headers in <toolset>/include, and this 30 file shadows <functional> on the include path, so the real one has to be reached 31 explicitly. The path below resolves against the toolset's own include 32 directory and against nothing else on the search path -- the same trick 33 the VC9 branch uses, retargeted at the layout a modern toolset has. 34 #include_next, used by the branches around this one, is a GCC extension 35 that MSVC does not have. */ 36 #include <../include/functional> 37#elif defined(_MSC_VER) 38 #include <../../VC/include/functional> 39 namespace std { using tr1::hash; } 40#if 0 // TODO: enable only when std::_Swap_adl is not available 41 // note: VS2008SP1 has known problems after a security update (KB971092,KB974479,KB974223) 42 namespace std{ template<class _T> void _Swap_adl(_T& l, _T& r) {swap(l,r);} } 43#endif 44#elif defined(__cplusplus) && (__cplusplus >= 201103L) 45 #include_next <functional> 46#else // fall back to boost/tr1 47 #include <boost/tr1/tr1/functional> 48 #include <boost/functional/hash.hpp> 49#endif 50 51 52#ifndef NO_STLPORT4_EMULATION 53 54namespace std 55{ 56// emulate SGI extensions to the STL using http://www.sgi.com/tech/stl/stl_function.h as reference 57template< typename T> struct identity : unary_function<T,T> { T operator()(const T& t) const { return t;} }; 58template< typename T, typename U> struct project2nd : public binary_function<T,U,U> { U operator()(const T&, const U& u) const { return u;}}; 59template<typename P> struct select1st : public unary_function<P, typename P::first_type> { const typename P::first_type& operator()(const P& p) const { return p.first; }}; 60template<typename P> struct select2nd : public unary_function<P, typename P::second_type> { const typename P::second_type& operator()(const P& p) const { return p.second; }}; 61 62#if (defined(_MSC_VER) && (_MSC_VER >= 1600)) || defined(__GXX_EXPERIMENTAL_CXX0X__) 63template<typename T> inline T&& forward( typename identity<T>::type&& t) { return t; } 64#endif // C++11 move semantics 65 66template<typename Op1, typename Op2> class unary_compose : public unary_function<typename Op2::argument_type, typename Op1::result_type> 67{ 68protected: 69 Op1 aOp1; 70 Op2 aOp2; 71public: 72 unary_compose( const Op1& rOp1, const Op2& rOp2) : aOp1(rOp1), aOp2(rOp2) {} 73 typename Op1::result_type operator()( const typename Op2::argument_type& x) const { return aOp1(aOp2(x)); } 74}; 75 76template<typename Op1, typename Op2> inline unary_compose<Op1,Op2> compose1( const Op1& rOp1, const Op2& rOp2) { return unary_compose<Op1,Op2>(rOp1, rOp2); } 77 78} // namespace std 79 80#endif // NO_STLPORT4_EMULATION 81 82#endif 83 84