2 files changed, 34 insertions, 1 deletions
diff --git a/3rdParty/Boost/src/boost/lambda/detail/lambda_functors.hpp b/3rdParty/Boost/src/boost/lambda/detail/lambda_functors.hpp
index 9b1b082..9ce29ad 100644
--- a/3rdParty/Boost/src/boost/lambda/detail/lambda_functors.hpp
+++ b/3rdParty/Boost/src/boost/lambda/detail/lambda_functors.hpp
@@ -1,52 +1,53 @@
 // Boost Lambda Library -  lambda_functors.hpp -------------------------------
 
 // Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //
 // For more information, see http://www.boost.org
 
 // ------------------------------------------------
 
 #ifndef BOOST_LAMBDA_LAMBDA_FUNCTORS_HPP
 #define BOOST_LAMBDA_LAMBDA_FUNCTORS_HPP
 
 #include <boost/config.hpp>
 #include <boost/detail/workaround.hpp>
+#include <boost/utility/result_of.hpp>
 
 #if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
 
 #include <boost/mpl/or.hpp>
 #include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/is_array.hpp>
 
 #define BOOST_LAMBDA_DISABLE_IF_ARRAY1(A1, R1)\
   typename lazy_disable_if<is_array<A1>, typename R1 >::type
 #define BOOST_LAMBDA_DISABLE_IF_ARRAY2(A1, A2, R1, R2) \
   typename lazy_disable_if<mpl::or_<is_array<A1>, is_array<A2> >, typename R1, R2 >::type
 #define BOOST_LAMBDA_DISABLE_IF_ARRAY3(A1, A2, A3, R1, R2, R3) \
   typename lazy_disable_if<mpl::or_<is_array<A1>, is_array<A2>, is_array<A3> >, typename R1, R2, R3 >::type
 
 #else
 
 #define BOOST_LAMBDA_DISABLE_IF_ARRAY1(A1, R1) typename R1::type
 #define BOOST_LAMBDA_DISABLE_IF_ARRAY2(A1, A2, R1, R2) typename R1, R2::type
 #define BOOST_LAMBDA_DISABLE_IF_ARRAY3(A1, A2, A3, R1, R2, R3) typename R1, R2, R3::type
 
 #endif
 
 namespace boost { 
 namespace lambda {
 
 // -- lambda_functor --------------------------------------------
 // --------------------------------------------------------------
 
 //inline const null_type const_null_type() { return null_type(); }
 
 namespace detail {
 namespace {
 
   static const null_type constant_null_type = null_type();
 
@@ -265,60 +266,92 @@ public:
   const lambda_functor<lambda_functor_base<
                   other_action<assignment_action>,
                   boost::tuple<lambda_functor,
                   typename const_copy_argument <const A>::type> > >
   operator=(const A& a) const {
     return lambda_functor_base<
                   other_action<assignment_action>,
                   boost::tuple<lambda_functor,
                   typename const_copy_argument <const A>::type> >
      (  boost::tuple<lambda_functor,
              typename const_copy_argument <const A>::type>(*this, a) );
   }
 
   template<class A> 
   const lambda_functor<lambda_functor_base< 
                   other_action<subscript_action>, 
                   boost::tuple<lambda_functor, 
                         typename const_copy_argument <const A>::type> > > 
   operator[](const A& a) const { 
     return lambda_functor_base< 
                   other_action<subscript_action>, 
                   boost::tuple<lambda_functor, 
                         typename const_copy_argument <const A>::type> >
      ( boost::tuple<lambda_functor, 
              typename const_copy_argument <const A>::type>(*this, a ) ); 
   } 
 };
 
 #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
 #pragma warning(pop)
 #endif
 
 } // namespace lambda
 } // namespace boost
 
+namespace boost {
+
+#if !defined(BOOST_RESULT_OF_USE_DECLTYPE) || defined(BOOST_NO_DECLTYPE)
+
+template<class T>
+struct result_of<boost::lambda::lambda_functor<T>()>
+{
+    typedef typename boost::lambda::lambda_functor<T>::nullary_return_type type;
+};
+
+template<class T>
+struct result_of<const boost::lambda::lambda_functor<T>()>
+{
+    typedef typename boost::lambda::lambda_functor<T>::nullary_return_type type;
+};
+
+#endif
+
+template<class T>
+struct tr1_result_of<boost::lambda::lambda_functor<T>()>
+{
+    typedef typename boost::lambda::lambda_functor<T>::nullary_return_type type;
+};
+
+template<class T>
+struct tr1_result_of<const boost::lambda::lambda_functor<T>()>
+{
+    typedef typename boost::lambda::lambda_functor<T>::nullary_return_type type;
+};
+
+}
+
 // is_placeholder
 
 #include <boost/is_placeholder.hpp>
 
 namespace boost
 {
 
 template<> struct is_placeholder< lambda::lambda_functor< lambda::placeholder<lambda::FIRST> > >
 {
     enum _vt { value = 1 };
 };
 
 template<> struct is_placeholder< lambda::lambda_functor< lambda::placeholder<lambda::SECOND> > >
 {
     enum _vt { value = 2 };
 };
 
 template<> struct is_placeholder< lambda::lambda_functor< lambda::placeholder<lambda::THIRD> > >
 {
     enum _vt { value = 3 };
 };
 
 } // namespace boost
 
 #endif
diff --git a/3rdParty/Boost/src/boost/lambda/detail/ret.hpp b/3rdParty/Boost/src/boost/lambda/detail/ret.hpp
index fbd8b3a..96f5fc1 100644
--- a/3rdParty/Boost/src/boost/lambda/detail/ret.hpp
+++ b/3rdParty/Boost/src/boost/lambda/detail/ret.hpp
@@ -252,71 +252,71 @@ const_parameters(const lambda_functor<Arg>& lf)
 // the wrapped lambda functor is evaluated, but we just don't do anything
 // with the result.
 struct voidifier_action {
   template<class Ret, class A> static void apply(A&) {}
 };
 
 template<class Args> struct return_type_N<voidifier_action, Args> {
   typedef void type;
 };
 
 template<class Arg1>
 inline const 
 lambda_functor<
   lambda_functor_base<
     action<1, voidifier_action>,
     tuple<lambda_functor<Arg1> >
   > 
 > 
 make_void(const lambda_functor<Arg1>& a1) { 
 return 
     lambda_functor_base<
       action<1, voidifier_action>,
       tuple<lambda_functor<Arg1> >
     > 
   (tuple<lambda_functor<Arg1> > (a1));
 }
 
 // for non-lambda functors, make_void does nothing 
 // (the argument gets evaluated immediately)
 
 template<class Arg1>
 inline const 
 lambda_functor<
   lambda_functor_base<do_nothing_action, null_type> 
 > 
-make_void(const Arg1& a1) { 
+make_void(const Arg1&) { 
 return 
     lambda_functor_base<do_nothing_action, null_type>();
 }
 
 // std_functor -----------------------------------------------------
 
 //  The STL uses the result_type typedef as the convention to let binders know
 //  the return type of a function object. 
 //  LL uses the sig template.
 //  To let LL know that the function object has the result_type typedef 
 //  defined, it can be wrapped with the std_functor function.
 
 
 // Just inherit form the template parameter (the standard functor), 
 // and provide a sig template. So we have a class which is still the
 // same functor + the sig template.
 
 template<class T>
 struct result_type_to_sig : public T {
   template<class Args> struct sig { typedef typename T::result_type type; };
   result_type_to_sig(const T& t) : T(t) {}
 };
 
 template<class F>
 inline result_type_to_sig<F> std_functor(const F& f) { return f; }
 
 
 } // namespace lambda 
 } // namespace boost
 
 #endif