diff --git a/include/ndnboost/lambda/bind.hpp b/include/ndnboost/lambda/bind.hpp
index 3ec3bab..3b2c814 100644
--- a/include/ndnboost/lambda/bind.hpp
+++ b/include/ndnboost/lambda/bind.hpp
@@ -9,8 +9,8 @@
 //
 // For more information, see http://www.boost.org 
 
-#ifndef BOOST_LAMBDA_BIND_HPP
-#define BOOST_LAMBDA_BIND_HPP
+#ifndef NDNBOOST_LAMBDA_BIND_HPP
+#define NDNBOOST_LAMBDA_BIND_HPP
 
 #include "ndnboost/lambda/core.hpp"
 
diff --git a/include/ndnboost/lambda/core.hpp b/include/ndnboost/lambda/core.hpp
index 1ff8342..301ec43 100644
--- a/include/ndnboost/lambda/core.hpp
+++ b/include/ndnboost/lambda/core.hpp
@@ -19,8 +19,8 @@
 // call operator for placeholder variables.
 // -------------------------------------------------------------------------
 
-#ifndef BOOST_LAMBDA_CORE_HPP
-#define BOOST_LAMBDA_CORE_HPP
+#ifndef NDNBOOST_LAMBDA_CORE_HPP
+#define NDNBOOST_LAMBDA_CORE_HPP
 
 #include "ndnboost/type_traits/transform_traits.hpp"
 #include "ndnboost/type_traits/cv_traits.hpp"
@@ -76,4 +76,4 @@
 } // boost
    
    
-#endif //BOOST_LAMBDA_CORE_HPP
+#endif //NDNBOOST_LAMBDA_CORE_HPP
diff --git a/include/ndnboost/lambda/detail/actions.hpp b/include/ndnboost/lambda/detail/actions.hpp
index 8892bb1..322820b 100644
--- a/include/ndnboost/lambda/detail/actions.hpp
+++ b/include/ndnboost/lambda/detail/actions.hpp
@@ -10,8 +10,8 @@
 
 // ----------------------------------------------------------------
 
-#ifndef BOOST_LAMBDA_ACTIONS_HPP
-#define BOOST_LAMBDA_ACTIONS_HPP
+#ifndef NDNBOOST_LAMBDA_ACTIONS_HPP
+#define NDNBOOST_LAMBDA_ACTIONS_HPP
 
 namespace ndnboost { 
 namespace lambda {
@@ -42,14 +42,14 @@
   // deduction.
 
 template <class Action> struct is_protectable {
-  BOOST_STATIC_CONSTANT(bool, value = false);
+  NDNBOOST_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);
+  NDNBOOST_STATIC_CONSTANT(bool, value = true);
 };
 
 
diff --git a/include/ndnboost/lambda/detail/arity_code.hpp b/include/ndnboost/lambda/detail/arity_code.hpp
index 2b762c3..5735608 100644
--- a/include/ndnboost/lambda/detail/arity_code.hpp
+++ b/include/ndnboost/lambda/detail/arity_code.hpp
@@ -10,8 +10,8 @@
 
 // --------------------------------------------------
 
-#ifndef BOOST_LAMBDA_ARITY_CODE_HPP
-#define BOOST_LAMBDA_ARITY_CODE_HPP
+#ifndef NDNBOOST_LAMBDA_ARITY_CODE_HPP
+#define NDNBOOST_LAMBDA_ARITY_CODE_HPP
 
 #include "ndnboost/type_traits/cv_traits.hpp"
 #include "ndnboost/type_traits/transform_traits.hpp"
@@ -46,7 +46,7 @@
 
 template <class T> struct get_arity {
 
-  BOOST_STATIC_CONSTANT(int, value = detail::get_arity_<typename ndnboost::remove_cv<typename ndnboost::remove_reference<T>::type>::type>::value);
+  NDNBOOST_STATIC_CONSTANT(int, value = detail::get_arity_<typename ndnboost::remove_cv<typename ndnboost::remove_reference<T>::type>::type>::value);
 
 };
 
@@ -54,35 +54,35 @@
 
 template<class T>
 struct get_arity_ {
-  BOOST_STATIC_CONSTANT(int, value = 0);
+  NDNBOOST_STATIC_CONSTANT(int, value = 0);
 };
 
 template<class T>
 struct get_arity_<lambda_functor<T> > {
-  BOOST_STATIC_CONSTANT(int, value = get_arity<T>::value);
+  NDNBOOST_STATIC_CONSTANT(int, value = get_arity<T>::value);
 };
 
 template<class Action, class Args>
 struct get_arity_<lambda_functor_base<Action, Args> > {
-  BOOST_STATIC_CONSTANT(int, value = get_tuple_arity<Args>::value);
+  NDNBOOST_STATIC_CONSTANT(int, value = get_tuple_arity<Args>::value);
 };
 
 template<int I>
 struct get_arity_<placeholder<I> > {
-  BOOST_STATIC_CONSTANT(int, value = I);
+  NDNBOOST_STATIC_CONSTANT(int, value = I);
 };
 
 } // detail 
 
 template<class T>
 struct get_tuple_arity {
-  BOOST_STATIC_CONSTANT(int, value = get_arity<typename T::head_type>::value | get_tuple_arity<typename T::tail_type>::value);
+  NDNBOOST_STATIC_CONSTANT(int, value = get_arity<typename T::head_type>::value | get_tuple_arity<typename T::tail_type>::value);
 };
 
 
 template<>
 struct get_tuple_arity<null_type> {
-  BOOST_STATIC_CONSTANT(int, value = 0);
+  NDNBOOST_STATIC_CONSTANT(int, value = 0);
 };
 
 
@@ -90,17 +90,17 @@
 
 template<class T, int I>
 struct has_placeholder {
-  BOOST_STATIC_CONSTANT(bool, value = (get_arity<T>::value & I) != 0);
+  NDNBOOST_STATIC_CONSTANT(bool, value = (get_arity<T>::value & I) != 0);
 }; 
 
 template<int I, int J>
 struct includes_placeholder {
-  BOOST_STATIC_CONSTANT(bool, value = (J & I) != 0);
+  NDNBOOST_STATIC_CONSTANT(bool, value = (J & I) != 0);
 };
 
 template<int I, int J>
 struct lacks_placeholder {
-  BOOST_STATIC_CONSTANT(bool, value = ((J & I) == 0));
+  NDNBOOST_STATIC_CONSTANT(bool, value = ((J & I) == 0));
 };
 
 
diff --git a/include/ndnboost/lambda/detail/bind_functions.hpp b/include/ndnboost/lambda/detail/bind_functions.hpp
index 4288067..ec7f4e9 100644
--- a/include/ndnboost/lambda/detail/bind_functions.hpp
+++ b/include/ndnboost/lambda/detail/bind_functions.hpp
@@ -10,14 +10,14 @@
 
 // ----------------------------------------------------------------
 
-#ifndef BOOST_LAMBDA_BIND_FUNCTIONS_HPP
-#define BOOST_LAMBDA_BIND_FUNCTIONS_HPP
+#ifndef NDNBOOST_LAMBDA_BIND_FUNCTIONS_HPP
+#define NDNBOOST_LAMBDA_BIND_FUNCTIONS_HPP
 
 
 namespace ndnboost { 
 namespace lambda {
 
-#ifdef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING
+#ifdef NDNBOOST_LAMBDA_INCORRECT_BIND_OVERLOADING
 
   // gcc 2.96 instantiates bind functions it does not even call.
   // These instantiations lead to incorrect types in the return type, 
@@ -36,7 +36,7 @@
 }
 #endif
 // 1-argument bind functions --------------------------
-#ifndef BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T
+#ifndef NDNBOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T
 template <class Result>
 inline const
 lambda_functor<
@@ -58,7 +58,7 @@
 }
 #endif
 
- #ifndef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING 
+ #ifndef NDNBOOST_LAMBDA_INCORRECT_BIND_OVERLOADING 
 template <class Arg1>
 inline const
 lambda_functor<
@@ -177,7 +177,7 @@
 #endif 
 
 // 2-argument bind functions --------------------------
-#ifndef BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T
+#ifndef NDNBOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T
 template <class Result, class Par1, class Arg2>
 inline const
 lambda_functor<
@@ -199,7 +199,7 @@
 }
 #endif
 
-#ifndef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING 
+#ifndef NDNBOOST_LAMBDA_INCORRECT_BIND_OVERLOADING 
 template <class Arg1, class Arg2>
 inline const
 lambda_functor<
@@ -318,7 +318,7 @@
  #endif 
 
 // 3-argument bind functions --------------------------
-#ifndef BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T
+#ifndef NDNBOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T
 template <class Result, class Par1, class Par2, class Arg2, class Arg3>
 inline const
 lambda_functor<
@@ -346,7 +346,7 @@
 }
 #endif
 
- #ifndef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING 
+ #ifndef NDNBOOST_LAMBDA_INCORRECT_BIND_OVERLOADING 
 template <class Arg1, class Arg2, class Arg3>
 inline const
 lambda_functor<
@@ -487,7 +487,7 @@
  #endif 
 
 // 4-argument bind functions --------------------------
-#ifndef BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T
+#ifndef NDNBOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T
 template <class Result, class Par1, class Par2, class Par3, class Arg2,
           class Arg3, class Arg4>
 inline const
@@ -517,7 +517,7 @@
 }
 #endif
 
- #ifndef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING 
+ #ifndef NDNBOOST_LAMBDA_INCORRECT_BIND_OVERLOADING 
 template <class Arg1, class Arg2, class Arg3, class Arg4>
 inline const
 lambda_functor<
@@ -662,7 +662,7 @@
  #endif 
 
 // 5-argument bind functions --------------------------
-#ifndef BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T
+#ifndef NDNBOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T
 template <class Result, class Par1, class Par2, class Par3, class Par4,
           class Arg2, class Arg3, class Arg4, class Arg5>
 inline const
@@ -695,7 +695,7 @@
 }
 #endif
 
- #ifndef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING 
+ #ifndef NDNBOOST_LAMBDA_INCORRECT_BIND_OVERLOADING 
 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5>
 inline const
 lambda_functor<
@@ -849,7 +849,7 @@
  #endif 
 
 // 6-argument bind functions --------------------------
-#ifndef BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T
+#ifndef NDNBOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T
 template <class Result, class Par1, class Par2, class Par3, class Par4,
           class Par5, class Arg2, class Arg3, class Arg4, class Arg5,
           class Arg6>
@@ -883,7 +883,7 @@
 }
 #endif
 
- #ifndef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING 
+ #ifndef NDNBOOST_LAMBDA_INCORRECT_BIND_OVERLOADING 
 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5,
           class Arg6>
 inline const
@@ -1040,7 +1040,7 @@
  #endif 
 
 // 7-argument bind functions --------------------------
-#ifndef BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T
+#ifndef NDNBOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T
 template <class Result, class Par1, class Par2, class Par3, class Par4,
           class Par5, class Par6, class Arg2, class Arg3, class Arg4,
           class Arg5, class Arg6, class Arg7>
@@ -1075,7 +1075,7 @@
 }
 #endif
 
- #ifndef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING 
+ #ifndef NDNBOOST_LAMBDA_INCORRECT_BIND_OVERLOADING 
 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5,
           class Arg6, class Arg7>
 inline const
@@ -1239,7 +1239,7 @@
  #endif 
 
 // 8-argument bind functions --------------------------
-#ifndef BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T
+#ifndef NDNBOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T
 template <class Result, class Par1, class Par2, class Par3, class Par4,
           class Par5, class Par6, class Par7, class Arg2, class Arg3,
           class Arg4, class Arg5, class Arg6, class Arg7, class Arg8>
@@ -1274,7 +1274,7 @@
 }
 #endif
 
- #ifndef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING 
+ #ifndef NDNBOOST_LAMBDA_INCORRECT_BIND_OVERLOADING 
 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5,
           class Arg6, class Arg7, class Arg8>
 inline const
@@ -1438,7 +1438,7 @@
  #endif 
 
 // 9-argument bind functions --------------------------
-#ifndef BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T
+#ifndef NDNBOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T
 template <class Result, class Par1, class Par2, class Par3, class Par4,
           class Par5, class Par6, class Par7, class Par8, class Arg2,
           class Arg3, class Arg4, class Arg5, class Arg6, class Arg7,
@@ -1477,7 +1477,7 @@
 }
 #endif
 
- #ifndef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING 
+ #ifndef NDNBOOST_LAMBDA_INCORRECT_BIND_OVERLOADING 
 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5,
           class Arg6, class Arg7, class Arg8, class Arg9>
 inline const
@@ -1653,7 +1653,7 @@
  #endif 
 
 // 10-argument bind functions --------------------------
-#ifndef BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T
+#ifndef NDNBOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T
 template <class Result, class Par1, class Par2, class Par3, class Par4,
           class Par5, class Par6, class Par7, class Par8, class Par9,
           class Arg2, class Arg3, class Arg4, class Arg5, class Arg6,
@@ -1693,7 +1693,7 @@
 }
 #endif
 
- #ifndef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING 
+ #ifndef NDNBOOST_LAMBDA_INCORRECT_BIND_OVERLOADING 
 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5,
           class Arg6, class Arg7, class Arg8, class Arg9, class Arg10>
 inline const
diff --git a/include/ndnboost/lambda/detail/function_adaptors.hpp b/include/ndnboost/lambda/detail/function_adaptors.hpp
index df5367e..c527354 100644
--- a/include/ndnboost/lambda/detail/function_adaptors.hpp
+++ b/include/ndnboost/lambda/detail/function_adaptors.hpp
@@ -9,8 +9,8 @@
 // For more information, see www.boost.org
 
 
-#ifndef BOOST_LAMBDA_FUNCTION_ADAPTORS_HPP
-#define BOOST_LAMBDA_FUNCTION_ADAPTORS_HPP
+#ifndef NDNBOOST_LAMBDA_FUNCTION_ADAPTORS_HPP
+#define NDNBOOST_LAMBDA_FUNCTION_ADAPTORS_HPP
 
 #include "ndnboost/mpl/has_xxx.hpp"
 #include "ndnboost/tuple/tuple.hpp"
@@ -26,7 +26,7 @@
 
 namespace detail {
 
-BOOST_MPL_HAS_XXX_TEMPLATE_DEF(sig)
+NDNBOOST_MPL_HAS_XXX_TEMPLATE_DEF(sig)
 
 template<class Tuple>
 struct remove_references_from_elements {
@@ -47,7 +47,7 @@
 
   typedef typename detail::remove_reference_and_cv<Func>::type plainF;
 
-#if !defined(BOOST_NO_RESULT_OF)
+#if !defined(NDNBOOST_NO_RESULT_OF)
   // Support functors that use the ndnboost::result_of return type convention.
   template<class Tuple, int Length, bool HasSig>
   struct result_converter;
@@ -166,7 +166,7 @@
       , detail::has_sig<plainF>::value
       >
   {};
-#else // BOOST_NO_RESULT_OF
+#else // NDNBOOST_NO_RESULT_OF
 
   template <class Args> class sig {
     typedef typename detail::remove_reference_and_cv<Func>::type plainF;
diff --git a/include/ndnboost/lambda/detail/is_instance_of.hpp b/include/ndnboost/lambda/detail/is_instance_of.hpp
index 3e91c66..1b03597 100644
--- a/include/ndnboost/lambda/detail/is_instance_of.hpp
+++ b/include/ndnboost/lambda/detail/is_instance_of.hpp
@@ -10,10 +10,10 @@
 
 // ---------------------------------------------------------------
 
-#ifndef BOOST_LAMBDA_IS_INSTANCE_OF
-#define BOOST_LAMBDA_IS_INSTANCE_OF
+#ifndef NDNBOOST_LAMBDA_IS_INSTANCE_OF
+#define NDNBOOST_LAMBDA_IS_INSTANCE_OF
 
-#include "ndnboost/config.hpp" // for BOOST_STATIC_CONSTANT
+#include "ndnboost/config.hpp" // for NDNBOOST_STATIC_CONSTANT
 #include "ndnboost/type_traits/conversion_traits.hpp" // for is_convertible
 #include "ndnboost/preprocessor/enum_shifted_params.hpp"
 #include "ndnboost/preprocessor/repeat_2nd.hpp"
@@ -38,60 +38,60 @@
 // Now we only have one version of is_instance_of templates, which delagate
 // all the nasty compiler tricks to is_convertible. 
 
-#define BOOST_LAMBDA_CLASS(z, N,A) BOOST_PP_COMMA_IF(N) class
-#define BOOST_LAMBDA_CLASS_ARG(z, N,A) BOOST_PP_COMMA_IF(N) class A##N 
-#define BOOST_LAMBDA_ARG(z, N,A) BOOST_PP_COMMA_IF(N) A##N 
+#define NDNBOOST_LAMBDA_CLASS(z, N,A) NDNBOOST_PP_COMMA_IF(N) class
+#define NDNBOOST_LAMBDA_CLASS_ARG(z, N,A) NDNBOOST_PP_COMMA_IF(N) class A##N 
+#define NDNBOOST_LAMBDA_ARG(z, N,A) NDNBOOST_PP_COMMA_IF(N) A##N 
 
-#define BOOST_LAMBDA_CLASS_LIST(n, NAME) BOOST_PP_REPEAT(n, BOOST_LAMBDA_CLASS, NAME)
+#define NDNBOOST_LAMBDA_CLASS_LIST(n, NAME) NDNBOOST_PP_REPEAT(n, NDNBOOST_LAMBDA_CLASS, NAME)
 
-#define BOOST_LAMBDA_CLASS_ARG_LIST(n, NAME) BOOST_PP_REPEAT(n, BOOST_LAMBDA_CLASS_ARG, NAME)
+#define NDNBOOST_LAMBDA_CLASS_ARG_LIST(n, NAME) NDNBOOST_PP_REPEAT(n, NDNBOOST_LAMBDA_CLASS_ARG, NAME)
 
-#define BOOST_LAMBDA_ARG_LIST(n, NAME) BOOST_PP_REPEAT(n, BOOST_LAMBDA_ARG, NAME)
+#define NDNBOOST_LAMBDA_ARG_LIST(n, NAME) NDNBOOST_PP_REPEAT(n, NDNBOOST_LAMBDA_ARG, NAME)
 
 namespace ndnboost {
 namespace lambda {
 
-#define BOOST_LAMBDA_IS_INSTANCE_OF_TEMPLATE(INDEX)                         \
+#define NDNBOOST_LAMBDA_IS_INSTANCE_OF_TEMPLATE(INDEX)                         \
                                                                             \
 namespace detail {                                                          \
                                                                             \
-template <template<BOOST_LAMBDA_CLASS_LIST(INDEX,T)> class F>               \
-struct BOOST_PP_CAT(conversion_tester_,INDEX) {                             \
-  template<BOOST_LAMBDA_CLASS_ARG_LIST(INDEX,A)>                            \
-  BOOST_PP_CAT(conversion_tester_,INDEX)                                    \
-    (const F<BOOST_LAMBDA_ARG_LIST(INDEX,A)>&);                             \
+template <template<NDNBOOST_LAMBDA_CLASS_LIST(INDEX,T)> class F>               \
+struct NDNBOOST_PP_CAT(conversion_tester_,INDEX) {                             \
+  template<NDNBOOST_LAMBDA_CLASS_ARG_LIST(INDEX,A)>                            \
+  NDNBOOST_PP_CAT(conversion_tester_,INDEX)                                    \
+    (const F<NDNBOOST_LAMBDA_ARG_LIST(INDEX,A)>&);                             \
 };                                                                          \
                                                                             \
 } /* end detail */                                                          \
                                                                             \
-template <class From, template <BOOST_LAMBDA_CLASS_LIST(INDEX,T)> class To> \
-struct BOOST_PP_CAT(is_instance_of_,INDEX)                                  \
+template <class From, template <NDNBOOST_LAMBDA_CLASS_LIST(INDEX,T)> class To> \
+struct NDNBOOST_PP_CAT(is_instance_of_,INDEX)                                  \
 {                                                                           \
  private:                                                                   \
    typedef ::ndnboost::is_convertible<                                         \
      From,                                                                  \
-     BOOST_PP_CAT(detail::conversion_tester_,INDEX)<To>                     \
+     NDNBOOST_PP_CAT(detail::conversion_tester_,INDEX)<To>                     \
    > helper_type;                                                           \
                                                                             \
 public:                                                                     \
-  BOOST_STATIC_CONSTANT(bool, value = helper_type::value);                  \
+  NDNBOOST_STATIC_CONSTANT(bool, value = helper_type::value);                  \
 };
 
 
-#define BOOST_LAMBDA_HELPER(z, N, A) BOOST_LAMBDA_IS_INSTANCE_OF_TEMPLATE( BOOST_PP_INC(N) )
+#define NDNBOOST_LAMBDA_HELPER(z, N, A) NDNBOOST_LAMBDA_IS_INSTANCE_OF_TEMPLATE( NDNBOOST_PP_INC(N) )
 
 // Generate the traits for 1-4 argument templates
 
-BOOST_PP_REPEAT_2ND(4,BOOST_LAMBDA_HELPER,FOO)
+NDNBOOST_PP_REPEAT_2ND(4,NDNBOOST_LAMBDA_HELPER,FOO)
 
-#undef BOOST_LAMBDA_HELPER
-#undef BOOST_LAMBDA_IS_INSTANCE_OF_TEMPLATE
-#undef BOOST_LAMBDA_CLASS
-#undef BOOST_LAMBDA_ARG
-#undef BOOST_LAMBDA_CLASS_ARG
-#undef BOOST_LAMBDA_CLASS_LIST
-#undef BOOST_LAMBDA_ARG_LIST
-#undef BOOST_LAMBDA_CLASS_ARG_LIST
+#undef NDNBOOST_LAMBDA_HELPER
+#undef NDNBOOST_LAMBDA_IS_INSTANCE_OF_TEMPLATE
+#undef NDNBOOST_LAMBDA_CLASS
+#undef NDNBOOST_LAMBDA_ARG
+#undef NDNBOOST_LAMBDA_CLASS_ARG
+#undef NDNBOOST_LAMBDA_CLASS_LIST
+#undef NDNBOOST_LAMBDA_ARG_LIST
+#undef NDNBOOST_LAMBDA_CLASS_ARG_LIST
 
 } // lambda
 } // boost
diff --git a/include/ndnboost/lambda/detail/lambda_config.hpp b/include/ndnboost/lambda/detail/lambda_config.hpp
index c994383..ce5dce2 100644
--- a/include/ndnboost/lambda/detail/lambda_config.hpp
+++ b/include/ndnboost/lambda/detail/lambda_config.hpp
@@ -10,8 +10,8 @@
 
 // ---------------------------------------------------------------
 
-#ifndef BOOST_LAMBDA_LAMBDA_CONFIG_HPP
-#define BOOST_LAMBDA_LAMBDA_CONFIG_HPP
+#ifndef NDNBOOST_LAMBDA_LAMBDA_CONFIG_HPP
+#define NDNBOOST_LAMBDA_LAMBDA_CONFIG_HPP
 
 // add to ndnboost/config.hpp
 // for now
@@ -19,22 +19,22 @@
 
 # if defined __GNUC__
 #   if (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) 
-#     define BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T
-#     define BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING
+#     define NDNBOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T
+#     define NDNBOOST_LAMBDA_INCORRECT_BIND_OVERLOADING
 #   endif
 #   if (__GNUC__ == 2 && __GNUC_MINOR__ <= 97) 
-#     define BOOST_NO_TEMPLATED_STREAMS
-#     define BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING
+#     define NDNBOOST_NO_TEMPLATED_STREAMS
+#     define NDNBOOST_LAMBDA_INCORRECT_BIND_OVERLOADING
 #   endif
 #   if (__GNUC__ == 2 && __GNUC_MINOR__ <= 95) 
-#     define BOOST_LAMBDA_FAILS_IN_TEMPLATE_KEYWORD_AFTER_SCOPE_OPER
+#     define NDNBOOST_LAMBDA_FAILS_IN_TEMPLATE_KEYWORD_AFTER_SCOPE_OPER
 #   endif
 # endif  // __GNUC__
  
 
 #if defined __KCC
 
-#define BOOST_NO_FDECL_TEMPLATES_AS_TEMPLATE_TEMPLATE_PARAMS
+#define NDNBOOST_NO_FDECL_TEMPLATES_AS_TEMPLATE_TEMPLATE_PARAMS
 
 #endif  // __KCC
 
diff --git a/include/ndnboost/lambda/detail/lambda_functor_base.hpp b/include/ndnboost/lambda/detail/lambda_functor_base.hpp
index 2c90f56..bfb012f 100644
--- a/include/ndnboost/lambda/detail/lambda_functor_base.hpp
+++ b/include/ndnboost/lambda/detail/lambda_functor_base.hpp
@@ -10,8 +10,8 @@
 
 // ------------------------------------------------------------
 
-#ifndef BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_HPP
-#define BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_HPP
+#ifndef NDNBOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_HPP
+#define NDNBOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_HPP
 
 #include "ndnboost/type_traits/add_reference.hpp"
 #include "ndnboost/type_traits/add_const.hpp"
@@ -22,7 +22,7 @@
 namespace ndnboost { 
 namespace lambda {
 
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#if NDNBOOST_WORKAROUND(NDNBOOST_MSVC, >= 1400)
 #pragma warning(push)
 #pragma warning(disable:4512) //assignment operator could not be generated
 #endif
@@ -52,7 +52,7 @@
   RET call(CALL_FORMAL_ARGS) const { CALL_USE_ARGS; return elem; }
 };
 
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#if NDNBOOST_WORKAROUND(NDNBOOST_MSVC, >= 1400)
 #pragma warning(pop)
 #endif
 
@@ -156,16 +156,16 @@
   // sig template for nullary case even if the nullary operator() is not
   // called
 template <class T> struct is_null_type 
-{ BOOST_STATIC_CONSTANT(bool, value = false); };
+{ NDNBOOST_STATIC_CONSTANT(bool, value = false); };
 
 template <> struct is_null_type<null_type> 
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
+{ NDNBOOST_STATIC_CONSTANT(bool, value = true); };
 
 template<class Tuple> struct has_null_type {
-  BOOST_STATIC_CONSTANT(bool, value = (is_null_type<typename Tuple::head_type>::value || has_null_type<typename Tuple::tail_type>::value));
+  NDNBOOST_STATIC_CONSTANT(bool, value = (is_null_type<typename Tuple::head_type>::value || has_null_type<typename Tuple::tail_type>::value));
 };
 template<> struct has_null_type<null_type> {
-  BOOST_STATIC_CONSTANT(bool, value = false);
+  NDNBOOST_STATIC_CONSTANT(bool, value = false);
 };
 
 
@@ -367,12 +367,12 @@
 };
 
 
-#if defined BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART  
-#error "Multiple defines of BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART"  
+#if defined NDNBOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART  
+#error "Multiple defines of NDNBOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART"  
 #endif  
   
   
-#define BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(ARITY)             \
+#define NDNBOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(ARITY)             \
 template<class Act, class Args>                                        \
 class lambda_functor_base<action<ARITY, Act>, Args>                    \
 {                                                                      \
@@ -398,7 +398,7 @@
     using detail::element_or_null;                                     \
     using detail::deduce_argument_types;                                
 
-BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(1)
+NDNBOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(1)
 
   typedef typename
     deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t;
@@ -411,7 +411,7 @@
 };
 
 
-BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(2)
+NDNBOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(2)
   
   typedef typename 
     deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t;
@@ -425,7 +425,7 @@
   }
 };
 
-BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(3)
+NDNBOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(3)
 
   typedef typename 
     deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t;
@@ -442,7 +442,7 @@
   }
 };
 
-BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(4)
+NDNBOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(4)
   typedef typename 
     deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t;
   typedef typename element_or_null<0, rets_t>::type rt0;
@@ -459,7 +459,7 @@
   }
 };
 
-BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(5)
+NDNBOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(5)
   typedef typename 
     deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t;
   typedef typename element_or_null<0, rets_t>::type rt0;
@@ -478,7 +478,7 @@
   }
 };
 
-BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(6)
+NDNBOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(6)
 
   typedef typename 
     deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t;
@@ -501,7 +501,7 @@
   }
 };
 
-BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(7)
+NDNBOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(7)
   typedef typename 
     deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t;
   typedef typename element_or_null<0, rets_t>::type rt0;
@@ -525,7 +525,7 @@
   }
 };
 
-BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(8)
+NDNBOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(8)
   typedef typename 
     deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t;
   typedef typename element_or_null<0, rets_t>::type rt0;
@@ -550,7 +550,7 @@
   }
 };
 
-BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(9)
+NDNBOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(9)
   typedef typename 
     deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t;
   typedef typename element_or_null<0, rets_t>::type rt0;
@@ -577,7 +577,7 @@
   }
 };
 
-BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(10) 
+NDNBOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(10) 
   typedef typename 
     deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t;
   typedef typename element_or_null<0, rets_t>::type rt0;
@@ -606,7 +606,7 @@
   }
 };
 
-#undef BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART
+#undef NDNBOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART
 
 
 } // namespace lambda
diff --git a/include/ndnboost/lambda/detail/lambda_functors.hpp b/include/ndnboost/lambda/detail/lambda_functors.hpp
index a6a9a7c..020e86e 100644
--- a/include/ndnboost/lambda/detail/lambda_functors.hpp
+++ b/include/ndnboost/lambda/detail/lambda_functors.hpp
@@ -10,31 +10,31 @@
 
 // ------------------------------------------------
 
-#ifndef BOOST_LAMBDA_LAMBDA_FUNCTORS_HPP
-#define BOOST_LAMBDA_LAMBDA_FUNCTORS_HPP
+#ifndef NDNBOOST_LAMBDA_LAMBDA_FUNCTORS_HPP
+#define NDNBOOST_LAMBDA_LAMBDA_FUNCTORS_HPP
 
 #include <ndnboost/config.hpp>
 #include <ndnboost/detail/workaround.hpp>
 #include <ndnboost/utility/result_of.hpp>
 
-#if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
+#if NDNBOOST_WORKAROUND(NDNBOOST_MSVC, == 1310)
 
 #include <ndnboost/mpl/or.hpp>
 #include <ndnboost/utility/enable_if.hpp>
 #include <ndnboost/type_traits/is_array.hpp>
 
-#define BOOST_LAMBDA_DISABLE_IF_ARRAY1(A1, R1)\
+#define NDNBOOST_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) \
+#define NDNBOOST_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) \
+#define NDNBOOST_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
+#define NDNBOOST_LAMBDA_DISABLE_IF_ARRAY1(A1, R1) typename R1::type
+#define NDNBOOST_LAMBDA_DISABLE_IF_ARRAY2(A1, A2, R1, R2) typename R1, R2::type
+#define NDNBOOST_LAMBDA_DISABLE_IF_ARRAY3(A1, A2, A3, R1, R2, R3) typename R1, R2, R3::type
 
 #endif
 
@@ -82,7 +82,7 @@
 
   template<class RET, CALL_TEMPLATE_ARGS> 
   RET call(CALL_FORMAL_ARGS) const { 
-    BOOST_STATIC_ASSERT(ndnboost::is_reference<RET>::value); 
+    NDNBOOST_STATIC_ASSERT(ndnboost::is_reference<RET>::value); 
     CALL_USE_ARGS; // does nothing, prevents warnings for unused args
     return a; 
   }
@@ -130,7 +130,7 @@
 // other lambda_functors.
 // -------------------------------------------------------------------
 
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#if NDNBOOST_WORKAROUND(NDNBOOST_MSVC, >= 1400)
 #pragma warning(push)
 #pragma warning(disable:4512) //assignment operator could not be generated
 #endif
@@ -140,7 +140,7 @@
 class lambda_functor : public T 
 {
 
-BOOST_STATIC_CONSTANT(int, arity_bits = get_arity<T>::value);
+NDNBOOST_STATIC_CONSTANT(int, arity_bits = get_arity<T>::value);
  
 public:
   typedef T inherited;
@@ -196,7 +196,7 @@
   }
 
   template<class A>
-  BOOST_LAMBDA_DISABLE_IF_ARRAY1(A, inherited::template sig<tuple<A const&> >)
+  NDNBOOST_LAMBDA_DISABLE_IF_ARRAY1(A, inherited::template sig<tuple<A const&> >)
   operator()(A const& a) const { 
     return inherited::template call<
       typename inherited::template sig<tuple<A const&> >::type
@@ -212,7 +212,7 @@
   }
 
   template<class A, class B>
-  BOOST_LAMBDA_DISABLE_IF_ARRAY2(A, B, inherited::template sig<tuple<A const&, B&> >)
+  NDNBOOST_LAMBDA_DISABLE_IF_ARRAY2(A, B, inherited::template sig<tuple<A const&, B&> >)
   operator()(A const& a, B& b) const { 
     return inherited::template call<
       typename inherited::template sig<tuple<A const&, B&> >::type
@@ -220,7 +220,7 @@
   }
 
   template<class A, class B>
-  BOOST_LAMBDA_DISABLE_IF_ARRAY2(A, B, inherited::template sig<tuple<A&, B const&> >)
+  NDNBOOST_LAMBDA_DISABLE_IF_ARRAY2(A, B, inherited::template sig<tuple<A&, B const&> >)
   operator()(A& a, B const& b) const { 
     return inherited::template call<
       typename inherited::template sig<tuple<A&, B const&> >::type
@@ -228,7 +228,7 @@
   }
 
   template<class A, class B>
-  BOOST_LAMBDA_DISABLE_IF_ARRAY2(A, B, inherited::template sig<tuple<A const&, B const&> >)
+  NDNBOOST_LAMBDA_DISABLE_IF_ARRAY2(A, B, inherited::template sig<tuple<A const&, B const&> >)
   operator()(A const& a, B const& b) const { 
     return inherited::template call<
       typename inherited::template sig<tuple<A const&, B const&> >::type
@@ -245,7 +245,7 @@
   }
 
   template<class A, class B, class C>
-  BOOST_LAMBDA_DISABLE_IF_ARRAY3(A, B, C, inherited::template sig<tuple<A const&, B const&, C const&> >)
+  NDNBOOST_LAMBDA_DISABLE_IF_ARRAY3(A, B, C, inherited::template sig<tuple<A const&, B const&, C const&> >)
   operator()(A const& a, B const& b, C const& c) const
   { 
     return inherited::template call<
@@ -291,7 +291,7 @@
   } 
 };
 
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#if NDNBOOST_WORKAROUND(NDNBOOST_MSVC, >= 1400)
 #pragma warning(pop)
 #endif
 
@@ -300,7 +300,7 @@
 
 namespace ndnboost {
 
-#if !defined(BOOST_RESULT_OF_USE_DECLTYPE) || defined(BOOST_NO_DECLTYPE)
+#if !defined(NDNBOOST_RESULT_OF_USE_DECLTYPE) || defined(NDNBOOST_NO_DECLTYPE)
 
 template<class T>
 struct result_of<ndnboost::lambda::lambda_functor<T>()>
diff --git a/include/ndnboost/lambda/detail/lambda_fwd.hpp b/include/ndnboost/lambda/detail/lambda_fwd.hpp
index e0253b7..098cef6 100644
--- a/include/ndnboost/lambda/detail/lambda_fwd.hpp
+++ b/include/ndnboost/lambda/detail/lambda_fwd.hpp
@@ -10,8 +10,8 @@
 
 // -------------------------------------------------------
 
-#ifndef BOOST_LAMBDA_FWD_HPP
-#define BOOST_LAMBDA_FWD_HPP
+#ifndef NDNBOOST_LAMBDA_FWD_HPP
+#define NDNBOOST_LAMBDA_FWD_HPP
 
 namespace ndnboost { 
 namespace lambda { 
diff --git a/include/ndnboost/lambda/detail/lambda_traits.hpp b/include/ndnboost/lambda/detail/lambda_traits.hpp
index aa241b6..0236e09 100644
--- a/include/ndnboost/lambda/detail/lambda_traits.hpp
+++ b/include/ndnboost/lambda/detail/lambda_traits.hpp
@@ -9,8 +9,8 @@
 // For more information, see www.boost.org
 // -------------------------------------------------------------------------
 
-#ifndef BOOST_LAMBDA_LAMBDA_TRAITS_HPP
-#define BOOST_LAMBDA_LAMBDA_TRAITS_HPP
+#ifndef NDNBOOST_LAMBDA_LAMBDA_TRAITS_HPP
+#define NDNBOOST_LAMBDA_LAMBDA_TRAITS_HPP
 
 #include "ndnboost/type_traits/transform_traits.hpp"
 #include "ndnboost/type_traits/cv_traits.hpp"
@@ -65,14 +65,14 @@
 template<class T>
 struct IF_value_
 {
-  BOOST_STATIC_CONSTANT(int, value = T::value);
+  NDNBOOST_STATIC_CONSTANT(int, value = T::value);
 };
 
 
 template<bool C, class T, class E>
 struct IF_value
 {
-  BOOST_STATIC_CONSTANT(int, value = (IF_value_<typename IF<C, T, E>::RET>::value));
+  NDNBOOST_STATIC_CONSTANT(int, value = (IF_value_<typename IF<C, T, E>::RET>::value));
 };
 
 
@@ -120,18 +120,18 @@
 // is_lambda_functor -------------------------------------------------   
 
 template <class T> struct is_lambda_functor_ {
-  BOOST_STATIC_CONSTANT(bool, value = false);
+  NDNBOOST_STATIC_CONSTANT(bool, value = false);
 };
    
 template <class Arg> struct is_lambda_functor_<lambda_functor<Arg> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
+  NDNBOOST_STATIC_CONSTANT(bool, value = true);
 };
    
 } // end detail
 
    
 template <class T> struct is_lambda_functor {
-  BOOST_STATIC_CONSTANT(bool, 
+  NDNBOOST_STATIC_CONSTANT(bool, 
      value = 
        detail::is_lambda_functor_<
          typename detail::remove_reference_and_cv<T>::type
@@ -544,7 +544,7 @@
     T0, T1, T2, T3, T4, T5, T6, T7, T8, T9
   >::type args_t;
 
-  BOOST_STATIC_CONSTANT(int, nof_elems = ndnboost::tuples::length<args_t>::value);
+  NDNBOOST_STATIC_CONSTANT(int, nof_elems = ndnboost::tuples::length<args_t>::value);
 
   typedef 
     action<
@@ -575,4 +575,4 @@
 
 
    
-#endif // BOOST_LAMBDA_TRAITS_HPP
+#endif // NDNBOOST_LAMBDA_TRAITS_HPP
diff --git a/include/ndnboost/lambda/detail/member_ptr.hpp b/include/ndnboost/lambda/detail/member_ptr.hpp
index 37c10ab..a6abb74 100644
--- a/include/ndnboost/lambda/detail/member_ptr.hpp
+++ b/include/ndnboost/lambda/detail/member_ptr.hpp
@@ -11,8 +11,8 @@
 
 // --------------------------------------------------------------------------
 
-#if !defined(BOOST_LAMBDA_MEMBER_PTR_HPP)
-#define BOOST_LAMBDA_MEMBER_PTR_HPP
+#if !defined(NDNBOOST_LAMBDA_MEMBER_PTR_HPP)
+#define NDNBOOST_LAMBDA_MEMBER_PTR_HPP
 
 namespace ndnboost { 
 namespace lambda {
@@ -30,8 +30,8 @@
   typedef typename ndnboost::add_reference<T>::type type;
   typedef detail::unspecified class_type;
   typedef detail::unspecified qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = false);
 };
 
 template<class T, class U>
@@ -39,8 +39,8 @@
   typedef typename ndnboost::add_reference<T>::type type;
   typedef U class_type;
   typedef U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = true);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = false);
 };
 
 template<class T, class U>
@@ -48,8 +48,8 @@
   typedef typename ndnboost::add_reference<const T>::type type;
   typedef U class_type;
   typedef const U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = true);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = false);
 };
 
 template<class T, class U>
@@ -57,8 +57,8 @@
   typedef typename ndnboost::add_reference<volatile T>::type type;
   typedef U class_type;
   typedef volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = true);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = false);
 };
 
 template<class T, class U>
@@ -66,8 +66,8 @@
   typedef typename ndnboost::add_reference<const volatile T>::type type;
   typedef U class_type;
   typedef const volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = true);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = false);
 };
 
 // -- nonconst member functions --
@@ -76,48 +76,48 @@
   typedef T type;
   typedef U class_type;
   typedef U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = true);
 };
 template<class T, class U, class A1>
 struct member_pointer<T (U::*)(A1)> {
   typedef T type;
   typedef U class_type;
   typedef U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = true);
 };
 template<class T, class U, class A1, class A2>
 struct member_pointer<T (U::*)(A1, A2)> {
   typedef T type;
   typedef U class_type;
   typedef U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = true);
 };
 template<class T, class U, class A1, class A2, class A3>
 struct member_pointer<T (U::*)(A1, A2, A3)> {
   typedef T type;
   typedef U class_type;
   typedef U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = true);
 };
 template<class T, class U, class A1, class A2, class A3, class A4>
 struct member_pointer<T (U::*)(A1, A2, A3, A4)> {
   typedef T type;
   typedef U class_type;
   typedef U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = true);
 };
 template<class T, class U, class A1, class A2, class A3, class A4, class A5>
 struct member_pointer<T (U::*)(A1, A2, A3, A4, A5)> {
   typedef T type;
   typedef U class_type;
   typedef U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = true);
 };
 template<class T, class U, class A1, class A2, class A3, class A4, class A5,
          class A6>
@@ -125,8 +125,8 @@
   typedef T type;
   typedef U class_type;
   typedef U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = true);
 };
 template<class T, class U, class A1, class A2, class A3, class A4, class A5,
          class A6, class A7>
@@ -134,8 +134,8 @@
   typedef T type;
   typedef U class_type;
   typedef U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = true);
 };
 template<class T, class U, class A1, class A2, class A3, class A4, class A5,
          class A6, class A7, class A8>
@@ -143,8 +143,8 @@
   typedef T type;
   typedef U class_type;
   typedef U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = true);
 };
 template<class T, class U, class A1, class A2, class A3, class A4, class A5,
          class A6, class A7, class A8, class A9>
@@ -152,8 +152,8 @@
   typedef T type;
   typedef U class_type;
   typedef U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = true);
 };
 // -- const member functions --
 template<class T, class U>
@@ -161,48 +161,48 @@
   typedef T type;
   typedef U class_type;
   typedef const U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = true);
 };
 template<class T, class U, class A1>
 struct member_pointer<T (U::*)(A1) const> {
   typedef T type;
   typedef U class_type;
   typedef const U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = true);
 };
 template<class T, class U, class A1, class A2>
 struct member_pointer<T (U::*)(A1, A2) const> {
   typedef T type;
   typedef U class_type;
   typedef const U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = true);
 };
 template<class T, class U, class A1, class A2, class A3>
 struct member_pointer<T (U::*)(A1, A2, A3) const> {
   typedef T type;
   typedef U class_type;
   typedef const U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = true);
 };
 template<class T, class U, class A1, class A2, class A3, class A4>
 struct member_pointer<T (U::*)(A1, A2, A3, A4) const> {
   typedef T type;
   typedef U class_type;
   typedef const U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = true);
 };
 template<class T, class U, class A1, class A2, class A3, class A4, class A5>
 struct member_pointer<T (U::*)(A1, A2, A3, A4, A5) const> {
   typedef T type;
   typedef U class_type;
   typedef const U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = true);
 };
 template<class T, class U, class A1, class A2, class A3, class A4, class A5,
          class A6>
@@ -210,8 +210,8 @@
   typedef T type;
   typedef U class_type;
   typedef const U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = true);
 };
 template<class T, class U, class A1, class A2, class A3, class A4, class A5,
          class A6, class A7>
@@ -219,8 +219,8 @@
   typedef T type;
   typedef U class_type;
   typedef const U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = true);
 };
 template<class T, class U, class A1, class A2, class A3, class A4, class A5,
          class A6, class A7, class A8>
@@ -228,8 +228,8 @@
   typedef T type;
   typedef U class_type;
   typedef const U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = true);
 };
 template<class T, class U, class A1, class A2, class A3, class A4, class A5,
          class A6, class A7, class A8, class A9>
@@ -237,8 +237,8 @@
   typedef T type;
   typedef U class_type;
   typedef const U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = true);
 };
   // -- volatile --
 template<class T, class U>
@@ -246,48 +246,48 @@
   typedef T type;
   typedef U class_type;
   typedef volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = true);
 };
 template<class T, class U, class A1>
 struct member_pointer<T (U::*)(A1) volatile> {
   typedef T type;
   typedef U class_type;
   typedef volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = true);
 };
 template<class T, class U, class A1, class A2>
 struct member_pointer<T (U::*)(A1, A2) volatile> {
   typedef T type;
   typedef U class_type;
   typedef volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = true);
 };
 template<class T, class U, class A1, class A2, class A3>
 struct member_pointer<T (U::*)(A1, A2, A3) volatile> {
   typedef T type;
   typedef U class_type;
   typedef volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = true);
 };
 template<class T, class U, class A1, class A2, class A3, class A4>
 struct member_pointer<T (U::*)(A1, A2, A3, A4) volatile> {
   typedef T type;
   typedef U class_type;
   typedef volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = true);
 };
 template<class T, class U, class A1, class A2, class A3, class A4, class A5>
 struct member_pointer<T (U::*)(A1, A2, A3, A4, A5) volatile> {
   typedef T type;
   typedef U class_type;
   typedef volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = true);
 };
 template<class T, class U, class A1, class A2, class A3, class A4, class A5,
          class A6>
@@ -295,8 +295,8 @@
   typedef T type;
   typedef U class_type;
   typedef volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = true);
 };
 template<class T, class U, class A1, class A2, class A3, class A4, class A5,
          class A6, class A7>
@@ -304,8 +304,8 @@
   typedef T type;
   typedef U class_type;
   typedef volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = true);
 };
 template<class T, class U, class A1, class A2, class A3, class A4, class A5,
          class A6, class A7, class A8>
@@ -313,8 +313,8 @@
   typedef T type;
   typedef U class_type;
   typedef volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = true);
 };
 template<class T, class U, class A1, class A2, class A3, class A4, class A5,
          class A6, class A7, class A8, class A9>
@@ -322,8 +322,8 @@
   typedef T type;
   typedef U class_type;
   typedef volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = true);
 };
   // -- const volatile
 template<class T, class U>
@@ -331,32 +331,32 @@
   typedef T type;
   typedef U class_type;
   typedef const volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = true);
 };
 template<class T, class U, class A1>
 struct member_pointer<T (U::*)(A1) const volatile> {
   typedef T type;
   typedef U class_type;
   typedef const volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = true);
 };
 template<class T, class U, class A1, class A2>
 struct member_pointer<T (U::*)(A1, A2) const volatile> {
   typedef T type;
   typedef U class_type;
   typedef const volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = true);
 };
 template<class T, class U, class A1, class A2, class A3>
 struct member_pointer<T (U::*)(A1, A2, A3) const volatile> {
   typedef T type;
   typedef U class_type;
   typedef const volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = true);
 };
 template<class T, class U, class A1, class A2, class A3, class A4>
 struct member_pointer<T (U::*)(A1, A2, A3, A4) const volatile> {
@@ -369,8 +369,8 @@
   typedef T type;
   typedef U class_type;
   typedef const volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = true);
 };
 template<class T, class U, class A1, class A2, class A3, class A4, class A5,
          class A6>
@@ -378,8 +378,8 @@
   typedef T type;
   typedef U class_type;
   typedef const volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = true);
 };
 template<class T, class U, class A1, class A2, class A3, class A4, class A5,
          class A6, class A7>
@@ -387,8 +387,8 @@
   typedef T type;
   typedef U class_type;
   typedef const volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = true);
 };
 template<class T, class U, class A1, class A2, class A3, class A4, class A5,
          class A6, class A7, class A8>
@@ -396,8 +396,8 @@
   typedef T type;
   typedef U class_type;
   typedef const volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = true);
 };
 template<class T, class U, class A1, class A2, class A3, class A4, class A5,
          class A6, class A7, class A8, class A9>
@@ -405,8 +405,8 @@
   typedef T type;
   typedef U class_type;
   typedef const volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
+  NDNBOOST_STATIC_CONSTANT(bool, is_data_member = false);
+  NDNBOOST_STATIC_CONSTANT(bool, is_function_member = true);
 };
 
 } // detail
diff --git a/include/ndnboost/lambda/detail/operator_actions.hpp b/include/ndnboost/lambda/detail/operator_actions.hpp
index 4947792..4d05f9f 100644
--- a/include/ndnboost/lambda/detail/operator_actions.hpp
+++ b/include/ndnboost/lambda/detail/operator_actions.hpp
@@ -8,8 +8,8 @@
 
 // For more information, see http://lambda.cs.utu.fi 
 
-#ifndef BOOST_LAMBDA_OPERATOR_ACTIONS_HPP
-#define BOOST_LAMBDA_OPERATOR_ACTIONS_HPP
+#ifndef NDNBOOST_LAMBDA_OPERATOR_ACTIONS_HPP
+#define NDNBOOST_LAMBDA_OPERATOR_ACTIONS_HPP
 
 namespace ndnboost { 
 namespace lambda {
@@ -78,48 +78,48 @@
   // deduction.
 
 template <class Act> struct is_protectable<arithmetic_action<Act> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
+  NDNBOOST_STATIC_CONSTANT(bool, value = true);
 };
 template <class Act> struct is_protectable<bitwise_action<Act> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
+  NDNBOOST_STATIC_CONSTANT(bool, value = true);
 };
 template <class Act> struct is_protectable<logical_action<Act> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
+  NDNBOOST_STATIC_CONSTANT(bool, value = true);
 };
 template <class Act> struct is_protectable<relational_action<Act> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
+  NDNBOOST_STATIC_CONSTANT(bool, value = true);
 };
 template <class Act> 
 struct is_protectable<arithmetic_assignment_action<Act> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
+  NDNBOOST_STATIC_CONSTANT(bool, value = true);
 };
 template <class Act> struct is_protectable<bitwise_assignment_action<Act> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
+  NDNBOOST_STATIC_CONSTANT(bool, value = true);
 };
 template <class Act> struct is_protectable<unary_arithmetic_action<Act> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
+  NDNBOOST_STATIC_CONSTANT(bool, value = true);
 };
 template <class Act> 
 struct is_protectable<pre_increment_decrement_action<Act> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
+  NDNBOOST_STATIC_CONSTANT(bool, value = true);
 };
 template <class Act> struct 
 is_protectable<post_increment_decrement_action<Act> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
+  NDNBOOST_STATIC_CONSTANT(bool, value = true);
 };
 
 template <> struct is_protectable<other_action<addressof_action> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
+  NDNBOOST_STATIC_CONSTANT(bool, value = true);
 };
 template <> struct is_protectable<other_action<contentsof_action> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
+  NDNBOOST_STATIC_CONSTANT(bool, value = true);
 };
 
 template<> struct is_protectable<other_action<subscript_action> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
+  NDNBOOST_STATIC_CONSTANT(bool, value = true);
 };
 template<> struct is_protectable<other_action<assignment_action> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
+  NDNBOOST_STATIC_CONSTANT(bool, value = true);
 };
 
 // NOTE: comma action is also protectable, but the specialization is
diff --git a/include/ndnboost/lambda/detail/operator_lambda_func_base.hpp b/include/ndnboost/lambda/detail/operator_lambda_func_base.hpp
index 777726a..20bb45d 100644
--- a/include/ndnboost/lambda/detail/operator_lambda_func_base.hpp
+++ b/include/ndnboost/lambda/detail/operator_lambda_func_base.hpp
@@ -10,8 +10,8 @@
 
 // ------------------------------------------------------------
 
-#ifndef BOOST_LAMBDA_OPERATOR_LAMBDA_FUNC_BASE_HPP
-#define BOOST_LAMBDA_OPERATOR_LAMBDA_FUNC_BASE_HPP
+#ifndef NDNBOOST_LAMBDA_OPERATOR_LAMBDA_FUNC_BASE_HPP
+#define NDNBOOST_LAMBDA_OPERATOR_LAMBDA_FUNC_BASE_HPP
 
 namespace ndnboost { 
 namespace lambda {
@@ -145,7 +145,7 @@
 };  
 
 
-#define BOOST_LAMBDA_BINARY_ACTION(SYMBOL, ACTION_CLASS)  \
+#define NDNBOOST_LAMBDA_BINARY_ACTION(SYMBOL, ACTION_CLASS)  \
 template<class Args>                                                      \
 class lambda_functor_base<ACTION_CLASS, Args> {                           \
 public:                                                                   \
@@ -165,7 +165,7 @@
   };                                                                      \
 };  
 
-#define BOOST_LAMBDA_PREFIX_UNARY_ACTION(SYMBOL, ACTION_CLASS)            \
+#define NDNBOOST_LAMBDA_PREFIX_UNARY_ACTION(SYMBOL, ACTION_CLASS)            \
 template<class Args>                                                      \
 class lambda_functor_base<ACTION_CLASS, Args> {                           \
 public:                                                                   \
@@ -184,7 +184,7 @@
   };                                                                      \
 };  
 
-#define BOOST_LAMBDA_POSTFIX_UNARY_ACTION(SYMBOL, ACTION_CLASS)           \
+#define NDNBOOST_LAMBDA_POSTFIX_UNARY_ACTION(SYMBOL, ACTION_CLASS)           \
 template<class Args>                                                      \
 class lambda_functor_base<ACTION_CLASS, Args> {                           \
 public:                                                                   \
@@ -203,57 +203,57 @@
   };                                                                      \
 };  
 
-BOOST_LAMBDA_BINARY_ACTION(+,arithmetic_action<plus_action>)
-BOOST_LAMBDA_BINARY_ACTION(-,arithmetic_action<minus_action>)
-BOOST_LAMBDA_BINARY_ACTION(*,arithmetic_action<multiply_action>)
-BOOST_LAMBDA_BINARY_ACTION(/,arithmetic_action<divide_action>)
-BOOST_LAMBDA_BINARY_ACTION(%,arithmetic_action<remainder_action>)
+NDNBOOST_LAMBDA_BINARY_ACTION(+,arithmetic_action<plus_action>)
+NDNBOOST_LAMBDA_BINARY_ACTION(-,arithmetic_action<minus_action>)
+NDNBOOST_LAMBDA_BINARY_ACTION(*,arithmetic_action<multiply_action>)
+NDNBOOST_LAMBDA_BINARY_ACTION(/,arithmetic_action<divide_action>)
+NDNBOOST_LAMBDA_BINARY_ACTION(%,arithmetic_action<remainder_action>)
 
-BOOST_LAMBDA_BINARY_ACTION(<<,bitwise_action<leftshift_action>)
-BOOST_LAMBDA_BINARY_ACTION(>>,bitwise_action<rightshift_action>)
-BOOST_LAMBDA_BINARY_ACTION(&,bitwise_action<and_action>)
-BOOST_LAMBDA_BINARY_ACTION(|,bitwise_action<or_action>)
-BOOST_LAMBDA_BINARY_ACTION(^,bitwise_action<xor_action>)
+NDNBOOST_LAMBDA_BINARY_ACTION(<<,bitwise_action<leftshift_action>)
+NDNBOOST_LAMBDA_BINARY_ACTION(>>,bitwise_action<rightshift_action>)
+NDNBOOST_LAMBDA_BINARY_ACTION(&,bitwise_action<and_action>)
+NDNBOOST_LAMBDA_BINARY_ACTION(|,bitwise_action<or_action>)
+NDNBOOST_LAMBDA_BINARY_ACTION(^,bitwise_action<xor_action>)
 
-BOOST_LAMBDA_BINARY_ACTION(<,relational_action<less_action>)
-BOOST_LAMBDA_BINARY_ACTION(>,relational_action<greater_action>)
-BOOST_LAMBDA_BINARY_ACTION(<=,relational_action<lessorequal_action>)
-BOOST_LAMBDA_BINARY_ACTION(>=,relational_action<greaterorequal_action>)
-BOOST_LAMBDA_BINARY_ACTION(==,relational_action<equal_action>)
-BOOST_LAMBDA_BINARY_ACTION(!=,relational_action<notequal_action>)
+NDNBOOST_LAMBDA_BINARY_ACTION(<,relational_action<less_action>)
+NDNBOOST_LAMBDA_BINARY_ACTION(>,relational_action<greater_action>)
+NDNBOOST_LAMBDA_BINARY_ACTION(<=,relational_action<lessorequal_action>)
+NDNBOOST_LAMBDA_BINARY_ACTION(>=,relational_action<greaterorequal_action>)
+NDNBOOST_LAMBDA_BINARY_ACTION(==,relational_action<equal_action>)
+NDNBOOST_LAMBDA_BINARY_ACTION(!=,relational_action<notequal_action>)
 
-BOOST_LAMBDA_BINARY_ACTION(+=,arithmetic_assignment_action<plus_action>)
-BOOST_LAMBDA_BINARY_ACTION(-=,arithmetic_assignment_action<minus_action>)
-BOOST_LAMBDA_BINARY_ACTION(*=,arithmetic_assignment_action<multiply_action>)
-BOOST_LAMBDA_BINARY_ACTION(/=,arithmetic_assignment_action<divide_action>)
-BOOST_LAMBDA_BINARY_ACTION(%=,arithmetic_assignment_action<remainder_action>)
+NDNBOOST_LAMBDA_BINARY_ACTION(+=,arithmetic_assignment_action<plus_action>)
+NDNBOOST_LAMBDA_BINARY_ACTION(-=,arithmetic_assignment_action<minus_action>)
+NDNBOOST_LAMBDA_BINARY_ACTION(*=,arithmetic_assignment_action<multiply_action>)
+NDNBOOST_LAMBDA_BINARY_ACTION(/=,arithmetic_assignment_action<divide_action>)
+NDNBOOST_LAMBDA_BINARY_ACTION(%=,arithmetic_assignment_action<remainder_action>)
 
-BOOST_LAMBDA_BINARY_ACTION(<<=,bitwise_assignment_action<leftshift_action>)
-BOOST_LAMBDA_BINARY_ACTION(>>=,bitwise_assignment_action<rightshift_action>)
-BOOST_LAMBDA_BINARY_ACTION(&=,bitwise_assignment_action<and_action>)
-BOOST_LAMBDA_BINARY_ACTION(|=,bitwise_assignment_action<or_action>)
-BOOST_LAMBDA_BINARY_ACTION(^=,bitwise_assignment_action<xor_action>)
+NDNBOOST_LAMBDA_BINARY_ACTION(<<=,bitwise_assignment_action<leftshift_action>)
+NDNBOOST_LAMBDA_BINARY_ACTION(>>=,bitwise_assignment_action<rightshift_action>)
+NDNBOOST_LAMBDA_BINARY_ACTION(&=,bitwise_assignment_action<and_action>)
+NDNBOOST_LAMBDA_BINARY_ACTION(|=,bitwise_assignment_action<or_action>)
+NDNBOOST_LAMBDA_BINARY_ACTION(^=,bitwise_assignment_action<xor_action>)
 
-BOOST_LAMBDA_BINARY_ACTION(=,other_action< assignment_action>)
+NDNBOOST_LAMBDA_BINARY_ACTION(=,other_action< assignment_action>)
 
 
-BOOST_LAMBDA_PREFIX_UNARY_ACTION(+, unary_arithmetic_action<plus_action>)
-BOOST_LAMBDA_PREFIX_UNARY_ACTION(-, unary_arithmetic_action<minus_action>)
-BOOST_LAMBDA_PREFIX_UNARY_ACTION(~, bitwise_action<not_action>)
-BOOST_LAMBDA_PREFIX_UNARY_ACTION(!, logical_action<not_action>)
-BOOST_LAMBDA_PREFIX_UNARY_ACTION(++, pre_increment_decrement_action<increment_action>)
-BOOST_LAMBDA_PREFIX_UNARY_ACTION(--, pre_increment_decrement_action<decrement_action>)
+NDNBOOST_LAMBDA_PREFIX_UNARY_ACTION(+, unary_arithmetic_action<plus_action>)
+NDNBOOST_LAMBDA_PREFIX_UNARY_ACTION(-, unary_arithmetic_action<minus_action>)
+NDNBOOST_LAMBDA_PREFIX_UNARY_ACTION(~, bitwise_action<not_action>)
+NDNBOOST_LAMBDA_PREFIX_UNARY_ACTION(!, logical_action<not_action>)
+NDNBOOST_LAMBDA_PREFIX_UNARY_ACTION(++, pre_increment_decrement_action<increment_action>)
+NDNBOOST_LAMBDA_PREFIX_UNARY_ACTION(--, pre_increment_decrement_action<decrement_action>)
 
-BOOST_LAMBDA_PREFIX_UNARY_ACTION(&,other_action<addressof_action>)
-BOOST_LAMBDA_PREFIX_UNARY_ACTION(*,other_action<contentsof_action>)
+NDNBOOST_LAMBDA_PREFIX_UNARY_ACTION(&,other_action<addressof_action>)
+NDNBOOST_LAMBDA_PREFIX_UNARY_ACTION(*,other_action<contentsof_action>)
 
-BOOST_LAMBDA_POSTFIX_UNARY_ACTION(++, post_increment_decrement_action<increment_action>)
-BOOST_LAMBDA_POSTFIX_UNARY_ACTION(--, post_increment_decrement_action<decrement_action>)
+NDNBOOST_LAMBDA_POSTFIX_UNARY_ACTION(++, post_increment_decrement_action<increment_action>)
+NDNBOOST_LAMBDA_POSTFIX_UNARY_ACTION(--, post_increment_decrement_action<decrement_action>)
 
 
-#undef BOOST_LAMBDA_POSTFIX_UNARY_ACTION
-#undef BOOST_LAMBDA_PREFIX_UNARY_ACTION
-#undef BOOST_LAMBDA_BINARY_ACTION
+#undef NDNBOOST_LAMBDA_POSTFIX_UNARY_ACTION
+#undef NDNBOOST_LAMBDA_PREFIX_UNARY_ACTION
+#undef NDNBOOST_LAMBDA_BINARY_ACTION
 
 } // namespace lambda
 } // namespace ndnboost
diff --git a/include/ndnboost/lambda/detail/operator_return_type_traits.hpp b/include/ndnboost/lambda/detail/operator_return_type_traits.hpp
index 0ee927b..10b37ca 100644
--- a/include/ndnboost/lambda/detail/operator_return_type_traits.hpp
+++ b/include/ndnboost/lambda/detail/operator_return_type_traits.hpp
@@ -8,8 +8,8 @@
 //
 // For more information, see www.boost.org
 
-#ifndef BOOST_LAMBDA_OPERATOR_RETURN_TYPE_TRAITS_HPP
-#define BOOST_LAMBDA_OPERATOR_RETURN_TYPE_TRAITS_HPP
+#ifndef NDNBOOST_LAMBDA_OPERATOR_RETURN_TYPE_TRAITS_HPP
+#define NDNBOOST_LAMBDA_OPERATOR_RETURN_TYPE_TRAITS_HPP
 
 #include "ndnboost/lambda/detail/is_instance_of.hpp"
 #include "ndnboost/type_traits/same_traits.hpp"
@@ -530,13 +530,13 @@
   // bitwise operators not defined for floating point types
   // these test are not strictly needed here, since the error will be caught in
   // the apply function
-  BOOST_STATIC_ASSERT(!(ndnboost::is_float<plain_A>::value && ndnboost::is_float<plain_B>::value));
+  NDNBOOST_STATIC_ASSERT(!(ndnboost::is_float<plain_A>::value && ndnboost::is_float<plain_B>::value));
 
 };
 
 namespace detail {
 
-#ifdef BOOST_NO_TEMPLATED_STREAMS
+#ifdef NDNBOOST_NO_TEMPLATED_STREAMS
 
 template<class A, class B>
 struct leftshift_type {
diff --git a/include/ndnboost/lambda/detail/operators.hpp b/include/ndnboost/lambda/detail/operators.hpp
index 7c3bc8b..fac9a48 100644
--- a/include/ndnboost/lambda/detail/operators.hpp
+++ b/include/ndnboost/lambda/detail/operators.hpp
@@ -10,16 +10,16 @@
 
 // ---------------------------------------------------------------
 
-#ifndef BOOST_LAMBDA_OPERATORS_HPP
-#define BOOST_LAMBDA_OPERATORS_HPP
+#ifndef NDNBOOST_LAMBDA_OPERATORS_HPP
+#define NDNBOOST_LAMBDA_OPERATORS_HPP
 
 #include "ndnboost/lambda/detail/is_instance_of.hpp"
 
 namespace ndnboost { 
 namespace lambda {
 
-#if defined BOOST_LAMBDA_BE1
-#error "Multiple defines of BOOST_LAMBDA_BE1"
+#if defined NDNBOOST_LAMBDA_BE1
+#error "Multiple defines of NDNBOOST_LAMBDA_BE1"
 #endif
 
   // For all BOOSTA_LAMBDA_BE* macros:
@@ -31,7 +31,7 @@
   // the need to pass in emtpy macro arguments, which gives warnings on some
   // compilers
 
-#define BOOST_LAMBDA_BE1(OPER_NAME, ACTION, CONSTA, CONSTB, CONVERSION)      \
+#define NDNBOOST_LAMBDA_BE1(OPER_NAME, ACTION, CONSTA, CONSTB, CONVERSION)      \
 template<class Arg, class B>                                                 \
 inline const                                                                 \
 lambda_functor<                                                              \
@@ -50,11 +50,11 @@
 }
 
 
-#if defined BOOST_LAMBDA_BE2
-#error "Multiple defines of BOOST_LAMBDA_BE2"
+#if defined NDNBOOST_LAMBDA_BE2
+#error "Multiple defines of NDNBOOST_LAMBDA_BE2"
 #endif
 
-#define BOOST_LAMBDA_BE2(OPER_NAME, ACTION, CONSTA, CONSTB, CONVERSION)      \
+#define NDNBOOST_LAMBDA_BE2(OPER_NAME, ACTION, CONSTA, CONSTB, CONVERSION)      \
 template<class A, class Arg>                                                 \
 inline const                                                                 \
 lambda_functor<                                                              \
@@ -73,11 +73,11 @@
 }
 
 
-#if defined BOOST_LAMBDA_BE3
-#error "Multiple defines of BOOST_LAMBDA_BE3"
+#if defined NDNBOOST_LAMBDA_BE3
+#error "Multiple defines of NDNBOOST_LAMBDA_BE3"
 #endif
 
-#define BOOST_LAMBDA_BE3(OPER_NAME, ACTION, CONSTA, CONSTB, CONVERSION)    \
+#define NDNBOOST_LAMBDA_BE3(OPER_NAME, ACTION, CONSTA, CONSTB, CONVERSION)    \
 template<class ArgA, class ArgB>                                           \
 inline const                                                               \
 lambda_functor<                                                            \
@@ -95,58 +95,58 @@
   (tuple<lambda_functor<ArgA>, lambda_functor<ArgB> >(a, b));              \
 }
 
-#if defined BOOST_LAMBDA_BE
-#error "Multiple defines of BOOST_LAMBDA_BE"
+#if defined NDNBOOST_LAMBDA_BE
+#error "Multiple defines of NDNBOOST_LAMBDA_BE"
 #endif
 
-#define BOOST_LAMBDA_BE(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION) \
-BOOST_LAMBDA_BE1(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION)        \
-BOOST_LAMBDA_BE2(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION)        \
-BOOST_LAMBDA_BE3(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION)
+#define NDNBOOST_LAMBDA_BE(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION) \
+NDNBOOST_LAMBDA_BE1(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION)        \
+NDNBOOST_LAMBDA_BE2(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION)        \
+NDNBOOST_LAMBDA_BE3(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION)
 
-#define BOOST_LAMBDA_EMPTY() 
+#define NDNBOOST_LAMBDA_EMPTY() 
 
-BOOST_LAMBDA_BE(operator+, arithmetic_action<plus_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator-, arithmetic_action<minus_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator*, arithmetic_action<multiply_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator/, arithmetic_action<divide_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator%, arithmetic_action<remainder_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator<<, bitwise_action<leftshift_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator>>, bitwise_action<rightshift_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator&, bitwise_action<and_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator|, bitwise_action<or_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator^, bitwise_action<xor_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator&&, logical_action<and_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator||, logical_action<or_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator<, relational_action<less_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator>, relational_action<greater_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator<=, relational_action<lessorequal_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator>=, relational_action<greaterorequal_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator==, relational_action<equal_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator!=, relational_action<notequal_action>, const A, const B, const_copy_argument)
+NDNBOOST_LAMBDA_BE(operator+, arithmetic_action<plus_action>, const A, const B, const_copy_argument)
+NDNBOOST_LAMBDA_BE(operator-, arithmetic_action<minus_action>, const A, const B, const_copy_argument)
+NDNBOOST_LAMBDA_BE(operator*, arithmetic_action<multiply_action>, const A, const B, const_copy_argument)
+NDNBOOST_LAMBDA_BE(operator/, arithmetic_action<divide_action>, const A, const B, const_copy_argument)
+NDNBOOST_LAMBDA_BE(operator%, arithmetic_action<remainder_action>, const A, const B, const_copy_argument)
+NDNBOOST_LAMBDA_BE(operator<<, bitwise_action<leftshift_action>, const A, const B, const_copy_argument)
+NDNBOOST_LAMBDA_BE(operator>>, bitwise_action<rightshift_action>, const A, const B, const_copy_argument)
+NDNBOOST_LAMBDA_BE(operator&, bitwise_action<and_action>, const A, const B, const_copy_argument)
+NDNBOOST_LAMBDA_BE(operator|, bitwise_action<or_action>, const A, const B, const_copy_argument)
+NDNBOOST_LAMBDA_BE(operator^, bitwise_action<xor_action>, const A, const B, const_copy_argument)
+NDNBOOST_LAMBDA_BE(operator&&, logical_action<and_action>, const A, const B, const_copy_argument)
+NDNBOOST_LAMBDA_BE(operator||, logical_action<or_action>, const A, const B, const_copy_argument)
+NDNBOOST_LAMBDA_BE(operator<, relational_action<less_action>, const A, const B, const_copy_argument)
+NDNBOOST_LAMBDA_BE(operator>, relational_action<greater_action>, const A, const B, const_copy_argument)
+NDNBOOST_LAMBDA_BE(operator<=, relational_action<lessorequal_action>, const A, const B, const_copy_argument)
+NDNBOOST_LAMBDA_BE(operator>=, relational_action<greaterorequal_action>, const A, const B, const_copy_argument)
+NDNBOOST_LAMBDA_BE(operator==, relational_action<equal_action>, const A, const B, const_copy_argument)
+NDNBOOST_LAMBDA_BE(operator!=, relational_action<notequal_action>, const A, const B, const_copy_argument)
 
-BOOST_LAMBDA_BE(operator+=, arithmetic_assignment_action<plus_action>, A, const B, reference_argument)
-BOOST_LAMBDA_BE(operator-=, arithmetic_assignment_action<minus_action>, A, const B, reference_argument)
-BOOST_LAMBDA_BE(operator*=, arithmetic_assignment_action<multiply_action>, A, const B, reference_argument)
-BOOST_LAMBDA_BE(operator/=, arithmetic_assignment_action<divide_action>, A, const B, reference_argument)
-BOOST_LAMBDA_BE(operator%=, arithmetic_assignment_action<remainder_action>, A, const B, reference_argument)
-BOOST_LAMBDA_BE(operator<<=, bitwise_assignment_action<leftshift_action>, A, const B, reference_argument)
-BOOST_LAMBDA_BE(operator>>=, bitwise_assignment_action<rightshift_action>, A, const B, reference_argument)
-BOOST_LAMBDA_BE(operator&=, bitwise_assignment_action<and_action>, A, const B, reference_argument)
-BOOST_LAMBDA_BE(operator|=, bitwise_assignment_action<or_action>, A, const B, reference_argument)
-BOOST_LAMBDA_BE(operator^=, bitwise_assignment_action<xor_action>, A, const B, reference_argument)
+NDNBOOST_LAMBDA_BE(operator+=, arithmetic_assignment_action<plus_action>, A, const B, reference_argument)
+NDNBOOST_LAMBDA_BE(operator-=, arithmetic_assignment_action<minus_action>, A, const B, reference_argument)
+NDNBOOST_LAMBDA_BE(operator*=, arithmetic_assignment_action<multiply_action>, A, const B, reference_argument)
+NDNBOOST_LAMBDA_BE(operator/=, arithmetic_assignment_action<divide_action>, A, const B, reference_argument)
+NDNBOOST_LAMBDA_BE(operator%=, arithmetic_assignment_action<remainder_action>, A, const B, reference_argument)
+NDNBOOST_LAMBDA_BE(operator<<=, bitwise_assignment_action<leftshift_action>, A, const B, reference_argument)
+NDNBOOST_LAMBDA_BE(operator>>=, bitwise_assignment_action<rightshift_action>, A, const B, reference_argument)
+NDNBOOST_LAMBDA_BE(operator&=, bitwise_assignment_action<and_action>, A, const B, reference_argument)
+NDNBOOST_LAMBDA_BE(operator|=, bitwise_assignment_action<or_action>, A, const B, reference_argument)
+NDNBOOST_LAMBDA_BE(operator^=, bitwise_assignment_action<xor_action>, A, const B, reference_argument)
 
 
 // A special trick for comma operator for correct preprocessing
-#if defined BOOST_LAMBDA_COMMA_OPERATOR_NAME
-#error "Multiple defines of BOOST_LAMBDA_COMMA_OPERATOR_NAME"
+#if defined NDNBOOST_LAMBDA_COMMA_OPERATOR_NAME
+#error "Multiple defines of NDNBOOST_LAMBDA_COMMA_OPERATOR_NAME"
 #endif
 
-#define BOOST_LAMBDA_COMMA_OPERATOR_NAME operator,
+#define NDNBOOST_LAMBDA_COMMA_OPERATOR_NAME operator,
 
-BOOST_LAMBDA_BE1(BOOST_LAMBDA_COMMA_OPERATOR_NAME, other_action<comma_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE2(BOOST_LAMBDA_COMMA_OPERATOR_NAME, other_action<comma_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE3(BOOST_LAMBDA_COMMA_OPERATOR_NAME, other_action<comma_action>, const A, const B, const_copy_argument)
+NDNBOOST_LAMBDA_BE1(NDNBOOST_LAMBDA_COMMA_OPERATOR_NAME, other_action<comma_action>, const A, const B, const_copy_argument)
+NDNBOOST_LAMBDA_BE2(NDNBOOST_LAMBDA_COMMA_OPERATOR_NAME, other_action<comma_action>, const A, const B, const_copy_argument)
+NDNBOOST_LAMBDA_BE3(NDNBOOST_LAMBDA_COMMA_OPERATOR_NAME, other_action<comma_action>, const A, const B, const_copy_argument)
 
 
 
@@ -161,7 +161,7 @@
 
 // Note that the overloading is const vs. non-const first argument
 
-#ifdef BOOST_NO_TEMPLATED_STREAMS
+#ifdef NDNBOOST_NO_TEMPLATED_STREAMS
 template<class T> struct convert_ostream_to_ref_others_to_c_plain_by_default {
   typedef typename detail::IF<
                        ndnboost::is_convertible<T*, std::ostream*>::value,
@@ -202,8 +202,8 @@
 
 } // detail
 
-BOOST_LAMBDA_BE2(operator<<, bitwise_action< leftshift_action>, A, const B, detail::convert_ostream_to_ref_others_to_c_plain_by_default)
-BOOST_LAMBDA_BE2(operator>>, bitwise_action< rightshift_action>, A, const B, detail::convert_istream_to_ref_others_to_c_plain_by_default)      
+NDNBOOST_LAMBDA_BE2(operator<<, bitwise_action< leftshift_action>, A, const B, detail::convert_ostream_to_ref_others_to_c_plain_by_default)
+NDNBOOST_LAMBDA_BE2(operator>>, bitwise_action< rightshift_action>, A, const B, detail::convert_istream_to_ref_others_to_c_plain_by_default)      
 
 
 // special case for io_manipulators.
@@ -254,11 +254,11 @@
 // the result of a+1 would be const
 // To make the latter work too, 
 // non-const arrays are taken as non-const and stored as non-const as well.
-#if defined  BOOST_LAMBDA_PTR_ARITHMETIC_E1
-#error "Multiple defines of  BOOST_LAMBDA_PTR_ARITHMETIC_E1"
+#if defined  NDNBOOST_LAMBDA_PTR_ARITHMETIC_E1
+#error "Multiple defines of  NDNBOOST_LAMBDA_PTR_ARITHMETIC_E1"
 #endif
 
-#define BOOST_LAMBDA_PTR_ARITHMETIC_E1(OPER_NAME, ACTION, CONSTB)           \
+#define NDNBOOST_LAMBDA_PTR_ARITHMETIC_E1(OPER_NAME, ACTION, CONSTB)           \
 template<class Arg, int N, class B>                                         \
 inline const                                                                \
 lambda_functor<                                                             \
@@ -272,11 +272,11 @@
 }
 
 
-#if defined  BOOST_LAMBDA_PTR_ARITHMETIC_E2
-#error "Multiple defines of  BOOST_LAMBDA_PTR_ARITHMETIC_E2"
+#if defined  NDNBOOST_LAMBDA_PTR_ARITHMETIC_E2
+#error "Multiple defines of  NDNBOOST_LAMBDA_PTR_ARITHMETIC_E2"
 #endif
 
-#define BOOST_LAMBDA_PTR_ARITHMETIC_E2(OPER_NAME, ACTION, CONSTA)           \
+#define NDNBOOST_LAMBDA_PTR_ARITHMETIC_E2(OPER_NAME, ACTION, CONSTA)           \
 template<int N, class A, class Arg>                                         \
 inline const                                                                \
 lambda_functor<                                                             \
@@ -290,38 +290,38 @@
 }
 
 
-BOOST_LAMBDA_PTR_ARITHMETIC_E1(operator+, arithmetic_action<plus_action>, B)
-BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator+, arithmetic_action<plus_action>, A)
-BOOST_LAMBDA_PTR_ARITHMETIC_E1(operator+, arithmetic_action<plus_action>,const B)
-BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator+, arithmetic_action<plus_action>,const A)
+NDNBOOST_LAMBDA_PTR_ARITHMETIC_E1(operator+, arithmetic_action<plus_action>, B)
+NDNBOOST_LAMBDA_PTR_ARITHMETIC_E2(operator+, arithmetic_action<plus_action>, A)
+NDNBOOST_LAMBDA_PTR_ARITHMETIC_E1(operator+, arithmetic_action<plus_action>,const B)
+NDNBOOST_LAMBDA_PTR_ARITHMETIC_E2(operator+, arithmetic_action<plus_action>,const A)
 
 
-//BOOST_LAMBDA_PTR_ARITHMETIC_E1(operator-, arithmetic_action<minus_action>)
+//NDNBOOST_LAMBDA_PTR_ARITHMETIC_E1(operator-, arithmetic_action<minus_action>)
 // This is not needed, since the result of ptr-ptr is an rvalue anyway
 
-BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator-, arithmetic_action<minus_action>, A)
-BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator-, arithmetic_action<minus_action>, const A)
+NDNBOOST_LAMBDA_PTR_ARITHMETIC_E2(operator-, arithmetic_action<minus_action>, A)
+NDNBOOST_LAMBDA_PTR_ARITHMETIC_E2(operator-, arithmetic_action<minus_action>, const A)
 
 
-#undef BOOST_LAMBDA_BE1
-#undef BOOST_LAMBDA_BE2
-#undef BOOST_LAMBDA_BE3
-#undef BOOST_LAMBDA_BE
-#undef BOOST_LAMBDA_COMMA_OPERATOR_NAME
+#undef NDNBOOST_LAMBDA_BE1
+#undef NDNBOOST_LAMBDA_BE2
+#undef NDNBOOST_LAMBDA_BE3
+#undef NDNBOOST_LAMBDA_BE
+#undef NDNBOOST_LAMBDA_COMMA_OPERATOR_NAME
 
-#undef BOOST_LAMBDA_PTR_ARITHMETIC_E1
-#undef BOOST_LAMBDA_PTR_ARITHMETIC_E2
+#undef NDNBOOST_LAMBDA_PTR_ARITHMETIC_E1
+#undef NDNBOOST_LAMBDA_PTR_ARITHMETIC_E2
 
 
 // ---------------------------------------------------------------------
 // unary operators -----------------------------------------------------
 // ---------------------------------------------------------------------
 
-#if defined BOOST_LAMBDA_UE
-#error "Multiple defines of BOOST_LAMBDA_UE"
+#if defined NDNBOOST_LAMBDA_UE
+#error "Multiple defines of NDNBOOST_LAMBDA_UE"
 #endif
 
-#define BOOST_LAMBDA_UE(OPER_NAME, ACTION)                                 \
+#define NDNBOOST_LAMBDA_UE(OPER_NAME, ACTION)                                 \
 template<class Arg>                                                        \
 inline const                                                               \
 lambda_functor<lambda_functor_base<ACTION, tuple<lambda_functor<Arg> > > > \
@@ -333,20 +333,20 @@
 }
 
 
-BOOST_LAMBDA_UE(operator+, unary_arithmetic_action<plus_action>)
-BOOST_LAMBDA_UE(operator-, unary_arithmetic_action<minus_action>)
-BOOST_LAMBDA_UE(operator~, bitwise_action<not_action>)
-BOOST_LAMBDA_UE(operator!, logical_action<not_action>)
-BOOST_LAMBDA_UE(operator++, pre_increment_decrement_action<increment_action>)
-BOOST_LAMBDA_UE(operator--, pre_increment_decrement_action<decrement_action>)
-BOOST_LAMBDA_UE(operator*, other_action<contentsof_action>)
-BOOST_LAMBDA_UE(operator&, other_action<addressof_action>)
+NDNBOOST_LAMBDA_UE(operator+, unary_arithmetic_action<plus_action>)
+NDNBOOST_LAMBDA_UE(operator-, unary_arithmetic_action<minus_action>)
+NDNBOOST_LAMBDA_UE(operator~, bitwise_action<not_action>)
+NDNBOOST_LAMBDA_UE(operator!, logical_action<not_action>)
+NDNBOOST_LAMBDA_UE(operator++, pre_increment_decrement_action<increment_action>)
+NDNBOOST_LAMBDA_UE(operator--, pre_increment_decrement_action<decrement_action>)
+NDNBOOST_LAMBDA_UE(operator*, other_action<contentsof_action>)
+NDNBOOST_LAMBDA_UE(operator&, other_action<addressof_action>)
 
-#if defined BOOST_LAMBDA_POSTFIX_UE
-#error "Multiple defines of BOOST_LAMBDA_POSTFIX_UE"
+#if defined NDNBOOST_LAMBDA_POSTFIX_UE
+#error "Multiple defines of NDNBOOST_LAMBDA_POSTFIX_UE"
 #endif
 
-#define BOOST_LAMBDA_POSTFIX_UE(OPER_NAME, ACTION)                         \
+#define NDNBOOST_LAMBDA_POSTFIX_UE(OPER_NAME, ACTION)                         \
 template<class Arg>                                                        \
 inline const                                                               \
 lambda_functor<lambda_functor_base<ACTION, tuple<lambda_functor<Arg> > > > \
@@ -358,11 +358,11 @@
 }
 
 
-BOOST_LAMBDA_POSTFIX_UE(operator++, post_increment_decrement_action<increment_action>)
-BOOST_LAMBDA_POSTFIX_UE(operator--, post_increment_decrement_action<decrement_action>)
+NDNBOOST_LAMBDA_POSTFIX_UE(operator++, post_increment_decrement_action<increment_action>)
+NDNBOOST_LAMBDA_POSTFIX_UE(operator--, post_increment_decrement_action<decrement_action>)
 
-#undef BOOST_LAMBDA_UE
-#undef BOOST_LAMBDA_POSTFIX_UE
+#undef NDNBOOST_LAMBDA_UE
+#undef NDNBOOST_LAMBDA_POSTFIX_UE
 
 } // namespace lambda
 } // namespace ndnboost
diff --git a/include/ndnboost/lambda/detail/ret.hpp b/include/ndnboost/lambda/detail/ret.hpp
index 8261bbd..9145ece 100644
--- a/include/ndnboost/lambda/detail/ret.hpp
+++ b/include/ndnboost/lambda/detail/ret.hpp
@@ -9,8 +9,8 @@
 // For more information, see www.boost.org
 
 
-#ifndef BOOST_LAMBDA_RET_HPP
-#define BOOST_LAMBDA_RET_HPP
+#ifndef NDNBOOST_LAMBDA_RET_HPP
+#define NDNBOOST_LAMBDA_RET_HPP
 
 namespace ndnboost { 
 namespace lambda {
diff --git a/include/ndnboost/lambda/detail/return_type_traits.hpp b/include/ndnboost/lambda/detail/return_type_traits.hpp
index 58771b7..7950a68 100644
--- a/include/ndnboost/lambda/detail/return_type_traits.hpp
+++ b/include/ndnboost/lambda/detail/return_type_traits.hpp
@@ -9,8 +9,8 @@
 // For more information, see www.boost.org
 
 
-#ifndef BOOST_LAMBDA_RETURN_TYPE_TRAITS_HPP
-#define BOOST_LAMBDA_RETURN_TYPE_TRAITS_HPP
+#ifndef NDNBOOST_LAMBDA_RETURN_TYPE_TRAITS_HPP
+#define NDNBOOST_LAMBDA_RETURN_TYPE_TRAITS_HPP
 
 #include "ndnboost/mpl/has_xxx.hpp"
 
@@ -239,7 +239,7 @@
 namespace detail
 {
 
-BOOST_MPL_HAS_XXX_TRAIT_DEF(result_type)
+NDNBOOST_MPL_HAS_XXX_TRAIT_DEF(result_type)
 
 template<class F> struct get_result_type
 {
diff --git a/include/ndnboost/lambda/detail/select_functions.hpp b/include/ndnboost/lambda/detail/select_functions.hpp
index 7b3ef8a..515ce05 100644
--- a/include/ndnboost/lambda/detail/select_functions.hpp
+++ b/include/ndnboost/lambda/detail/select_functions.hpp
@@ -9,8 +9,8 @@
 // For more information, see http://www.boost.org
 
 
-#ifndef BOOST_LAMBDA_SELECT_FUNCTIONS_HPP
-#define BOOST_LAMBDA_SELECT_FUNCTIONS_HPP
+#ifndef NDNBOOST_LAMBDA_SELECT_FUNCTIONS_HPP
+#define NDNBOOST_LAMBDA_SELECT_FUNCTIONS_HPP
 
 namespace ndnboost { 
 namespace lambda {
diff --git a/include/ndnboost/lambda/lambda.hpp b/include/ndnboost/lambda/lambda.hpp
index 593ef70..2434652 100644
--- a/include/ndnboost/lambda/lambda.hpp
+++ b/include/ndnboost/lambda/lambda.hpp
@@ -7,13 +7,13 @@
 //
 // For more information, see http://lambda.cs.utu.fi 
 
-#ifndef BOOST_LAMBDA_LAMBDA_HPP
-#define BOOST_LAMBDA_LAMBDA_HPP
+#ifndef NDNBOOST_LAMBDA_LAMBDA_HPP
+#define NDNBOOST_LAMBDA_LAMBDA_HPP
 
 
 #include "ndnboost/lambda/core.hpp"
 
-#ifdef BOOST_NO_FDECL_TEMPLATES_AS_TEMPLATE_TEMPLATE_PARAMS
+#ifdef NDNBOOST_NO_FDECL_TEMPLATES_AS_TEMPLATE_TEMPLATE_PARAMS
 #include <istream>
 #include <ostream>
 #endif
@@ -25,7 +25,7 @@
 
 #include "ndnboost/lambda/detail/operators.hpp"
 
-#ifndef BOOST_LAMBDA_FAILS_IN_TEMPLATE_KEYWORD_AFTER_SCOPE_OPER
+#ifndef NDNBOOST_LAMBDA_FAILS_IN_TEMPLATE_KEYWORD_AFTER_SCOPE_OPER
 // sorry, member ptr does not work with gcc2.95
 #include "ndnboost/lambda/detail/member_ptr.hpp"
 #endif