diff --git a/include/ndnboost/bind/apply.hpp b/include/ndnboost/bind/apply.hpp
index 8519c06..a1d96bd 100644
--- a/include/ndnboost/bind/apply.hpp
+++ b/include/ndnboost/bind/apply.hpp
@@ -1,5 +1,5 @@
-#ifndef BOOST_BIND_APPLY_HPP_INCLUDED
-#define BOOST_BIND_APPLY_HPP_INCLUDED
+#ifndef NDNBOOST_BIND_APPLY_HPP_INCLUDED
+#define NDNBOOST_BIND_APPLY_HPP_INCLUDED
 
 //
 //  apply.hpp
@@ -71,4 +71,4 @@
 
 } // namespace ndnboost
 
-#endif // #ifndef BOOST_BIND_APPLY_HPP_INCLUDED
+#endif // #ifndef NDNBOOST_BIND_APPLY_HPP_INCLUDED
diff --git a/include/ndnboost/bind/arg.hpp b/include/ndnboost/bind/arg.hpp
index 7551575..d420e7f 100644
--- a/include/ndnboost/bind/arg.hpp
+++ b/include/ndnboost/bind/arg.hpp
@@ -1,5 +1,5 @@
-#ifndef BOOST_BIND_ARG_HPP_INCLUDED
-#define BOOST_BIND_ARG_HPP_INCLUDED
+#ifndef NDNBOOST_BIND_ARG_HPP_INCLUDED
+#define NDNBOOST_BIND_ARG_HPP_INCLUDED
 
 // MS compatible compilers support #pragma once
 
@@ -43,7 +43,7 @@
     return true;
 }
 
-#if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
+#if !defined( NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
 
 template< int I > struct is_placeholder< arg<I> >
 {
@@ -59,4 +59,4 @@
 
 } // namespace ndnboost
 
-#endif // #ifndef BOOST_BIND_ARG_HPP_INCLUDED
+#endif // #ifndef NDNBOOST_BIND_ARG_HPP_INCLUDED
diff --git a/include/ndnboost/bind/bind.hpp b/include/ndnboost/bind/bind.hpp
index db16788..bf0bb2b 100644
--- a/include/ndnboost/bind/bind.hpp
+++ b/include/ndnboost/bind/bind.hpp
@@ -1,5 +1,5 @@
-#ifndef BOOST_BIND_BIND_HPP_INCLUDED
-#define BOOST_BIND_BIND_HPP_INCLUDED
+#ifndef NDNBOOST_BIND_BIND_HPP_INCLUDED
+#define NDNBOOST_BIND_BIND_HPP_INCLUDED
 
 // MS compatible compilers support #pragma once
 
@@ -33,14 +33,14 @@
 // Borland-specific bug, visit_each() silently fails to produce code
 
 #if defined(__BORLANDC__)
-#  define BOOST_BIND_VISIT_EACH ndnboost::visit_each
+#  define NDNBOOST_BIND_VISIT_EACH ndnboost::visit_each
 #else
-#  define BOOST_BIND_VISIT_EACH visit_each
+#  define NDNBOOST_BIND_VISIT_EACH visit_each
 #endif
 
 #include <ndnboost/bind/storage.hpp>
 
-#ifdef BOOST_MSVC
+#ifdef NDNBOOST_MSVC
 # pragma warning(push)
 # pragma warning(disable: 4512) // assignment operator could not be generated
 #endif
@@ -60,7 +60,7 @@
     typedef R type;
 };
 
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+#if !defined(NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING)
 
 struct unspecified {};
 
@@ -207,7 +207,7 @@
     }
 };
 
-#ifdef BOOST_MSVC
+#ifdef NDNBOOST_MSVC
 // MSVC is bright enough to realise that the parameter rhs 
 // in operator==may be unused for some template argument types:
 #pragma warning(push)
@@ -853,13 +853,13 @@
     }
 };
 
-#ifdef BOOST_MSVC
+#ifdef NDNBOOST_MSVC
 #pragma warning(pop)
 #endif
 
 // bind_t
 
-#ifndef BOOST_NO_VOID_RETURNS
+#ifndef NDNBOOST_NO_VOID_RETURNS
 
 template<class R, class F, class L> class bind_t
 {
@@ -869,9 +869,9 @@
 
     bind_t(F f, L const & l): f_(f), l_(l) {}
 
-#define BOOST_BIND_RETURN return
+#define NDNBOOST_BIND_RETURN return
 #include <ndnboost/bind/bind_template.hpp>
-#undef BOOST_BIND_RETURN
+#undef NDNBOOST_BIND_RETURN
 
 };
 
@@ -888,9 +888,9 @@
 
     implementation(F f, L const & l): f_(f), l_(l) {}
 
-#define BOOST_BIND_RETURN return
+#define NDNBOOST_BIND_RETURN return
 #include <ndnboost/bind/bind_template.hpp>
-#undef BOOST_BIND_RETURN
+#undef NDNBOOST_BIND_RETURN
 
 };
 
@@ -911,19 +911,19 @@
 
     implementation(F f, L const & l): f_(f), l_(l) {}
 
-#define BOOST_BIND_RETURN
+#define NDNBOOST_BIND_RETURN
 #include <ndnboost/bind/bind_template.hpp>
-#undef BOOST_BIND_RETURN
+#undef NDNBOOST_BIND_RETURN
 
 };
 
 };
 
-template<class R2, class F, class L> class bind_t: public bind_t_generator<R2>::BOOST_NESTED_TEMPLATE implementation<F, L>
+template<class R2, class F, class L> class bind_t: public bind_t_generator<R2>::NDNBOOST_NESTED_TEMPLATE implementation<F, L>
 {
 public:
 
-    bind_t(F f, L const & l): bind_t_generator<R2>::BOOST_NESTED_TEMPLATE implementation<F, L>(f, l) {}
+    bind_t(F f, L const & l): bind_t_generator<R2>::NDNBOOST_NESTED_TEMPLATE implementation<F, L>(f, l) {}
 
 };
 
@@ -931,11 +931,11 @@
 
 // function_equal
 
-#ifndef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
+#ifndef NDNBOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
 
 // put overloads in _bi, rely on ADL
 
-# ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+# ifndef NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING
 
 template<class R, class F, class L> bool function_equal( bind_t<R, F, L> const & a, bind_t<R, F, L> const & b )
 {
@@ -949,15 +949,15 @@
     return a.compare(b);
 }
 
-# endif // #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+# endif // #ifndef NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING
 
-#else // BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
+#else // NDNBOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
 
 // put overloads in boost
 
 } // namespace _bi
 
-# ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+# ifndef NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING
 
 template<class R, class F, class L> bool function_equal( _bi::bind_t<R, F, L> const & a, _bi::bind_t<R, F, L> const & b )
 {
@@ -971,18 +971,18 @@
     return a.compare(b);
 }
 
-# endif // #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+# endif // #ifndef NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING
 
 namespace _bi
 {
 
-#endif // BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
+#endif // NDNBOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
 
 // add_value
 
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) || (__SUNPRO_CC >= 0x530)
+#if !defined(NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) || (__SUNPRO_CC >= 0x530)
 
-#if defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x582) )
+#if defined( __BORLANDC__ ) && NDNBOOST_WORKAROUND( __BORLANDC__, NDNBOOST_TESTED_AT(0x582) )
 
 template<class T> struct add_value
 {
@@ -1181,7 +1181,7 @@
 
 // relational operators
 
-#define BOOST_BIND_OPERATOR( op, name ) \
+#define NDNBOOST_BIND_OPERATOR( op, name ) \
 \
 struct name \
 { \
@@ -1197,25 +1197,25 @@
     return bind_t<bool, name, list_type> ( name(), list_type(f, a2) ); \
 }
 
-BOOST_BIND_OPERATOR( ==, equal )
-BOOST_BIND_OPERATOR( !=, not_equal )
+NDNBOOST_BIND_OPERATOR( ==, equal )
+NDNBOOST_BIND_OPERATOR( !=, not_equal )
 
-BOOST_BIND_OPERATOR( <, less )
-BOOST_BIND_OPERATOR( <=, less_equal )
+NDNBOOST_BIND_OPERATOR( <, less )
+NDNBOOST_BIND_OPERATOR( <=, less_equal )
 
-BOOST_BIND_OPERATOR( >, greater )
-BOOST_BIND_OPERATOR( >=, greater_equal )
+NDNBOOST_BIND_OPERATOR( >, greater )
+NDNBOOST_BIND_OPERATOR( >=, greater_equal )
 
-BOOST_BIND_OPERATOR( &&, logical_and )
-BOOST_BIND_OPERATOR( ||, logical_or )
+NDNBOOST_BIND_OPERATOR( &&, logical_and )
+NDNBOOST_BIND_OPERATOR( ||, logical_or )
 
-#undef BOOST_BIND_OPERATOR
+#undef NDNBOOST_BIND_OPERATOR
 
-#if defined(__GNUC__) && BOOST_WORKAROUND(__GNUC__, < 3)
+#if defined(__GNUC__) && NDNBOOST_WORKAROUND(__GNUC__, < 3)
 
 // resolve ambiguity with rel_ops
 
-#define BOOST_BIND_OPERATOR( op, name ) \
+#define NDNBOOST_BIND_OPERATOR( op, name ) \
 \
 template<class R, class F, class L> \
     bind_t< bool, name, list2< bind_t<R, F, L>, bind_t<R, F, L> > > \
@@ -1225,22 +1225,22 @@
     return bind_t<bool, name, list_type> ( name(), list_type(f, g) ); \
 }
 
-BOOST_BIND_OPERATOR( !=, not_equal )
-BOOST_BIND_OPERATOR( <=, less_equal )
-BOOST_BIND_OPERATOR( >, greater )
-BOOST_BIND_OPERATOR( >=, greater_equal )
+NDNBOOST_BIND_OPERATOR( !=, not_equal )
+NDNBOOST_BIND_OPERATOR( <=, less_equal )
+NDNBOOST_BIND_OPERATOR( >, greater )
+NDNBOOST_BIND_OPERATOR( >=, greater_equal )
 
 #endif
 
 // visit_each, ADL
 
-#if !defined( BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP ) && !defined( __BORLANDC__ ) \
+#if !defined( NDNBOOST_NO_ARGUMENT_DEPENDENT_LOOKUP ) && !defined( __BORLANDC__ ) \
    && !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
 
 template<class V, class T> void visit_each( V & v, value<T> const & t, int )
 {
     using ndnboost::visit_each;
-    BOOST_BIND_VISIT_EACH( v, t.get(), 0 );
+    NDNBOOST_BIND_VISIT_EACH( v, t.get(), 0 );
 }
 
 template<class V, class R, class F, class L> void visit_each( V & v, bind_t<R, F, L> const & t, int )
@@ -1254,12 +1254,12 @@
 
 // visit_each, no ADL
 
-#if defined( BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP ) || defined( __BORLANDC__ ) \
+#if defined( NDNBOOST_NO_ARGUMENT_DEPENDENT_LOOKUP ) || defined( __BORLANDC__ ) \
   || (defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
 
 template<class V, class T> void visit_each( V & v, _bi::value<T> const & t, int )
 {
-    BOOST_BIND_VISIT_EACH( v, t.get(), 0 );
+    NDNBOOST_BIND_VISIT_EACH( v, t.get(), 0 );
 }
 
 template<class V, class R, class F, class L> void visit_each( V & v, _bi::bind_t<R, F, L> const & t, int )
@@ -1276,7 +1276,7 @@
     enum _vt { value = 0 };
 };
 
-#if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
+#if !defined( NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
 
 template< class R, class F, class L > struct is_bind_expression< _bi::bind_t< R, F, L > >
 {
@@ -1287,15 +1287,15 @@
 
 // bind
 
-#ifndef BOOST_BIND
-#define BOOST_BIND bind
+#ifndef NDNBOOST_BIND
+#define NDNBOOST_BIND bind
 #endif
 
 // generic function objects
 
 template<class R, class F>
     _bi::bind_t<R, F, _bi::list0>
-    BOOST_BIND(F f)
+    NDNBOOST_BIND(F f)
 {
     typedef _bi::list0 list_type;
     return _bi::bind_t<R, F, list_type> (f, list_type());
@@ -1303,7 +1303,7 @@
 
 template<class R, class F, class A1>
     _bi::bind_t<R, F, typename _bi::list_av_1<A1>::type>
-    BOOST_BIND(F f, A1 a1)
+    NDNBOOST_BIND(F f, A1 a1)
 {
     typedef typename _bi::list_av_1<A1>::type list_type;
     return _bi::bind_t<R, F, list_type> (f, list_type(a1));
@@ -1311,7 +1311,7 @@
 
 template<class R, class F, class A1, class A2>
     _bi::bind_t<R, F, typename _bi::list_av_2<A1, A2>::type>
-    BOOST_BIND(F f, A1 a1, A2 a2)
+    NDNBOOST_BIND(F f, A1 a1, A2 a2)
 {
     typedef typename _bi::list_av_2<A1, A2>::type list_type;
     return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
@@ -1319,7 +1319,7 @@
 
 template<class R, class F, class A1, class A2, class A3>
     _bi::bind_t<R, F, typename _bi::list_av_3<A1, A2, A3>::type>
-    BOOST_BIND(F f, A1 a1, A2 a2, A3 a3)
+    NDNBOOST_BIND(F f, A1 a1, A2 a2, A3 a3)
 {
     typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
@@ -1327,7 +1327,7 @@
 
 template<class R, class F, class A1, class A2, class A3, class A4>
     _bi::bind_t<R, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>
-    BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4)
+    NDNBOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4)
 {
     typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
@@ -1335,7 +1335,7 @@
 
 template<class R, class F, class A1, class A2, class A3, class A4, class A5>
     _bi::bind_t<R, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
-    BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+    NDNBOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
 {
     typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
@@ -1343,7 +1343,7 @@
 
 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6>
     _bi::bind_t<R, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
-    BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+    NDNBOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
 {
     typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
@@ -1351,7 +1351,7 @@
 
 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
     _bi::bind_t<R, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
-    BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+    NDNBOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
 {
     typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
@@ -1359,7 +1359,7 @@
 
 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
     _bi::bind_t<R, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
-    BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+    NDNBOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
 {
     typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
@@ -1367,7 +1367,7 @@
 
 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
     _bi::bind_t<R, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
-    BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+    NDNBOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
 {
     typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
@@ -1377,7 +1377,7 @@
 
 template<class R, class F>
     _bi::bind_t<R, F, _bi::list0>
-    BOOST_BIND(ndnboost::type<R>, F f)
+    NDNBOOST_BIND(ndnboost::type<R>, F f)
 {
     typedef _bi::list0 list_type;
     return _bi::bind_t<R, F, list_type> (f, list_type());
@@ -1385,7 +1385,7 @@
 
 template<class R, class F, class A1>
     _bi::bind_t<R, F, typename _bi::list_av_1<A1>::type>
-    BOOST_BIND(ndnboost::type<R>, F f, A1 a1)
+    NDNBOOST_BIND(ndnboost::type<R>, F f, A1 a1)
 {
     typedef typename _bi::list_av_1<A1>::type list_type;
     return _bi::bind_t<R, F, list_type> (f, list_type(a1));
@@ -1393,7 +1393,7 @@
 
 template<class R, class F, class A1, class A2>
     _bi::bind_t<R, F, typename _bi::list_av_2<A1, A2>::type>
-    BOOST_BIND(ndnboost::type<R>, F f, A1 a1, A2 a2)
+    NDNBOOST_BIND(ndnboost::type<R>, F f, A1 a1, A2 a2)
 {
     typedef typename _bi::list_av_2<A1, A2>::type list_type;
     return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
@@ -1401,7 +1401,7 @@
 
 template<class R, class F, class A1, class A2, class A3>
     _bi::bind_t<R, F, typename _bi::list_av_3<A1, A2, A3>::type>
-    BOOST_BIND(ndnboost::type<R>, F f, A1 a1, A2 a2, A3 a3)
+    NDNBOOST_BIND(ndnboost::type<R>, F f, A1 a1, A2 a2, A3 a3)
 {
     typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
@@ -1409,7 +1409,7 @@
 
 template<class R, class F, class A1, class A2, class A3, class A4>
     _bi::bind_t<R, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>
-    BOOST_BIND(ndnboost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4)
+    NDNBOOST_BIND(ndnboost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4)
 {
     typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
@@ -1417,7 +1417,7 @@
 
 template<class R, class F, class A1, class A2, class A3, class A4, class A5>
     _bi::bind_t<R, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
-    BOOST_BIND(ndnboost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+    NDNBOOST_BIND(ndnboost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
 {
     typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
@@ -1425,7 +1425,7 @@
 
 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6>
     _bi::bind_t<R, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
-    BOOST_BIND(ndnboost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+    NDNBOOST_BIND(ndnboost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
 {
     typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
@@ -1433,7 +1433,7 @@
 
 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
     _bi::bind_t<R, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
-    BOOST_BIND(ndnboost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+    NDNBOOST_BIND(ndnboost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
 {
     typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
@@ -1441,7 +1441,7 @@
 
 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
     _bi::bind_t<R, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
-    BOOST_BIND(ndnboost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+    NDNBOOST_BIND(ndnboost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
 {
     typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
@@ -1449,19 +1449,19 @@
 
 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
     _bi::bind_t<R, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
-    BOOST_BIND(ndnboost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+    NDNBOOST_BIND(ndnboost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
 {
     typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
 }
 
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+#if !defined(NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING)
 
 // adaptable function objects
 
 template<class F>
     _bi::bind_t<_bi::unspecified, F, _bi::list0>
-    BOOST_BIND(F f)
+    NDNBOOST_BIND(F f)
 {
     typedef _bi::list0 list_type;
     return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type());
@@ -1469,7 +1469,7 @@
 
 template<class F, class A1>
     _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_1<A1>::type>
-    BOOST_BIND(F f, A1 a1)
+    NDNBOOST_BIND(F f, A1 a1)
 {
     typedef typename _bi::list_av_1<A1>::type list_type;
     return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type(a1));
@@ -1477,7 +1477,7 @@
 
 template<class F, class A1, class A2>
     _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_2<A1, A2>::type>
-    BOOST_BIND(F f, A1 a1, A2 a2)
+    NDNBOOST_BIND(F f, A1 a1, A2 a2)
 {
     typedef typename _bi::list_av_2<A1, A2>::type list_type;
     return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type(a1, a2));
@@ -1485,7 +1485,7 @@
 
 template<class F, class A1, class A2, class A3>
     _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_3<A1, A2, A3>::type>
-    BOOST_BIND(F f, A1 a1, A2 a2, A3 a3)
+    NDNBOOST_BIND(F f, A1 a1, A2 a2, A3 a3)
 {
     typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
     return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3));
@@ -1493,7 +1493,7 @@
 
 template<class F, class A1, class A2, class A3, class A4>
     _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>
-    BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4)
+    NDNBOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4)
 {
     typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
     return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4));
@@ -1501,7 +1501,7 @@
 
 template<class F, class A1, class A2, class A3, class A4, class A5>
     _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
-    BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+    NDNBOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
 {
     typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
     return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
@@ -1509,7 +1509,7 @@
 
 template<class F, class A1, class A2, class A3, class A4, class A5, class A6>
     _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
-    BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+    NDNBOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
 {
     typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
     return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
@@ -1517,7 +1517,7 @@
 
 template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
     _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
-    BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+    NDNBOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
 {
     typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
     return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
@@ -1525,7 +1525,7 @@
 
 template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
     _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
-    BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+    NDNBOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
 {
     typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
     return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
@@ -1533,118 +1533,118 @@
 
 template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
     _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
-    BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+    NDNBOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
 {
     typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
     return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
 }
 
-#endif // !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+#endif // !defined(NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING)
 
 // function pointers
 
-#define BOOST_BIND_CC
-#define BOOST_BIND_ST
+#define NDNBOOST_BIND_CC
+#define NDNBOOST_BIND_ST
 
 #include <ndnboost/bind/bind_cc.hpp>
 
-#undef BOOST_BIND_CC
-#undef BOOST_BIND_ST
+#undef NDNBOOST_BIND_CC
+#undef NDNBOOST_BIND_ST
 
-#ifdef BOOST_BIND_ENABLE_STDCALL
+#ifdef NDNBOOST_BIND_ENABLE_STDCALL
 
-#define BOOST_BIND_CC __stdcall
-#define BOOST_BIND_ST
+#define NDNBOOST_BIND_CC __stdcall
+#define NDNBOOST_BIND_ST
 
 #include <ndnboost/bind/bind_cc.hpp>
 
-#undef BOOST_BIND_CC
-#undef BOOST_BIND_ST
+#undef NDNBOOST_BIND_CC
+#undef NDNBOOST_BIND_ST
 
 #endif
 
-#ifdef BOOST_BIND_ENABLE_FASTCALL
+#ifdef NDNBOOST_BIND_ENABLE_FASTCALL
 
-#define BOOST_BIND_CC __fastcall
-#define BOOST_BIND_ST
+#define NDNBOOST_BIND_CC __fastcall
+#define NDNBOOST_BIND_ST
 
 #include <ndnboost/bind/bind_cc.hpp>
 
-#undef BOOST_BIND_CC
-#undef BOOST_BIND_ST
+#undef NDNBOOST_BIND_CC
+#undef NDNBOOST_BIND_ST
 
 #endif
 
-#ifdef BOOST_BIND_ENABLE_PASCAL
+#ifdef NDNBOOST_BIND_ENABLE_PASCAL
 
-#define BOOST_BIND_ST pascal
-#define BOOST_BIND_CC
+#define NDNBOOST_BIND_ST pascal
+#define NDNBOOST_BIND_CC
 
 #include <ndnboost/bind/bind_cc.hpp>
 
-#undef BOOST_BIND_ST
-#undef BOOST_BIND_CC
+#undef NDNBOOST_BIND_ST
+#undef NDNBOOST_BIND_CC
 
 #endif
 
 // member function pointers
 
-#define BOOST_BIND_MF_NAME(X) X
-#define BOOST_BIND_MF_CC
+#define NDNBOOST_BIND_MF_NAME(X) X
+#define NDNBOOST_BIND_MF_CC
 
 #include <ndnboost/bind/bind_mf_cc.hpp>
 #include <ndnboost/bind/bind_mf2_cc.hpp>
 
-#undef BOOST_BIND_MF_NAME
-#undef BOOST_BIND_MF_CC
+#undef NDNBOOST_BIND_MF_NAME
+#undef NDNBOOST_BIND_MF_CC
 
-#ifdef BOOST_MEM_FN_ENABLE_CDECL
+#ifdef NDNBOOST_MEM_FN_ENABLE_CDECL
 
-#define BOOST_BIND_MF_NAME(X) X##_cdecl
-#define BOOST_BIND_MF_CC __cdecl
+#define NDNBOOST_BIND_MF_NAME(X) X##_cdecl
+#define NDNBOOST_BIND_MF_CC __cdecl
 
 #include <ndnboost/bind/bind_mf_cc.hpp>
 #include <ndnboost/bind/bind_mf2_cc.hpp>
 
-#undef BOOST_BIND_MF_NAME
-#undef BOOST_BIND_MF_CC
+#undef NDNBOOST_BIND_MF_NAME
+#undef NDNBOOST_BIND_MF_CC
 
 #endif
 
-#ifdef BOOST_MEM_FN_ENABLE_STDCALL
+#ifdef NDNBOOST_MEM_FN_ENABLE_STDCALL
 
-#define BOOST_BIND_MF_NAME(X) X##_stdcall
-#define BOOST_BIND_MF_CC __stdcall
+#define NDNBOOST_BIND_MF_NAME(X) X##_stdcall
+#define NDNBOOST_BIND_MF_CC __stdcall
 
 #include <ndnboost/bind/bind_mf_cc.hpp>
 #include <ndnboost/bind/bind_mf2_cc.hpp>
 
-#undef BOOST_BIND_MF_NAME
-#undef BOOST_BIND_MF_CC
+#undef NDNBOOST_BIND_MF_NAME
+#undef NDNBOOST_BIND_MF_CC
 
 #endif
 
-#ifdef BOOST_MEM_FN_ENABLE_FASTCALL
+#ifdef NDNBOOST_MEM_FN_ENABLE_FASTCALL
 
-#define BOOST_BIND_MF_NAME(X) X##_fastcall
-#define BOOST_BIND_MF_CC __fastcall
+#define NDNBOOST_BIND_MF_NAME(X) X##_fastcall
+#define NDNBOOST_BIND_MF_CC __fastcall
 
 #include <ndnboost/bind/bind_mf_cc.hpp>
 #include <ndnboost/bind/bind_mf2_cc.hpp>
 
-#undef BOOST_BIND_MF_NAME
-#undef BOOST_BIND_MF_CC
+#undef NDNBOOST_BIND_MF_NAME
+#undef NDNBOOST_BIND_MF_CC
 
 #endif
 
 // data member pointers
 
-#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
-    || ( defined(__BORLANDC__) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT( 0x620 ) ) )
+#if defined(NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) || defined(NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
+    || ( defined(__BORLANDC__) && NDNBOOST_WORKAROUND( __BORLANDC__, NDNBOOST_TESTED_AT( 0x620 ) ) )
 
 template<class R, class T, class A1>
 _bi::bind_t< R, _mfi::dm<R, T>, typename _bi::list_av_1<A1>::type >
-    BOOST_BIND(R T::*f, A1 a1)
+    NDNBOOST_BIND(R T::*f, A1 a1)
 {
     typedef _mfi::dm<R, T> F;
     typedef typename _bi::list_av_1<A1>::type list_type;
@@ -1665,12 +1665,12 @@
 
 template< class M, class T > struct add_cref< M T::*, 1 >
 {
-#ifdef BOOST_MSVC
+#ifdef NDNBOOST_MSVC
 #pragma warning(push)
 #pragma warning(disable:4180)
 #endif
     typedef M const & type;
-#ifdef BOOST_MSVC
+#ifdef NDNBOOST_MSVC
 #pragma warning(pop)
 #endif
 };
@@ -1725,7 +1725,7 @@
     typename _bi::list_av_1<A1>::type
 >
 
-BOOST_BIND( M T::*f, A1 a1 )
+NDNBOOST_BIND( M T::*f, A1 a1 )
 {
     typedef typename _bi::dm_result< M T::*, A1 >::type result_type;
     typedef _mfi::dm<M, T> F;
@@ -1737,15 +1737,15 @@
 
 } // namespace ndnboost
 
-#ifndef BOOST_BIND_NO_PLACEHOLDERS
+#ifndef NDNBOOST_BIND_NO_PLACEHOLDERS
 
 # include <ndnboost/bind/placeholders.hpp>
 
 #endif
 
-#ifdef BOOST_MSVC
+#ifdef NDNBOOST_MSVC
 # pragma warning(default: 4512) // assignment operator could not be generated
 # pragma warning(pop)
 #endif
 
-#endif // #ifndef BOOST_BIND_BIND_HPP_INCLUDED
+#endif // #ifndef NDNBOOST_BIND_BIND_HPP_INCLUDED
diff --git a/include/ndnboost/bind/bind_cc.hpp b/include/ndnboost/bind/bind_cc.hpp
index 35f8ece..cb95e6a 100644
--- a/include/ndnboost/bind/bind_cc.hpp
+++ b/include/ndnboost/bind/bind_cc.hpp
@@ -13,28 +13,28 @@
 //
 
 template<class R>
-    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (), _bi::list0>
-    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) ())
+    _bi::bind_t<R, NDNBOOST_BIND_ST R (NDNBOOST_BIND_CC *) (), _bi::list0>
+    NDNBOOST_BIND(NDNBOOST_BIND_ST R (NDNBOOST_BIND_CC *f) ())
 {
-    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) ();
+    typedef NDNBOOST_BIND_ST R (NDNBOOST_BIND_CC *F) ();
     typedef _bi::list0 list_type;
     return _bi::bind_t<R, F, list_type> (f, list_type());
 }
 
 template<class R, class B1, class A1>
-    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1), typename _bi::list_av_1<A1>::type>
-    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1), A1 a1)
+    _bi::bind_t<R, NDNBOOST_BIND_ST R (NDNBOOST_BIND_CC *) (B1), typename _bi::list_av_1<A1>::type>
+    NDNBOOST_BIND(NDNBOOST_BIND_ST R (NDNBOOST_BIND_CC *f) (B1), A1 a1)
 {
-    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1);
+    typedef NDNBOOST_BIND_ST R (NDNBOOST_BIND_CC *F) (B1);
     typedef typename _bi::list_av_1<A1>::type list_type;
     return _bi::bind_t<R, F, list_type> (f, list_type(a1));
 }
 
 template<class R, class B1, class B2, class A1, class A2>
-    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1, B2), typename _bi::list_av_2<A1, A2>::type>
-    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2), A1 a1, A2 a2)
+    _bi::bind_t<R, NDNBOOST_BIND_ST R (NDNBOOST_BIND_CC *) (B1, B2), typename _bi::list_av_2<A1, A2>::type>
+    NDNBOOST_BIND(NDNBOOST_BIND_ST R (NDNBOOST_BIND_CC *f) (B1, B2), A1 a1, A2 a2)
 {
-    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2);
+    typedef NDNBOOST_BIND_ST R (NDNBOOST_BIND_CC *F) (B1, B2);
     typedef typename _bi::list_av_2<A1, A2>::type list_type;
     return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
 }
@@ -42,10 +42,10 @@
 template<class R,
     class B1, class B2, class B3,
     class A1, class A2, class A3>
-    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1, B2, B3), typename _bi::list_av_3<A1, A2, A3>::type>
-    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3), A1 a1, A2 a2, A3 a3)
+    _bi::bind_t<R, NDNBOOST_BIND_ST R (NDNBOOST_BIND_CC *) (B1, B2, B3), typename _bi::list_av_3<A1, A2, A3>::type>
+    NDNBOOST_BIND(NDNBOOST_BIND_ST R (NDNBOOST_BIND_CC *f) (B1, B2, B3), A1 a1, A2 a2, A3 a3)
 {
-    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3);
+    typedef NDNBOOST_BIND_ST R (NDNBOOST_BIND_CC *F) (B1, B2, B3);
     typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
 }
@@ -53,10 +53,10 @@
 template<class R,
     class B1, class B2, class B3, class B4,
     class A1, class A2, class A3, class A4>
-    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1, B2, B3, B4), typename _bi::list_av_4<A1, A2, A3, A4>::type>
-    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4)
+    _bi::bind_t<R, NDNBOOST_BIND_ST R (NDNBOOST_BIND_CC *) (B1, B2, B3, B4), typename _bi::list_av_4<A1, A2, A3, A4>::type>
+    NDNBOOST_BIND(NDNBOOST_BIND_ST R (NDNBOOST_BIND_CC *f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4)
 {
-    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4);
+    typedef NDNBOOST_BIND_ST R (NDNBOOST_BIND_CC *F) (B1, B2, B3, B4);
     typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
 }
@@ -64,10 +64,10 @@
 template<class R,
     class B1, class B2, class B3, class B4, class B5,
     class A1, class A2, class A3, class A4, class A5>
-    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1, B2, B3, B4, B5), typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
-    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+    _bi::bind_t<R, NDNBOOST_BIND_ST R (NDNBOOST_BIND_CC *) (B1, B2, B3, B4, B5), typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
+    NDNBOOST_BIND(NDNBOOST_BIND_ST R (NDNBOOST_BIND_CC *f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
 {
-    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5);
+    typedef NDNBOOST_BIND_ST R (NDNBOOST_BIND_CC *F) (B1, B2, B3, B4, B5);
     typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
 }
@@ -75,10 +75,10 @@
 template<class R,
     class B1, class B2, class B3, class B4, class B5, class B6,
     class A1, class A2, class A3, class A4, class A5, class A6>
-    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1, B2, B3, B4, B5, B6), typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
-    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+    _bi::bind_t<R, NDNBOOST_BIND_ST R (NDNBOOST_BIND_CC *) (B1, B2, B3, B4, B5, B6), typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
+    NDNBOOST_BIND(NDNBOOST_BIND_ST R (NDNBOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
 {
-    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6);
+    typedef NDNBOOST_BIND_ST R (NDNBOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6);
     typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
 }
@@ -86,10 +86,10 @@
 template<class R,
     class B1, class B2, class B3, class B4, class B5, class B6, class B7,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1, B2, B3, B4, B5, B6, B7), typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
-    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+    _bi::bind_t<R, NDNBOOST_BIND_ST R (NDNBOOST_BIND_CC *) (B1, B2, B3, B4, B5, B6, B7), typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
+    NDNBOOST_BIND(NDNBOOST_BIND_ST R (NDNBOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
 {
-    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6, B7);
+    typedef NDNBOOST_BIND_ST R (NDNBOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6, B7);
     typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
 }
@@ -97,10 +97,10 @@
 template<class R,
     class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1, B2, B3, B4, B5, B6, B7, B8), typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
-    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+    _bi::bind_t<R, NDNBOOST_BIND_ST R (NDNBOOST_BIND_CC *) (B1, B2, B3, B4, B5, B6, B7, B8), typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
+    NDNBOOST_BIND(NDNBOOST_BIND_ST R (NDNBOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
 {
-    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6, B7, B8);
+    typedef NDNBOOST_BIND_ST R (NDNBOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6, B7, B8);
     typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
 }
@@ -108,10 +108,10 @@
 template<class R,
     class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8, class B9,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1, B2, B3, B4, B5, B6, B7, B8, B9), typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
-    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6, B7, B8, B9), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+    _bi::bind_t<R, NDNBOOST_BIND_ST R (NDNBOOST_BIND_CC *) (B1, B2, B3, B4, B5, B6, B7, B8, B9), typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
+    NDNBOOST_BIND(NDNBOOST_BIND_ST R (NDNBOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6, B7, B8, B9), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
 {
-    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6, B7, B8, B9);
+    typedef NDNBOOST_BIND_ST R (NDNBOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6, B7, B8, B9);
     typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
 }
diff --git a/include/ndnboost/bind/bind_mf2_cc.hpp b/include/ndnboost/bind/bind_mf2_cc.hpp
index efb8b25..563deef 100644
--- a/include/ndnboost/bind/bind_mf2_cc.hpp
+++ b/include/ndnboost/bind/bind_mf2_cc.hpp
@@ -17,20 +17,20 @@
 
 template<class Rt2, class R, class T,
     class A1>
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf0)<R, T>, typename _bi::list_av_1<A1>::type>
-    BOOST_BIND(ndnboost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (), A1 a1)
+    _bi::bind_t<Rt2, _mfi::NDNBOOST_BIND_MF_NAME(mf0)<R, T>, typename _bi::list_av_1<A1>::type>
+    NDNBOOST_BIND(ndnboost::type<Rt2>, R (NDNBOOST_BIND_MF_CC T::*f) (), A1 a1)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf0)<R, T> F;
+    typedef _mfi::NDNBOOST_BIND_MF_NAME(mf0)<R, T> F;
     typedef typename _bi::list_av_1<A1>::type list_type;
     return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1));
 }
 
 template<class Rt2, class R, class T,
     class A1>
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf0)<R, T>, typename _bi::list_av_1<A1>::type>
-    BOOST_BIND(ndnboost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) () const, A1 a1)
+    _bi::bind_t<Rt2, _mfi::NDNBOOST_BIND_MF_NAME(cmf0)<R, T>, typename _bi::list_av_1<A1>::type>
+    NDNBOOST_BIND(ndnboost::type<Rt2>, R (NDNBOOST_BIND_MF_CC T::*f) () const, A1 a1)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf0)<R, T> F;
+    typedef _mfi::NDNBOOST_BIND_MF_NAME(cmf0)<R, T> F;
     typedef typename _bi::list_av_1<A1>::type list_type;
     return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1));
 }
@@ -40,10 +40,10 @@
 template<class Rt2, class R, class T,
     class B1,
     class A1, class A2>
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf1)<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
-    BOOST_BIND(ndnboost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1), A1 a1, A2 a2)
+    _bi::bind_t<Rt2, _mfi::NDNBOOST_BIND_MF_NAME(mf1)<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
+    NDNBOOST_BIND(ndnboost::type<Rt2>, R (NDNBOOST_BIND_MF_CC T::*f) (B1), A1 a1, A2 a2)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf1)<R, T, B1> F;
+    typedef _mfi::NDNBOOST_BIND_MF_NAME(mf1)<R, T, B1> F;
     typedef typename _bi::list_av_2<A1, A2>::type list_type;
     return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2));
 }
@@ -51,10 +51,10 @@
 template<class Rt2, class R, class T,
     class B1,
     class A1, class A2>
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf1)<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
-    BOOST_BIND(ndnboost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1) const, A1 a1, A2 a2)
+    _bi::bind_t<Rt2, _mfi::NDNBOOST_BIND_MF_NAME(cmf1)<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
+    NDNBOOST_BIND(ndnboost::type<Rt2>, R (NDNBOOST_BIND_MF_CC T::*f) (B1) const, A1 a1, A2 a2)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf1)<R, T, B1> F;
+    typedef _mfi::NDNBOOST_BIND_MF_NAME(cmf1)<R, T, B1> F;
     typedef typename _bi::list_av_2<A1, A2>::type list_type;
     return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2));
 }
@@ -64,10 +64,10 @@
 template<class Rt2, class R, class T,
     class B1, class B2,
     class A1, class A2, class A3>
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf2)<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
-    BOOST_BIND(ndnboost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2), A1 a1, A2 a2, A3 a3)
+    _bi::bind_t<Rt2, _mfi::NDNBOOST_BIND_MF_NAME(mf2)<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
+    NDNBOOST_BIND(ndnboost::type<Rt2>, R (NDNBOOST_BIND_MF_CC T::*f) (B1, B2), A1 a1, A2 a2, A3 a3)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf2)<R, T, B1, B2> F;
+    typedef _mfi::NDNBOOST_BIND_MF_NAME(mf2)<R, T, B1, B2> F;
     typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
     return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3));
 }
@@ -75,10 +75,10 @@
 template<class Rt2, class R, class T,
     class B1, class B2,
     class A1, class A2, class A3>
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf2)<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
-    BOOST_BIND(ndnboost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2) const, A1 a1, A2 a2, A3 a3)
+    _bi::bind_t<Rt2, _mfi::NDNBOOST_BIND_MF_NAME(cmf2)<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
+    NDNBOOST_BIND(ndnboost::type<Rt2>, R (NDNBOOST_BIND_MF_CC T::*f) (B1, B2) const, A1 a1, A2 a2, A3 a3)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf2)<R, T, B1, B2> F;
+    typedef _mfi::NDNBOOST_BIND_MF_NAME(cmf2)<R, T, B1, B2> F;
     typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
     return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3));
 }
@@ -88,10 +88,10 @@
 template<class Rt2, class R, class T,
     class B1, class B2, class B3,
     class A1, class A2, class A3, class A4>
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf3)<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
-    BOOST_BIND(ndnboost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3), A1 a1, A2 a2, A3 a3, A4 a4)
+    _bi::bind_t<Rt2, _mfi::NDNBOOST_BIND_MF_NAME(mf3)<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
+    NDNBOOST_BIND(ndnboost::type<Rt2>, R (NDNBOOST_BIND_MF_CC T::*f) (B1, B2, B3), A1 a1, A2 a2, A3 a3, A4 a4)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf3)<R, T, B1, B2, B3> F;
+    typedef _mfi::NDNBOOST_BIND_MF_NAME(mf3)<R, T, B1, B2, B3> F;
     typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
     return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
 }
@@ -99,10 +99,10 @@
 template<class Rt2, class R, class T,
     class B1, class B2, class B3,
     class A1, class A2, class A3, class A4>
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf3)<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
-    BOOST_BIND(ndnboost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3) const, A1 a1, A2 a2, A3 a3, A4 a4)
+    _bi::bind_t<Rt2, _mfi::NDNBOOST_BIND_MF_NAME(cmf3)<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
+    NDNBOOST_BIND(ndnboost::type<Rt2>, R (NDNBOOST_BIND_MF_CC T::*f) (B1, B2, B3) const, A1 a1, A2 a2, A3 a3, A4 a4)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf3)<R, T, B1, B2, B3> F;
+    typedef _mfi::NDNBOOST_BIND_MF_NAME(cmf3)<R, T, B1, B2, B3> F;
     typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
     return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
 }
@@ -112,10 +112,10 @@
 template<class Rt2, class R, class T,
     class B1, class B2, class B3, class B4,
     class A1, class A2, class A3, class A4, class A5>
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf4)<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
-    BOOST_BIND(ndnboost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+    _bi::bind_t<Rt2, _mfi::NDNBOOST_BIND_MF_NAME(mf4)<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
+    NDNBOOST_BIND(ndnboost::type<Rt2>, R (NDNBOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf4)<R, T, B1, B2, B3, B4> F;
+    typedef _mfi::NDNBOOST_BIND_MF_NAME(mf4)<R, T, B1, B2, B3, B4> F;
     typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
     return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
 }
@@ -123,10 +123,10 @@
 template<class Rt2, class R, class T,
     class B1, class B2, class B3, class B4,
     class A1, class A2, class A3, class A4, class A5>
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf4)<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
-    BOOST_BIND(ndnboost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+    _bi::bind_t<Rt2, _mfi::NDNBOOST_BIND_MF_NAME(cmf4)<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
+    NDNBOOST_BIND(ndnboost::type<Rt2>, R (NDNBOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf4)<R, T, B1, B2, B3, B4> F;
+    typedef _mfi::NDNBOOST_BIND_MF_NAME(cmf4)<R, T, B1, B2, B3, B4> F;
     typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
     return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
 }
@@ -136,10 +136,10 @@
 template<class Rt2, class R, class T,
     class B1, class B2, class B3, class B4, class B5,
     class A1, class A2, class A3, class A4, class A5, class A6>
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf5)<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
-    BOOST_BIND(ndnboost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+    _bi::bind_t<Rt2, _mfi::NDNBOOST_BIND_MF_NAME(mf5)<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
+    NDNBOOST_BIND(ndnboost::type<Rt2>, R (NDNBOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf5)<R, T, B1, B2, B3, B4, B5> F;
+    typedef _mfi::NDNBOOST_BIND_MF_NAME(mf5)<R, T, B1, B2, B3, B4, B5> F;
     typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
     return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
 }
@@ -147,10 +147,10 @@
 template<class Rt2, class R, class T,
     class B1, class B2, class B3, class B4, class B5,
     class A1, class A2, class A3, class A4, class A5, class A6>
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf5)<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
-    BOOST_BIND(ndnboost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+    _bi::bind_t<Rt2, _mfi::NDNBOOST_BIND_MF_NAME(cmf5)<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
+    NDNBOOST_BIND(ndnboost::type<Rt2>, R (NDNBOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf5)<R, T, B1, B2, B3, B4, B5> F;
+    typedef _mfi::NDNBOOST_BIND_MF_NAME(cmf5)<R, T, B1, B2, B3, B4, B5> F;
     typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
     return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
 }
@@ -160,10 +160,10 @@
 template<class Rt2, class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf6)<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
-    BOOST_BIND(ndnboost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+    _bi::bind_t<Rt2, _mfi::NDNBOOST_BIND_MF_NAME(mf6)<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
+    NDNBOOST_BIND(ndnboost::type<Rt2>, R (NDNBOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf6)<R, T, B1, B2, B3, B4, B5, B6> F;
+    typedef _mfi::NDNBOOST_BIND_MF_NAME(mf6)<R, T, B1, B2, B3, B4, B5, B6> F;
     typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
     return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
 }
@@ -171,10 +171,10 @@
 template<class Rt2, class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf6)<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
-    BOOST_BIND(ndnboost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+    _bi::bind_t<Rt2, _mfi::NDNBOOST_BIND_MF_NAME(cmf6)<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
+    NDNBOOST_BIND(ndnboost::type<Rt2>, R (NDNBOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf6)<R, T, B1, B2, B3, B4, B5, B6> F;
+    typedef _mfi::NDNBOOST_BIND_MF_NAME(cmf6)<R, T, B1, B2, B3, B4, B5, B6> F;
     typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
     return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
 }
@@ -184,10 +184,10 @@
 template<class Rt2, class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6, class B7,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf7)<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
-    BOOST_BIND(ndnboost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+    _bi::bind_t<Rt2, _mfi::NDNBOOST_BIND_MF_NAME(mf7)<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
+    NDNBOOST_BIND(ndnboost::type<Rt2>, R (NDNBOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf7)<R, T, B1, B2, B3, B4, B5, B6, B7> F;
+    typedef _mfi::NDNBOOST_BIND_MF_NAME(mf7)<R, T, B1, B2, B3, B4, B5, B6, B7> F;
     typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
     return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
 }
@@ -195,10 +195,10 @@
 template<class Rt2, class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6, class B7,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf7)<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
-    BOOST_BIND(ndnboost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+    _bi::bind_t<Rt2, _mfi::NDNBOOST_BIND_MF_NAME(cmf7)<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
+    NDNBOOST_BIND(ndnboost::type<Rt2>, R (NDNBOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf7)<R, T, B1, B2, B3, B4, B5, B6, B7> F;
+    typedef _mfi::NDNBOOST_BIND_MF_NAME(cmf7)<R, T, B1, B2, B3, B4, B5, B6, B7> F;
     typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
     return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
 }
@@ -208,10 +208,10 @@
 template<class Rt2, class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
-    BOOST_BIND(ndnboost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+    _bi::bind_t<Rt2, _mfi::NDNBOOST_BIND_MF_NAME(mf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
+    NDNBOOST_BIND(ndnboost::type<Rt2>, R (NDNBOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
+    typedef _mfi::NDNBOOST_BIND_MF_NAME(mf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
     typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
     return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
 }
@@ -219,10 +219,10 @@
 template<class Rt2, class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
-    BOOST_BIND(ndnboost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+    _bi::bind_t<Rt2, _mfi::NDNBOOST_BIND_MF_NAME(cmf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
+    NDNBOOST_BIND(ndnboost::type<Rt2>, R (NDNBOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
+    typedef _mfi::NDNBOOST_BIND_MF_NAME(cmf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
     typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
     return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
 }
diff --git a/include/ndnboost/bind/bind_mf_cc.hpp b/include/ndnboost/bind/bind_mf_cc.hpp
index 88be822..34108e7 100644
--- a/include/ndnboost/bind/bind_mf_cc.hpp
+++ b/include/ndnboost/bind/bind_mf_cc.hpp
@@ -16,20 +16,20 @@
 
 template<class R, class T,
     class A1>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf0)<R, T>, typename _bi::list_av_1<A1>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (), A1 a1)
+    _bi::bind_t<R, _mfi::NDNBOOST_BIND_MF_NAME(mf0)<R, T>, typename _bi::list_av_1<A1>::type>
+    NDNBOOST_BIND(R (NDNBOOST_BIND_MF_CC T::*f) (), A1 a1)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf0)<R, T> F;
+    typedef _mfi::NDNBOOST_BIND_MF_NAME(mf0)<R, T> F;
     typedef typename _bi::list_av_1<A1>::type list_type;
     return _bi::bind_t<R, F, list_type>(F(f), list_type(a1));
 }
 
 template<class R, class T,
     class A1>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf0)<R, T>, typename _bi::list_av_1<A1>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) () const, A1 a1)
+    _bi::bind_t<R, _mfi::NDNBOOST_BIND_MF_NAME(cmf0)<R, T>, typename _bi::list_av_1<A1>::type>
+    NDNBOOST_BIND(R (NDNBOOST_BIND_MF_CC T::*f) () const, A1 a1)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf0)<R, T> F;
+    typedef _mfi::NDNBOOST_BIND_MF_NAME(cmf0)<R, T> F;
     typedef typename _bi::list_av_1<A1>::type list_type;
     return _bi::bind_t<R, F, list_type>(F(f), list_type(a1));
 }
@@ -39,10 +39,10 @@
 template<class R, class T,
     class B1,
     class A1, class A2>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf1)<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1), A1 a1, A2 a2)
+    _bi::bind_t<R, _mfi::NDNBOOST_BIND_MF_NAME(mf1)<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
+    NDNBOOST_BIND(R (NDNBOOST_BIND_MF_CC T::*f) (B1), A1 a1, A2 a2)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf1)<R, T, B1> F;
+    typedef _mfi::NDNBOOST_BIND_MF_NAME(mf1)<R, T, B1> F;
     typedef typename _bi::list_av_2<A1, A2>::type list_type;
     return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2));
 }
@@ -50,10 +50,10 @@
 template<class R, class T,
     class B1,
     class A1, class A2>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf1)<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1) const, A1 a1, A2 a2)
+    _bi::bind_t<R, _mfi::NDNBOOST_BIND_MF_NAME(cmf1)<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
+    NDNBOOST_BIND(R (NDNBOOST_BIND_MF_CC T::*f) (B1) const, A1 a1, A2 a2)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf1)<R, T, B1> F;
+    typedef _mfi::NDNBOOST_BIND_MF_NAME(cmf1)<R, T, B1> F;
     typedef typename _bi::list_av_2<A1, A2>::type list_type;
     return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2));
 }
@@ -63,10 +63,10 @@
 template<class R, class T,
     class B1, class B2,
     class A1, class A2, class A3>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf2)<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2), A1 a1, A2 a2, A3 a3)
+    _bi::bind_t<R, _mfi::NDNBOOST_BIND_MF_NAME(mf2)<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
+    NDNBOOST_BIND(R (NDNBOOST_BIND_MF_CC T::*f) (B1, B2), A1 a1, A2 a2, A3 a3)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf2)<R, T, B1, B2> F;
+    typedef _mfi::NDNBOOST_BIND_MF_NAME(mf2)<R, T, B1, B2> F;
     typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
     return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3));
 }
@@ -74,10 +74,10 @@
 template<class R, class T,
     class B1, class B2,
     class A1, class A2, class A3>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf2)<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2) const, A1 a1, A2 a2, A3 a3)
+    _bi::bind_t<R, _mfi::NDNBOOST_BIND_MF_NAME(cmf2)<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
+    NDNBOOST_BIND(R (NDNBOOST_BIND_MF_CC T::*f) (B1, B2) const, A1 a1, A2 a2, A3 a3)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf2)<R, T, B1, B2> F;
+    typedef _mfi::NDNBOOST_BIND_MF_NAME(cmf2)<R, T, B1, B2> F;
     typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
     return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3));
 }
@@ -87,10 +87,10 @@
 template<class R, class T,
     class B1, class B2, class B3,
     class A1, class A2, class A3, class A4>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf3)<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3), A1 a1, A2 a2, A3 a3, A4 a4)
+    _bi::bind_t<R, _mfi::NDNBOOST_BIND_MF_NAME(mf3)<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
+    NDNBOOST_BIND(R (NDNBOOST_BIND_MF_CC T::*f) (B1, B2, B3), A1 a1, A2 a2, A3 a3, A4 a4)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf3)<R, T, B1, B2, B3> F;
+    typedef _mfi::NDNBOOST_BIND_MF_NAME(mf3)<R, T, B1, B2, B3> F;
     typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
     return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4));
 }
@@ -98,10 +98,10 @@
 template<class R, class T,
     class B1, class B2, class B3,
     class A1, class A2, class A3, class A4>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf3)<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3) const, A1 a1, A2 a2, A3 a3, A4 a4)
+    _bi::bind_t<R, _mfi::NDNBOOST_BIND_MF_NAME(cmf3)<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
+    NDNBOOST_BIND(R (NDNBOOST_BIND_MF_CC T::*f) (B1, B2, B3) const, A1 a1, A2 a2, A3 a3, A4 a4)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf3)<R, T, B1, B2, B3> F;
+    typedef _mfi::NDNBOOST_BIND_MF_NAME(cmf3)<R, T, B1, B2, B3> F;
     typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
     return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4));
 }
@@ -111,10 +111,10 @@
 template<class R, class T,
     class B1, class B2, class B3, class B4,
     class A1, class A2, class A3, class A4, class A5>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf4)<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+    _bi::bind_t<R, _mfi::NDNBOOST_BIND_MF_NAME(mf4)<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
+    NDNBOOST_BIND(R (NDNBOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf4)<R, T, B1, B2, B3, B4> F;
+    typedef _mfi::NDNBOOST_BIND_MF_NAME(mf4)<R, T, B1, B2, B3, B4> F;
     typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
     return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
 }
@@ -122,10 +122,10 @@
 template<class R, class T,
     class B1, class B2, class B3, class B4,
     class A1, class A2, class A3, class A4, class A5>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf4)<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+    _bi::bind_t<R, _mfi::NDNBOOST_BIND_MF_NAME(cmf4)<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
+    NDNBOOST_BIND(R (NDNBOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf4)<R, T, B1, B2, B3, B4> F;
+    typedef _mfi::NDNBOOST_BIND_MF_NAME(cmf4)<R, T, B1, B2, B3, B4> F;
     typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
     return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
 }
@@ -135,10 +135,10 @@
 template<class R, class T,
     class B1, class B2, class B3, class B4, class B5,
     class A1, class A2, class A3, class A4, class A5, class A6>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf5)<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+    _bi::bind_t<R, _mfi::NDNBOOST_BIND_MF_NAME(mf5)<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
+    NDNBOOST_BIND(R (NDNBOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf5)<R, T, B1, B2, B3, B4, B5> F;
+    typedef _mfi::NDNBOOST_BIND_MF_NAME(mf5)<R, T, B1, B2, B3, B4, B5> F;
     typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
     return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
 }
@@ -146,10 +146,10 @@
 template<class R, class T,
     class B1, class B2, class B3, class B4, class B5,
     class A1, class A2, class A3, class A4, class A5, class A6>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf5)<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+    _bi::bind_t<R, _mfi::NDNBOOST_BIND_MF_NAME(cmf5)<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
+    NDNBOOST_BIND(R (NDNBOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf5)<R, T, B1, B2, B3, B4, B5> F;
+    typedef _mfi::NDNBOOST_BIND_MF_NAME(cmf5)<R, T, B1, B2, B3, B4, B5> F;
     typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
     return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
 }
@@ -159,10 +159,10 @@
 template<class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf6)<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+    _bi::bind_t<R, _mfi::NDNBOOST_BIND_MF_NAME(mf6)<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
+    NDNBOOST_BIND(R (NDNBOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf6)<R, T, B1, B2, B3, B4, B5, B6> F;
+    typedef _mfi::NDNBOOST_BIND_MF_NAME(mf6)<R, T, B1, B2, B3, B4, B5, B6> F;
     typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
     return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
 }
@@ -170,10 +170,10 @@
 template<class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf6)<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+    _bi::bind_t<R, _mfi::NDNBOOST_BIND_MF_NAME(cmf6)<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
+    NDNBOOST_BIND(R (NDNBOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf6)<R, T, B1, B2, B3, B4, B5, B6> F;
+    typedef _mfi::NDNBOOST_BIND_MF_NAME(cmf6)<R, T, B1, B2, B3, B4, B5, B6> F;
     typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
     return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
 }
@@ -183,10 +183,10 @@
 template<class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6, class B7,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf7)<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+    _bi::bind_t<R, _mfi::NDNBOOST_BIND_MF_NAME(mf7)<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
+    NDNBOOST_BIND(R (NDNBOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf7)<R, T, B1, B2, B3, B4, B5, B6, B7> F;
+    typedef _mfi::NDNBOOST_BIND_MF_NAME(mf7)<R, T, B1, B2, B3, B4, B5, B6, B7> F;
     typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
     return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
 }
@@ -194,10 +194,10 @@
 template<class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6, class B7,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf7)<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+    _bi::bind_t<R, _mfi::NDNBOOST_BIND_MF_NAME(cmf7)<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
+    NDNBOOST_BIND(R (NDNBOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf7)<R, T, B1, B2, B3, B4, B5, B6, B7> F;
+    typedef _mfi::NDNBOOST_BIND_MF_NAME(cmf7)<R, T, B1, B2, B3, B4, B5, B6, B7> F;
     typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
     return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
 }
@@ -207,10 +207,10 @@
 template<class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+    _bi::bind_t<R, _mfi::NDNBOOST_BIND_MF_NAME(mf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
+    NDNBOOST_BIND(R (NDNBOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
+    typedef _mfi::NDNBOOST_BIND_MF_NAME(mf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
     typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
     return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
 }
@@ -218,10 +218,10 @@
 template<class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+    _bi::bind_t<R, _mfi::NDNBOOST_BIND_MF_NAME(cmf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
+    NDNBOOST_BIND(R (NDNBOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
+    typedef _mfi::NDNBOOST_BIND_MF_NAME(cmf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
     typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
     return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
 }
diff --git a/include/ndnboost/bind/bind_template.hpp b/include/ndnboost/bind/bind_template.hpp
index 6946aa9..f3037ec 100644
--- a/include/ndnboost/bind/bind_template.hpp
+++ b/include/ndnboost/bind/bind_template.hpp
@@ -17,40 +17,40 @@
     result_type operator()()
     {
         list0 a;
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
     result_type operator()() const
     {
         list0 a;
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
     template<class A1> result_type operator()(A1 & a1)
     {
         list1<A1 &> a(a1);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
     template<class A1> result_type operator()(A1 & a1) const
     {
         list1<A1 &> a(a1);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
- && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
+#if !defined(NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
+ && !NDNBOOST_WORKAROUND(__EDG_VERSION__, <= 238)
 
     template<class A1> result_type operator()(A1 const & a1)
     {
         list1<A1 const &> a(a1);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
     template<class A1> result_type operator()(A1 const & a1) const
     {
         list1<A1 const &> a(a1);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
 #endif
@@ -58,54 +58,54 @@
     template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2)
     {
         list2<A1 &, A2 &> a(a1, a2);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
     template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2) const
     {
         list2<A1 &, A2 &> a(a1, a2);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
- && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
+#if !defined(NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
+ && !NDNBOOST_WORKAROUND(__EDG_VERSION__, <= 238)
 
     template<class A1, class A2> result_type operator()(A1 const & a1, A2 & a2)
     {
         list2<A1 const &, A2 &> a(a1, a2);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
     template<class A1, class A2> result_type operator()(A1 const & a1, A2 & a2) const
     {
         list2<A1 const &, A2 &> a(a1, a2);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
 
     template<class A1, class A2> result_type operator()(A1 & a1, A2 const & a2)
     {
         list2<A1 &, A2 const &> a(a1, a2);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
     template<class A1, class A2> result_type operator()(A1 & a1, A2 const & a2) const
     {
         list2<A1 &, A2 const &> a(a1, a2);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
 
     template<class A1, class A2> result_type operator()(A1 const & a1, A2 const & a2)
     {
         list2<A1 const &, A2 const &> a(a1, a2);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
     template<class A1, class A2> result_type operator()(A1 const & a1, A2 const & a2) const
     {
         list2<A1 const &, A2 const &> a(a1, a2);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
 #endif
@@ -113,28 +113,28 @@
     template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3)
     {
         list3<A1 &, A2 &, A3 &> a(a1, a2, a3);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
     template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3) const
     {
         list3<A1 &, A2 &, A3 &> a(a1, a2, a3);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
- && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
+#if !defined(NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
+ && !NDNBOOST_WORKAROUND(__EDG_VERSION__, <= 238)
 
     template<class A1, class A2, class A3> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3)
     {
         list3<A1 const &, A2 const &, A3 const &> a(a1, a2, a3);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
     template<class A1, class A2, class A3> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3) const
     {
         list3<A1 const &, A2 const &, A3 const &> a(a1, a2, a3);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
 #endif
@@ -142,28 +142,28 @@
     template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4)
     {
         list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
     template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4) const
     {
         list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
- && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
+#if !defined(NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
+ && !NDNBOOST_WORKAROUND(__EDG_VERSION__, <= 238)
 
     template<class A1, class A2, class A3, class A4> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4)
     {
         list4<A1 const &, A2 const &, A3 const &, A4 const &> a(a1, a2, a3, a4);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
     template<class A1, class A2, class A3, class A4> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4) const
     {
         list4<A1 const &, A2 const &, A3 const &, A4 const &> a(a1, a2, a3, a4);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
 #endif
@@ -171,28 +171,28 @@
     template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5)
     {
         list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
     template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5) const
     {
         list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
- && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
+#if !defined(NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
+ && !NDNBOOST_WORKAROUND(__EDG_VERSION__, <= 238)
 
     template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5)
     {
         list5<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &> a(a1, a2, a3, a4, a5);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
     template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5) const
     {
         list5<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &> a(a1, a2, a3, a4, a5);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
 #endif
@@ -200,28 +200,28 @@
     template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6)
     {
         list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
     template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6) const
     {
         list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
- && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
+#if !defined(NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
+ && !NDNBOOST_WORKAROUND(__EDG_VERSION__, <= 238)
 
     template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6)
     {
         list6<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &> a(a1, a2, a3, a4, a5, a6);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
     template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6) const
     {
         list6<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &> a(a1, a2, a3, a4, a5, a6);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
 #endif
@@ -229,28 +229,28 @@
     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7)
     {
         list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7) const
     {
         list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
- && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
+#if !defined(NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
+ && !NDNBOOST_WORKAROUND(__EDG_VERSION__, <= 238)
 
     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7)
     {
         list7<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &> a(a1, a2, a3, a4, a5, a6, a7);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7) const
     {
         list7<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &> a(a1, a2, a3, a4, a5, a6, a7);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
 #endif
@@ -258,28 +258,28 @@
     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8)
     {
         list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8) const
     {
         list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
- && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
+#if !defined(NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
+ && !NDNBOOST_WORKAROUND(__EDG_VERSION__, <= 238)
 
     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8)
     {
         list8<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &> a(a1, a2, a3, a4, a5, a6, a7, a8);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8) const
     {
         list8<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &> a(a1, a2, a3, a4, a5, a6, a7, a8);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
 #endif
@@ -287,50 +287,50 @@
     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9)
     {
         list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9) const
     {
         list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
- && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
+#if !defined(NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
+ && !NDNBOOST_WORKAROUND(__EDG_VERSION__, <= 238)
 
     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9)
     {
         list9<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &, A9 const &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9) const
     {
         list9<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &, A9 const &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
 #endif
 
     template<class A> result_type eval(A & a)
     {
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
     template<class A> result_type eval(A & a) const
     {
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        NDNBOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
 
     template<class V> void accept(V & v) const
     {
-#if !defined( BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP ) && !defined( __BORLANDC__ )
+#if !defined( NDNBOOST_NO_ARGUMENT_DEPENDENT_LOOKUP ) && !defined( __BORLANDC__ )
 
         using ndnboost::visit_each;
 
 #endif
-        BOOST_BIND_VISIT_EACH(v, f_, 0);
+        NDNBOOST_BIND_VISIT_EACH(v, f_, 0);
         l_.accept(v);
     }
 
diff --git a/include/ndnboost/bind/make_adaptable.hpp b/include/ndnboost/bind/make_adaptable.hpp
index 77742f0..619eddd 100644
--- a/include/ndnboost/bind/make_adaptable.hpp
+++ b/include/ndnboost/bind/make_adaptable.hpp
@@ -1,5 +1,5 @@
-#ifndef BOOST_BIND_MAKE_ADAPTABLE_HPP_INCLUDED
-#define BOOST_BIND_MAKE_ADAPTABLE_HPP_INCLUDED
+#ifndef NDNBOOST_BIND_MAKE_ADAPTABLE_HPP_INCLUDED
+#define NDNBOOST_BIND_MAKE_ADAPTABLE_HPP_INCLUDED
 
 //
 //  make_adaptable.hpp
@@ -184,4 +184,4 @@
 
 } // namespace ndnboost
 
-#endif // #ifndef BOOST_BIND_MAKE_ADAPTABLE_HPP_INCLUDED
+#endif // #ifndef NDNBOOST_BIND_MAKE_ADAPTABLE_HPP_INCLUDED
diff --git a/include/ndnboost/bind/mem_fn.hpp b/include/ndnboost/bind/mem_fn.hpp
index 7c07d4f..b2a915e 100644
--- a/include/ndnboost/bind/mem_fn.hpp
+++ b/include/ndnboost/bind/mem_fn.hpp
@@ -1,5 +1,5 @@
-#ifndef BOOST_BIND_MEM_FN_HPP_INCLUDED
-#define BOOST_BIND_MEM_FN_HPP_INCLUDED
+#ifndef NDNBOOST_BIND_MEM_FN_HPP_INCLUDED
+#define NDNBOOST_BIND_MEM_FN_HPP_INCLUDED
 
 // MS compatible compilers support #pragma once
 
@@ -28,10 +28,10 @@
 namespace ndnboost
 {
 
-#if defined(BOOST_NO_VOID_RETURNS)
+#if defined(NDNBOOST_NO_VOID_RETURNS)
 
-#define BOOST_MEM_FN_CLASS_F , class F
-#define BOOST_MEM_FN_TYPEDEF(X)
+#define NDNBOOST_MEM_FN_CLASS_F , class F
+#define NDNBOOST_MEM_FN_TYPEDEF(X)
 
 namespace _mfi // mem_fun_impl
 {
@@ -39,270 +39,270 @@
 template<class V> struct mf
 {
 
-#define BOOST_MEM_FN_RETURN return
+#define NDNBOOST_MEM_FN_RETURN return
 
-#define BOOST_MEM_FN_NAME(X) inner_##X
-#define BOOST_MEM_FN_CC
+#define NDNBOOST_MEM_FN_NAME(X) inner_##X
+#define NDNBOOST_MEM_FN_CC
 
 #include <ndnboost/bind/mem_fn_template.hpp>
 
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
+#undef NDNBOOST_MEM_FN_CC
+#undef NDNBOOST_MEM_FN_NAME
 
-#ifdef BOOST_MEM_FN_ENABLE_CDECL
+#ifdef NDNBOOST_MEM_FN_ENABLE_CDECL
 
-#define BOOST_MEM_FN_NAME(X) inner_##X##_cdecl
-#define BOOST_MEM_FN_CC __cdecl
+#define NDNBOOST_MEM_FN_NAME(X) inner_##X##_cdecl
+#define NDNBOOST_MEM_FN_CC __cdecl
 
 #include <ndnboost/bind/mem_fn_template.hpp>
 
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
+#undef NDNBOOST_MEM_FN_CC
+#undef NDNBOOST_MEM_FN_NAME
 
 #endif
 
-#ifdef BOOST_MEM_FN_ENABLE_STDCALL
+#ifdef NDNBOOST_MEM_FN_ENABLE_STDCALL
 
-#define BOOST_MEM_FN_NAME(X) inner_##X##_stdcall
-#define BOOST_MEM_FN_CC __stdcall
+#define NDNBOOST_MEM_FN_NAME(X) inner_##X##_stdcall
+#define NDNBOOST_MEM_FN_CC __stdcall
 
 #include <ndnboost/bind/mem_fn_template.hpp>
 
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
+#undef NDNBOOST_MEM_FN_CC
+#undef NDNBOOST_MEM_FN_NAME
 
 #endif
 
-#ifdef BOOST_MEM_FN_ENABLE_FASTCALL
+#ifdef NDNBOOST_MEM_FN_ENABLE_FASTCALL
 
-#define BOOST_MEM_FN_NAME(X) inner_##X##_fastcall
-#define BOOST_MEM_FN_CC __fastcall
+#define NDNBOOST_MEM_FN_NAME(X) inner_##X##_fastcall
+#define NDNBOOST_MEM_FN_CC __fastcall
 
 #include <ndnboost/bind/mem_fn_template.hpp>
 
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
+#undef NDNBOOST_MEM_FN_CC
+#undef NDNBOOST_MEM_FN_NAME
 
 #endif
 
-#undef BOOST_MEM_FN_RETURN
+#undef NDNBOOST_MEM_FN_RETURN
 
 }; // struct mf<V>
 
 template<> struct mf<void>
 {
 
-#define BOOST_MEM_FN_RETURN
+#define NDNBOOST_MEM_FN_RETURN
 
-#define BOOST_MEM_FN_NAME(X) inner_##X
-#define BOOST_MEM_FN_CC
+#define NDNBOOST_MEM_FN_NAME(X) inner_##X
+#define NDNBOOST_MEM_FN_CC
 
 #include <ndnboost/bind/mem_fn_template.hpp>
 
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
+#undef NDNBOOST_MEM_FN_CC
+#undef NDNBOOST_MEM_FN_NAME
 
-#ifdef BOOST_MEM_FN_ENABLE_CDECL
+#ifdef NDNBOOST_MEM_FN_ENABLE_CDECL
 
-#define BOOST_MEM_FN_NAME(X) inner_##X##_cdecl
-#define BOOST_MEM_FN_CC __cdecl
+#define NDNBOOST_MEM_FN_NAME(X) inner_##X##_cdecl
+#define NDNBOOST_MEM_FN_CC __cdecl
 
 #include <ndnboost/bind/mem_fn_template.hpp>
 
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
+#undef NDNBOOST_MEM_FN_CC
+#undef NDNBOOST_MEM_FN_NAME
 
 #endif
 
-#ifdef BOOST_MEM_FN_ENABLE_STDCALL
+#ifdef NDNBOOST_MEM_FN_ENABLE_STDCALL
 
-#define BOOST_MEM_FN_NAME(X) inner_##X##_stdcall
-#define BOOST_MEM_FN_CC __stdcall
+#define NDNBOOST_MEM_FN_NAME(X) inner_##X##_stdcall
+#define NDNBOOST_MEM_FN_CC __stdcall
 
 #include <ndnboost/bind/mem_fn_template.hpp>
 
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
+#undef NDNBOOST_MEM_FN_CC
+#undef NDNBOOST_MEM_FN_NAME
 
 #endif
 
-#ifdef BOOST_MEM_FN_ENABLE_FASTCALL
+#ifdef NDNBOOST_MEM_FN_ENABLE_FASTCALL
 
-#define BOOST_MEM_FN_NAME(X) inner_##X##_fastcall
-#define BOOST_MEM_FN_CC __fastcall
+#define NDNBOOST_MEM_FN_NAME(X) inner_##X##_fastcall
+#define NDNBOOST_MEM_FN_CC __fastcall
 
 #include <ndnboost/bind/mem_fn_template.hpp>
 
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
+#undef NDNBOOST_MEM_FN_CC
+#undef NDNBOOST_MEM_FN_NAME
 
 #endif
 
-#undef BOOST_MEM_FN_RETURN
+#undef NDNBOOST_MEM_FN_RETURN
 
 }; // struct mf<void>
 
-#undef BOOST_MEM_FN_CLASS_F
-#undef BOOST_MEM_FN_TYPEDEF_F
+#undef NDNBOOST_MEM_FN_CLASS_F
+#undef NDNBOOST_MEM_FN_TYPEDEF_F
 
-#define BOOST_MEM_FN_NAME(X) X
-#define BOOST_MEM_FN_NAME2(X) inner_##X
-#define BOOST_MEM_FN_CC
+#define NDNBOOST_MEM_FN_NAME(X) X
+#define NDNBOOST_MEM_FN_NAME2(X) inner_##X
+#define NDNBOOST_MEM_FN_CC
 
 #include <ndnboost/bind/mem_fn_vw.hpp>
 
-#undef BOOST_MEM_FN_NAME
-#undef BOOST_MEM_FN_NAME2
-#undef BOOST_MEM_FN_CC
+#undef NDNBOOST_MEM_FN_NAME
+#undef NDNBOOST_MEM_FN_NAME2
+#undef NDNBOOST_MEM_FN_CC
 
-#ifdef BOOST_MEM_FN_ENABLE_CDECL
+#ifdef NDNBOOST_MEM_FN_ENABLE_CDECL
 
-#define BOOST_MEM_FN_NAME(X) X##_cdecl
-#define BOOST_MEM_FN_NAME2(X) inner_##X##_cdecl
-#define BOOST_MEM_FN_CC __cdecl
+#define NDNBOOST_MEM_FN_NAME(X) X##_cdecl
+#define NDNBOOST_MEM_FN_NAME2(X) inner_##X##_cdecl
+#define NDNBOOST_MEM_FN_CC __cdecl
 
 #include <ndnboost/bind/mem_fn_vw.hpp>
 
-#undef BOOST_MEM_FN_NAME
-#undef BOOST_MEM_FN_NAME2
-#undef BOOST_MEM_FN_CC
+#undef NDNBOOST_MEM_FN_NAME
+#undef NDNBOOST_MEM_FN_NAME2
+#undef NDNBOOST_MEM_FN_CC
 
 #endif
 
-#ifdef BOOST_MEM_FN_ENABLE_STDCALL
+#ifdef NDNBOOST_MEM_FN_ENABLE_STDCALL
 
-#define BOOST_MEM_FN_NAME(X) X##_stdcall
-#define BOOST_MEM_FN_NAME2(X) inner_##X##_stdcall
-#define BOOST_MEM_FN_CC __stdcall
+#define NDNBOOST_MEM_FN_NAME(X) X##_stdcall
+#define NDNBOOST_MEM_FN_NAME2(X) inner_##X##_stdcall
+#define NDNBOOST_MEM_FN_CC __stdcall
 
 #include <ndnboost/bind/mem_fn_vw.hpp>
 
-#undef BOOST_MEM_FN_NAME
-#undef BOOST_MEM_FN_NAME2
-#undef BOOST_MEM_FN_CC
+#undef NDNBOOST_MEM_FN_NAME
+#undef NDNBOOST_MEM_FN_NAME2
+#undef NDNBOOST_MEM_FN_CC
 
 #endif
 
-#ifdef BOOST_MEM_FN_ENABLE_FASTCALL
+#ifdef NDNBOOST_MEM_FN_ENABLE_FASTCALL
 
-#define BOOST_MEM_FN_NAME(X) X##_fastcall
-#define BOOST_MEM_FN_NAME2(X) inner_##X##_fastcall
-#define BOOST_MEM_FN_CC __fastcall
+#define NDNBOOST_MEM_FN_NAME(X) X##_fastcall
+#define NDNBOOST_MEM_FN_NAME2(X) inner_##X##_fastcall
+#define NDNBOOST_MEM_FN_CC __fastcall
 
 #include <ndnboost/bind/mem_fn_vw.hpp>
 
-#undef BOOST_MEM_FN_NAME
-#undef BOOST_MEM_FN_NAME2
-#undef BOOST_MEM_FN_CC
+#undef NDNBOOST_MEM_FN_NAME
+#undef NDNBOOST_MEM_FN_NAME2
+#undef NDNBOOST_MEM_FN_CC
 
 #endif
 
 } // namespace _mfi
 
-#else // #ifdef BOOST_NO_VOID_RETURNS
+#else // #ifdef NDNBOOST_NO_VOID_RETURNS
 
-#define BOOST_MEM_FN_CLASS_F
-#define BOOST_MEM_FN_TYPEDEF(X) typedef X;
+#define NDNBOOST_MEM_FN_CLASS_F
+#define NDNBOOST_MEM_FN_TYPEDEF(X) typedef X;
 
 namespace _mfi
 {
 
-#define BOOST_MEM_FN_RETURN return
+#define NDNBOOST_MEM_FN_RETURN return
 
-#define BOOST_MEM_FN_NAME(X) X
-#define BOOST_MEM_FN_CC
+#define NDNBOOST_MEM_FN_NAME(X) X
+#define NDNBOOST_MEM_FN_CC
 
 #include <ndnboost/bind/mem_fn_template.hpp>
 
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
+#undef NDNBOOST_MEM_FN_CC
+#undef NDNBOOST_MEM_FN_NAME
 
-#ifdef BOOST_MEM_FN_ENABLE_CDECL
+#ifdef NDNBOOST_MEM_FN_ENABLE_CDECL
 
-#define BOOST_MEM_FN_NAME(X) X##_cdecl
-#define BOOST_MEM_FN_CC __cdecl
+#define NDNBOOST_MEM_FN_NAME(X) X##_cdecl
+#define NDNBOOST_MEM_FN_CC __cdecl
 
 #include <ndnboost/bind/mem_fn_template.hpp>
 
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
+#undef NDNBOOST_MEM_FN_CC
+#undef NDNBOOST_MEM_FN_NAME
 
 #endif
 
-#ifdef BOOST_MEM_FN_ENABLE_STDCALL
+#ifdef NDNBOOST_MEM_FN_ENABLE_STDCALL
 
-#define BOOST_MEM_FN_NAME(X) X##_stdcall
-#define BOOST_MEM_FN_CC __stdcall
+#define NDNBOOST_MEM_FN_NAME(X) X##_stdcall
+#define NDNBOOST_MEM_FN_CC __stdcall
 
 #include <ndnboost/bind/mem_fn_template.hpp>
 
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
+#undef NDNBOOST_MEM_FN_CC
+#undef NDNBOOST_MEM_FN_NAME
 
 #endif
 
-#ifdef BOOST_MEM_FN_ENABLE_FASTCALL
+#ifdef NDNBOOST_MEM_FN_ENABLE_FASTCALL
 
-#define BOOST_MEM_FN_NAME(X) X##_fastcall
-#define BOOST_MEM_FN_CC __fastcall
+#define NDNBOOST_MEM_FN_NAME(X) X##_fastcall
+#define NDNBOOST_MEM_FN_CC __fastcall
 
 #include <ndnboost/bind/mem_fn_template.hpp>
 
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
+#undef NDNBOOST_MEM_FN_CC
+#undef NDNBOOST_MEM_FN_NAME
 
 #endif
 
-#undef BOOST_MEM_FN_RETURN
+#undef NDNBOOST_MEM_FN_RETURN
 
 } // namespace _mfi
 
-#undef BOOST_MEM_FN_CLASS_F
-#undef BOOST_MEM_FN_TYPEDEF
+#undef NDNBOOST_MEM_FN_CLASS_F
+#undef NDNBOOST_MEM_FN_TYPEDEF
 
-#endif // #ifdef BOOST_NO_VOID_RETURNS
+#endif // #ifdef NDNBOOST_NO_VOID_RETURNS
 
-#define BOOST_MEM_FN_NAME(X) X
-#define BOOST_MEM_FN_CC
+#define NDNBOOST_MEM_FN_NAME(X) X
+#define NDNBOOST_MEM_FN_CC
 
 #include <ndnboost/bind/mem_fn_cc.hpp>
 
-#undef BOOST_MEM_FN_NAME
-#undef BOOST_MEM_FN_CC
+#undef NDNBOOST_MEM_FN_NAME
+#undef NDNBOOST_MEM_FN_CC
 
-#ifdef BOOST_MEM_FN_ENABLE_CDECL
+#ifdef NDNBOOST_MEM_FN_ENABLE_CDECL
 
-#define BOOST_MEM_FN_NAME(X) X##_cdecl
-#define BOOST_MEM_FN_CC __cdecl
+#define NDNBOOST_MEM_FN_NAME(X) X##_cdecl
+#define NDNBOOST_MEM_FN_CC __cdecl
 
 #include <ndnboost/bind/mem_fn_cc.hpp>
 
-#undef BOOST_MEM_FN_NAME
-#undef BOOST_MEM_FN_CC
+#undef NDNBOOST_MEM_FN_NAME
+#undef NDNBOOST_MEM_FN_CC
 
 #endif
 
-#ifdef BOOST_MEM_FN_ENABLE_STDCALL
+#ifdef NDNBOOST_MEM_FN_ENABLE_STDCALL
 
-#define BOOST_MEM_FN_NAME(X) X##_stdcall
-#define BOOST_MEM_FN_CC __stdcall
+#define NDNBOOST_MEM_FN_NAME(X) X##_stdcall
+#define NDNBOOST_MEM_FN_CC __stdcall
 
 #include <ndnboost/bind/mem_fn_cc.hpp>
 
-#undef BOOST_MEM_FN_NAME
-#undef BOOST_MEM_FN_CC
+#undef NDNBOOST_MEM_FN_NAME
+#undef NDNBOOST_MEM_FN_CC
 
 #endif
 
-#ifdef BOOST_MEM_FN_ENABLE_FASTCALL
+#ifdef NDNBOOST_MEM_FN_ENABLE_FASTCALL
 
-#define BOOST_MEM_FN_NAME(X) X##_fastcall
-#define BOOST_MEM_FN_CC __fastcall
+#define NDNBOOST_MEM_FN_NAME(X) X##_fastcall
+#define NDNBOOST_MEM_FN_CC __fastcall
 
 #include <ndnboost/bind/mem_fn_cc.hpp>
 
-#undef BOOST_MEM_FN_NAME
-#undef BOOST_MEM_FN_CC
+#undef NDNBOOST_MEM_FN_NAME
+#undef NDNBOOST_MEM_FN_CC
 
 #endif
 
@@ -352,7 +352,7 @@
         return call(u, &u);
     }
 
-#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) && !BOOST_WORKAROUND(__MWERKS__, < 0x3200)
+#if !NDNBOOST_WORKAROUND(NDNBOOST_MSVC, <= 1300) && !NDNBOOST_WORKAROUND(__MWERKS__, < 0x3200)
 
     R & operator()(T & t) const
     {
@@ -386,4 +386,4 @@
 
 } // namespace ndnboost
 
-#endif // #ifndef BOOST_BIND_MEM_FN_HPP_INCLUDED
+#endif // #ifndef NDNBOOST_BIND_MEM_FN_HPP_INCLUDED
diff --git a/include/ndnboost/bind/mem_fn_cc.hpp b/include/ndnboost/bind/mem_fn_cc.hpp
index 8b6ea0b..a094d3b 100644
--- a/include/ndnboost/bind/mem_fn_cc.hpp
+++ b/include/ndnboost/bind/mem_fn_cc.hpp
@@ -12,92 +12,92 @@
 //  See http://www.boost.org/libs/bind/mem_fn.html for documentation.
 //
 
-template<class R, class T> _mfi::BOOST_MEM_FN_NAME(mf0)<R, T> mem_fn(R (BOOST_MEM_FN_CC T::*f) ())
+template<class R, class T> _mfi::NDNBOOST_MEM_FN_NAME(mf0)<R, T> mem_fn(R (NDNBOOST_MEM_FN_CC T::*f) ())
 {
-    return _mfi::BOOST_MEM_FN_NAME(mf0)<R, T>(f);
+    return _mfi::NDNBOOST_MEM_FN_NAME(mf0)<R, T>(f);
 }
 
-template<class R, class T> _mfi::BOOST_MEM_FN_NAME(cmf0)<R, T> mem_fn(R (BOOST_MEM_FN_CC T::*f) () const)
+template<class R, class T> _mfi::NDNBOOST_MEM_FN_NAME(cmf0)<R, T> mem_fn(R (NDNBOOST_MEM_FN_CC T::*f) () const)
 {
-    return _mfi::BOOST_MEM_FN_NAME(cmf0)<R, T>(f);
+    return _mfi::NDNBOOST_MEM_FN_NAME(cmf0)<R, T>(f);
 }
 
-template<class R, class T, class A1> _mfi::BOOST_MEM_FN_NAME(mf1)<R, T, A1> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1))
+template<class R, class T, class A1> _mfi::NDNBOOST_MEM_FN_NAME(mf1)<R, T, A1> mem_fn(R (NDNBOOST_MEM_FN_CC T::*f) (A1))
 {
-    return _mfi::BOOST_MEM_FN_NAME(mf1)<R, T, A1>(f);
+    return _mfi::NDNBOOST_MEM_FN_NAME(mf1)<R, T, A1>(f);
 }
 
-template<class R, class T, class A1> _mfi::BOOST_MEM_FN_NAME(cmf1)<R, T, A1> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1) const)
+template<class R, class T, class A1> _mfi::NDNBOOST_MEM_FN_NAME(cmf1)<R, T, A1> mem_fn(R (NDNBOOST_MEM_FN_CC T::*f) (A1) const)
 {
-    return _mfi::BOOST_MEM_FN_NAME(cmf1)<R, T, A1>(f);
+    return _mfi::NDNBOOST_MEM_FN_NAME(cmf1)<R, T, A1>(f);
 }
 
-template<class R, class T, class A1, class A2> _mfi::BOOST_MEM_FN_NAME(mf2)<R, T, A1, A2> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2))
+template<class R, class T, class A1, class A2> _mfi::NDNBOOST_MEM_FN_NAME(mf2)<R, T, A1, A2> mem_fn(R (NDNBOOST_MEM_FN_CC T::*f) (A1, A2))
 {
-    return _mfi::BOOST_MEM_FN_NAME(mf2)<R, T, A1, A2>(f);
+    return _mfi::NDNBOOST_MEM_FN_NAME(mf2)<R, T, A1, A2>(f);
 }
 
-template<class R, class T, class A1, class A2> _mfi::BOOST_MEM_FN_NAME(cmf2)<R, T, A1, A2> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2) const)
+template<class R, class T, class A1, class A2> _mfi::NDNBOOST_MEM_FN_NAME(cmf2)<R, T, A1, A2> mem_fn(R (NDNBOOST_MEM_FN_CC T::*f) (A1, A2) const)
 {
-    return _mfi::BOOST_MEM_FN_NAME(cmf2)<R, T, A1, A2>(f);
+    return _mfi::NDNBOOST_MEM_FN_NAME(cmf2)<R, T, A1, A2>(f);
 }
 
-template<class R, class T, class A1, class A2, class A3> _mfi::BOOST_MEM_FN_NAME(mf3)<R, T, A1, A2, A3> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3))
+template<class R, class T, class A1, class A2, class A3> _mfi::NDNBOOST_MEM_FN_NAME(mf3)<R, T, A1, A2, A3> mem_fn(R (NDNBOOST_MEM_FN_CC T::*f) (A1, A2, A3))
 {
-    return _mfi::BOOST_MEM_FN_NAME(mf3)<R, T, A1, A2, A3>(f);
+    return _mfi::NDNBOOST_MEM_FN_NAME(mf3)<R, T, A1, A2, A3>(f);
 }
 
-template<class R, class T, class A1, class A2, class A3> _mfi::BOOST_MEM_FN_NAME(cmf3)<R, T, A1, A2, A3> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3) const)
+template<class R, class T, class A1, class A2, class A3> _mfi::NDNBOOST_MEM_FN_NAME(cmf3)<R, T, A1, A2, A3> mem_fn(R (NDNBOOST_MEM_FN_CC T::*f) (A1, A2, A3) const)
 {
-    return _mfi::BOOST_MEM_FN_NAME(cmf3)<R, T, A1, A2, A3>(f);
+    return _mfi::NDNBOOST_MEM_FN_NAME(cmf3)<R, T, A1, A2, A3>(f);
 }
 
-template<class R, class T, class A1, class A2, class A3, class A4> _mfi::BOOST_MEM_FN_NAME(mf4)<R, T, A1, A2, A3, A4> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4))
+template<class R, class T, class A1, class A2, class A3, class A4> _mfi::NDNBOOST_MEM_FN_NAME(mf4)<R, T, A1, A2, A3, A4> mem_fn(R (NDNBOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4))
 {
-    return _mfi::BOOST_MEM_FN_NAME(mf4)<R, T, A1, A2, A3, A4>(f);
+    return _mfi::NDNBOOST_MEM_FN_NAME(mf4)<R, T, A1, A2, A3, A4>(f);
 }
 
-template<class R, class T, class A1, class A2, class A3, class A4> _mfi::BOOST_MEM_FN_NAME(cmf4)<R, T, A1, A2, A3, A4> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4) const)
+template<class R, class T, class A1, class A2, class A3, class A4> _mfi::NDNBOOST_MEM_FN_NAME(cmf4)<R, T, A1, A2, A3, A4> mem_fn(R (NDNBOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4) const)
 {
-    return _mfi::BOOST_MEM_FN_NAME(cmf4)<R, T, A1, A2, A3, A4>(f);
+    return _mfi::NDNBOOST_MEM_FN_NAME(cmf4)<R, T, A1, A2, A3, A4>(f);
 }
 
-template<class R, class T, class A1, class A2, class A3, class A4, class A5> _mfi::BOOST_MEM_FN_NAME(mf5)<R, T, A1, A2, A3, A4, A5> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5))
+template<class R, class T, class A1, class A2, class A3, class A4, class A5> _mfi::NDNBOOST_MEM_FN_NAME(mf5)<R, T, A1, A2, A3, A4, A5> mem_fn(R (NDNBOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5))
 {
-    return _mfi::BOOST_MEM_FN_NAME(mf5)<R, T, A1, A2, A3, A4, A5>(f);
+    return _mfi::NDNBOOST_MEM_FN_NAME(mf5)<R, T, A1, A2, A3, A4, A5>(f);
 }
 
-template<class R, class T, class A1, class A2, class A3, class A4, class A5> _mfi::BOOST_MEM_FN_NAME(cmf5)<R, T, A1, A2, A3, A4, A5> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5) const)
+template<class R, class T, class A1, class A2, class A3, class A4, class A5> _mfi::NDNBOOST_MEM_FN_NAME(cmf5)<R, T, A1, A2, A3, A4, A5> mem_fn(R (NDNBOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5) const)
 {
-    return _mfi::BOOST_MEM_FN_NAME(cmf5)<R, T, A1, A2, A3, A4, A5>(f);
+    return _mfi::NDNBOOST_MEM_FN_NAME(cmf5)<R, T, A1, A2, A3, A4, A5>(f);
 }
 
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> _mfi::BOOST_MEM_FN_NAME(mf6)<R, T, A1, A2, A3, A4, A5, A6> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6))
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> _mfi::NDNBOOST_MEM_FN_NAME(mf6)<R, T, A1, A2, A3, A4, A5, A6> mem_fn(R (NDNBOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6))
 {
-    return _mfi::BOOST_MEM_FN_NAME(mf6)<R, T, A1, A2, A3, A4, A5, A6>(f);
+    return _mfi::NDNBOOST_MEM_FN_NAME(mf6)<R, T, A1, A2, A3, A4, A5, A6>(f);
 }
 
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> _mfi::BOOST_MEM_FN_NAME(cmf6)<R, T, A1, A2, A3, A4, A5, A6> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6) const)
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> _mfi::NDNBOOST_MEM_FN_NAME(cmf6)<R, T, A1, A2, A3, A4, A5, A6> mem_fn(R (NDNBOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6) const)
 {
-    return _mfi::BOOST_MEM_FN_NAME(cmf6)<R, T, A1, A2, A3, A4, A5, A6>(f);
+    return _mfi::NDNBOOST_MEM_FN_NAME(cmf6)<R, T, A1, A2, A3, A4, A5, A6>(f);
 }
 
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> _mfi::BOOST_MEM_FN_NAME(mf7)<R, T, A1, A2, A3, A4, A5, A6, A7> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6, A7))
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> _mfi::NDNBOOST_MEM_FN_NAME(mf7)<R, T, A1, A2, A3, A4, A5, A6, A7> mem_fn(R (NDNBOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6, A7))
 {
-    return _mfi::BOOST_MEM_FN_NAME(mf7)<R, T, A1, A2, A3, A4, A5, A6, A7>(f);
+    return _mfi::NDNBOOST_MEM_FN_NAME(mf7)<R, T, A1, A2, A3, A4, A5, A6, A7>(f);
 }
 
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> _mfi::BOOST_MEM_FN_NAME(cmf7)<R, T, A1, A2, A3, A4, A5, A6, A7> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6, A7) const)
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> _mfi::NDNBOOST_MEM_FN_NAME(cmf7)<R, T, A1, A2, A3, A4, A5, A6, A7> mem_fn(R (NDNBOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6, A7) const)
 {
-    return _mfi::BOOST_MEM_FN_NAME(cmf7)<R, T, A1, A2, A3, A4, A5, A6, A7>(f);
+    return _mfi::NDNBOOST_MEM_FN_NAME(cmf7)<R, T, A1, A2, A3, A4, A5, A6, A7>(f);
 }
 
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> _mfi::BOOST_MEM_FN_NAME(mf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6, A7, A8))
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> _mfi::NDNBOOST_MEM_FN_NAME(mf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8> mem_fn(R (NDNBOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6, A7, A8))
 {
-    return _mfi::BOOST_MEM_FN_NAME(mf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8>(f);
+    return _mfi::NDNBOOST_MEM_FN_NAME(mf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8>(f);
 }
 
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> _mfi::BOOST_MEM_FN_NAME(cmf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6, A7, A8) const)
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> _mfi::NDNBOOST_MEM_FN_NAME(cmf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8> mem_fn(R (NDNBOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6, A7, A8) const)
 {
-    return _mfi::BOOST_MEM_FN_NAME(cmf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8>(f);
+    return _mfi::NDNBOOST_MEM_FN_NAME(cmf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8>(f);
 }
diff --git a/include/ndnboost/bind/mem_fn_template.hpp b/include/ndnboost/bind/mem_fn_template.hpp
index b26d585..3ea24e7 100644
--- a/include/ndnboost/bind/mem_fn_template.hpp
+++ b/include/ndnboost/bind/mem_fn_template.hpp
@@ -12,13 +12,13 @@
 //  See http://www.boost.org/libs/bind/mem_fn.html for documentation.
 //
 
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-# define BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
+#if !defined(NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+# define NDNBOOST_MEM_FN_ENABLE_CONST_OVERLOADS
 #endif
 
 // mf0
 
-template<class R, class T BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf0)
+template<class R, class T NDNBOOST_MEM_FN_CLASS_F> class NDNBOOST_MEM_FN_NAME(mf0)
 {
 public:
 
@@ -27,55 +27,55 @@
 
 private:
     
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) ())
+    NDNBOOST_MEM_FN_TYPEDEF(R (NDNBOOST_MEM_FN_CC T::*F) ())
     F f_;
 
     template<class U> R call(U & u, T const *) const
     {
-        BOOST_MEM_FN_RETURN (u.*f_)();
+        NDNBOOST_MEM_FN_RETURN (u.*f_)();
     }
 
     template<class U> R call(U & u, void const *) const
     {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)();
+        NDNBOOST_MEM_FN_RETURN (get_pointer(u)->*f_)();
     }
 
 public:
     
-    explicit BOOST_MEM_FN_NAME(mf0)(F f): f_(f) {}
+    explicit NDNBOOST_MEM_FN_NAME(mf0)(F f): f_(f) {}
 
     R operator()(T * p) const
     {
-        BOOST_MEM_FN_RETURN (p->*f_)();
+        NDNBOOST_MEM_FN_RETURN (p->*f_)();
     }
 
     template<class U> R operator()(U & u) const
     {
         U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p);
+        NDNBOOST_MEM_FN_RETURN call(u, p);
     }
 
-#ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
+#ifdef NDNBOOST_MEM_FN_ENABLE_CONST_OVERLOADS
 
     template<class U> R operator()(U const & u) const
     {
         U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p);
+        NDNBOOST_MEM_FN_RETURN call(u, p);
     }
 
 #endif
 
     R operator()(T & t) const
     {
-        BOOST_MEM_FN_RETURN (t.*f_)();
+        NDNBOOST_MEM_FN_RETURN (t.*f_)();
     }
 
-    bool operator==(BOOST_MEM_FN_NAME(mf0) const & rhs) const
+    bool operator==(NDNBOOST_MEM_FN_NAME(mf0) const & rhs) const
     {
         return f_ == rhs.f_;
     }
 
-    bool operator!=(BOOST_MEM_FN_NAME(mf0) const & rhs) const
+    bool operator!=(NDNBOOST_MEM_FN_NAME(mf0) const & rhs) const
     {
         return f_ != rhs.f_;
     }
@@ -83,7 +83,7 @@
 
 // cmf0
 
-template<class R, class T BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf0)
+template<class R, class T NDNBOOST_MEM_FN_CLASS_F> class NDNBOOST_MEM_FN_NAME(cmf0)
 {
 public:
 
@@ -92,40 +92,40 @@
 
 private:
     
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) () const)
+    NDNBOOST_MEM_FN_TYPEDEF(R (NDNBOOST_MEM_FN_CC T::*F) () const)
     F f_;
 
     template<class U> R call(U & u, T const *) const
     {
-        BOOST_MEM_FN_RETURN (u.*f_)();
+        NDNBOOST_MEM_FN_RETURN (u.*f_)();
     }
 
     template<class U> R call(U & u, void const *) const
     {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)();
+        NDNBOOST_MEM_FN_RETURN (get_pointer(u)->*f_)();
     }
 
 public:
     
-    explicit BOOST_MEM_FN_NAME(cmf0)(F f): f_(f) {}
+    explicit NDNBOOST_MEM_FN_NAME(cmf0)(F f): f_(f) {}
 
     template<class U> R operator()(U const & u) const
     {
         U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p);
+        NDNBOOST_MEM_FN_RETURN call(u, p);
     }
 
     R operator()(T const & t) const
     {
-        BOOST_MEM_FN_RETURN (t.*f_)();
+        NDNBOOST_MEM_FN_RETURN (t.*f_)();
     }
 
-    bool operator==(BOOST_MEM_FN_NAME(cmf0) const & rhs) const
+    bool operator==(NDNBOOST_MEM_FN_NAME(cmf0) const & rhs) const
     {
         return f_ == rhs.f_;
     }
 
-    bool operator!=(BOOST_MEM_FN_NAME(cmf0) const & rhs) const
+    bool operator!=(NDNBOOST_MEM_FN_NAME(cmf0) const & rhs) const
     {
         return f_ != rhs.f_;
     }
@@ -133,7 +133,7 @@
 
 // mf1
 
-template<class R, class T, class A1 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf1)
+template<class R, class T, class A1 NDNBOOST_MEM_FN_CLASS_F> class NDNBOOST_MEM_FN_NAME(mf1)
 {
 public:
 
@@ -143,55 +143,55 @@
 
 private:
     
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1))
+    NDNBOOST_MEM_FN_TYPEDEF(R (NDNBOOST_MEM_FN_CC T::*F) (A1))
     F f_;
 
     template<class U, class B1> R call(U & u, T const *, B1 & b1) const
     {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1);
+        NDNBOOST_MEM_FN_RETURN (u.*f_)(b1);
     }
 
     template<class U, class B1> R call(U & u, void const *, B1 & b1) const
     {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1);
+        NDNBOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1);
     }
 
 public:
     
-    explicit BOOST_MEM_FN_NAME(mf1)(F f): f_(f) {}
+    explicit NDNBOOST_MEM_FN_NAME(mf1)(F f): f_(f) {}
 
     R operator()(T * p, A1 a1) const
     {
-        BOOST_MEM_FN_RETURN (p->*f_)(a1);
+        NDNBOOST_MEM_FN_RETURN (p->*f_)(a1);
     }
 
     template<class U> R operator()(U & u, A1 a1) const
     {
         U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1);
+        NDNBOOST_MEM_FN_RETURN call(u, p, a1);
     }
 
-#ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
+#ifdef NDNBOOST_MEM_FN_ENABLE_CONST_OVERLOADS
 
     template<class U> R operator()(U const & u, A1 a1) const
     {
         U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1);
+        NDNBOOST_MEM_FN_RETURN call(u, p, a1);
     }
 
 #endif
 
     R operator()(T & t, A1 a1) const
     {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1);
+        NDNBOOST_MEM_FN_RETURN (t.*f_)(a1);
     }
 
-    bool operator==(BOOST_MEM_FN_NAME(mf1) const & rhs) const
+    bool operator==(NDNBOOST_MEM_FN_NAME(mf1) const & rhs) const
     {
         return f_ == rhs.f_;
     }
 
-    bool operator!=(BOOST_MEM_FN_NAME(mf1) const & rhs) const
+    bool operator!=(NDNBOOST_MEM_FN_NAME(mf1) const & rhs) const
     {
         return f_ != rhs.f_;
     }
@@ -199,7 +199,7 @@
 
 // cmf1
 
-template<class R, class T, class A1 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf1)
+template<class R, class T, class A1 NDNBOOST_MEM_FN_CLASS_F> class NDNBOOST_MEM_FN_NAME(cmf1)
 {
 public:
 
@@ -209,40 +209,40 @@
 
 private:
     
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1) const)
+    NDNBOOST_MEM_FN_TYPEDEF(R (NDNBOOST_MEM_FN_CC T::*F) (A1) const)
     F f_;
 
     template<class U, class B1> R call(U & u, T const *, B1 & b1) const
     {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1);
+        NDNBOOST_MEM_FN_RETURN (u.*f_)(b1);
     }
 
     template<class U, class B1> R call(U & u, void const *, B1 & b1) const
     {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1);
+        NDNBOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1);
     }
 
 public:
     
-    explicit BOOST_MEM_FN_NAME(cmf1)(F f): f_(f) {}
+    explicit NDNBOOST_MEM_FN_NAME(cmf1)(F f): f_(f) {}
 
     template<class U> R operator()(U const & u, A1 a1) const
     {
         U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1);
+        NDNBOOST_MEM_FN_RETURN call(u, p, a1);
     }
 
     R operator()(T const & t, A1 a1) const
     {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1);
+        NDNBOOST_MEM_FN_RETURN (t.*f_)(a1);
     }
 
-    bool operator==(BOOST_MEM_FN_NAME(cmf1) const & rhs) const
+    bool operator==(NDNBOOST_MEM_FN_NAME(cmf1) const & rhs) const
     {
         return f_ == rhs.f_;
     }
 
-    bool operator!=(BOOST_MEM_FN_NAME(cmf1) const & rhs) const
+    bool operator!=(NDNBOOST_MEM_FN_NAME(cmf1) const & rhs) const
     {
         return f_ != rhs.f_;
     }
@@ -250,7 +250,7 @@
 
 // mf2
 
-template<class R, class T, class A1, class A2 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf2)
+template<class R, class T, class A1, class A2 NDNBOOST_MEM_FN_CLASS_F> class NDNBOOST_MEM_FN_NAME(mf2)
 {
 public:
 
@@ -258,55 +258,55 @@
 
 private:
     
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2))
+    NDNBOOST_MEM_FN_TYPEDEF(R (NDNBOOST_MEM_FN_CC T::*F) (A1, A2))
     F f_;
 
     template<class U, class B1, class B2> R call(U & u, T const *, B1 & b1, B2 & b2) const
     {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2);
+        NDNBOOST_MEM_FN_RETURN (u.*f_)(b1, b2);
     }
 
     template<class U, class B1, class B2> R call(U & u, void const *, B1 & b1, B2 & b2) const
     {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2);
+        NDNBOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2);
     }
 
 public:
     
-    explicit BOOST_MEM_FN_NAME(mf2)(F f): f_(f) {}
+    explicit NDNBOOST_MEM_FN_NAME(mf2)(F f): f_(f) {}
 
     R operator()(T * p, A1 a1, A2 a2) const
     {
-        BOOST_MEM_FN_RETURN (p->*f_)(a1, a2);
+        NDNBOOST_MEM_FN_RETURN (p->*f_)(a1, a2);
     }
 
     template<class U> R operator()(U & u, A1 a1, A2 a2) const
     {
         U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2);
+        NDNBOOST_MEM_FN_RETURN call(u, p, a1, a2);
     }
 
-#ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
+#ifdef NDNBOOST_MEM_FN_ENABLE_CONST_OVERLOADS
 
     template<class U> R operator()(U const & u, A1 a1, A2 a2) const
     {
         U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2);
+        NDNBOOST_MEM_FN_RETURN call(u, p, a1, a2);
     }
 
 #endif
 
     R operator()(T & t, A1 a1, A2 a2) const
     {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2);
+        NDNBOOST_MEM_FN_RETURN (t.*f_)(a1, a2);
     }
 
-    bool operator==(BOOST_MEM_FN_NAME(mf2) const & rhs) const
+    bool operator==(NDNBOOST_MEM_FN_NAME(mf2) const & rhs) const
     {
         return f_ == rhs.f_;
     }
 
-    bool operator!=(BOOST_MEM_FN_NAME(mf2) const & rhs) const
+    bool operator!=(NDNBOOST_MEM_FN_NAME(mf2) const & rhs) const
     {
         return f_ != rhs.f_;
     }
@@ -314,7 +314,7 @@
 
 // cmf2
 
-template<class R, class T, class A1, class A2 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf2)
+template<class R, class T, class A1, class A2 NDNBOOST_MEM_FN_CLASS_F> class NDNBOOST_MEM_FN_NAME(cmf2)
 {
 public:
 
@@ -322,40 +322,40 @@
 
 private:
     
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2) const)
+    NDNBOOST_MEM_FN_TYPEDEF(R (NDNBOOST_MEM_FN_CC T::*F) (A1, A2) const)
     F f_;
 
     template<class U, class B1, class B2> R call(U & u, T const *, B1 & b1, B2 & b2) const
     {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2);
+        NDNBOOST_MEM_FN_RETURN (u.*f_)(b1, b2);
     }
 
     template<class U, class B1, class B2> R call(U & u, void const *, B1 & b1, B2 & b2) const
     {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2);
+        NDNBOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2);
     }
 
 public:
     
-    explicit BOOST_MEM_FN_NAME(cmf2)(F f): f_(f) {}
+    explicit NDNBOOST_MEM_FN_NAME(cmf2)(F f): f_(f) {}
 
     template<class U> R operator()(U const & u, A1 a1, A2 a2) const
     {
         U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2);
+        NDNBOOST_MEM_FN_RETURN call(u, p, a1, a2);
     }
 
     R operator()(T const & t, A1 a1, A2 a2) const
     {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2);
+        NDNBOOST_MEM_FN_RETURN (t.*f_)(a1, a2);
     }
 
-    bool operator==(BOOST_MEM_FN_NAME(cmf2) const & rhs) const
+    bool operator==(NDNBOOST_MEM_FN_NAME(cmf2) const & rhs) const
     {
         return f_ == rhs.f_;
     }
 
-    bool operator!=(BOOST_MEM_FN_NAME(cmf2) const & rhs) const
+    bool operator!=(NDNBOOST_MEM_FN_NAME(cmf2) const & rhs) const
     {
         return f_ != rhs.f_;
     }
@@ -363,7 +363,7 @@
 
 // mf3
 
-template<class R, class T, class A1, class A2, class A3 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf3)
+template<class R, class T, class A1, class A2, class A3 NDNBOOST_MEM_FN_CLASS_F> class NDNBOOST_MEM_FN_NAME(mf3)
 {
 public:
 
@@ -371,55 +371,55 @@
 
 private:
     
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3))
+    NDNBOOST_MEM_FN_TYPEDEF(R (NDNBOOST_MEM_FN_CC T::*F) (A1, A2, A3))
     F f_;
 
     template<class U, class B1, class B2, class B3> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3) const
     {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3);
+        NDNBOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3);
     }
 
     template<class U, class B1, class B2, class B3> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3) const
     {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3);
+        NDNBOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3);
     }
 
 public:
     
-    explicit BOOST_MEM_FN_NAME(mf3)(F f): f_(f) {}
+    explicit NDNBOOST_MEM_FN_NAME(mf3)(F f): f_(f) {}
 
     R operator()(T * p, A1 a1, A2 a2, A3 a3) const
     {
-        BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3);
+        NDNBOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3);
     }
 
     template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3) const
     {
         U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3);
+        NDNBOOST_MEM_FN_RETURN call(u, p, a1, a2, a3);
     }
 
-#ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
+#ifdef NDNBOOST_MEM_FN_ENABLE_CONST_OVERLOADS
 
     template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3) const
     {
         U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3);
+        NDNBOOST_MEM_FN_RETURN call(u, p, a1, a2, a3);
     }
 
 #endif
 
     R operator()(T & t, A1 a1, A2 a2, A3 a3) const
     {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3);
+        NDNBOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3);
     }
 
-    bool operator==(BOOST_MEM_FN_NAME(mf3) const & rhs) const
+    bool operator==(NDNBOOST_MEM_FN_NAME(mf3) const & rhs) const
     {
         return f_ == rhs.f_;
     }
 
-    bool operator!=(BOOST_MEM_FN_NAME(mf3) const & rhs) const
+    bool operator!=(NDNBOOST_MEM_FN_NAME(mf3) const & rhs) const
     {
         return f_ != rhs.f_;
     }
@@ -427,7 +427,7 @@
 
 // cmf3
 
-template<class R, class T, class A1, class A2, class A3 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf3)
+template<class R, class T, class A1, class A2, class A3 NDNBOOST_MEM_FN_CLASS_F> class NDNBOOST_MEM_FN_NAME(cmf3)
 {
 public:
 
@@ -435,40 +435,40 @@
 
 private:
 
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3) const)
+    NDNBOOST_MEM_FN_TYPEDEF(R (NDNBOOST_MEM_FN_CC T::*F) (A1, A2, A3) const)
     F f_;
 
     template<class U, class B1, class B2, class B3> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3) const
     {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3);
+        NDNBOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3);
     }
 
     template<class U, class B1, class B2, class B3> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3) const
     {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3);
+        NDNBOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3);
     }
 
 public:
 
-    explicit BOOST_MEM_FN_NAME(cmf3)(F f): f_(f) {}
+    explicit NDNBOOST_MEM_FN_NAME(cmf3)(F f): f_(f) {}
 
     template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3) const
     {
         U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3);
+        NDNBOOST_MEM_FN_RETURN call(u, p, a1, a2, a3);
     }
 
     R operator()(T const & t, A1 a1, A2 a2, A3 a3) const
     {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3);
+        NDNBOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3);
     }
 
-    bool operator==(BOOST_MEM_FN_NAME(cmf3) const & rhs) const
+    bool operator==(NDNBOOST_MEM_FN_NAME(cmf3) const & rhs) const
     {
         return f_ == rhs.f_;
     }
 
-    bool operator!=(BOOST_MEM_FN_NAME(cmf3) const & rhs) const
+    bool operator!=(NDNBOOST_MEM_FN_NAME(cmf3) const & rhs) const
     {
         return f_ != rhs.f_;
     }
@@ -476,7 +476,7 @@
 
 // mf4
 
-template<class R, class T, class A1, class A2, class A3, class A4 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf4)
+template<class R, class T, class A1, class A2, class A3, class A4 NDNBOOST_MEM_FN_CLASS_F> class NDNBOOST_MEM_FN_NAME(mf4)
 {
 public:
 
@@ -484,55 +484,55 @@
 
 private:
     
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4))
+    NDNBOOST_MEM_FN_TYPEDEF(R (NDNBOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4))
     F f_;
 
     template<class U, class B1, class B2, class B3, class B4> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
     {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4);
+        NDNBOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4);
     }
 
     template<class U, class B1, class B2, class B3, class B4> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
     {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4);
+        NDNBOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4);
     }
 
 public:
     
-    explicit BOOST_MEM_FN_NAME(mf4)(F f): f_(f) {}
+    explicit NDNBOOST_MEM_FN_NAME(mf4)(F f): f_(f) {}
 
     R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4) const
     {
-        BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4);
+        NDNBOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4);
     }
 
     template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4) const
     {
         U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4);
+        NDNBOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4);
     }
 
-#ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
+#ifdef NDNBOOST_MEM_FN_ENABLE_CONST_OVERLOADS
 
     template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4) const
     {
         U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4);
+        NDNBOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4);
     }
 
 #endif
 
     R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4) const
     {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4);
+        NDNBOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4);
     }
 
-    bool operator==(BOOST_MEM_FN_NAME(mf4) const & rhs) const
+    bool operator==(NDNBOOST_MEM_FN_NAME(mf4) const & rhs) const
     {
         return f_ == rhs.f_;
     }
 
-    bool operator!=(BOOST_MEM_FN_NAME(mf4) const & rhs) const
+    bool operator!=(NDNBOOST_MEM_FN_NAME(mf4) const & rhs) const
     {
         return f_ != rhs.f_;
     }
@@ -540,7 +540,7 @@
 
 // cmf4
 
-template<class R, class T, class A1, class A2, class A3, class A4 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf4)
+template<class R, class T, class A1, class A2, class A3, class A4 NDNBOOST_MEM_FN_CLASS_F> class NDNBOOST_MEM_FN_NAME(cmf4)
 {
 public:
 
@@ -548,40 +548,40 @@
 
 private:
     
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4) const)
+    NDNBOOST_MEM_FN_TYPEDEF(R (NDNBOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4) const)
     F f_;
 
     template<class U, class B1, class B2, class B3, class B4> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
     {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4);
+        NDNBOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4);
     }
 
     template<class U, class B1, class B2, class B3, class B4> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
     {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4);
+        NDNBOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4);
     }
 
 public:
     
-    explicit BOOST_MEM_FN_NAME(cmf4)(F f): f_(f) {}
+    explicit NDNBOOST_MEM_FN_NAME(cmf4)(F f): f_(f) {}
 
     template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4) const
     {
         U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4);
+        NDNBOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4);
     }
 
     R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4) const
     {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4);
+        NDNBOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4);
     }
 
-    bool operator==(BOOST_MEM_FN_NAME(cmf4) const & rhs) const
+    bool operator==(NDNBOOST_MEM_FN_NAME(cmf4) const & rhs) const
     {
         return f_ == rhs.f_;
     }
 
-    bool operator!=(BOOST_MEM_FN_NAME(cmf4) const & rhs) const
+    bool operator!=(NDNBOOST_MEM_FN_NAME(cmf4) const & rhs) const
     {
         return f_ != rhs.f_;
     }
@@ -589,7 +589,7 @@
 
 // mf5
 
-template<class R, class T, class A1, class A2, class A3, class A4, class A5 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf5)
+template<class R, class T, class A1, class A2, class A3, class A4, class A5 NDNBOOST_MEM_FN_CLASS_F> class NDNBOOST_MEM_FN_NAME(mf5)
 {
 public:
 
@@ -597,55 +597,55 @@
 
 private:
     
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5))
+    NDNBOOST_MEM_FN_TYPEDEF(R (NDNBOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5))
     F f_;
 
     template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
     {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5);
+        NDNBOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5);
     }
 
     template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
     {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5);
+        NDNBOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5);
     }
 
 public:
     
-    explicit BOOST_MEM_FN_NAME(mf5)(F f): f_(f) {}
+    explicit NDNBOOST_MEM_FN_NAME(mf5)(F f): f_(f) {}
 
     R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
     {
-        BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5);
+        NDNBOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5);
     }
 
     template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
     {
         U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5);
+        NDNBOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5);
     }
 
-#ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
+#ifdef NDNBOOST_MEM_FN_ENABLE_CONST_OVERLOADS
 
     template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
     {
         U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5);
+        NDNBOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5);
     }
 
 #endif
 
     R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
     {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5);
+        NDNBOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5);
     }
 
-    bool operator==(BOOST_MEM_FN_NAME(mf5) const & rhs) const
+    bool operator==(NDNBOOST_MEM_FN_NAME(mf5) const & rhs) const
     {
         return f_ == rhs.f_;
     }
 
-    bool operator!=(BOOST_MEM_FN_NAME(mf5) const & rhs) const
+    bool operator!=(NDNBOOST_MEM_FN_NAME(mf5) const & rhs) const
     {
         return f_ != rhs.f_;
     }
@@ -653,7 +653,7 @@
 
 // cmf5
 
-template<class R, class T, class A1, class A2, class A3, class A4, class A5 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf5)
+template<class R, class T, class A1, class A2, class A3, class A4, class A5 NDNBOOST_MEM_FN_CLASS_F> class NDNBOOST_MEM_FN_NAME(cmf5)
 {
 public:
 
@@ -661,40 +661,40 @@
 
 private:
     
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5) const)
+    NDNBOOST_MEM_FN_TYPEDEF(R (NDNBOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5) const)
     F f_;
 
     template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
     {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5);
+        NDNBOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5);
     }
 
     template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
     {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5);
+        NDNBOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5);
     }
 
 public:
     
-    explicit BOOST_MEM_FN_NAME(cmf5)(F f): f_(f) {}
+    explicit NDNBOOST_MEM_FN_NAME(cmf5)(F f): f_(f) {}
 
     template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
     {
         U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5);
+        NDNBOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5);
     }
 
     R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
     {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5);
+        NDNBOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5);
     }
 
-    bool operator==(BOOST_MEM_FN_NAME(cmf5) const & rhs) const
+    bool operator==(NDNBOOST_MEM_FN_NAME(cmf5) const & rhs) const
     {
         return f_ == rhs.f_;
     }
 
-    bool operator!=(BOOST_MEM_FN_NAME(cmf5) const & rhs) const
+    bool operator!=(NDNBOOST_MEM_FN_NAME(cmf5) const & rhs) const
     {
         return f_ != rhs.f_;
     }
@@ -702,7 +702,7 @@
 
 // mf6
 
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf6)
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6 NDNBOOST_MEM_FN_CLASS_F> class NDNBOOST_MEM_FN_NAME(mf6)
 {
 public:
 
@@ -710,55 +710,55 @@
 
 private:
 
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6))
+    NDNBOOST_MEM_FN_TYPEDEF(R (NDNBOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6))
     F f_;
 
     template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
     {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6);
+        NDNBOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6);
     }
 
     template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
     {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6);
+        NDNBOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6);
     }
 
 public:
 
-    explicit BOOST_MEM_FN_NAME(mf6)(F f): f_(f) {}
+    explicit NDNBOOST_MEM_FN_NAME(mf6)(F f): f_(f) {}
 
     R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
     {
-        BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6);
+        NDNBOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6);
     }
 
     template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
     {
         U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6);
+        NDNBOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6);
     }
 
-#ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
+#ifdef NDNBOOST_MEM_FN_ENABLE_CONST_OVERLOADS
 
     template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
     {
         U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6);
+        NDNBOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6);
     }
 
 #endif
 
     R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
     {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6);
+        NDNBOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6);
     }
 
-    bool operator==(BOOST_MEM_FN_NAME(mf6) const & rhs) const
+    bool operator==(NDNBOOST_MEM_FN_NAME(mf6) const & rhs) const
     {
         return f_ == rhs.f_;
     }
 
-    bool operator!=(BOOST_MEM_FN_NAME(mf6) const & rhs) const
+    bool operator!=(NDNBOOST_MEM_FN_NAME(mf6) const & rhs) const
     {
         return f_ != rhs.f_;
     }
@@ -766,7 +766,7 @@
 
 // cmf6
 
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf6)
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6 NDNBOOST_MEM_FN_CLASS_F> class NDNBOOST_MEM_FN_NAME(cmf6)
 {
 public:
 
@@ -774,40 +774,40 @@
 
 private:
     
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6) const)
+    NDNBOOST_MEM_FN_TYPEDEF(R (NDNBOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6) const)
     F f_;
 
     template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
     {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6);
+        NDNBOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6);
     }
 
     template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
     {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6);
+        NDNBOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6);
     }
 
 public:
     
-    explicit BOOST_MEM_FN_NAME(cmf6)(F f): f_(f) {}
+    explicit NDNBOOST_MEM_FN_NAME(cmf6)(F f): f_(f) {}
 
     template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
     {
         U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6);
+        NDNBOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6);
     }
 
     R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
     {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6);
+        NDNBOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6);
     }
 
-    bool operator==(BOOST_MEM_FN_NAME(cmf6) const & rhs) const
+    bool operator==(NDNBOOST_MEM_FN_NAME(cmf6) const & rhs) const
     {
         return f_ == rhs.f_;
     }
 
-    bool operator!=(BOOST_MEM_FN_NAME(cmf6) const & rhs) const
+    bool operator!=(NDNBOOST_MEM_FN_NAME(cmf6) const & rhs) const
     {
         return f_ != rhs.f_;
     }
@@ -815,7 +815,7 @@
 
 // mf7
 
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf7)
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 NDNBOOST_MEM_FN_CLASS_F> class NDNBOOST_MEM_FN_NAME(mf7)
 {
 public:
 
@@ -823,55 +823,55 @@
 
 private:
     
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7))
+    NDNBOOST_MEM_FN_TYPEDEF(R (NDNBOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7))
     F f_;
 
     template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
     {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7);
+        NDNBOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7);
     }
 
     template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
     {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7);
+        NDNBOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7);
     }
 
 public:
     
-    explicit BOOST_MEM_FN_NAME(mf7)(F f): f_(f) {}
+    explicit NDNBOOST_MEM_FN_NAME(mf7)(F f): f_(f) {}
 
     R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
     {
-        BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6, a7);
+        NDNBOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6, a7);
     }
 
     template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
     {
         U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7);
+        NDNBOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7);
     }
 
-#ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
+#ifdef NDNBOOST_MEM_FN_ENABLE_CONST_OVERLOADS
 
     template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
     {
         U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7);
+        NDNBOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7);
     }
 
 #endif
 
     R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
     {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
+        NDNBOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
     }
 
-    bool operator==(BOOST_MEM_FN_NAME(mf7) const & rhs) const
+    bool operator==(NDNBOOST_MEM_FN_NAME(mf7) const & rhs) const
     {
         return f_ == rhs.f_;
     }
 
-    bool operator!=(BOOST_MEM_FN_NAME(mf7) const & rhs) const
+    bool operator!=(NDNBOOST_MEM_FN_NAME(mf7) const & rhs) const
     {
         return f_ != rhs.f_;
     }
@@ -879,7 +879,7 @@
 
 // cmf7
 
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf7)
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 NDNBOOST_MEM_FN_CLASS_F> class NDNBOOST_MEM_FN_NAME(cmf7)
 {
 public:
 
@@ -887,40 +887,40 @@
 
 private:
     
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7) const)
+    NDNBOOST_MEM_FN_TYPEDEF(R (NDNBOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7) const)
     F f_;
 
     template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
     {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7);
+        NDNBOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7);
     }
 
     template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
     {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7);
+        NDNBOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7);
     }
 
 public:
     
-    explicit BOOST_MEM_FN_NAME(cmf7)(F f): f_(f) {}
+    explicit NDNBOOST_MEM_FN_NAME(cmf7)(F f): f_(f) {}
 
     template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
     {
         U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7);
+        NDNBOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7);
     }
 
     R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
     {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
+        NDNBOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
     }
 
-    bool operator==(BOOST_MEM_FN_NAME(cmf7) const & rhs) const
+    bool operator==(NDNBOOST_MEM_FN_NAME(cmf7) const & rhs) const
     {
         return f_ == rhs.f_;
     }
 
-    bool operator!=(BOOST_MEM_FN_NAME(cmf7) const & rhs) const
+    bool operator!=(NDNBOOST_MEM_FN_NAME(cmf7) const & rhs) const
     {
         return f_ != rhs.f_;
     }
@@ -928,7 +928,7 @@
 
 // mf8
 
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf8)
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 NDNBOOST_MEM_FN_CLASS_F> class NDNBOOST_MEM_FN_NAME(mf8)
 {
 public:
 
@@ -936,55 +936,55 @@
 
 private:
     
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8))
+    NDNBOOST_MEM_FN_TYPEDEF(R (NDNBOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8))
     F f_;
 
     template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
     {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
+        NDNBOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
     }
 
     template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
     {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
+        NDNBOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
     }
 
 public:
     
-    explicit BOOST_MEM_FN_NAME(mf8)(F f): f_(f) {}
+    explicit NDNBOOST_MEM_FN_NAME(mf8)(F f): f_(f) {}
 
     R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
     {
-        BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
+        NDNBOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
     }
 
     template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
     {
         U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
+        NDNBOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
     }
 
-#ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
+#ifdef NDNBOOST_MEM_FN_ENABLE_CONST_OVERLOADS
 
     template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
     {
         U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
+        NDNBOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
     }
 
 #endif
 
     R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
     {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
+        NDNBOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
     }
 
-    bool operator==(BOOST_MEM_FN_NAME(mf8) const & rhs) const
+    bool operator==(NDNBOOST_MEM_FN_NAME(mf8) const & rhs) const
     {
         return f_ == rhs.f_;
     }
 
-    bool operator!=(BOOST_MEM_FN_NAME(mf8) const & rhs) const
+    bool operator!=(NDNBOOST_MEM_FN_NAME(mf8) const & rhs) const
     {
         return f_ != rhs.f_;
     }
@@ -992,7 +992,7 @@
 
 // cmf8
 
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf8)
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 NDNBOOST_MEM_FN_CLASS_F> class NDNBOOST_MEM_FN_NAME(cmf8)
 {
 public:
 
@@ -1000,48 +1000,48 @@
 
 private:
     
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8) const)
+    NDNBOOST_MEM_FN_TYPEDEF(R (NDNBOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8) const)
     F f_;
 
     template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
     {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
+        NDNBOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
     }
 
     template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
     {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
+        NDNBOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
     }
 
 public:
     
-    explicit BOOST_MEM_FN_NAME(cmf8)(F f): f_(f) {}
+    explicit NDNBOOST_MEM_FN_NAME(cmf8)(F f): f_(f) {}
 
     R operator()(T const * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
     {
-        BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
+        NDNBOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
     }
 
     template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
     {
         U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
+        NDNBOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
     }
 
     R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
     {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
+        NDNBOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
     }
 
-    bool operator==(BOOST_MEM_FN_NAME(cmf8) const & rhs) const
+    bool operator==(NDNBOOST_MEM_FN_NAME(cmf8) const & rhs) const
     {
         return f_ == rhs.f_;
     }
 
-    bool operator!=(BOOST_MEM_FN_NAME(cmf8) const & rhs) const
+    bool operator!=(NDNBOOST_MEM_FN_NAME(cmf8) const & rhs) const
     {
         return f_ != rhs.f_;
     }
 };
 
-#undef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
+#undef NDNBOOST_MEM_FN_ENABLE_CONST_OVERLOADS
diff --git a/include/ndnboost/bind/mem_fn_vw.hpp b/include/ndnboost/bind/mem_fn_vw.hpp
index f3fc58d..0ffa660 100644
--- a/include/ndnboost/bind/mem_fn_vw.hpp
+++ b/include/ndnboost/bind/mem_fn_vw.hpp
@@ -12,119 +12,119 @@
 //  See http://www.boost.org/libs/bind/mem_fn.html for documentation.
 //
 
-template<class R, class T> struct BOOST_MEM_FN_NAME(mf0): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf0)<R, T, R (BOOST_MEM_FN_CC T::*) ()>
+template<class R, class T> struct NDNBOOST_MEM_FN_NAME(mf0): public mf<R>::NDNBOOST_NESTED_TEMPLATE NDNBOOST_MEM_FN_NAME2(mf0)<R, T, R (NDNBOOST_MEM_FN_CC T::*) ()>
 {
-    typedef R (BOOST_MEM_FN_CC T::*F) ();
-    explicit BOOST_MEM_FN_NAME(mf0)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf0)<R, T, F>(f) {}
+    typedef R (NDNBOOST_MEM_FN_CC T::*F) ();
+    explicit NDNBOOST_MEM_FN_NAME(mf0)(F f): mf<R>::NDNBOOST_NESTED_TEMPLATE NDNBOOST_MEM_FN_NAME2(mf0)<R, T, F>(f) {}
 };
 
-template<class R, class T> struct BOOST_MEM_FN_NAME(cmf0): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf0)<R, T, R (BOOST_MEM_FN_CC T::*) () const>
+template<class R, class T> struct NDNBOOST_MEM_FN_NAME(cmf0): public mf<R>::NDNBOOST_NESTED_TEMPLATE NDNBOOST_MEM_FN_NAME2(cmf0)<R, T, R (NDNBOOST_MEM_FN_CC T::*) () const>
 {
-    typedef R (BOOST_MEM_FN_CC T::*F) () const;
-    explicit BOOST_MEM_FN_NAME(cmf0)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf0)<R, T, F>(f) {}
+    typedef R (NDNBOOST_MEM_FN_CC T::*F) () const;
+    explicit NDNBOOST_MEM_FN_NAME(cmf0)(F f): mf<R>::NDNBOOST_NESTED_TEMPLATE NDNBOOST_MEM_FN_NAME2(cmf0)<R, T, F>(f) {}
 };
 
 
-template<class R, class T, class A1> struct BOOST_MEM_FN_NAME(mf1): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf1)<R, T, A1, R (BOOST_MEM_FN_CC T::*) (A1)>
+template<class R, class T, class A1> struct NDNBOOST_MEM_FN_NAME(mf1): public mf<R>::NDNBOOST_NESTED_TEMPLATE NDNBOOST_MEM_FN_NAME2(mf1)<R, T, A1, R (NDNBOOST_MEM_FN_CC T::*) (A1)>
 {
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1);
-    explicit BOOST_MEM_FN_NAME(mf1)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf1)<R, T, A1, F>(f) {}
+    typedef R (NDNBOOST_MEM_FN_CC T::*F) (A1);
+    explicit NDNBOOST_MEM_FN_NAME(mf1)(F f): mf<R>::NDNBOOST_NESTED_TEMPLATE NDNBOOST_MEM_FN_NAME2(mf1)<R, T, A1, F>(f) {}
 };
 
-template<class R, class T, class A1> struct BOOST_MEM_FN_NAME(cmf1): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf1)<R, T, A1, R (BOOST_MEM_FN_CC T::*) (A1) const>
+template<class R, class T, class A1> struct NDNBOOST_MEM_FN_NAME(cmf1): public mf<R>::NDNBOOST_NESTED_TEMPLATE NDNBOOST_MEM_FN_NAME2(cmf1)<R, T, A1, R (NDNBOOST_MEM_FN_CC T::*) (A1) const>
 {
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1) const;
-    explicit BOOST_MEM_FN_NAME(cmf1)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf1)<R, T, A1, F>(f) {}
+    typedef R (NDNBOOST_MEM_FN_CC T::*F) (A1) const;
+    explicit NDNBOOST_MEM_FN_NAME(cmf1)(F f): mf<R>::NDNBOOST_NESTED_TEMPLATE NDNBOOST_MEM_FN_NAME2(cmf1)<R, T, A1, F>(f) {}
 };
 
 
-template<class R, class T, class A1, class A2> struct BOOST_MEM_FN_NAME(mf2): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf2)<R, T, A1, A2, R (BOOST_MEM_FN_CC T::*) (A1, A2)>
+template<class R, class T, class A1, class A2> struct NDNBOOST_MEM_FN_NAME(mf2): public mf<R>::NDNBOOST_NESTED_TEMPLATE NDNBOOST_MEM_FN_NAME2(mf2)<R, T, A1, A2, R (NDNBOOST_MEM_FN_CC T::*) (A1, A2)>
 {
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2);
-    explicit BOOST_MEM_FN_NAME(mf2)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf2)<R, T, A1, A2, F>(f) {}
+    typedef R (NDNBOOST_MEM_FN_CC T::*F) (A1, A2);
+    explicit NDNBOOST_MEM_FN_NAME(mf2)(F f): mf<R>::NDNBOOST_NESTED_TEMPLATE NDNBOOST_MEM_FN_NAME2(mf2)<R, T, A1, A2, F>(f) {}
 };
 
-template<class R, class T, class A1, class A2> struct BOOST_MEM_FN_NAME(cmf2): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf2)<R, T, A1, A2, R (BOOST_MEM_FN_CC T::*) (A1, A2) const>
+template<class R, class T, class A1, class A2> struct NDNBOOST_MEM_FN_NAME(cmf2): public mf<R>::NDNBOOST_NESTED_TEMPLATE NDNBOOST_MEM_FN_NAME2(cmf2)<R, T, A1, A2, R (NDNBOOST_MEM_FN_CC T::*) (A1, A2) const>
 {
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2) const;
-    explicit BOOST_MEM_FN_NAME(cmf2)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf2)<R, T, A1, A2, F>(f) {}
+    typedef R (NDNBOOST_MEM_FN_CC T::*F) (A1, A2) const;
+    explicit NDNBOOST_MEM_FN_NAME(cmf2)(F f): mf<R>::NDNBOOST_NESTED_TEMPLATE NDNBOOST_MEM_FN_NAME2(cmf2)<R, T, A1, A2, F>(f) {}
 };
 
 
-template<class R, class T, class A1, class A2, class A3> struct BOOST_MEM_FN_NAME(mf3): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf3)<R, T, A1, A2, A3, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3)>
+template<class R, class T, class A1, class A2, class A3> struct NDNBOOST_MEM_FN_NAME(mf3): public mf<R>::NDNBOOST_NESTED_TEMPLATE NDNBOOST_MEM_FN_NAME2(mf3)<R, T, A1, A2, A3, R (NDNBOOST_MEM_FN_CC T::*) (A1, A2, A3)>
 {
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3);
-    explicit BOOST_MEM_FN_NAME(mf3)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf3)<R, T, A1, A2, A3, F>(f) {}
+    typedef R (NDNBOOST_MEM_FN_CC T::*F) (A1, A2, A3);
+    explicit NDNBOOST_MEM_FN_NAME(mf3)(F f): mf<R>::NDNBOOST_NESTED_TEMPLATE NDNBOOST_MEM_FN_NAME2(mf3)<R, T, A1, A2, A3, F>(f) {}
 };
 
-template<class R, class T, class A1, class A2, class A3> struct BOOST_MEM_FN_NAME(cmf3): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf3)<R, T, A1, A2, A3, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3) const>
+template<class R, class T, class A1, class A2, class A3> struct NDNBOOST_MEM_FN_NAME(cmf3): public mf<R>::NDNBOOST_NESTED_TEMPLATE NDNBOOST_MEM_FN_NAME2(cmf3)<R, T, A1, A2, A3, R (NDNBOOST_MEM_FN_CC T::*) (A1, A2, A3) const>
 {
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3) const;
-    explicit BOOST_MEM_FN_NAME(cmf3)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf3)<R, T, A1, A2, A3, F>(f) {}
+    typedef R (NDNBOOST_MEM_FN_CC T::*F) (A1, A2, A3) const;
+    explicit NDNBOOST_MEM_FN_NAME(cmf3)(F f): mf<R>::NDNBOOST_NESTED_TEMPLATE NDNBOOST_MEM_FN_NAME2(cmf3)<R, T, A1, A2, A3, F>(f) {}
 };
 
 
-template<class R, class T, class A1, class A2, class A3, class A4> struct BOOST_MEM_FN_NAME(mf4): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf4)<R, T, A1, A2, A3, A4, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4)>
+template<class R, class T, class A1, class A2, class A3, class A4> struct NDNBOOST_MEM_FN_NAME(mf4): public mf<R>::NDNBOOST_NESTED_TEMPLATE NDNBOOST_MEM_FN_NAME2(mf4)<R, T, A1, A2, A3, A4, R (NDNBOOST_MEM_FN_CC T::*) (A1, A2, A3, A4)>
 {
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4);
-    explicit BOOST_MEM_FN_NAME(mf4)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf4)<R, T, A1, A2, A3, A4, F>(f) {}
+    typedef R (NDNBOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4);
+    explicit NDNBOOST_MEM_FN_NAME(mf4)(F f): mf<R>::NDNBOOST_NESTED_TEMPLATE NDNBOOST_MEM_FN_NAME2(mf4)<R, T, A1, A2, A3, A4, F>(f) {}
 };
 
-template<class R, class T, class A1, class A2, class A3, class A4> struct BOOST_MEM_FN_NAME(cmf4): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf4)<R, T, A1, A2, A3, A4, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4) const>
+template<class R, class T, class A1, class A2, class A3, class A4> struct NDNBOOST_MEM_FN_NAME(cmf4): public mf<R>::NDNBOOST_NESTED_TEMPLATE NDNBOOST_MEM_FN_NAME2(cmf4)<R, T, A1, A2, A3, A4, R (NDNBOOST_MEM_FN_CC T::*) (A1, A2, A3, A4) const>
 {
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4) const;
-    explicit BOOST_MEM_FN_NAME(cmf4)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf4)<R, T, A1, A2, A3, A4, F>(f) {}
+    typedef R (NDNBOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4) const;
+    explicit NDNBOOST_MEM_FN_NAME(cmf4)(F f): mf<R>::NDNBOOST_NESTED_TEMPLATE NDNBOOST_MEM_FN_NAME2(cmf4)<R, T, A1, A2, A3, A4, F>(f) {}
 };
 
 
-template<class R, class T, class A1, class A2, class A3, class A4, class A5> struct BOOST_MEM_FN_NAME(mf5): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf5)<R, T, A1, A2, A3, A4, A5, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5)>
+template<class R, class T, class A1, class A2, class A3, class A4, class A5> struct NDNBOOST_MEM_FN_NAME(mf5): public mf<R>::NDNBOOST_NESTED_TEMPLATE NDNBOOST_MEM_FN_NAME2(mf5)<R, T, A1, A2, A3, A4, A5, R (NDNBOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5)>
 {
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5);
-    explicit BOOST_MEM_FN_NAME(mf5)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf5)<R, T, A1, A2, A3, A4, A5, F>(f) {}
+    typedef R (NDNBOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5);
+    explicit NDNBOOST_MEM_FN_NAME(mf5)(F f): mf<R>::NDNBOOST_NESTED_TEMPLATE NDNBOOST_MEM_FN_NAME2(mf5)<R, T, A1, A2, A3, A4, A5, F>(f) {}
 };
 
-template<class R, class T, class A1, class A2, class A3, class A4, class A5> struct BOOST_MEM_FN_NAME(cmf5): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf5)<R, T, A1, A2, A3, A4, A5, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5) const>
+template<class R, class T, class A1, class A2, class A3, class A4, class A5> struct NDNBOOST_MEM_FN_NAME(cmf5): public mf<R>::NDNBOOST_NESTED_TEMPLATE NDNBOOST_MEM_FN_NAME2(cmf5)<R, T, A1, A2, A3, A4, A5, R (NDNBOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5) const>
 {
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5) const;
-    explicit BOOST_MEM_FN_NAME(cmf5)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf5)<R, T, A1, A2, A3, A4, A5, F>(f) {}
+    typedef R (NDNBOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5) const;
+    explicit NDNBOOST_MEM_FN_NAME(cmf5)(F f): mf<R>::NDNBOOST_NESTED_TEMPLATE NDNBOOST_MEM_FN_NAME2(cmf5)<R, T, A1, A2, A3, A4, A5, F>(f) {}
 };
 
 
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> struct BOOST_MEM_FN_NAME(mf6): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf6)<R, T, A1, A2, A3, A4, A5, A6, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6)>
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> struct NDNBOOST_MEM_FN_NAME(mf6): public mf<R>::NDNBOOST_NESTED_TEMPLATE NDNBOOST_MEM_FN_NAME2(mf6)<R, T, A1, A2, A3, A4, A5, A6, R (NDNBOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6)>
 {
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6);
-    explicit BOOST_MEM_FN_NAME(mf6)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf6)<R, T, A1, A2, A3, A4, A5, A6, F>(f) {}
+    typedef R (NDNBOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6);
+    explicit NDNBOOST_MEM_FN_NAME(mf6)(F f): mf<R>::NDNBOOST_NESTED_TEMPLATE NDNBOOST_MEM_FN_NAME2(mf6)<R, T, A1, A2, A3, A4, A5, A6, F>(f) {}
 };
 
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> struct BOOST_MEM_FN_NAME(cmf6): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf6)<R, T, A1, A2, A3, A4, A5, A6, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6) const>
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> struct NDNBOOST_MEM_FN_NAME(cmf6): public mf<R>::NDNBOOST_NESTED_TEMPLATE NDNBOOST_MEM_FN_NAME2(cmf6)<R, T, A1, A2, A3, A4, A5, A6, R (NDNBOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6) const>
 {
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6) const;
-    explicit BOOST_MEM_FN_NAME(cmf6)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf6)<R, T, A1, A2, A3, A4, A5, A6, F>(f) {}
+    typedef R (NDNBOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6) const;
+    explicit NDNBOOST_MEM_FN_NAME(cmf6)(F f): mf<R>::NDNBOOST_NESTED_TEMPLATE NDNBOOST_MEM_FN_NAME2(cmf6)<R, T, A1, A2, A3, A4, A5, A6, F>(f) {}
 };
 
 
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct BOOST_MEM_FN_NAME(mf7): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf7)<R, T, A1, A2, A3, A4, A5, A6, A7, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6, A7)>
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct NDNBOOST_MEM_FN_NAME(mf7): public mf<R>::NDNBOOST_NESTED_TEMPLATE NDNBOOST_MEM_FN_NAME2(mf7)<R, T, A1, A2, A3, A4, A5, A6, A7, R (NDNBOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6, A7)>
 {
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7);
-    explicit BOOST_MEM_FN_NAME(mf7)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf7)<R, T, A1, A2, A3, A4, A5, A6, A7, F>(f) {}
+    typedef R (NDNBOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7);
+    explicit NDNBOOST_MEM_FN_NAME(mf7)(F f): mf<R>::NDNBOOST_NESTED_TEMPLATE NDNBOOST_MEM_FN_NAME2(mf7)<R, T, A1, A2, A3, A4, A5, A6, A7, F>(f) {}
 };
 
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct BOOST_MEM_FN_NAME(cmf7): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf7)<R, T, A1, A2, A3, A4, A5, A6, A7, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6, A7) const>
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct NDNBOOST_MEM_FN_NAME(cmf7): public mf<R>::NDNBOOST_NESTED_TEMPLATE NDNBOOST_MEM_FN_NAME2(cmf7)<R, T, A1, A2, A3, A4, A5, A6, A7, R (NDNBOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6, A7) const>
 {
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7) const;
-    explicit BOOST_MEM_FN_NAME(cmf7)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf7)<R, T, A1, A2, A3, A4, A5, A6, A7, F>(f) {}
+    typedef R (NDNBOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7) const;
+    explicit NDNBOOST_MEM_FN_NAME(cmf7)(F f): mf<R>::NDNBOOST_NESTED_TEMPLATE NDNBOOST_MEM_FN_NAME2(cmf7)<R, T, A1, A2, A3, A4, A5, A6, A7, F>(f) {}
 };
 
 
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct BOOST_MEM_FN_NAME(mf8): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6, A7, A8)>
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct NDNBOOST_MEM_FN_NAME(mf8): public mf<R>::NDNBOOST_NESTED_TEMPLATE NDNBOOST_MEM_FN_NAME2(mf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8, R (NDNBOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6, A7, A8)>
 {
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8);
-    explicit BOOST_MEM_FN_NAME(mf8)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8, F>(f) {}
+    typedef R (NDNBOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8);
+    explicit NDNBOOST_MEM_FN_NAME(mf8)(F f): mf<R>::NDNBOOST_NESTED_TEMPLATE NDNBOOST_MEM_FN_NAME2(mf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8, F>(f) {}
 };
 
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct BOOST_MEM_FN_NAME(cmf8): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6, A7, A8) const>
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct NDNBOOST_MEM_FN_NAME(cmf8): public mf<R>::NDNBOOST_NESTED_TEMPLATE NDNBOOST_MEM_FN_NAME2(cmf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8, R (NDNBOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6, A7, A8) const>
 {
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8) const;
-    explicit BOOST_MEM_FN_NAME(cmf8)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8, F>(f) {}
+    typedef R (NDNBOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8) const;
+    explicit NDNBOOST_MEM_FN_NAME(cmf8)(F f): mf<R>::NDNBOOST_NESTED_TEMPLATE NDNBOOST_MEM_FN_NAME2(cmf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8, F>(f) {}
 };
 
diff --git a/include/ndnboost/bind/placeholders.hpp b/include/ndnboost/bind/placeholders.hpp
index 0b9f0fc..9b383f5 100644
--- a/include/ndnboost/bind/placeholders.hpp
+++ b/include/ndnboost/bind/placeholders.hpp
@@ -1,5 +1,5 @@
-#ifndef BOOST_BIND_PLACEHOLDERS_HPP_INCLUDED
-#define BOOST_BIND_PLACEHOLDERS_HPP_INCLUDED
+#ifndef NDNBOOST_BIND_PLACEHOLDERS_HPP_INCLUDED
+#define NDNBOOST_BIND_PLACEHOLDERS_HPP_INCLUDED
 
 // MS compatible compilers support #pragma once
 
@@ -37,7 +37,7 @@
 static inline ndnboost::arg<8> _8() { return ndnboost::arg<8>(); }
 static inline ndnboost::arg<9> _9() { return ndnboost::arg<9>(); }
 
-#elif defined(BOOST_MSVC) || (defined(__DECCXX_VER) && __DECCXX_VER <= 60590031) || defined(__MWERKS__) || \
+#elif defined(NDNBOOST_MSVC) || (defined(__DECCXX_VER) && __DECCXX_VER <= 60590031) || defined(__MWERKS__) || \
     defined(__GNUC__) && (__GNUC__ == 4 && __GNUC_MINOR__ < 2)  
 
 static ndnboost::arg<1> _1;
@@ -66,4 +66,4 @@
 
 } // unnamed namespace
 
-#endif // #ifndef BOOST_BIND_PLACEHOLDERS_HPP_INCLUDED
+#endif // #ifndef NDNBOOST_BIND_PLACEHOLDERS_HPP_INCLUDED
diff --git a/include/ndnboost/bind/protect.hpp b/include/ndnboost/bind/protect.hpp
index 4d70f84..edfbb1e 100644
--- a/include/ndnboost/bind/protect.hpp
+++ b/include/ndnboost/bind/protect.hpp
@@ -1,5 +1,5 @@
-#ifndef BOOST_BIND_PROTECT_HPP_INCLUDED
-#define BOOST_BIND_PROTECT_HPP_INCLUDED
+#ifndef NDNBOOST_BIND_PROTECT_HPP_INCLUDED
+#define NDNBOOST_BIND_PROTECT_HPP_INCLUDED
 
 //
 //  protect.hpp
@@ -52,8 +52,8 @@
     }
 
 
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
- && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
+#if !defined(NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
+ && !NDNBOOST_WORKAROUND(__EDG_VERSION__, <= 238)
 
     template<class A1> result_type operator()(const A1 & a1)
     {
@@ -77,8 +77,8 @@
         return f_(a1, a2);
     }
 
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
- && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
+#if !defined(NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
+ && !NDNBOOST_WORKAROUND(__EDG_VERSION__, <= 238)
 
     template<class A1, class A2> result_type operator()(A1 const & a1, A2 & a2)
     {
@@ -122,8 +122,8 @@
         return f_(a1, a2, a3);
     }
     
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
- && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
+#if !defined(NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
+ && !NDNBOOST_WORKAROUND(__EDG_VERSION__, <= 238)
 
     template<class A1, class A2, class A3> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3)
     {
@@ -147,8 +147,8 @@
         return f_(a1, a2, a3, a4);
     }
     
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
- && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
+#if !defined(NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
+ && !NDNBOOST_WORKAROUND(__EDG_VERSION__, <= 238)
 
     template<class A1, class A2, class A3, class A4> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4)
     {
@@ -172,8 +172,8 @@
         return f_(a1, a2, a3, a4, a5);
     }
     
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
- && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
+#if !defined(NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
+ && !NDNBOOST_WORKAROUND(__EDG_VERSION__, <= 238)
 
     template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5)
     {
@@ -197,8 +197,8 @@
         return f_(a1, a2, a3, a4, a5, a6);
     }
     
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
- && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
+#if !defined(NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
+ && !NDNBOOST_WORKAROUND(__EDG_VERSION__, <= 238)
 
     template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6)
     {
@@ -222,8 +222,8 @@
         return f_(a1, a2, a3, a4, a5, a6, a7);
     }
     
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
- && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
+#if !defined(NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
+ && !NDNBOOST_WORKAROUND(__EDG_VERSION__, <= 238)
 
     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7)
     {
@@ -247,8 +247,8 @@
         return f_(a1, a2, a3, a4, a5, a6, a7, a8);
     }
     
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
- && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
+#if !defined(NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
+ && !NDNBOOST_WORKAROUND(__EDG_VERSION__, <= 238)
 
     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8)
     {
@@ -272,8 +272,8 @@
         return f_(a1, a2, a3, a4, a5, a6, a7, a8, a9);
     }
     
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
- && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
+#if !defined(NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
+ && !NDNBOOST_WORKAROUND(__EDG_VERSION__, <= 238)
 
     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9)
     {
@@ -301,4 +301,4 @@
 
 } // namespace ndnboost
 
-#endif // #ifndef BOOST_BIND_PROTECT_HPP_INCLUDED
+#endif // #ifndef NDNBOOST_BIND_PROTECT_HPP_INCLUDED
diff --git a/include/ndnboost/bind/storage.hpp b/include/ndnboost/bind/storage.hpp
index ef1a870..f50928f 100644
--- a/include/ndnboost/bind/storage.hpp
+++ b/include/ndnboost/bind/storage.hpp
@@ -1,5 +1,5 @@
-#ifndef BOOST_BIND_STORAGE_HPP_INCLUDED
-#define BOOST_BIND_STORAGE_HPP_INCLUDED
+#ifndef NDNBOOST_BIND_STORAGE_HPP_INCLUDED
+#define NDNBOOST_BIND_STORAGE_HPP_INCLUDED
 
 // MS compatible compilers support #pragma once
 
@@ -24,7 +24,7 @@
 #include <ndnboost/config.hpp>
 #include <ndnboost/bind/arg.hpp>
 
-#ifdef BOOST_MSVC
+#ifdef NDNBOOST_MSVC
 # pragma warning(push)
 # pragma warning(disable: 4512) // assignment operator could not be generated
 #endif
@@ -43,13 +43,13 @@
 
     template<class V> void accept(V & v) const
     {
-        BOOST_BIND_VISIT_EACH(v, a1_, 0);
+        NDNBOOST_BIND_VISIT_EACH(v, a1_, 0);
     }
 
     A1 a1_;
 };
 
-#if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) && !defined( __BORLANDC__ )
+#if !defined( NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) && !defined( __BORLANDC__ )
 
 template<int I> struct storage1< ndnboost::arg<I> >
 {
@@ -82,13 +82,13 @@
     template<class V> void accept(V & v) const
     {
         inherited::accept(v);
-        BOOST_BIND_VISIT_EACH(v, a2_, 0);
+        NDNBOOST_BIND_VISIT_EACH(v, a2_, 0);
     }
 
     A2 a2_;
 };
 
-#if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
+#if !defined( NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
 
 template<class A1, int I> struct storage2< A1, ndnboost::arg<I> >: public storage1<A1>
 {
@@ -131,13 +131,13 @@
     template<class V> void accept(V & v) const
     {
         inherited::accept(v);
-        BOOST_BIND_VISIT_EACH(v, a3_, 0);
+        NDNBOOST_BIND_VISIT_EACH(v, a3_, 0);
     }
 
     A3 a3_;
 };
 
-#if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
+#if !defined( NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
 
 template<class A1, class A2, int I> struct storage3< A1, A2, ndnboost::arg<I> >: public storage2< A1, A2 >
 {
@@ -180,13 +180,13 @@
     template<class V> void accept(V & v) const
     {
         inherited::accept(v);
-        BOOST_BIND_VISIT_EACH(v, a4_, 0);
+        NDNBOOST_BIND_VISIT_EACH(v, a4_, 0);
     }
 
     A4 a4_;
 };
 
-#if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
+#if !defined( NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
 
 template<class A1, class A2, class A3, int I> struct storage4< A1, A2, A3, ndnboost::arg<I> >: public storage3< A1, A2, A3 >
 {
@@ -229,13 +229,13 @@
     template<class V> void accept(V & v) const
     {
         inherited::accept(v);
-        BOOST_BIND_VISIT_EACH(v, a5_, 0);
+        NDNBOOST_BIND_VISIT_EACH(v, a5_, 0);
     }
 
     A5 a5_;
 };
 
-#if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
+#if !defined( NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
 
 template<class A1, class A2, class A3, class A4, int I> struct storage5< A1, A2, A3, A4, ndnboost::arg<I> >: public storage4< A1, A2, A3, A4 >
 {
@@ -278,13 +278,13 @@
     template<class V> void accept(V & v) const
     {
         inherited::accept(v);
-        BOOST_BIND_VISIT_EACH(v, a6_, 0);
+        NDNBOOST_BIND_VISIT_EACH(v, a6_, 0);
     }
 
     A6 a6_;
 };
 
-#if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
+#if !defined( NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
 
 template<class A1, class A2, class A3, class A4, class A5, int I> struct storage6< A1, A2, A3, A4, A5, ndnboost::arg<I> >: public storage5< A1, A2, A3, A4, A5 >
 {
@@ -327,13 +327,13 @@
     template<class V> void accept(V & v) const
     {
         inherited::accept(v);
-        BOOST_BIND_VISIT_EACH(v, a7_, 0);
+        NDNBOOST_BIND_VISIT_EACH(v, a7_, 0);
     }
 
     A7 a7_;
 };
 
-#if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
+#if !defined( NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
 
 template<class A1, class A2, class A3, class A4, class A5, class A6, int I> struct storage7< A1, A2, A3, A4, A5, A6, ndnboost::arg<I> >: public storage6< A1, A2, A3, A4, A5, A6 >
 {
@@ -376,13 +376,13 @@
     template<class V> void accept(V & v) const
     {
         inherited::accept(v);
-        BOOST_BIND_VISIT_EACH(v, a8_, 0);
+        NDNBOOST_BIND_VISIT_EACH(v, a8_, 0);
     }
 
     A8 a8_;
 };
 
-#if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
+#if !defined( NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
 
 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, int I> struct storage8< A1, A2, A3, A4, A5, A6, A7, ndnboost::arg<I> >: public storage7< A1, A2, A3, A4, A5, A6, A7 >
 {
@@ -425,13 +425,13 @@
     template<class V> void accept(V & v) const
     {
         inherited::accept(v);
-        BOOST_BIND_VISIT_EACH(v, a9_, 0);
+        NDNBOOST_BIND_VISIT_EACH(v, a9_, 0);
     }
 
     A9 a9_;
 };
 
-#if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
+#if !defined( NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
 
 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, int I> struct storage9< A1, A2, A3, A4, A5, A6, A7, A8, ndnboost::arg<I> >: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
 {
@@ -467,9 +467,9 @@
 
 } // namespace ndnboost
 
-#ifdef BOOST_MSVC
+#ifdef NDNBOOST_MSVC
 # pragma warning(default: 4512) // assignment operator could not be generated
 # pragma warning(pop)
 #endif
 
-#endif // #ifndef BOOST_BIND_STORAGE_HPP_INCLUDED
+#endif // #ifndef NDNBOOST_BIND_STORAGE_HPP_INCLUDED