diff --git a/include/ndnboost/function/detail/function_iterate.hpp b/include/ndnboost/function/detail/function_iterate.hpp
index 5c41196..344f283 100644
--- a/include/ndnboost/function/detail/function_iterate.hpp
+++ b/include/ndnboost/function/detail/function_iterate.hpp
@@ -6,11 +6,11 @@
 //  http://www.boost.org/LICENSE_1_0.txt)
 
 // For more information, see http://www.boost.org
-#if !defined(BOOST_PP_IS_ITERATING)
+#if !defined(NDNBOOST_PP_IS_ITERATING)
 # error Boost.Function - do not include this file!
 #endif
 
-#define BOOST_FUNCTION_NUM_ARGS BOOST_PP_ITERATION()
+#define NDNBOOST_FUNCTION_NUM_ARGS NDNBOOST_PP_ITERATION()
 #include <ndnboost/function/detail/maybe_include.hpp>
-#undef BOOST_FUNCTION_NUM_ARGS
+#undef NDNBOOST_FUNCTION_NUM_ARGS
 
diff --git a/include/ndnboost/function/detail/gen_maybe_include.pl b/include/ndnboost/function/detail/gen_maybe_include.pl
index ab4367d..53dcf8f 100644
--- a/include/ndnboost/function/detail/gen_maybe_include.pl
+++ b/include/ndnboost/function/detail/gen_maybe_include.pl
@@ -26,9 +26,9 @@
     else {
 	print OUT "#elif";
     }
-    print OUT " BOOST_FUNCTION_NUM_ARGS == $on_arg\n";
-    print OUT "#  ifndef BOOST_FUNCTION_$on_arg\n";
-    print OUT "#    define BOOST_FUNCTION_$on_arg\n";
+    print OUT " NDNBOOST_FUNCTION_NUM_ARGS == $on_arg\n";
+    print OUT "#  ifndef NDNBOOST_FUNCTION_$on_arg\n";
+    print OUT "#    define NDNBOOST_FUNCTION_$on_arg\n";
     print OUT "#    include <ndnboost/function/function_template.hpp>\n";
     print OUT "#  endif\n";
 }
diff --git a/include/ndnboost/function/detail/maybe_include.hpp b/include/ndnboost/function/detail/maybe_include.hpp
index a2f003e..90b998e 100644
--- a/include/ndnboost/function/detail/maybe_include.hpp
+++ b/include/ndnboost/function/detail/maybe_include.hpp
@@ -7,259 +7,259 @@
 
 // For more information, see http://www.boost.org
 
-#if BOOST_FUNCTION_NUM_ARGS == 0
-#  ifndef BOOST_FUNCTION_0
-#    define BOOST_FUNCTION_0
+#if NDNBOOST_FUNCTION_NUM_ARGS == 0
+#  ifndef NDNBOOST_FUNCTION_0
+#    define NDNBOOST_FUNCTION_0
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 1
-#  ifndef BOOST_FUNCTION_1
-#    define BOOST_FUNCTION_1
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 1
+#  ifndef NDNBOOST_FUNCTION_1
+#    define NDNBOOST_FUNCTION_1
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 2
-#  ifndef BOOST_FUNCTION_2
-#    define BOOST_FUNCTION_2
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 2
+#  ifndef NDNBOOST_FUNCTION_2
+#    define NDNBOOST_FUNCTION_2
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 3
-#  ifndef BOOST_FUNCTION_3
-#    define BOOST_FUNCTION_3
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 3
+#  ifndef NDNBOOST_FUNCTION_3
+#    define NDNBOOST_FUNCTION_3
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 4
-#  ifndef BOOST_FUNCTION_4
-#    define BOOST_FUNCTION_4
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 4
+#  ifndef NDNBOOST_FUNCTION_4
+#    define NDNBOOST_FUNCTION_4
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 5
-#  ifndef BOOST_FUNCTION_5
-#    define BOOST_FUNCTION_5
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 5
+#  ifndef NDNBOOST_FUNCTION_5
+#    define NDNBOOST_FUNCTION_5
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 6
-#  ifndef BOOST_FUNCTION_6
-#    define BOOST_FUNCTION_6
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 6
+#  ifndef NDNBOOST_FUNCTION_6
+#    define NDNBOOST_FUNCTION_6
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 7
-#  ifndef BOOST_FUNCTION_7
-#    define BOOST_FUNCTION_7
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 7
+#  ifndef NDNBOOST_FUNCTION_7
+#    define NDNBOOST_FUNCTION_7
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 8
-#  ifndef BOOST_FUNCTION_8
-#    define BOOST_FUNCTION_8
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 8
+#  ifndef NDNBOOST_FUNCTION_8
+#    define NDNBOOST_FUNCTION_8
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 9
-#  ifndef BOOST_FUNCTION_9
-#    define BOOST_FUNCTION_9
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 9
+#  ifndef NDNBOOST_FUNCTION_9
+#    define NDNBOOST_FUNCTION_9
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 10
-#  ifndef BOOST_FUNCTION_10
-#    define BOOST_FUNCTION_10
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 10
+#  ifndef NDNBOOST_FUNCTION_10
+#    define NDNBOOST_FUNCTION_10
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 11
-#  ifndef BOOST_FUNCTION_11
-#    define BOOST_FUNCTION_11
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 11
+#  ifndef NDNBOOST_FUNCTION_11
+#    define NDNBOOST_FUNCTION_11
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 12
-#  ifndef BOOST_FUNCTION_12
-#    define BOOST_FUNCTION_12
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 12
+#  ifndef NDNBOOST_FUNCTION_12
+#    define NDNBOOST_FUNCTION_12
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 13
-#  ifndef BOOST_FUNCTION_13
-#    define BOOST_FUNCTION_13
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 13
+#  ifndef NDNBOOST_FUNCTION_13
+#    define NDNBOOST_FUNCTION_13
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 14
-#  ifndef BOOST_FUNCTION_14
-#    define BOOST_FUNCTION_14
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 14
+#  ifndef NDNBOOST_FUNCTION_14
+#    define NDNBOOST_FUNCTION_14
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 15
-#  ifndef BOOST_FUNCTION_15
-#    define BOOST_FUNCTION_15
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 15
+#  ifndef NDNBOOST_FUNCTION_15
+#    define NDNBOOST_FUNCTION_15
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 16
-#  ifndef BOOST_FUNCTION_16
-#    define BOOST_FUNCTION_16
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 16
+#  ifndef NDNBOOST_FUNCTION_16
+#    define NDNBOOST_FUNCTION_16
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 17
-#  ifndef BOOST_FUNCTION_17
-#    define BOOST_FUNCTION_17
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 17
+#  ifndef NDNBOOST_FUNCTION_17
+#    define NDNBOOST_FUNCTION_17
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 18
-#  ifndef BOOST_FUNCTION_18
-#    define BOOST_FUNCTION_18
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 18
+#  ifndef NDNBOOST_FUNCTION_18
+#    define NDNBOOST_FUNCTION_18
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 19
-#  ifndef BOOST_FUNCTION_19
-#    define BOOST_FUNCTION_19
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 19
+#  ifndef NDNBOOST_FUNCTION_19
+#    define NDNBOOST_FUNCTION_19
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 20
-#  ifndef BOOST_FUNCTION_20
-#    define BOOST_FUNCTION_20
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 20
+#  ifndef NDNBOOST_FUNCTION_20
+#    define NDNBOOST_FUNCTION_20
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 21
-#  ifndef BOOST_FUNCTION_21
-#    define BOOST_FUNCTION_21
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 21
+#  ifndef NDNBOOST_FUNCTION_21
+#    define NDNBOOST_FUNCTION_21
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 22
-#  ifndef BOOST_FUNCTION_22
-#    define BOOST_FUNCTION_22
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 22
+#  ifndef NDNBOOST_FUNCTION_22
+#    define NDNBOOST_FUNCTION_22
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 23
-#  ifndef BOOST_FUNCTION_23
-#    define BOOST_FUNCTION_23
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 23
+#  ifndef NDNBOOST_FUNCTION_23
+#    define NDNBOOST_FUNCTION_23
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 24
-#  ifndef BOOST_FUNCTION_24
-#    define BOOST_FUNCTION_24
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 24
+#  ifndef NDNBOOST_FUNCTION_24
+#    define NDNBOOST_FUNCTION_24
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 25
-#  ifndef BOOST_FUNCTION_25
-#    define BOOST_FUNCTION_25
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 25
+#  ifndef NDNBOOST_FUNCTION_25
+#    define NDNBOOST_FUNCTION_25
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 26
-#  ifndef BOOST_FUNCTION_26
-#    define BOOST_FUNCTION_26
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 26
+#  ifndef NDNBOOST_FUNCTION_26
+#    define NDNBOOST_FUNCTION_26
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 27
-#  ifndef BOOST_FUNCTION_27
-#    define BOOST_FUNCTION_27
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 27
+#  ifndef NDNBOOST_FUNCTION_27
+#    define NDNBOOST_FUNCTION_27
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 28
-#  ifndef BOOST_FUNCTION_28
-#    define BOOST_FUNCTION_28
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 28
+#  ifndef NDNBOOST_FUNCTION_28
+#    define NDNBOOST_FUNCTION_28
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 29
-#  ifndef BOOST_FUNCTION_29
-#    define BOOST_FUNCTION_29
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 29
+#  ifndef NDNBOOST_FUNCTION_29
+#    define NDNBOOST_FUNCTION_29
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 30
-#  ifndef BOOST_FUNCTION_30
-#    define BOOST_FUNCTION_30
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 30
+#  ifndef NDNBOOST_FUNCTION_30
+#    define NDNBOOST_FUNCTION_30
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 31
-#  ifndef BOOST_FUNCTION_31
-#    define BOOST_FUNCTION_31
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 31
+#  ifndef NDNBOOST_FUNCTION_31
+#    define NDNBOOST_FUNCTION_31
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 32
-#  ifndef BOOST_FUNCTION_32
-#    define BOOST_FUNCTION_32
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 32
+#  ifndef NDNBOOST_FUNCTION_32
+#    define NDNBOOST_FUNCTION_32
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 33
-#  ifndef BOOST_FUNCTION_33
-#    define BOOST_FUNCTION_33
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 33
+#  ifndef NDNBOOST_FUNCTION_33
+#    define NDNBOOST_FUNCTION_33
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 34
-#  ifndef BOOST_FUNCTION_34
-#    define BOOST_FUNCTION_34
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 34
+#  ifndef NDNBOOST_FUNCTION_34
+#    define NDNBOOST_FUNCTION_34
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 35
-#  ifndef BOOST_FUNCTION_35
-#    define BOOST_FUNCTION_35
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 35
+#  ifndef NDNBOOST_FUNCTION_35
+#    define NDNBOOST_FUNCTION_35
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 36
-#  ifndef BOOST_FUNCTION_36
-#    define BOOST_FUNCTION_36
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 36
+#  ifndef NDNBOOST_FUNCTION_36
+#    define NDNBOOST_FUNCTION_36
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 37
-#  ifndef BOOST_FUNCTION_37
-#    define BOOST_FUNCTION_37
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 37
+#  ifndef NDNBOOST_FUNCTION_37
+#    define NDNBOOST_FUNCTION_37
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 38
-#  ifndef BOOST_FUNCTION_38
-#    define BOOST_FUNCTION_38
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 38
+#  ifndef NDNBOOST_FUNCTION_38
+#    define NDNBOOST_FUNCTION_38
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 39
-#  ifndef BOOST_FUNCTION_39
-#    define BOOST_FUNCTION_39
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 39
+#  ifndef NDNBOOST_FUNCTION_39
+#    define NDNBOOST_FUNCTION_39
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 40
-#  ifndef BOOST_FUNCTION_40
-#    define BOOST_FUNCTION_40
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 40
+#  ifndef NDNBOOST_FUNCTION_40
+#    define NDNBOOST_FUNCTION_40
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 41
-#  ifndef BOOST_FUNCTION_41
-#    define BOOST_FUNCTION_41
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 41
+#  ifndef NDNBOOST_FUNCTION_41
+#    define NDNBOOST_FUNCTION_41
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 42
-#  ifndef BOOST_FUNCTION_42
-#    define BOOST_FUNCTION_42
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 42
+#  ifndef NDNBOOST_FUNCTION_42
+#    define NDNBOOST_FUNCTION_42
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 43
-#  ifndef BOOST_FUNCTION_43
-#    define BOOST_FUNCTION_43
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 43
+#  ifndef NDNBOOST_FUNCTION_43
+#    define NDNBOOST_FUNCTION_43
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 44
-#  ifndef BOOST_FUNCTION_44
-#    define BOOST_FUNCTION_44
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 44
+#  ifndef NDNBOOST_FUNCTION_44
+#    define NDNBOOST_FUNCTION_44
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 45
-#  ifndef BOOST_FUNCTION_45
-#    define BOOST_FUNCTION_45
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 45
+#  ifndef NDNBOOST_FUNCTION_45
+#    define NDNBOOST_FUNCTION_45
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 46
-#  ifndef BOOST_FUNCTION_46
-#    define BOOST_FUNCTION_46
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 46
+#  ifndef NDNBOOST_FUNCTION_46
+#    define NDNBOOST_FUNCTION_46
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 47
-#  ifndef BOOST_FUNCTION_47
-#    define BOOST_FUNCTION_47
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 47
+#  ifndef NDNBOOST_FUNCTION_47
+#    define NDNBOOST_FUNCTION_47
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 48
-#  ifndef BOOST_FUNCTION_48
-#    define BOOST_FUNCTION_48
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 48
+#  ifndef NDNBOOST_FUNCTION_48
+#    define NDNBOOST_FUNCTION_48
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 49
-#  ifndef BOOST_FUNCTION_49
-#    define BOOST_FUNCTION_49
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 49
+#  ifndef NDNBOOST_FUNCTION_49
+#    define NDNBOOST_FUNCTION_49
 #    include <ndnboost/function/function_template.hpp>
 #  endif
-#elif BOOST_FUNCTION_NUM_ARGS == 50
-#  ifndef BOOST_FUNCTION_50
-#    define BOOST_FUNCTION_50
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 50
+#  ifndef NDNBOOST_FUNCTION_50
+#    define NDNBOOST_FUNCTION_50
 #    include <ndnboost/function/function_template.hpp>
 #  endif
 #else
diff --git a/include/ndnboost/function/detail/prologue.hpp b/include/ndnboost/function/detail/prologue.hpp
index 458324c..fac6e8e 100644
--- a/include/ndnboost/function/detail/prologue.hpp
+++ b/include/ndnboost/function/detail/prologue.hpp
@@ -7,8 +7,8 @@
 
 // For more information, see http://www.boost.org
 
-#ifndef BOOST_FUNCTION_PROLOGUE_HPP
-#define BOOST_FUNCTION_PROLOGUE_HPP
+#ifndef NDNBOOST_FUNCTION_PROLOGUE_HPP
+#define NDNBOOST_FUNCTION_PROLOGUE_HPP
 #  include <cassert>
 #  include <algorithm>
 #  include <ndnboost/config/no_tr1/functional.hpp> // unary_function, binary_function
@@ -23,4 +23,4 @@
 #  include <ndnboost/preprocessor/repeat.hpp>
 #  include <ndnboost/preprocessor/inc.hpp>
 #  include <ndnboost/type_traits/is_void.hpp>
-#endif // BOOST_FUNCTION_PROLOGUE_HPP
+#endif // NDNBOOST_FUNCTION_PROLOGUE_HPP
diff --git a/include/ndnboost/function/function0.hpp b/include/ndnboost/function/function0.hpp
index 79211dc..ea15d62 100644
--- a/include/ndnboost/function/function0.hpp
+++ b/include/ndnboost/function/function0.hpp
@@ -7,6 +7,6 @@
 
 // For more information, see http://www.boost.org
 
-#define BOOST_FUNCTION_NUM_ARGS 0
+#define NDNBOOST_FUNCTION_NUM_ARGS 0
 #include <ndnboost/function/detail/maybe_include.hpp>
-#undef BOOST_FUNCTION_NUM_ARGS
+#undef NDNBOOST_FUNCTION_NUM_ARGS
diff --git a/include/ndnboost/function/function1.hpp b/include/ndnboost/function/function1.hpp
index 83fbc19..bf4a605 100644
--- a/include/ndnboost/function/function1.hpp
+++ b/include/ndnboost/function/function1.hpp
@@ -7,6 +7,6 @@
 
 // For more information, see http://www.boost.org
 
-#define BOOST_FUNCTION_NUM_ARGS 1
+#define NDNBOOST_FUNCTION_NUM_ARGS 1
 #include <ndnboost/function/detail/maybe_include.hpp>
-#undef BOOST_FUNCTION_NUM_ARGS
+#undef NDNBOOST_FUNCTION_NUM_ARGS
diff --git a/include/ndnboost/function/function10.hpp b/include/ndnboost/function/function10.hpp
index bbd3dec..fd0ee32 100644
--- a/include/ndnboost/function/function10.hpp
+++ b/include/ndnboost/function/function10.hpp
@@ -7,6 +7,6 @@
 
 // For more information, see http://www.boost.org
 
-#define BOOST_FUNCTION_NUM_ARGS 10
+#define NDNBOOST_FUNCTION_NUM_ARGS 10
 #include <ndnboost/function/detail/maybe_include.hpp>
-#undef BOOST_FUNCTION_NUM_ARGS
+#undef NDNBOOST_FUNCTION_NUM_ARGS
diff --git a/include/ndnboost/function/function2.hpp b/include/ndnboost/function/function2.hpp
index 65dbfda..603c2d0 100644
--- a/include/ndnboost/function/function2.hpp
+++ b/include/ndnboost/function/function2.hpp
@@ -7,6 +7,6 @@
 
 // For more information, see http://www.boost.org
 
-#define BOOST_FUNCTION_NUM_ARGS 2
+#define NDNBOOST_FUNCTION_NUM_ARGS 2
 #include <ndnboost/function/detail/maybe_include.hpp>
-#undef BOOST_FUNCTION_NUM_ARGS
+#undef NDNBOOST_FUNCTION_NUM_ARGS
diff --git a/include/ndnboost/function/function3.hpp b/include/ndnboost/function/function3.hpp
index 3244755..3ec62d5 100644
--- a/include/ndnboost/function/function3.hpp
+++ b/include/ndnboost/function/function3.hpp
@@ -7,6 +7,6 @@
 
 // For more information, see http://www.boost.org
 
-#define BOOST_FUNCTION_NUM_ARGS 3
+#define NDNBOOST_FUNCTION_NUM_ARGS 3
 #include <ndnboost/function/detail/maybe_include.hpp>
-#undef BOOST_FUNCTION_NUM_ARGS
+#undef NDNBOOST_FUNCTION_NUM_ARGS
diff --git a/include/ndnboost/function/function4.hpp b/include/ndnboost/function/function4.hpp
index 467b03b..e3a2be5 100644
--- a/include/ndnboost/function/function4.hpp
+++ b/include/ndnboost/function/function4.hpp
@@ -7,6 +7,6 @@
 
 // For more information, see http://www.boost.org
 
-#define BOOST_FUNCTION_NUM_ARGS 4
+#define NDNBOOST_FUNCTION_NUM_ARGS 4
 #include <ndnboost/function/detail/maybe_include.hpp>
-#undef BOOST_FUNCTION_NUM_ARGS
+#undef NDNBOOST_FUNCTION_NUM_ARGS
diff --git a/include/ndnboost/function/function5.hpp b/include/ndnboost/function/function5.hpp
index 77cf420..3d53e5a 100644
--- a/include/ndnboost/function/function5.hpp
+++ b/include/ndnboost/function/function5.hpp
@@ -7,6 +7,6 @@
 
 // For more information, see http://www.boost.org
 
-#define BOOST_FUNCTION_NUM_ARGS 5
+#define NDNBOOST_FUNCTION_NUM_ARGS 5
 #include <ndnboost/function/detail/maybe_include.hpp>
-#undef BOOST_FUNCTION_NUM_ARGS
+#undef NDNBOOST_FUNCTION_NUM_ARGS
diff --git a/include/ndnboost/function/function6.hpp b/include/ndnboost/function/function6.hpp
index eae829d..12746ea 100644
--- a/include/ndnboost/function/function6.hpp
+++ b/include/ndnboost/function/function6.hpp
@@ -7,6 +7,6 @@
 
 // For more information, see http://www.boost.org
 
-#define BOOST_FUNCTION_NUM_ARGS 6
+#define NDNBOOST_FUNCTION_NUM_ARGS 6
 #include <ndnboost/function/detail/maybe_include.hpp>
-#undef BOOST_FUNCTION_NUM_ARGS
+#undef NDNBOOST_FUNCTION_NUM_ARGS
diff --git a/include/ndnboost/function/function7.hpp b/include/ndnboost/function/function7.hpp
index 0c7a5aa..ed92ed2 100644
--- a/include/ndnboost/function/function7.hpp
+++ b/include/ndnboost/function/function7.hpp
@@ -7,6 +7,6 @@
 
 // For more information, see http://www.boost.org
 
-#define BOOST_FUNCTION_NUM_ARGS 7
+#define NDNBOOST_FUNCTION_NUM_ARGS 7
 #include <ndnboost/function/detail/maybe_include.hpp>
-#undef BOOST_FUNCTION_NUM_ARGS
+#undef NDNBOOST_FUNCTION_NUM_ARGS
diff --git a/include/ndnboost/function/function8.hpp b/include/ndnboost/function/function8.hpp
index c9cc28b..4817e51 100644
--- a/include/ndnboost/function/function8.hpp
+++ b/include/ndnboost/function/function8.hpp
@@ -7,6 +7,6 @@
 
 // For more information, see http://www.boost.org
 
-#define BOOST_FUNCTION_NUM_ARGS 8
+#define NDNBOOST_FUNCTION_NUM_ARGS 8
 #include <ndnboost/function/detail/maybe_include.hpp>
-#undef BOOST_FUNCTION_NUM_ARGS
+#undef NDNBOOST_FUNCTION_NUM_ARGS
diff --git a/include/ndnboost/function/function9.hpp b/include/ndnboost/function/function9.hpp
index 33c8836..a0cd21b 100644
--- a/include/ndnboost/function/function9.hpp
+++ b/include/ndnboost/function/function9.hpp
@@ -7,6 +7,6 @@
 
 // For more information, see http://www.boost.org
 
-#define BOOST_FUNCTION_NUM_ARGS 9
+#define NDNBOOST_FUNCTION_NUM_ARGS 9
 #include <ndnboost/function/detail/maybe_include.hpp>
-#undef BOOST_FUNCTION_NUM_ARGS
+#undef NDNBOOST_FUNCTION_NUM_ARGS
diff --git a/include/ndnboost/function/function_base.hpp b/include/ndnboost/function/function_base.hpp
index 30af1a3..f992eb3 100644
--- a/include/ndnboost/function/function_base.hpp
+++ b/include/ndnboost/function/function_base.hpp
@@ -8,8 +8,8 @@
 
 // For more information, see http://www.boost.org
 
-#ifndef BOOST_FUNCTION_BASE_HEADER
-#define BOOST_FUNCTION_BASE_HEADER
+#ifndef NDNBOOST_FUNCTION_BASE_HEADER
+#define NDNBOOST_FUNCTION_BASE_HEADER
 
 #include <stdexcept>
 #include <string>
@@ -30,7 +30,7 @@
 #include <ndnboost/mpl/if.hpp>
 #include <ndnboost/detail/workaround.hpp>
 #include <ndnboost/type_traits/alignment_of.hpp>
-#ifndef BOOST_NO_SFINAE
+#ifndef NDNBOOST_NO_SFINAE
 #  include "ndnboost/utility/enable_if.hpp"
 #else
 #  include "ndnboost/mpl/bool.hpp"
@@ -38,49 +38,49 @@
 #include <ndnboost/function_equal.hpp>
 #include <ndnboost/function/function_fwd.hpp>
 
-#if defined(BOOST_MSVC)
+#if defined(NDNBOOST_MSVC)
 #   pragma warning( push )
 #   pragma warning( disable : 4793 ) // complaint about native code generation
 #   pragma warning( disable : 4127 ) // "conditional expression is constant"
 #endif       
 
-// Define BOOST_FUNCTION_STD_NS to the namespace that contains type_info.
-#ifdef BOOST_NO_STD_TYPEINFO
+// Define NDNBOOST_FUNCTION_STD_NS to the namespace that contains type_info.
+#ifdef NDNBOOST_NO_STD_TYPEINFO
 // Embedded VC++ does not have type_info in namespace std
-#  define BOOST_FUNCTION_STD_NS
+#  define NDNBOOST_FUNCTION_STD_NS
 #else
-#  define BOOST_FUNCTION_STD_NS std
+#  define NDNBOOST_FUNCTION_STD_NS std
 #endif
 
 // Borrowed from Boost.Python library: determines the cases where we
 // need to use std::type_info::name to compare instead of operator==.
-#if defined( BOOST_NO_TYPEID )
-#  define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) ((X)==(Y))
+#if defined( NDNBOOST_NO_TYPEID )
+#  define NDNBOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) ((X)==(Y))
 #elif (defined(__GNUC__) && __GNUC__ >= 3) \
  || defined(_AIX) \
  || (   defined(__sgi) && defined(__host_mips))
 #  include <cstring>
-#  define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) \
+#  define NDNBOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) \
      (std::strcmp((X).name(),(Y).name()) == 0)
 # else
-#  define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) ((X)==(Y))
+#  define NDNBOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) ((X)==(Y))
 #endif
 
-#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 || defined(__ICL) && __ICL <= 600 || defined(__MWERKS__) && __MWERKS__ < 0x2406 && !defined(BOOST_STRICT_CONFIG)
-#  define BOOST_FUNCTION_TARGET_FIX(x) x
+#if defined(NDNBOOST_MSVC) && NDNBOOST_MSVC <= 1300 || defined(__ICL) && __ICL <= 600 || defined(__MWERKS__) && __MWERKS__ < 0x2406 && !defined(NDNBOOST_STRICT_CONFIG)
+#  define NDNBOOST_FUNCTION_TARGET_FIX(x) x
 #else
-#  define BOOST_FUNCTION_TARGET_FIX(x)
+#  define NDNBOOST_FUNCTION_TARGET_FIX(x)
 #endif // not MSVC
 
-#if !BOOST_WORKAROUND(__BORLANDC__, < 0x5A0)
-#  define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type)              \
+#if !NDNBOOST_WORKAROUND(__BORLANDC__, < 0x5A0)
+#  define NDNBOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type)              \
       typename ::ndnboost::enable_if_c<(::ndnboost::type_traits::ice_not<          \
                             (::ndnboost::is_integral<Functor>::value)>::value), \
                            Type>::type
 #else
 // BCC doesn't recognize this depends on a template argument and complains
 // about the use of 'typename'
-#  define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type)     \
+#  define NDNBOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type)     \
       ::ndnboost::enable_if_c<(::ndnboost::type_traits::ice_not<          \
                    (::ndnboost::is_integral<Functor>::value)>::value), \
                        Type>::type
@@ -222,7 +222,7 @@
 
               // Check whether we have the same type. We can add
               // cv-qualifiers, but we can't take them away.
-              if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(F))
+              if (NDNBOOST_FUNCTION_COMPARE_TYPE_ID(check_type, NDNBOOST_SP_TYPEID(F))
                   && (!in_buffer.obj_ref.is_const_qualified 
                       || out_buffer.type.const_qualified)
                   && (!in_buffer.obj_ref.is_volatile_qualified
@@ -234,7 +234,7 @@
             return;
 
           case get_functor_type_tag:
-            out_buffer.type.type = &BOOST_SP_TYPEID(F);
+            out_buffer.type.type = &NDNBOOST_SP_TYPEID(F);
             out_buffer.type.const_qualified = in_buffer.obj_ref.is_const_qualified;
             out_buffer.type.volatile_qualified = in_buffer.obj_ref.is_volatile_qualified;
             return;
@@ -249,7 +249,7 @@
       template<typename F>
       struct function_allows_small_object_optimization
       {
-        BOOST_STATIC_CONSTANT
+        NDNBOOST_STATIC_CONSTANT
           (bool, 
            value = ((sizeof(F) <= sizeof(function_buffer) &&
                      (alignment_of<function_buffer>::value 
@@ -296,12 +296,12 @@
           else if (op == check_functor_type_tag) {
             const detail::sp_typeinfo& check_type 
               = *out_buffer.type.type;
-            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
+            if (NDNBOOST_FUNCTION_COMPARE_TYPE_ID(check_type, NDNBOOST_SP_TYPEID(Functor)))
               out_buffer.obj_ptr = &in_buffer.func_ptr;
             else
               out_buffer.obj_ptr = 0;
           } else /* op == get_functor_type_tag */ {
-            out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
+            out_buffer.type.type = &NDNBOOST_SP_TYPEID(Functor);
             out_buffer.type.const_qualified = false;
             out_buffer.type.volatile_qualified = false;
           }
@@ -330,12 +330,12 @@
           } else if (op == check_functor_type_tag) {
             const detail::sp_typeinfo& check_type 
               = *out_buffer.type.type;
-            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
+            if (NDNBOOST_FUNCTION_COMPARE_TYPE_ID(check_type, NDNBOOST_SP_TYPEID(Functor)))
               out_buffer.obj_ptr = &in_buffer.data;
             else
               out_buffer.obj_ptr = 0;
           } else /* op == get_functor_type_tag */ {
-            out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
+            out_buffer.type.type = &NDNBOOST_SP_TYPEID(Functor);
             out_buffer.type.const_qualified = false;
             out_buffer.type.volatile_qualified = false;            
           }
@@ -391,12 +391,12 @@
           } else if (op == check_functor_type_tag) {
             const detail::sp_typeinfo& check_type
               = *out_buffer.type.type;
-            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
+            if (NDNBOOST_FUNCTION_COMPARE_TYPE_ID(check_type, NDNBOOST_SP_TYPEID(Functor)))
               out_buffer.obj_ptr = in_buffer.obj_ptr;
             else
               out_buffer.obj_ptr = 0;
           } else /* op == get_functor_type_tag */ {
-            out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
+            out_buffer.type.type = &NDNBOOST_SP_TYPEID(Functor);
             out_buffer.type.const_qualified = false;
             out_buffer.type.volatile_qualified = false;
           }
@@ -431,7 +431,7 @@
           typedef typename get_function_tag<functor_type>::type tag_type;
           switch (op) {
           case get_functor_type_tag:
-            out_buffer.type.type = &BOOST_SP_TYPEID(functor_type);
+            out_buffer.type.type = &NDNBOOST_SP_TYPEID(functor_type);
             out_buffer.type.const_qualified = false;
             out_buffer.type.volatile_qualified = false;
             return;
@@ -502,12 +502,12 @@
           } else if (op == check_functor_type_tag) {
             const detail::sp_typeinfo& check_type 
               = *out_buffer.type.type;
-            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
+            if (NDNBOOST_FUNCTION_COMPARE_TYPE_ID(check_type, NDNBOOST_SP_TYPEID(Functor)))
               out_buffer.obj_ptr = in_buffer.obj_ptr;
             else
               out_buffer.obj_ptr = 0;
           } else /* op == get_functor_type_tag */ {
-            out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
+            out_buffer.type.type = &NDNBOOST_SP_TYPEID(Functor);
             out_buffer.type.const_qualified = false;
             out_buffer.type.volatile_qualified = false;
           }
@@ -534,7 +534,7 @@
           typedef typename get_function_tag<functor_type>::type tag_type;
           switch (op) {
           case get_functor_type_tag:
-            out_buffer.type.type = &BOOST_SP_TYPEID(functor_type);
+            out_buffer.type.type = &NDNBOOST_SP_TYPEID(functor_type);
             out_buffer.type.const_qualified = false;
             out_buffer.type.volatile_qualified = false;
             return;
@@ -549,7 +549,7 @@
       // A type that is only used for comparisons against zero
       struct useless_clear_type {};
 
-#ifdef BOOST_NO_SFINAE
+#ifdef NDNBOOST_NO_SFINAE
       // These routines perform comparisons between a Boost.Function
       // object and an arbitrary function object (when the last
       // parameter is mpl::bool_<false>) or against zero (when the
@@ -606,7 +606,7 @@
             return fp != g.get_pointer();
           else return true;
         }
-#endif // BOOST_NO_SFINAE
+#endif // NDNBOOST_NO_SFINAE
 
       /**
        * Stores the "manager" portion of the vtable for a
@@ -635,11 +635,11 @@
   /** Determine if the function is empty (i.e., has no target). */
   bool empty() const { return !vtable; }
 
-  /** Retrieve the type of the stored function object, or BOOST_SP_TYPEID(void)
+  /** Retrieve the type of the stored function object, or NDNBOOST_SP_TYPEID(void)
       if this is empty. */
   const detail::sp_typeinfo& target_type() const
   {
-    if (!vtable) return BOOST_SP_TYPEID(void);
+    if (!vtable) return NDNBOOST_SP_TYPEID(void);
 
     detail::function::function_buffer type;
     get_vtable()->manager(functor, type, detail::function::get_functor_type_tag);
@@ -652,7 +652,7 @@
       if (!vtable) return 0;
 
       detail::function::function_buffer type_result;
-      type_result.type.type = &BOOST_SP_TYPEID(Functor);
+      type_result.type.type = &NDNBOOST_SP_TYPEID(Functor);
       type_result.type.const_qualified = is_const<Functor>::value;
       type_result.type.volatile_qualified = is_volatile<Functor>::value;
       get_vtable()->manager(functor, type_result, 
@@ -661,7 +661,7 @@
     }
 
   template<typename Functor>
-#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+#if defined(NDNBOOST_MSVC) && NDNBOOST_WORKAROUND(NDNBOOST_MSVC, < 1300)
     const Functor* target( Functor * = 0 ) const
 #else
     const Functor* target() const
@@ -670,7 +670,7 @@
       if (!vtable) return 0;
 
       detail::function::function_buffer type_result;
-      type_result.type.type = &BOOST_SP_TYPEID(Functor);
+      type_result.type.type = &NDNBOOST_SP_TYPEID(Functor);
       type_result.type.const_qualified = true;
       type_result.type.volatile_qualified = is_volatile<Functor>::value;
       get_vtable()->manager(functor, type_result, 
@@ -683,7 +683,7 @@
   template<typename F>
     bool contains(const F& f) const
     {
-#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+#if defined(NDNBOOST_MSVC) && NDNBOOST_WORKAROUND(NDNBOOST_MSVC, < 1300)
       if (const F* fp = this->target( (F*)0 ))
 #else
       if (const F* fp = this->template target<F>())
@@ -700,7 +700,7 @@
   // problems with instantiation of function return types before it
   // has been verified that the argument types match up.
   template<typename Functor>
-    BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+    NDNBOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
     operator==(Functor g) const
     {
       if (const Functor* fp = target<Functor>())
@@ -709,7 +709,7 @@
     }
 
   template<typename Functor>
-    BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+    NDNBOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
     operator!=(Functor g) const
     {
       if (const Functor* fp = target<Functor>())
@@ -742,7 +742,7 @@
   bad_function_call() : std::runtime_error("call to empty ndnboost::function") {}
 };
 
-#ifndef BOOST_NO_SFINAE
+#ifndef NDNBOOST_NO_SFINAE
 inline bool operator==(const function_base& f,
                        detail::function::useless_clear_type*)
 {
@@ -768,7 +768,7 @@
 }
 #endif
 
-#ifdef BOOST_NO_SFINAE
+#ifdef NDNBOOST_NO_SFINAE
 // Comparisons between ndnboost::function objects and arbitrary function objects
 template<typename Functor>
   inline bool operator==(const function_base& f, Functor g)
@@ -804,7 +804,7 @@
 // objects. GCC 3.3 and before has an obnoxious bug that prevents this
 // from working.
 template<typename Functor>
-  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+  NDNBOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
   operator==(const function_base& f, Functor g)
   {
     if (const Functor* fp = f.template target<Functor>())
@@ -813,7 +813,7 @@
   }
 
 template<typename Functor>
-  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+  NDNBOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
   operator==(Functor g, const function_base& f)
   {
     if (const Functor* fp = f.template target<Functor>())
@@ -822,7 +822,7 @@
   }
 
 template<typename Functor>
-  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+  NDNBOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
   operator!=(const function_base& f, Functor g)
   {
     if (const Functor* fp = f.template target<Functor>())
@@ -831,7 +831,7 @@
   }
 
 template<typename Functor>
-  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+  NDNBOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
   operator!=(Functor g, const function_base& f)
   {
     if (const Functor* fp = f.template target<Functor>())
@@ -841,7 +841,7 @@
 #  endif
 
 template<typename Functor>
-  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+  NDNBOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
   operator==(const function_base& f, reference_wrapper<Functor> g)
   {
     if (const Functor* fp = f.template target<Functor>())
@@ -850,7 +850,7 @@
   }
 
 template<typename Functor>
-  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+  NDNBOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
   operator==(reference_wrapper<Functor> g, const function_base& f)
   {
     if (const Functor* fp = f.template target<Functor>())
@@ -859,7 +859,7 @@
   }
 
 template<typename Functor>
-  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+  NDNBOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
   operator!=(const function_base& f, reference_wrapper<Functor> g)
   {
     if (const Functor* fp = f.template target<Functor>())
@@ -868,7 +868,7 @@
   }
 
 template<typename Functor>
-  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+  NDNBOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
   operator!=(reference_wrapper<Functor> g, const function_base& f)
   {
     if (const Functor* fp = f.template target<Functor>())
@@ -885,7 +885,7 @@
       return f->empty();
     }
 
-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1310)
+#if NDNBOOST_WORKAROUND(NDNBOOST_MSVC, <= 1310)
     inline bool has_empty_target(const void*)
     {
       return false;
@@ -900,11 +900,11 @@
 } // end namespace detail
 } // end namespace ndnboost
 
-#undef BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL
-#undef BOOST_FUNCTION_COMPARE_TYPE_ID
+#undef NDNBOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL
+#undef NDNBOOST_FUNCTION_COMPARE_TYPE_ID
 
-#if defined(BOOST_MSVC)
+#if defined(NDNBOOST_MSVC)
 #   pragma warning( pop )
 #endif       
 
-#endif // BOOST_FUNCTION_BASE_HEADER
+#endif // NDNBOOST_FUNCTION_BASE_HEADER
diff --git a/include/ndnboost/function/function_fwd.hpp b/include/ndnboost/function/function_fwd.hpp
index 11df6eb..3ebc33c 100644
--- a/include/ndnboost/function/function_fwd.hpp
+++ b/include/ndnboost/function/function_fwd.hpp
@@ -6,11 +6,11 @@
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
 // For more information, see http://www.boost.org
-#ifndef BOOST_FUNCTION_FWD_HPP
-#define BOOST_FUNCTION_FWD_HPP
+#ifndef NDNBOOST_FUNCTION_FWD_HPP
+#define NDNBOOST_FUNCTION_FWD_HPP
 #include <ndnboost/config.hpp>
 
-#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730 && !defined(BOOST_STRICT_CONFIG)
+#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730 && !defined(NDNBOOST_STRICT_CONFIG)
 // Work around a compiler bug.
 // ndnboost::python::objects::function has to be seen by the compiler before the
 // ndnboost::function class template.
@@ -19,16 +19,16 @@
 }}}
 #endif
 
-#if defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)                    \
- || defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG)                         \
- || !(defined(BOOST_STRICT_CONFIG) || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540)
-#  define BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX
+#if defined (NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)                    \
+ || defined(NDNBOOST_BCB_PARTIAL_SPECIALIZATION_BUG)                         \
+ || !(defined(NDNBOOST_STRICT_CONFIG) || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540)
+#  define NDNBOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX
 #endif
 
 namespace ndnboost {
   class bad_function_call;
 
-#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
+#if !defined(NDNBOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
   // Preferred syntax
   template<typename Signature> class function;
 
diff --git a/include/ndnboost/function/function_template.hpp b/include/ndnboost/function/function_template.hpp
index 6256b73..11642e6 100644
--- a/include/ndnboost/function/function_template.hpp
+++ b/include/ndnboost/function/function_template.hpp
@@ -13,69 +13,69 @@
 #include <ndnboost/function/detail/prologue.hpp>
 #include <ndnboost/detail/no_exceptions_support.hpp>
 
-#if defined(BOOST_MSVC)
+#if defined(NDNBOOST_MSVC)
 #   pragma warning( push )
 #   pragma warning( disable : 4127 ) // "conditional expression is constant"
 #endif       
 
-#define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T)
+#define NDNBOOST_FUNCTION_TEMPLATE_PARMS NDNBOOST_PP_ENUM_PARAMS(NDNBOOST_FUNCTION_NUM_ARGS, typename T)
 
-#define BOOST_FUNCTION_TEMPLATE_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, T)
+#define NDNBOOST_FUNCTION_TEMPLATE_ARGS NDNBOOST_PP_ENUM_PARAMS(NDNBOOST_FUNCTION_NUM_ARGS, T)
 
-#define BOOST_FUNCTION_PARM(J,I,D) BOOST_PP_CAT(T,I) BOOST_PP_CAT(a,I)
+#define NDNBOOST_FUNCTION_PARM(J,I,D) NDNBOOST_PP_CAT(T,I) NDNBOOST_PP_CAT(a,I)
 
-#define BOOST_FUNCTION_PARMS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_PARM,BOOST_PP_EMPTY)
+#define NDNBOOST_FUNCTION_PARMS NDNBOOST_PP_ENUM(NDNBOOST_FUNCTION_NUM_ARGS,NDNBOOST_FUNCTION_PARM,NDNBOOST_PP_EMPTY)
 
-#define BOOST_FUNCTION_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, a)
+#define NDNBOOST_FUNCTION_ARGS NDNBOOST_PP_ENUM_PARAMS(NDNBOOST_FUNCTION_NUM_ARGS, a)
 
-#define BOOST_FUNCTION_ARG_TYPE(J,I,D) \
-  typedef BOOST_PP_CAT(T,I) BOOST_PP_CAT(BOOST_PP_CAT(arg, BOOST_PP_INC(I)),_type);
+#define NDNBOOST_FUNCTION_ARG_TYPE(J,I,D) \
+  typedef NDNBOOST_PP_CAT(T,I) NDNBOOST_PP_CAT(NDNBOOST_PP_CAT(arg, NDNBOOST_PP_INC(I)),_type);
 
-#define BOOST_FUNCTION_ARG_TYPES BOOST_PP_REPEAT(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG_TYPE,BOOST_PP_EMPTY)
+#define NDNBOOST_FUNCTION_ARG_TYPES NDNBOOST_PP_REPEAT(NDNBOOST_FUNCTION_NUM_ARGS,NDNBOOST_FUNCTION_ARG_TYPE,NDNBOOST_PP_EMPTY)
 
 // Comma if nonzero number of arguments
-#if BOOST_FUNCTION_NUM_ARGS == 0
-#  define BOOST_FUNCTION_COMMA
+#if NDNBOOST_FUNCTION_NUM_ARGS == 0
+#  define NDNBOOST_FUNCTION_COMMA
 #else
-#  define BOOST_FUNCTION_COMMA ,
-#endif // BOOST_FUNCTION_NUM_ARGS > 0
+#  define NDNBOOST_FUNCTION_COMMA ,
+#endif // NDNBOOST_FUNCTION_NUM_ARGS > 0
 
 // Class names used in this version of the code
-#define BOOST_FUNCTION_FUNCTION BOOST_JOIN(function,BOOST_FUNCTION_NUM_ARGS)
-#define BOOST_FUNCTION_FUNCTION_INVOKER \
-  BOOST_JOIN(function_invoker,BOOST_FUNCTION_NUM_ARGS)
-#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER \
-  BOOST_JOIN(void_function_invoker,BOOST_FUNCTION_NUM_ARGS)
-#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER \
-  BOOST_JOIN(function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
-#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER \
-  BOOST_JOIN(void_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
-#define BOOST_FUNCTION_FUNCTION_REF_INVOKER \
-  BOOST_JOIN(function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
-#define BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER \
-  BOOST_JOIN(void_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
-#define BOOST_FUNCTION_MEMBER_INVOKER \
-  BOOST_JOIN(function_mem_invoker,BOOST_FUNCTION_NUM_ARGS)
-#define BOOST_FUNCTION_VOID_MEMBER_INVOKER \
-  BOOST_JOIN(function_void_mem_invoker,BOOST_FUNCTION_NUM_ARGS)
-#define BOOST_FUNCTION_GET_FUNCTION_INVOKER \
-  BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS)
-#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER \
-  BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
-#define BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER \
-  BOOST_JOIN(get_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
-#define BOOST_FUNCTION_GET_MEMBER_INVOKER \
-  BOOST_JOIN(get_member_invoker,BOOST_FUNCTION_NUM_ARGS)
-#define BOOST_FUNCTION_GET_INVOKER \
-  BOOST_JOIN(get_invoker,BOOST_FUNCTION_NUM_ARGS)
-#define BOOST_FUNCTION_VTABLE BOOST_JOIN(basic_vtable,BOOST_FUNCTION_NUM_ARGS)
+#define NDNBOOST_FUNCTION_FUNCTION NDNBOOST_JOIN(function,NDNBOOST_FUNCTION_NUM_ARGS)
+#define NDNBOOST_FUNCTION_FUNCTION_INVOKER \
+  NDNBOOST_JOIN(function_invoker,NDNBOOST_FUNCTION_NUM_ARGS)
+#define NDNBOOST_FUNCTION_VOID_FUNCTION_INVOKER \
+  NDNBOOST_JOIN(void_function_invoker,NDNBOOST_FUNCTION_NUM_ARGS)
+#define NDNBOOST_FUNCTION_FUNCTION_OBJ_INVOKER \
+  NDNBOOST_JOIN(function_obj_invoker,NDNBOOST_FUNCTION_NUM_ARGS)
+#define NDNBOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER \
+  NDNBOOST_JOIN(void_function_obj_invoker,NDNBOOST_FUNCTION_NUM_ARGS)
+#define NDNBOOST_FUNCTION_FUNCTION_REF_INVOKER \
+  NDNBOOST_JOIN(function_ref_invoker,NDNBOOST_FUNCTION_NUM_ARGS)
+#define NDNBOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER \
+  NDNBOOST_JOIN(void_function_ref_invoker,NDNBOOST_FUNCTION_NUM_ARGS)
+#define NDNBOOST_FUNCTION_MEMBER_INVOKER \
+  NDNBOOST_JOIN(function_mem_invoker,NDNBOOST_FUNCTION_NUM_ARGS)
+#define NDNBOOST_FUNCTION_VOID_MEMBER_INVOKER \
+  NDNBOOST_JOIN(function_void_mem_invoker,NDNBOOST_FUNCTION_NUM_ARGS)
+#define NDNBOOST_FUNCTION_GET_FUNCTION_INVOKER \
+  NDNBOOST_JOIN(get_function_invoker,NDNBOOST_FUNCTION_NUM_ARGS)
+#define NDNBOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER \
+  NDNBOOST_JOIN(get_function_obj_invoker,NDNBOOST_FUNCTION_NUM_ARGS)
+#define NDNBOOST_FUNCTION_GET_FUNCTION_REF_INVOKER \
+  NDNBOOST_JOIN(get_function_ref_invoker,NDNBOOST_FUNCTION_NUM_ARGS)
+#define NDNBOOST_FUNCTION_GET_MEMBER_INVOKER \
+  NDNBOOST_JOIN(get_member_invoker,NDNBOOST_FUNCTION_NUM_ARGS)
+#define NDNBOOST_FUNCTION_GET_INVOKER \
+  NDNBOOST_JOIN(get_invoker,NDNBOOST_FUNCTION_NUM_ARGS)
+#define NDNBOOST_FUNCTION_VTABLE NDNBOOST_JOIN(basic_vtable,NDNBOOST_FUNCTION_NUM_ARGS)
 
-#ifndef BOOST_NO_VOID_RETURNS
-#  define BOOST_FUNCTION_VOID_RETURN_TYPE void
-#  define BOOST_FUNCTION_RETURN(X) X
+#ifndef NDNBOOST_NO_VOID_RETURNS
+#  define NDNBOOST_FUNCTION_VOID_RETURN_TYPE void
+#  define NDNBOOST_FUNCTION_RETURN(X) X
 #else
-#  define BOOST_FUNCTION_VOID_RETURN_TYPE ndnboost::detail::function::unusable
-#  define BOOST_FUNCTION_RETURN(X) X; return BOOST_FUNCTION_VOID_RETURN_TYPE ()
+#  define NDNBOOST_FUNCTION_VOID_RETURN_TYPE ndnboost::detail::function::unusable
+#  define NDNBOOST_FUNCTION_RETURN(X) X; return NDNBOOST_FUNCTION_VOID_RETURN_TYPE ()
 #endif
 
 namespace ndnboost {
@@ -83,45 +83,45 @@
     namespace function {
       template<
         typename FunctionPtr,
-        typename R BOOST_FUNCTION_COMMA
-        BOOST_FUNCTION_TEMPLATE_PARMS
+        typename R NDNBOOST_FUNCTION_COMMA
+        NDNBOOST_FUNCTION_TEMPLATE_PARMS
         >
-      struct BOOST_FUNCTION_FUNCTION_INVOKER
+      struct NDNBOOST_FUNCTION_FUNCTION_INVOKER
       {
-        static R invoke(function_buffer& function_ptr BOOST_FUNCTION_COMMA
-                        BOOST_FUNCTION_PARMS)
+        static R invoke(function_buffer& function_ptr NDNBOOST_FUNCTION_COMMA
+                        NDNBOOST_FUNCTION_PARMS)
         {
           FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
-          return f(BOOST_FUNCTION_ARGS);
+          return f(NDNBOOST_FUNCTION_ARGS);
         }
       };
 
       template<
         typename FunctionPtr,
-        typename R BOOST_FUNCTION_COMMA
-        BOOST_FUNCTION_TEMPLATE_PARMS
+        typename R NDNBOOST_FUNCTION_COMMA
+        NDNBOOST_FUNCTION_TEMPLATE_PARMS
         >
-      struct BOOST_FUNCTION_VOID_FUNCTION_INVOKER
+      struct NDNBOOST_FUNCTION_VOID_FUNCTION_INVOKER
       {
-        static BOOST_FUNCTION_VOID_RETURN_TYPE
-        invoke(function_buffer& function_ptr BOOST_FUNCTION_COMMA
-               BOOST_FUNCTION_PARMS)
+        static NDNBOOST_FUNCTION_VOID_RETURN_TYPE
+        invoke(function_buffer& function_ptr NDNBOOST_FUNCTION_COMMA
+               NDNBOOST_FUNCTION_PARMS)
 
         {
           FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
-          BOOST_FUNCTION_RETURN(f(BOOST_FUNCTION_ARGS));
+          NDNBOOST_FUNCTION_RETURN(f(NDNBOOST_FUNCTION_ARGS));
         }
       };
 
       template<
         typename FunctionObj,
-        typename R BOOST_FUNCTION_COMMA
-        BOOST_FUNCTION_TEMPLATE_PARMS
+        typename R NDNBOOST_FUNCTION_COMMA
+        NDNBOOST_FUNCTION_TEMPLATE_PARMS
       >
-      struct BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
+      struct NDNBOOST_FUNCTION_FUNCTION_OBJ_INVOKER
       {
-        static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
-                        BOOST_FUNCTION_PARMS)
+        static R invoke(function_buffer& function_obj_ptr NDNBOOST_FUNCTION_COMMA
+                        NDNBOOST_FUNCTION_PARMS)
 
         {
           FunctionObj* f;
@@ -129,20 +129,20 @@
             f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
           else
             f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
-          return (*f)(BOOST_FUNCTION_ARGS);
+          return (*f)(NDNBOOST_FUNCTION_ARGS);
         }
       };
 
       template<
         typename FunctionObj,
-        typename R BOOST_FUNCTION_COMMA
-        BOOST_FUNCTION_TEMPLATE_PARMS
+        typename R NDNBOOST_FUNCTION_COMMA
+        NDNBOOST_FUNCTION_TEMPLATE_PARMS
       >
-      struct BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
+      struct NDNBOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
       {
-        static BOOST_FUNCTION_VOID_RETURN_TYPE
-        invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
-               BOOST_FUNCTION_PARMS)
+        static NDNBOOST_FUNCTION_VOID_RETURN_TYPE
+        invoke(function_buffer& function_obj_ptr NDNBOOST_FUNCTION_COMMA
+               NDNBOOST_FUNCTION_PARMS)
 
         {
           FunctionObj* f;
@@ -150,165 +150,165 @@
             f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
           else
             f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
-          BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS));
+          NDNBOOST_FUNCTION_RETURN((*f)(NDNBOOST_FUNCTION_ARGS));
         }
       };
 
       template<
         typename FunctionObj,
-        typename R BOOST_FUNCTION_COMMA
-        BOOST_FUNCTION_TEMPLATE_PARMS
+        typename R NDNBOOST_FUNCTION_COMMA
+        NDNBOOST_FUNCTION_TEMPLATE_PARMS
       >
-      struct BOOST_FUNCTION_FUNCTION_REF_INVOKER
+      struct NDNBOOST_FUNCTION_FUNCTION_REF_INVOKER
       {
-        static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
-                        BOOST_FUNCTION_PARMS)
+        static R invoke(function_buffer& function_obj_ptr NDNBOOST_FUNCTION_COMMA
+                        NDNBOOST_FUNCTION_PARMS)
 
         {
           FunctionObj* f = 
             reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
-          return (*f)(BOOST_FUNCTION_ARGS);
+          return (*f)(NDNBOOST_FUNCTION_ARGS);
         }
       };
 
       template<
         typename FunctionObj,
-        typename R BOOST_FUNCTION_COMMA
-        BOOST_FUNCTION_TEMPLATE_PARMS
+        typename R NDNBOOST_FUNCTION_COMMA
+        NDNBOOST_FUNCTION_TEMPLATE_PARMS
       >
-      struct BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
+      struct NDNBOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
       {
-        static BOOST_FUNCTION_VOID_RETURN_TYPE
-        invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
-               BOOST_FUNCTION_PARMS)
+        static NDNBOOST_FUNCTION_VOID_RETURN_TYPE
+        invoke(function_buffer& function_obj_ptr NDNBOOST_FUNCTION_COMMA
+               NDNBOOST_FUNCTION_PARMS)
 
         {
           FunctionObj* f = 
             reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
-          BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS));
+          NDNBOOST_FUNCTION_RETURN((*f)(NDNBOOST_FUNCTION_ARGS));
         }
       };
 
-#if BOOST_FUNCTION_NUM_ARGS > 0
+#if NDNBOOST_FUNCTION_NUM_ARGS > 0
       /* Handle invocation of member pointers. */
       template<
         typename MemberPtr,
-        typename R BOOST_FUNCTION_COMMA
-        BOOST_FUNCTION_TEMPLATE_PARMS
+        typename R NDNBOOST_FUNCTION_COMMA
+        NDNBOOST_FUNCTION_TEMPLATE_PARMS
       >
-      struct BOOST_FUNCTION_MEMBER_INVOKER
+      struct NDNBOOST_FUNCTION_MEMBER_INVOKER
       {
-        static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
-                        BOOST_FUNCTION_PARMS)
+        static R invoke(function_buffer& function_obj_ptr NDNBOOST_FUNCTION_COMMA
+                        NDNBOOST_FUNCTION_PARMS)
 
         {
           MemberPtr* f = 
             reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
-          return ndnboost::mem_fn(*f)(BOOST_FUNCTION_ARGS);
+          return ndnboost::mem_fn(*f)(NDNBOOST_FUNCTION_ARGS);
         }
       };
 
       template<
         typename MemberPtr,
-        typename R BOOST_FUNCTION_COMMA
-        BOOST_FUNCTION_TEMPLATE_PARMS
+        typename R NDNBOOST_FUNCTION_COMMA
+        NDNBOOST_FUNCTION_TEMPLATE_PARMS
       >
-      struct BOOST_FUNCTION_VOID_MEMBER_INVOKER
+      struct NDNBOOST_FUNCTION_VOID_MEMBER_INVOKER
       {
-        static BOOST_FUNCTION_VOID_RETURN_TYPE
-        invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
-               BOOST_FUNCTION_PARMS)
+        static NDNBOOST_FUNCTION_VOID_RETURN_TYPE
+        invoke(function_buffer& function_obj_ptr NDNBOOST_FUNCTION_COMMA
+               NDNBOOST_FUNCTION_PARMS)
 
         {
           MemberPtr* f = 
             reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
-          BOOST_FUNCTION_RETURN(ndnboost::mem_fn(*f)(BOOST_FUNCTION_ARGS));
+          NDNBOOST_FUNCTION_RETURN(ndnboost::mem_fn(*f)(NDNBOOST_FUNCTION_ARGS));
         }
       };
 #endif
 
       template<
         typename FunctionPtr,
-        typename R BOOST_FUNCTION_COMMA
-        BOOST_FUNCTION_TEMPLATE_PARMS
+        typename R NDNBOOST_FUNCTION_COMMA
+        NDNBOOST_FUNCTION_TEMPLATE_PARMS
       >
-      struct BOOST_FUNCTION_GET_FUNCTION_INVOKER
+      struct NDNBOOST_FUNCTION_GET_FUNCTION_INVOKER
       {
         typedef typename mpl::if_c<(is_void<R>::value),
-                            BOOST_FUNCTION_VOID_FUNCTION_INVOKER<
+                            NDNBOOST_FUNCTION_VOID_FUNCTION_INVOKER<
                             FunctionPtr,
-                            R BOOST_FUNCTION_COMMA
-                            BOOST_FUNCTION_TEMPLATE_ARGS
+                            R NDNBOOST_FUNCTION_COMMA
+                            NDNBOOST_FUNCTION_TEMPLATE_ARGS
                           >,
-                          BOOST_FUNCTION_FUNCTION_INVOKER<
+                          NDNBOOST_FUNCTION_FUNCTION_INVOKER<
                             FunctionPtr,
-                            R BOOST_FUNCTION_COMMA
-                            BOOST_FUNCTION_TEMPLATE_ARGS
+                            R NDNBOOST_FUNCTION_COMMA
+                            NDNBOOST_FUNCTION_TEMPLATE_ARGS
                           >
                        >::type type;
       };
 
       template<
         typename FunctionObj,
-        typename R BOOST_FUNCTION_COMMA
-        BOOST_FUNCTION_TEMPLATE_PARMS
+        typename R NDNBOOST_FUNCTION_COMMA
+        NDNBOOST_FUNCTION_TEMPLATE_PARMS
        >
-      struct BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
+      struct NDNBOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
       {
         typedef typename mpl::if_c<(is_void<R>::value),
-                            BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER<
+                            NDNBOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER<
                             FunctionObj,
-                            R BOOST_FUNCTION_COMMA
-                            BOOST_FUNCTION_TEMPLATE_ARGS
+                            R NDNBOOST_FUNCTION_COMMA
+                            NDNBOOST_FUNCTION_TEMPLATE_ARGS
                           >,
-                          BOOST_FUNCTION_FUNCTION_OBJ_INVOKER<
+                          NDNBOOST_FUNCTION_FUNCTION_OBJ_INVOKER<
                             FunctionObj,
-                            R BOOST_FUNCTION_COMMA
-                            BOOST_FUNCTION_TEMPLATE_ARGS
+                            R NDNBOOST_FUNCTION_COMMA
+                            NDNBOOST_FUNCTION_TEMPLATE_ARGS
                           >
                        >::type type;
       };
 
       template<
         typename FunctionObj,
-        typename R BOOST_FUNCTION_COMMA
-        BOOST_FUNCTION_TEMPLATE_PARMS
+        typename R NDNBOOST_FUNCTION_COMMA
+        NDNBOOST_FUNCTION_TEMPLATE_PARMS
        >
-      struct BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
+      struct NDNBOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
       {
         typedef typename mpl::if_c<(is_void<R>::value),
-                            BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER<
+                            NDNBOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER<
                             FunctionObj,
-                            R BOOST_FUNCTION_COMMA
-                            BOOST_FUNCTION_TEMPLATE_ARGS
+                            R NDNBOOST_FUNCTION_COMMA
+                            NDNBOOST_FUNCTION_TEMPLATE_ARGS
                           >,
-                          BOOST_FUNCTION_FUNCTION_REF_INVOKER<
+                          NDNBOOST_FUNCTION_FUNCTION_REF_INVOKER<
                             FunctionObj,
-                            R BOOST_FUNCTION_COMMA
-                            BOOST_FUNCTION_TEMPLATE_ARGS
+                            R NDNBOOST_FUNCTION_COMMA
+                            NDNBOOST_FUNCTION_TEMPLATE_ARGS
                           >
                        >::type type;
       };
 
-#if BOOST_FUNCTION_NUM_ARGS > 0
+#if NDNBOOST_FUNCTION_NUM_ARGS > 0
       /* Retrieve the appropriate invoker for a member pointer.  */
       template<
         typename MemberPtr,
-        typename R BOOST_FUNCTION_COMMA
-        BOOST_FUNCTION_TEMPLATE_PARMS
+        typename R NDNBOOST_FUNCTION_COMMA
+        NDNBOOST_FUNCTION_TEMPLATE_PARMS
        >
-      struct BOOST_FUNCTION_GET_MEMBER_INVOKER
+      struct NDNBOOST_FUNCTION_GET_MEMBER_INVOKER
       {
         typedef typename mpl::if_c<(is_void<R>::value),
-                            BOOST_FUNCTION_VOID_MEMBER_INVOKER<
+                            NDNBOOST_FUNCTION_VOID_MEMBER_INVOKER<
                             MemberPtr,
-                            R BOOST_FUNCTION_COMMA
-                            BOOST_FUNCTION_TEMPLATE_ARGS
+                            R NDNBOOST_FUNCTION_COMMA
+                            NDNBOOST_FUNCTION_TEMPLATE_ARGS
                           >,
-                          BOOST_FUNCTION_MEMBER_INVOKER<
+                          NDNBOOST_FUNCTION_MEMBER_INVOKER<
                             MemberPtr,
-                            R BOOST_FUNCTION_COMMA
-                            BOOST_FUNCTION_TEMPLATE_ARGS
+                            R NDNBOOST_FUNCTION_COMMA
+                            NDNBOOST_FUNCTION_TEMPLATE_ARGS
                           >
                        >::type type;
       };
@@ -324,20 +324,20 @@
          contains two typedefs, "invoker_type" and "manager_type",
          which correspond to the invoker and manager types. */
       template<typename Tag>
-      struct BOOST_FUNCTION_GET_INVOKER { };
+      struct NDNBOOST_FUNCTION_GET_INVOKER { };
 
       /* Retrieve the invoker for a function pointer. */
       template<>
-      struct BOOST_FUNCTION_GET_INVOKER<function_ptr_tag>
+      struct NDNBOOST_FUNCTION_GET_INVOKER<function_ptr_tag>
       {
         template<typename FunctionPtr,
-                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
+                 typename R NDNBOOST_FUNCTION_COMMA NDNBOOST_FUNCTION_TEMPLATE_PARMS>
         struct apply
         {
-          typedef typename BOOST_FUNCTION_GET_FUNCTION_INVOKER<
+          typedef typename NDNBOOST_FUNCTION_GET_FUNCTION_INVOKER<
                              FunctionPtr,
-                             R BOOST_FUNCTION_COMMA
-                             BOOST_FUNCTION_TEMPLATE_ARGS
+                             R NDNBOOST_FUNCTION_COMMA
+                             NDNBOOST_FUNCTION_TEMPLATE_ARGS
                            >::type
             invoker_type;
 
@@ -345,14 +345,14 @@
         };
 
         template<typename FunctionPtr,
-                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
+                 typename R NDNBOOST_FUNCTION_COMMA NDNBOOST_FUNCTION_TEMPLATE_PARMS,
                  typename Allocator>
         struct apply_a
         {
-          typedef typename BOOST_FUNCTION_GET_FUNCTION_INVOKER<
+          typedef typename NDNBOOST_FUNCTION_GET_FUNCTION_INVOKER<
                              FunctionPtr,
-                             R BOOST_FUNCTION_COMMA
-                             BOOST_FUNCTION_TEMPLATE_ARGS
+                             R NDNBOOST_FUNCTION_COMMA
+                             NDNBOOST_FUNCTION_TEMPLATE_ARGS
                            >::type
             invoker_type;
 
@@ -360,19 +360,19 @@
         };
       };
 
-#if BOOST_FUNCTION_NUM_ARGS > 0
+#if NDNBOOST_FUNCTION_NUM_ARGS > 0
       /* Retrieve the invoker for a member pointer. */
       template<>
-      struct BOOST_FUNCTION_GET_INVOKER<member_ptr_tag>
+      struct NDNBOOST_FUNCTION_GET_INVOKER<member_ptr_tag>
       {
         template<typename MemberPtr,
-                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
+                 typename R NDNBOOST_FUNCTION_COMMA NDNBOOST_FUNCTION_TEMPLATE_PARMS>
         struct apply
         {
-          typedef typename BOOST_FUNCTION_GET_MEMBER_INVOKER<
+          typedef typename NDNBOOST_FUNCTION_GET_MEMBER_INVOKER<
                              MemberPtr,
-                             R BOOST_FUNCTION_COMMA
-                             BOOST_FUNCTION_TEMPLATE_ARGS
+                             R NDNBOOST_FUNCTION_COMMA
+                             NDNBOOST_FUNCTION_TEMPLATE_ARGS
                            >::type
             invoker_type;
 
@@ -380,14 +380,14 @@
         };
 
         template<typename MemberPtr,
-                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
+                 typename R NDNBOOST_FUNCTION_COMMA NDNBOOST_FUNCTION_TEMPLATE_PARMS,
                  typename Allocator>
         struct apply_a
         {
-          typedef typename BOOST_FUNCTION_GET_MEMBER_INVOKER<
+          typedef typename NDNBOOST_FUNCTION_GET_MEMBER_INVOKER<
                              MemberPtr,
-                             R BOOST_FUNCTION_COMMA
-                             BOOST_FUNCTION_TEMPLATE_ARGS
+                             R NDNBOOST_FUNCTION_COMMA
+                             NDNBOOST_FUNCTION_TEMPLATE_ARGS
                            >::type
             invoker_type;
 
@@ -398,16 +398,16 @@
 
       /* Retrieve the invoker for a function object. */
       template<>
-      struct BOOST_FUNCTION_GET_INVOKER<function_obj_tag>
+      struct NDNBOOST_FUNCTION_GET_INVOKER<function_obj_tag>
       {
         template<typename FunctionObj,
-                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
+                 typename R NDNBOOST_FUNCTION_COMMA NDNBOOST_FUNCTION_TEMPLATE_PARMS>
         struct apply
         {
-          typedef typename BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
+          typedef typename NDNBOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
                              FunctionObj,
-                             R BOOST_FUNCTION_COMMA
-                             BOOST_FUNCTION_TEMPLATE_ARGS
+                             R NDNBOOST_FUNCTION_COMMA
+                             NDNBOOST_FUNCTION_TEMPLATE_ARGS
                            >::type
             invoker_type;
 
@@ -415,14 +415,14 @@
         };
 
         template<typename FunctionObj,
-                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
+                 typename R NDNBOOST_FUNCTION_COMMA NDNBOOST_FUNCTION_TEMPLATE_PARMS,
                  typename Allocator>
         struct apply_a
         {
-          typedef typename BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
+          typedef typename NDNBOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
                              FunctionObj,
-                             R BOOST_FUNCTION_COMMA
-                             BOOST_FUNCTION_TEMPLATE_ARGS
+                             R NDNBOOST_FUNCTION_COMMA
+                             NDNBOOST_FUNCTION_TEMPLATE_ARGS
                            >::type
             invoker_type;
 
@@ -432,16 +432,16 @@
 
       /* Retrieve the invoker for a reference to a function object. */
       template<>
-      struct BOOST_FUNCTION_GET_INVOKER<function_obj_ref_tag>
+      struct NDNBOOST_FUNCTION_GET_INVOKER<function_obj_ref_tag>
       {
         template<typename RefWrapper,
-                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
+                 typename R NDNBOOST_FUNCTION_COMMA NDNBOOST_FUNCTION_TEMPLATE_PARMS>
         struct apply
         {
-          typedef typename BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER<
+          typedef typename NDNBOOST_FUNCTION_GET_FUNCTION_REF_INVOKER<
                              typename RefWrapper::type,
-                             R BOOST_FUNCTION_COMMA
-                             BOOST_FUNCTION_TEMPLATE_ARGS
+                             R NDNBOOST_FUNCTION_COMMA
+                             NDNBOOST_FUNCTION_TEMPLATE_ARGS
                            >::type
             invoker_type;
 
@@ -449,14 +449,14 @@
         };
 
         template<typename RefWrapper,
-                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
+                 typename R NDNBOOST_FUNCTION_COMMA NDNBOOST_FUNCTION_TEMPLATE_PARMS,
                  typename Allocator>
         struct apply_a
         {
-          typedef typename BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER<
+          typedef typename NDNBOOST_FUNCTION_GET_FUNCTION_REF_INVOKER<
                              typename RefWrapper::type,
-                             R BOOST_FUNCTION_COMMA
-                             BOOST_FUNCTION_TEMPLATE_ARGS
+                             R NDNBOOST_FUNCTION_COMMA
+                             NDNBOOST_FUNCTION_TEMPLATE_ARGS
                            >::type
             invoker_type;
 
@@ -472,18 +472,18 @@
        * members. It therefore cannot have any constructors,
        * destructors, base classes, etc.
        */
-      template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
-      struct BOOST_FUNCTION_VTABLE
+      template<typename R NDNBOOST_FUNCTION_COMMA NDNBOOST_FUNCTION_TEMPLATE_PARMS>
+      struct NDNBOOST_FUNCTION_VTABLE
       {
-#ifndef BOOST_NO_VOID_RETURNS
+#ifndef NDNBOOST_NO_VOID_RETURNS
         typedef R         result_type;
 #else
         typedef typename function_return_type<R>::type result_type;
-#endif // BOOST_NO_VOID_RETURNS
+#endif // NDNBOOST_NO_VOID_RETURNS
 
         typedef result_type (*invoker_type)(function_buffer&
-                                            BOOST_FUNCTION_COMMA
-                                            BOOST_FUNCTION_TEMPLATE_ARGS);
+                                            NDNBOOST_FUNCTION_COMMA
+                                            NDNBOOST_FUNCTION_TEMPLATE_ARGS);
 
         template<typename F>
         bool assign_to(F f, function_buffer& functor) const
@@ -528,7 +528,7 @@
         }
 
         // Member pointers
-#if BOOST_FUNCTION_NUM_ARGS > 0
+#if NDNBOOST_FUNCTION_NUM_ARGS > 0
         template<typename MemberPtr>
         bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
         {
@@ -555,7 +555,7 @@
             return false;
           }
         }
-#endif // BOOST_FUNCTION_NUM_ARGS > 0
+#endif // NDNBOOST_FUNCTION_NUM_ARGS > 0
 
         // Function objects
         // Assign to a function object using the small object optimization
@@ -646,16 +646,16 @@
   } // end namespace detail
 
   template<
-    typename R BOOST_FUNCTION_COMMA
-    BOOST_FUNCTION_TEMPLATE_PARMS
+    typename R NDNBOOST_FUNCTION_COMMA
+    NDNBOOST_FUNCTION_TEMPLATE_PARMS
   >
-  class BOOST_FUNCTION_FUNCTION : public function_base
+  class NDNBOOST_FUNCTION_FUNCTION : public function_base
 
-#if BOOST_FUNCTION_NUM_ARGS == 1
+#if NDNBOOST_FUNCTION_NUM_ARGS == 1
 
     , public std::unary_function<T0,R>
 
-#elif BOOST_FUNCTION_NUM_ARGS == 2
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 2
 
     , public std::binary_function<T0,T1,R>
 
@@ -663,16 +663,16 @@
 
   {
   public:
-#ifndef BOOST_NO_VOID_RETURNS
+#ifndef NDNBOOST_NO_VOID_RETURNS
     typedef R         result_type;
 #else
     typedef  typename ndnboost::detail::function::function_return_type<R>::type
       result_type;
-#endif // BOOST_NO_VOID_RETURNS
+#endif // NDNBOOST_NO_VOID_RETURNS
 
   private:
-    typedef ndnboost::detail::function::BOOST_FUNCTION_VTABLE<
-              R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS>
+    typedef ndnboost::detail::function::NDNBOOST_FUNCTION_VTABLE<
+              R NDNBOOST_FUNCTION_COMMA NDNBOOST_FUNCTION_TEMPLATE_ARGS>
       vtable_type;
 
     vtable_type* get_vtable() const {
@@ -683,7 +683,7 @@
     struct clear_type {};
 
   public:
-    BOOST_STATIC_CONSTANT(int, args = BOOST_FUNCTION_NUM_ARGS);
+    NDNBOOST_STATIC_CONSTANT(int, args = NDNBOOST_FUNCTION_NUM_ARGS);
 
     // add signature for ndnboost::lambda
     template<typename Args>
@@ -692,178 +692,178 @@
       typedef result_type type;
     };
 
-#if BOOST_FUNCTION_NUM_ARGS == 1
+#if NDNBOOST_FUNCTION_NUM_ARGS == 1
     typedef T0 argument_type;
-#elif BOOST_FUNCTION_NUM_ARGS == 2
+#elif NDNBOOST_FUNCTION_NUM_ARGS == 2
     typedef T0 first_argument_type;
     typedef T1 second_argument_type;
 #endif
 
-    BOOST_STATIC_CONSTANT(int, arity = BOOST_FUNCTION_NUM_ARGS);
-    BOOST_FUNCTION_ARG_TYPES
+    NDNBOOST_STATIC_CONSTANT(int, arity = NDNBOOST_FUNCTION_NUM_ARGS);
+    NDNBOOST_FUNCTION_ARG_TYPES
 
-    typedef BOOST_FUNCTION_FUNCTION self_type;
+    typedef NDNBOOST_FUNCTION_FUNCTION self_type;
 
-    BOOST_FUNCTION_FUNCTION() : function_base() { }
+    NDNBOOST_FUNCTION_FUNCTION() : function_base() { }
 
     // MSVC chokes if the following two constructors are collapsed into
     // one with a default parameter.
     template<typename Functor>
-    BOOST_FUNCTION_FUNCTION(Functor BOOST_FUNCTION_TARGET_FIX(const &) f
-#ifndef BOOST_NO_SFINAE
+    NDNBOOST_FUNCTION_FUNCTION(Functor NDNBOOST_FUNCTION_TARGET_FIX(const &) f
+#ifndef NDNBOOST_NO_SFINAE
                             ,typename enable_if_c<
                             (ndnboost::type_traits::ice_not<
                              (is_integral<Functor>::value)>::value),
                                         int>::type = 0
-#endif // BOOST_NO_SFINAE
+#endif // NDNBOOST_NO_SFINAE
                             ) :
       function_base()
     {
       this->assign_to(f);
     }
     template<typename Functor,typename Allocator>
-    BOOST_FUNCTION_FUNCTION(Functor BOOST_FUNCTION_TARGET_FIX(const &) f, Allocator a
-#ifndef BOOST_NO_SFINAE
+    NDNBOOST_FUNCTION_FUNCTION(Functor NDNBOOST_FUNCTION_TARGET_FIX(const &) f, Allocator a
+#ifndef NDNBOOST_NO_SFINAE
                             ,typename enable_if_c<
                             (ndnboost::type_traits::ice_not<
                              (is_integral<Functor>::value)>::value),
                                         int>::type = 0
-#endif // BOOST_NO_SFINAE
+#endif // NDNBOOST_NO_SFINAE
                             ) :
       function_base()
     {
       this->assign_to_a(f,a);
     }
 
-#ifndef BOOST_NO_SFINAE
-    BOOST_FUNCTION_FUNCTION(clear_type*) : function_base() { }
+#ifndef NDNBOOST_NO_SFINAE
+    NDNBOOST_FUNCTION_FUNCTION(clear_type*) : function_base() { }
 #else
-    BOOST_FUNCTION_FUNCTION(int zero) : function_base()
+    NDNBOOST_FUNCTION_FUNCTION(int zero) : function_base()
     {
-      BOOST_ASSERT(zero == 0);
+      NDNBOOST_ASSERT(zero == 0);
     }
 #endif
 
-    BOOST_FUNCTION_FUNCTION(const BOOST_FUNCTION_FUNCTION& f) : function_base()
+    NDNBOOST_FUNCTION_FUNCTION(const NDNBOOST_FUNCTION_FUNCTION& f) : function_base()
     {
       this->assign_to_own(f);
     }
     
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    BOOST_FUNCTION_FUNCTION(BOOST_FUNCTION_FUNCTION&& f) : function_base()
+#ifndef NDNBOOST_NO_CXX11_RVALUE_REFERENCES
+    NDNBOOST_FUNCTION_FUNCTION(NDNBOOST_FUNCTION_FUNCTION&& f) : function_base()
     {
       this->move_assign(f);
     }
 #endif
     
-    ~BOOST_FUNCTION_FUNCTION() { clear(); }
+    ~NDNBOOST_FUNCTION_FUNCTION() { clear(); }
 
-    result_type operator()(BOOST_FUNCTION_PARMS) const
+    result_type operator()(NDNBOOST_FUNCTION_PARMS) const
     {
       if (this->empty())
         ndnboost::throw_exception(bad_function_call());
 
       return get_vtable()->invoker
-               (this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
+               (this->functor NDNBOOST_FUNCTION_COMMA NDNBOOST_FUNCTION_ARGS);
     }
 
-    // The distinction between when to use BOOST_FUNCTION_FUNCTION and
+    // The distinction between when to use NDNBOOST_FUNCTION_FUNCTION and
     // when to use self_type is obnoxious. MSVC cannot handle self_type as
     // the return type of these assignment operators, but Borland C++ cannot
-    // handle BOOST_FUNCTION_FUNCTION as the type of the temporary to
+    // handle NDNBOOST_FUNCTION_FUNCTION as the type of the temporary to
     // construct.
     template<typename Functor>
-#ifndef BOOST_NO_SFINAE
+#ifndef NDNBOOST_NO_SFINAE
     typename enable_if_c<
                (ndnboost::type_traits::ice_not<
                  (is_integral<Functor>::value)>::value),
-               BOOST_FUNCTION_FUNCTION&>::type
+               NDNBOOST_FUNCTION_FUNCTION&>::type
 #else
-    BOOST_FUNCTION_FUNCTION&
+    NDNBOOST_FUNCTION_FUNCTION&
 #endif
-    operator=(Functor BOOST_FUNCTION_TARGET_FIX(const &) f)
+    operator=(Functor NDNBOOST_FUNCTION_TARGET_FIX(const &) f)
     {
       this->clear();
-      BOOST_TRY  {
+      NDNBOOST_TRY  {
         this->assign_to(f);
-      } BOOST_CATCH (...) {
+      } NDNBOOST_CATCH (...) {
         vtable = 0;
-        BOOST_RETHROW;
+        NDNBOOST_RETHROW;
       }
-      BOOST_CATCH_END
+      NDNBOOST_CATCH_END
       return *this;
     }
     template<typename Functor,typename Allocator>
-    void assign(Functor BOOST_FUNCTION_TARGET_FIX(const &) f, Allocator a)
+    void assign(Functor NDNBOOST_FUNCTION_TARGET_FIX(const &) f, Allocator a)
     {
       this->clear();
-      BOOST_TRY{
+      NDNBOOST_TRY{
         this->assign_to_a(f,a);
-      } BOOST_CATCH (...) {
+      } NDNBOOST_CATCH (...) {
         vtable = 0;
-        BOOST_RETHROW;
+        NDNBOOST_RETHROW;
       }
-      BOOST_CATCH_END
+      NDNBOOST_CATCH_END
     }
 
-#ifndef BOOST_NO_SFINAE
-    BOOST_FUNCTION_FUNCTION& operator=(clear_type*)
+#ifndef NDNBOOST_NO_SFINAE
+    NDNBOOST_FUNCTION_FUNCTION& operator=(clear_type*)
     {
       this->clear();
       return *this;
     }
 #else
-    BOOST_FUNCTION_FUNCTION& operator=(int zero)
+    NDNBOOST_FUNCTION_FUNCTION& operator=(int zero)
     {
-      BOOST_ASSERT(zero == 0);
+      NDNBOOST_ASSERT(zero == 0);
       this->clear();
       return *this;
     }
 #endif
 
-    // Assignment from another BOOST_FUNCTION_FUNCTION
-    BOOST_FUNCTION_FUNCTION& operator=(const BOOST_FUNCTION_FUNCTION& f)
+    // Assignment from another NDNBOOST_FUNCTION_FUNCTION
+    NDNBOOST_FUNCTION_FUNCTION& operator=(const NDNBOOST_FUNCTION_FUNCTION& f)
     {
       if (&f == this)
         return *this;
 
       this->clear();
-      BOOST_TRY {
+      NDNBOOST_TRY {
         this->assign_to_own(f);
-      } BOOST_CATCH (...) {
+      } NDNBOOST_CATCH (...) {
         vtable = 0;
-        BOOST_RETHROW;
+        NDNBOOST_RETHROW;
       }
-      BOOST_CATCH_END
+      NDNBOOST_CATCH_END
       return *this;
     }
     
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    // Move assignment from another BOOST_FUNCTION_FUNCTION
-    BOOST_FUNCTION_FUNCTION& operator=(BOOST_FUNCTION_FUNCTION&& f)
+#ifndef NDNBOOST_NO_CXX11_RVALUE_REFERENCES
+    // Move assignment from another NDNBOOST_FUNCTION_FUNCTION
+    NDNBOOST_FUNCTION_FUNCTION& operator=(NDNBOOST_FUNCTION_FUNCTION&& f)
     {
       
       if (&f == this)
         return *this;
 
       this->clear();
-      BOOST_TRY {
+      NDNBOOST_TRY {
         this->move_assign(f);
-      } BOOST_CATCH (...) {
+      } NDNBOOST_CATCH (...) {
         vtable = 0;
-        BOOST_RETHROW;
+        NDNBOOST_RETHROW;
       }
-      BOOST_CATCH_END
+      NDNBOOST_CATCH_END
       return *this;
     }
 #endif
 
-    void swap(BOOST_FUNCTION_FUNCTION& other)
+    void swap(NDNBOOST_FUNCTION_FUNCTION& other)
     {
       if (&other == this)
         return;
 
-      BOOST_FUNCTION_FUNCTION tmp;
+      NDNBOOST_FUNCTION_FUNCTION tmp;
       tmp.move_assign(*this);
       this->move_assign(other);
       other.move_assign(tmp);
@@ -879,7 +879,7 @@
       }
     }
 
-#if (defined __SUNPRO_CC) && (__SUNPRO_CC <= 0x530) && !(defined BOOST_NO_COMPILER_CONFIG)
+#if (defined __SUNPRO_CC) && (__SUNPRO_CC <= 0x530) && !(defined NDNBOOST_NO_COMPILER_CONFIG)
     // Sun C++ 5.3 can't handle the safe_bool idiom, so don't use it
     operator bool () const { return !this->empty(); }
 #else
@@ -899,7 +899,7 @@
 #endif
 
   private:
-    void assign_to_own(const BOOST_FUNCTION_FUNCTION& f)
+    void assign_to_own(const NDNBOOST_FUNCTION_FUNCTION& f)
     {
       if (!f.empty()) {
         this->vtable = f.vtable;
@@ -917,10 +917,10 @@
       using detail::function::vtable_base;
 
       typedef typename detail::function::get_function_tag<Functor>::type tag;
-      typedef detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
+      typedef detail::function::NDNBOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
       typedef typename get_invoker::
-                         template apply<Functor, R BOOST_FUNCTION_COMMA 
-                        BOOST_FUNCTION_TEMPLATE_ARGS>
+                         template apply<Functor, R NDNBOOST_FUNCTION_COMMA 
+                        NDNBOOST_FUNCTION_TEMPLATE_ARGS>
         handler_type;
       
       typedef typename handler_type::invoker_type invoker_type;
@@ -950,10 +950,10 @@
       using detail::function::vtable_base;
 
       typedef typename detail::function::get_function_tag<Functor>::type tag;
-      typedef detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
+      typedef detail::function::NDNBOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
       typedef typename get_invoker::
-                         template apply_a<Functor, R BOOST_FUNCTION_COMMA 
-                         BOOST_FUNCTION_TEMPLATE_ARGS,
+                         template apply_a<Functor, R NDNBOOST_FUNCTION_COMMA 
+                         NDNBOOST_FUNCTION_TEMPLATE_ARGS,
                          Allocator>
         handler_type;
       
@@ -981,12 +981,12 @@
     // Moves the value from the specified argument to *this. If the argument 
     // has its function object allocated on the heap, move_assign will pass 
     // its buffer to *this, and set the argument's buffer pointer to NULL. 
-    void move_assign(BOOST_FUNCTION_FUNCTION& f) 
+    void move_assign(NDNBOOST_FUNCTION_FUNCTION& f) 
     { 
       if (&f == this)
         return;
 
-      BOOST_TRY {
+      NDNBOOST_TRY {
         if (!f.empty()) {
           this->vtable = f.vtable;
           if (this->has_trivial_copy_and_destroy())
@@ -998,57 +998,57 @@
         } else {
           clear();
         }
-      } BOOST_CATCH (...) {
+      } NDNBOOST_CATCH (...) {
         vtable = 0;
-        BOOST_RETHROW;
+        NDNBOOST_RETHROW;
       }
-      BOOST_CATCH_END
+      NDNBOOST_CATCH_END
     }
   };
 
-  template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
-  inline void swap(BOOST_FUNCTION_FUNCTION<
-                     R BOOST_FUNCTION_COMMA
-                     BOOST_FUNCTION_TEMPLATE_ARGS
+  template<typename R NDNBOOST_FUNCTION_COMMA NDNBOOST_FUNCTION_TEMPLATE_PARMS>
+  inline void swap(NDNBOOST_FUNCTION_FUNCTION<
+                     R NDNBOOST_FUNCTION_COMMA
+                     NDNBOOST_FUNCTION_TEMPLATE_ARGS
                    >& f1,
-                   BOOST_FUNCTION_FUNCTION<
-                     R BOOST_FUNCTION_COMMA
-                     BOOST_FUNCTION_TEMPLATE_ARGS
+                   NDNBOOST_FUNCTION_FUNCTION<
+                     R NDNBOOST_FUNCTION_COMMA
+                     NDNBOOST_FUNCTION_TEMPLATE_ARGS
                    >& f2)
   {
     f1.swap(f2);
   }
 
 // Poison comparisons between ndnboost::function objects of the same type.
-template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
-  void operator==(const BOOST_FUNCTION_FUNCTION<
-                          R BOOST_FUNCTION_COMMA
-                          BOOST_FUNCTION_TEMPLATE_ARGS>&,
-                  const BOOST_FUNCTION_FUNCTION<
-                          R BOOST_FUNCTION_COMMA
-                          BOOST_FUNCTION_TEMPLATE_ARGS>&);
-template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
-  void operator!=(const BOOST_FUNCTION_FUNCTION<
-                          R BOOST_FUNCTION_COMMA
-                          BOOST_FUNCTION_TEMPLATE_ARGS>&,
-                  const BOOST_FUNCTION_FUNCTION<
-                          R BOOST_FUNCTION_COMMA
-                          BOOST_FUNCTION_TEMPLATE_ARGS>& );
+template<typename R NDNBOOST_FUNCTION_COMMA NDNBOOST_FUNCTION_TEMPLATE_PARMS>
+  void operator==(const NDNBOOST_FUNCTION_FUNCTION<
+                          R NDNBOOST_FUNCTION_COMMA
+                          NDNBOOST_FUNCTION_TEMPLATE_ARGS>&,
+                  const NDNBOOST_FUNCTION_FUNCTION<
+                          R NDNBOOST_FUNCTION_COMMA
+                          NDNBOOST_FUNCTION_TEMPLATE_ARGS>&);
+template<typename R NDNBOOST_FUNCTION_COMMA NDNBOOST_FUNCTION_TEMPLATE_PARMS>
+  void operator!=(const NDNBOOST_FUNCTION_FUNCTION<
+                          R NDNBOOST_FUNCTION_COMMA
+                          NDNBOOST_FUNCTION_TEMPLATE_ARGS>&,
+                  const NDNBOOST_FUNCTION_FUNCTION<
+                          R NDNBOOST_FUNCTION_COMMA
+                          NDNBOOST_FUNCTION_TEMPLATE_ARGS>& );
 
-#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
+#if !defined(NDNBOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
 
-#if BOOST_FUNCTION_NUM_ARGS == 0
-#define BOOST_FUNCTION_PARTIAL_SPEC R (void)
+#if NDNBOOST_FUNCTION_NUM_ARGS == 0
+#define NDNBOOST_FUNCTION_PARTIAL_SPEC R (void)
 #else
-#define BOOST_FUNCTION_PARTIAL_SPEC R (BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS,T))
+#define NDNBOOST_FUNCTION_PARTIAL_SPEC R (NDNBOOST_PP_ENUM_PARAMS(NDNBOOST_FUNCTION_NUM_ARGS,T))
 #endif
 
-template<typename R BOOST_FUNCTION_COMMA
-         BOOST_FUNCTION_TEMPLATE_PARMS>
-class function<BOOST_FUNCTION_PARTIAL_SPEC>
-  : public BOOST_FUNCTION_FUNCTION<R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS>
+template<typename R NDNBOOST_FUNCTION_COMMA
+         NDNBOOST_FUNCTION_TEMPLATE_PARMS>
+class function<NDNBOOST_FUNCTION_PARTIAL_SPEC>
+  : public NDNBOOST_FUNCTION_FUNCTION<R NDNBOOST_FUNCTION_COMMA NDNBOOST_FUNCTION_TEMPLATE_ARGS>
 {
-  typedef BOOST_FUNCTION_FUNCTION<R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS> base_type;
+  typedef NDNBOOST_FUNCTION_FUNCTION<R NDNBOOST_FUNCTION_COMMA NDNBOOST_FUNCTION_TEMPLATE_ARGS> base_type;
   typedef function self_type;
 
   struct clear_type {};
@@ -1059,7 +1059,7 @@
 
   template<typename Functor>
   function(Functor f
-#ifndef BOOST_NO_SFINAE
+#ifndef NDNBOOST_NO_SFINAE
            ,typename enable_if_c<
                             (ndnboost::type_traits::ice_not<
                           (is_integral<Functor>::value)>::value),
@@ -1071,7 +1071,7 @@
   }
   template<typename Functor,typename Allocator>
   function(Functor f, Allocator a
-#ifndef BOOST_NO_SFINAE
+#ifndef NDNBOOST_NO_SFINAE
            ,typename enable_if_c<
                             (ndnboost::type_traits::ice_not<
                           (is_integral<Functor>::value)>::value),
@@ -1082,7 +1082,7 @@
   {
   }
 
-#ifndef BOOST_NO_SFINAE
+#ifndef NDNBOOST_NO_SFINAE
   function(clear_type*) : base_type() {}
 #endif
 
@@ -1090,7 +1090,7 @@
 
   function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
 
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+#ifndef NDNBOOST_NO_CXX11_RVALUE_REFERENCES
   // Move constructors
   function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
   function(base_type&& f): base_type(static_cast<base_type&&>(f)){}
@@ -1102,7 +1102,7 @@
     return *this;
   }
 
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+#ifndef NDNBOOST_NO_CXX11_RVALUE_REFERENCES
   self_type& operator=(self_type&& f)
   {
     self_type(static_cast<self_type&&>(f)).swap(*this);
@@ -1111,7 +1111,7 @@
 #endif  
 
   template<typename Functor>
-#ifndef BOOST_NO_SFINAE
+#ifndef NDNBOOST_NO_SFINAE
   typename enable_if_c<
                             (ndnboost::type_traits::ice_not<
                          (is_integral<Functor>::value)>::value),
@@ -1125,7 +1125,7 @@
     return *this;
   }
 
-#ifndef BOOST_NO_SFINAE
+#ifndef NDNBOOST_NO_SFINAE
   self_type& operator=(clear_type*)
   {
     this->clear();
@@ -1139,7 +1139,7 @@
     return *this;
   }
   
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+#ifndef NDNBOOST_NO_CXX11_RVALUE_REFERENCES
   self_type& operator=(base_type&& f)
   {
     self_type(static_cast<base_type&&>(f)).swap(*this);
@@ -1148,38 +1148,38 @@
 #endif 
 };
 
-#undef BOOST_FUNCTION_PARTIAL_SPEC
+#undef NDNBOOST_FUNCTION_PARTIAL_SPEC
 #endif // have partial specialization
 
 } // end namespace ndnboost
 
 // Cleanup after ourselves...
-#undef BOOST_FUNCTION_VTABLE
-#undef BOOST_FUNCTION_COMMA
-#undef BOOST_FUNCTION_FUNCTION
-#undef BOOST_FUNCTION_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_FUNCTION_REF_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
-#undef BOOST_FUNCTION_MEMBER_INVOKER
-#undef BOOST_FUNCTION_VOID_MEMBER_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
-#undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_GET_INVOKER
-#undef BOOST_FUNCTION_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_PARMS
-#undef BOOST_FUNCTION_PARM
-#undef BOOST_FUNCTION_ARGS
-#undef BOOST_FUNCTION_ARG_TYPE
-#undef BOOST_FUNCTION_ARG_TYPES
-#undef BOOST_FUNCTION_VOID_RETURN_TYPE
-#undef BOOST_FUNCTION_RETURN
+#undef NDNBOOST_FUNCTION_VTABLE
+#undef NDNBOOST_FUNCTION_COMMA
+#undef NDNBOOST_FUNCTION_FUNCTION
+#undef NDNBOOST_FUNCTION_FUNCTION_INVOKER
+#undef NDNBOOST_FUNCTION_VOID_FUNCTION_INVOKER
+#undef NDNBOOST_FUNCTION_FUNCTION_OBJ_INVOKER
+#undef NDNBOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
+#undef NDNBOOST_FUNCTION_FUNCTION_REF_INVOKER
+#undef NDNBOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
+#undef NDNBOOST_FUNCTION_MEMBER_INVOKER
+#undef NDNBOOST_FUNCTION_VOID_MEMBER_INVOKER
+#undef NDNBOOST_FUNCTION_GET_FUNCTION_INVOKER
+#undef NDNBOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
+#undef NDNBOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
+#undef NDNBOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
+#undef NDNBOOST_FUNCTION_GET_INVOKER
+#undef NDNBOOST_FUNCTION_TEMPLATE_PARMS
+#undef NDNBOOST_FUNCTION_TEMPLATE_ARGS
+#undef NDNBOOST_FUNCTION_PARMS
+#undef NDNBOOST_FUNCTION_PARM
+#undef NDNBOOST_FUNCTION_ARGS
+#undef NDNBOOST_FUNCTION_ARG_TYPE
+#undef NDNBOOST_FUNCTION_ARG_TYPES
+#undef NDNBOOST_FUNCTION_VOID_RETURN_TYPE
+#undef NDNBOOST_FUNCTION_RETURN
 
-#if defined(BOOST_MSVC)
+#if defined(NDNBOOST_MSVC)
 #   pragma warning( pop )
 #endif       
diff --git a/include/ndnboost/function/function_typeof.hpp b/include/ndnboost/function/function_typeof.hpp
index e3d26c5..3dc0744 100644
--- a/include/ndnboost/function/function_typeof.hpp
+++ b/include/ndnboost/function/function_typeof.hpp
@@ -6,40 +6,40 @@
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
 // For more information, see http://www.boost.org
-#ifndef BOOST_FUNCTION_TYPEOF_HPP
-#define BOOST_FUNCTION_TYPEOF_HPP
+#ifndef NDNBOOST_FUNCTION_TYPEOF_HPP
+#define NDNBOOST_FUNCTION_TYPEOF_HPP
 #include <ndnboost/function/function_fwd.hpp>
 #include <ndnboost/typeof/typeof.hpp>
 
-#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
+#include NDNBOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
 
-BOOST_TYPEOF_REGISTER_TYPE(ndnboost::bad_function_call)
+NDNBOOST_TYPEOF_REGISTER_TYPE(ndnboost::bad_function_call)
 
-#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
-BOOST_TYPEOF_REGISTER_TEMPLATE(ndnboost::function, (typename))
+#if !defined(NDNBOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
+NDNBOOST_TYPEOF_REGISTER_TEMPLATE(ndnboost::function, (typename))
 #endif
 
-BOOST_TYPEOF_REGISTER_TEMPLATE(ndnboost::function0, (typename))
-BOOST_TYPEOF_REGISTER_TEMPLATE(ndnboost::function1, (typename)(typename))
-BOOST_TYPEOF_REGISTER_TEMPLATE(ndnboost::function2, (typename)(typename)(typename))
-BOOST_TYPEOF_REGISTER_TEMPLATE(ndnboost::function3, 
+NDNBOOST_TYPEOF_REGISTER_TEMPLATE(ndnboost::function0, (typename))
+NDNBOOST_TYPEOF_REGISTER_TEMPLATE(ndnboost::function1, (typename)(typename))
+NDNBOOST_TYPEOF_REGISTER_TEMPLATE(ndnboost::function2, (typename)(typename)(typename))
+NDNBOOST_TYPEOF_REGISTER_TEMPLATE(ndnboost::function3, 
   (typename)(typename)(typename)(typename))
-BOOST_TYPEOF_REGISTER_TEMPLATE(ndnboost::function4, 
+NDNBOOST_TYPEOF_REGISTER_TEMPLATE(ndnboost::function4, 
   (typename)(typename)(typename)(typename)(typename))
-BOOST_TYPEOF_REGISTER_TEMPLATE(ndnboost::function5, 
+NDNBOOST_TYPEOF_REGISTER_TEMPLATE(ndnboost::function5, 
   (typename)(typename)(typename)(typename)(typename)(typename))
-BOOST_TYPEOF_REGISTER_TEMPLATE(ndnboost::function6, 
+NDNBOOST_TYPEOF_REGISTER_TEMPLATE(ndnboost::function6, 
   (typename)(typename)(typename)(typename)(typename)(typename)(typename))
-BOOST_TYPEOF_REGISTER_TEMPLATE(ndnboost::function7, 
+NDNBOOST_TYPEOF_REGISTER_TEMPLATE(ndnboost::function7, 
   (typename)(typename)(typename)(typename)(typename)(typename)(typename)
   (typename))
-BOOST_TYPEOF_REGISTER_TEMPLATE(ndnboost::function8, 
+NDNBOOST_TYPEOF_REGISTER_TEMPLATE(ndnboost::function8, 
   (typename)(typename)(typename)(typename)(typename)(typename)(typename)
   (typename)(typename))
-BOOST_TYPEOF_REGISTER_TEMPLATE(ndnboost::function9, 
+NDNBOOST_TYPEOF_REGISTER_TEMPLATE(ndnboost::function9, 
   (typename)(typename)(typename)(typename)(typename)(typename)(typename)
   (typename)(typename)(typename))
-BOOST_TYPEOF_REGISTER_TEMPLATE(ndnboost::function10, 
+NDNBOOST_TYPEOF_REGISTER_TEMPLATE(ndnboost::function10, 
   (typename)(typename)(typename)(typename)(typename)(typename)(typename)
   (typename)(typename)(typename)(typename))
 #endif
diff --git a/include/ndnboost/function/gen_function_N.pl b/include/ndnboost/function/gen_function_N.pl
index 7fc53c9..c3f4401 100644
--- a/include/ndnboost/function/gen_function_N.pl
+++ b/include/ndnboost/function/gen_function_N.pl
@@ -19,8 +19,8 @@
 $totalNumArgs = $ARGV[0];
 for ($numArgs = 0; $numArgs <= $totalNumArgs; ++$numArgs) {
   open OUT, ">function$numArgs.hpp";
-  print OUT "#define BOOST_FUNCTION_NUM_ARGS $numArgs\n";
+  print OUT "#define NDNBOOST_FUNCTION_NUM_ARGS $numArgs\n";
   print OUT "#include <ndnboost/function/detail/maybe_include.hpp>\n";
-  print OUT "#undef BOOST_FUNCTION_NUM_ARGS\n";
+  print OUT "#undef NDNBOOST_FUNCTION_NUM_ARGS\n";
   close OUT;
 }