boost/lambda/construct.hpp

0001 // - construct.hpp -- Lambda Library -------------
0002 //
0003 // Copyright (C) 2000 Gary Powell (powellg@amazon.com)
0004 // Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
0005 //
0006 // Distributed under the Boost Software License, Version 1.0. (See
0007 // accompanying file LICENSE_1_0.txt or copy at
0008 // http://www.boost.org/LICENSE_1_0.txt)
0009 //
0010 // For more information, see http://www.boost.org
0011 //
0012 // -----------------------------------------------
0013
0014 #if !defined(BOOST_LAMBDA_CONSTRUCT_HPP)
0015 #define BOOST_LAMBDA_CONSTRUCT_HPP
0016
0017 #include "boost/type_traits/remove_cv.hpp"
0018 #include "boost/type_traits/is_pointer.hpp"
0019 #include "boost/config.hpp"
0020
0021 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
0022 #include <utility>
0023 #endif
0024
0025 namespace boost {
0026 namespace lambda {
0027
0028   // constructor is used together with bind. constructor<A> creates a bindable
0029   // function object that passes its arguments forward to a constructor call
0030   // of type A
0031
0032 template<class T> struct constructor {
0033
0034   template <class U> struct sig { typedef T type; };
0035
0036 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
0037   template <class... Args>
0038   T operator()(Args&&... args) const {
0039     return T(std::forward<Args>(args)...);
0040   }
0041 #else
0042   T operator()() const {
0043     return T();
0044   }
0045
0046   template<class A1>
0047   T operator()(A1& a1) const {
0048     return T(a1);
0049   }
0050
0051   template<class A1, class A2>
0052   T operator()(A1& a1, A2& a2) const {
0053     return T(a1, a2);
0054   }
0055
0056   template<class A1, class A2, class A3>
0057   T operator()(A1& a1, A2& a2, A3& a3) const {
0058     return T(a1, a2, a3);
0059   }
0060
0061   template<class A1, class A2, class A3, class A4>
0062   T operator()(A1& a1, A2& a2, A3& a3, A4& a4) const {
0063     return T(a1, a2, a3, a4);
0064   }
0065
0066   template<class A1, class A2, class A3, class A4, class A5>
0067   T operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) const {
0068     return T(a1, a2, a3, a4, a5);
0069   }
0070
0071   template<class A1, class A2, class A3, class A4, class A5, class A6>
0072   T operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) const {
0073     return T(a1, a2, a3, a4, a5, a6);
0074   }
0075
0076   template<class A1, class A2, class A3, class A4, class A5, class A6, class A7>
0077   T operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) const {
0078     return T(a1, a2, a3, a4, a5, a6, a7);
0079   }
0080
0081   template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
0082   T operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) const {
0083     return T(a1, a2, a3, a4, a5, a6, a7, a8);
0084   }
0085
0086   template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
0087   T operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9) const {
0088     return T(a1, a2, a3, a4, a5, a6, a7, a8, a9);
0089   }
0090
0091   template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
0092   T operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10) const {
0093     return T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
0094   }
0095 #endif
0096
0097 };
0098
0099
0100 namespace detail {
0101
0102 // A standard conforming compiler could disambiguate between
0103 // A1* and A1&, but not all compilers do that, so we need the
0104 // helpers
0105
0106
0107 template <bool IsPointer>
0108 struct destructor_helper {
0109
0110   template<class A1>
0111   static void exec(A1& a1) {
0112     // remove all the qualifiers, not sure whether it is necessary
0113     typedef typename boost::remove_cv<A1>::type plainA1;
0114      a1.~plainA1();
0115   }
0116 };
0117
0118 template <>
0119 struct destructor_helper<true> {
0120
0121   template<class A1>
0122   static void exec(A1* a1) {
0123     typedef typename boost::remove_cv<A1>::type plainA1;
0124     (*a1).~plainA1();
0125   }
0126 };
0127
0128 }
0129
0130 // destructor funtion object
0131 struct destructor {
0132
0133   template <class T> struct sig { typedef void type; };
0134
0135   template<class A1>
0136   void operator()(A1& a1) const {
0137     typedef typename boost::remove_cv<A1>::type plainA1;
0138     detail::destructor_helper<boost::is_pointer<plainA1>::value>::exec(a1);
0139   }
0140 };
0141
0142
0143
0144 // new_ptr is used together with bind.
0145
0146   // note: placement new is not supported
0147
0148 template<class T> struct new_ptr {
0149
0150   template <class U> struct sig { typedef T* type; };
0151
0152 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
0153   template <class... Args>
0154   T* operator()(Args&&... args) const {
0155     return new T(std::forward<Args>(args)...);
0156   }
0157 #else
0158   T* operator()() const {
0159     return new T();
0160   }
0161
0162   template<class A1>
0163   T* operator()(A1& a1) const {
0164     return new T(a1);
0165   }
0166
0167   template<class A1, class A2>
0168   T* operator()(A1& a1, A2& a2) const {
0169     return new T(a1, a2);
0170   }
0171
0172   template<class A1, class A2, class A3>
0173   T* operator()(A1& a1, A2& a2, A3& a3) const {
0174     return new T(a1, a2, a3);
0175   }
0176
0177   template<class A1, class A2, class A3, class A4>
0178   T* operator()(A1& a1, A2& a2, A3& a3, A4& a4) const {
0179     return new T(a1, a2, a3, a4);
0180   }
0181
0182   template<class A1, class A2, class A3, class A4, class A5>
0183   T* operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) const {
0184     return new T(a1, a2, a3, a4, a5);
0185   }
0186
0187   template<class A1, class A2, class A3, class A4, class A5, class A6>
0188   T* operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) const {
0189     return new T(a1, a2, a3, a4, a5, a6);
0190   }
0191
0192   template<class A1, class A2, class A3, class A4, class A5, class A6, class A7>
0193   T* operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) const {
0194     return new T(a1, a2, a3, a4, a5, a6, a7);
0195   }
0196
0197   template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
0198   T* operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) const {
0199     return new T(a1, a2, a3, a4, a5, a6, a7, a8);
0200   }
0201
0202   template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
0203   T* operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9) const {
0204     return new T(a1, a2, a3, a4, a5, a6, a7, a8, a9);
0205   }
0206
0207   template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
0208   T* operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10) const {
0209     return new T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
0210   }
0211 #endif
0212
0213 };
0214
0215 // delete_ptr return void
0216
0217 struct delete_ptr {
0218
0219   template <class U> struct sig { typedef void type; };
0220
0221   template <class A1>
0222   void operator()(A1& a1) const {
0223     delete a1;
0224   }
0225
0226 };
0227
0228
0229 // new_array is used together with bind.
0230
0231 template<class T> struct new_array {
0232
0233   template <class U> struct sig { typedef T* type; };
0234
0235   T* operator()(int size) const {
0236     return new T[size];
0237   }
0238 };
0239
0240
0241 // delete_ptr return void
0242
0243 struct delete_array {
0244
0245   template <class U> struct sig { typedef void type; };
0246
0247   template <class A1>
0248   void operator()(A1& a1) const {
0249     delete[] a1;
0250   }
0251
0252 };
0253
0254
0255
0256 } // namespace lambda
0257 } // namespace boost
0258
0259 #endif