Include bind in ndnboost.
diff --git a/ndnboost/lambda/detail/actions.hpp b/ndnboost/lambda/detail/actions.hpp
new file mode 100644
index 0000000..8892bb1
--- /dev/null
+++ b/ndnboost/lambda/detail/actions.hpp
@@ -0,0 +1,174 @@
+// -- Boost Lambda Library - actions.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 www.boost.org
+
+// ----------------------------------------------------------------
+
+#ifndef BOOST_LAMBDA_ACTIONS_HPP
+#define BOOST_LAMBDA_ACTIONS_HPP
+
+namespace ndnboost {
+namespace lambda {
+
+
+
+template<int Arity, class Act> class action;
+
+// these need to be defined here, since the corresponding lambda
+// functions are members of lambda_functor classes
+
+class assignment_action {};
+class subscript_action {};
+
+template <class Action> class other_action;
+
+// action for specifying the explicit return type
+template <class RET> class explicit_return_type_action {};
+
+// action for preventing the expansion of a lambda expression
+struct protect_action {};
+
+ // must be defined here, comma is a special case
+struct comma_action {};
+
+
+ // actions, for which the existence of protect is checked in return type
+ // deduction.
+
+template <class Action> struct is_protectable {
+ BOOST_STATIC_CONSTANT(bool, value = false);
+};
+
+// NOTE: comma action is protectable. Other protectable actions
+// are listed in operator_actions.hpp
+
+template<> struct is_protectable<other_action<comma_action> > {
+ BOOST_STATIC_CONSTANT(bool, value = true);
+};
+
+
+namespace detail {
+
+ // this type is used in return type deductions to signal that deduction
+ // did not find a result. It does not necessarily mean an error, it commonly
+ // means that something else should be tried.
+ class unspecified {};
+}
+
+ // function action is a special case: bind functions can be called with
+ // the return type specialized explicitly e.g. bind<int>(foo);
+ // If this call syntax is used, the return type is stored in the latter
+ // argument of function_action template. Otherwise the argument gets the type
+ // 'unspecified'.
+ // This argument is only relevant in the return type deduction code
+template <int I, class Result_type = detail::unspecified>
+class function_action {};
+
+template<class T> class function_action<1, T> {
+public:
+ template<class RET, class A1>
+ static RET apply(A1& a1) {
+ return function_adaptor<typename ndnboost::remove_cv<A1>::type>::
+ template apply<RET>(a1);
+ }
+};
+
+template<class T> class function_action<2, T> {
+public:
+ template<class RET, class A1, class A2>
+ static RET apply(A1& a1, A2& a2) {
+ return function_adaptor<typename ndnboost::remove_cv<A1>::type>::
+ template apply<RET>(a1, a2);
+ }
+};
+
+template<class T> class function_action<3, T> {
+public:
+ template<class RET, class A1, class A2, class A3>
+ static RET apply(A1& a1, A2& a2, A3& a3) {
+ return function_adaptor<typename ndnboost::remove_cv<A1>::type>::
+ template apply<RET>(a1, a2, a3);
+ }
+};
+
+template<class T> class function_action<4, T> {
+public:
+ template<class RET, class A1, class A2, class A3, class A4>
+ static RET apply(A1& a1, A2& a2, A3& a3, A4& a4) {
+ return function_adaptor<typename ndnboost::remove_cv<A1>::type>::
+ template apply<RET>(a1, a2, a3, a4);
+ }
+};
+
+template<class T> class function_action<5, T> {
+public:
+ template<class RET, class A1, class A2, class A3, class A4, class A5>
+ static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
+ return function_adaptor<typename ndnboost::remove_cv<A1>::type>::
+ template apply<RET>(a1, a2, a3, a4, a5);
+ }
+};
+
+template<class T> class function_action<6, T> {
+public:
+ template<class RET, class A1, class A2, class A3, class A4, class A5,
+ class A6>
+ static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
+ return function_adaptor<typename ndnboost::remove_cv<A1>::type>::
+ template apply<RET>(a1, a2, a3, a4, a5, a6);
+ }
+};
+
+template<class T> class function_action<7, T> {
+public:
+ template<class RET, class A1, class A2, class A3, class A4, class A5,
+ class A6, class A7>
+ static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) {
+ return function_adaptor<typename ndnboost::remove_cv<A1>::type>::
+ template apply<RET>(a1, a2, a3, a4, a5, a6, a7);
+ }
+};
+
+template<class T> class function_action<8, T> {
+public:
+ template<class RET, class A1, class A2, class A3, class A4, class A5,
+ class A6, class A7, class A8>
+ static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7,
+ A8& a8) {
+ return function_adaptor<typename ndnboost::remove_cv<A1>::type>::
+ template apply<RET>(a1, a2, a3, a4, a5, a6, a7, a8);
+ }
+};
+
+template<class T> class function_action<9, T> {
+public:
+ template<class RET, class A1, class A2, class A3, class A4, class A5,
+ class A6, class A7, class A8, class A9>
+ static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7,
+ A8& a8, A9& a9) {
+ return function_adaptor<typename ndnboost::remove_cv<A1>::type>::
+ template apply<RET>(a1, a2, a3, a4, a5, a6, a7, a8, a9);
+ }
+};
+
+template<class T> class function_action<10, T> {
+public:
+ template<class RET, class A1, class A2, class A3, class A4, class A5,
+ class A6, class A7, class A8, class A9, class A10>
+ static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7,
+ A8& a8, A9& a9, A10& a10) {
+ return function_adaptor<typename ndnboost::remove_cv<A1>::type>::
+ template apply<RET>(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
+ }
+};
+
+} // namespace lambda
+} // namespace ndnboost
+
+#endif