diff --git a/include/ndnboost/detail/call_traits.hpp b/include/ndnboost/detail/call_traits.hpp
index 0a2cdb2..410f4ae 100644
--- a/include/ndnboost/detail/call_traits.hpp
+++ b/include/ndnboost/detail/call_traits.hpp
@@ -15,10 +15,10 @@
       (issue raised by Steve Cleary).
 */
 
-#ifndef BOOST_DETAIL_CALL_TRAITS_HPP
-#define BOOST_DETAIL_CALL_TRAITS_HPP
+#ifndef NDNBOOST_DETAIL_CALL_TRAITS_HPP
+#define NDNBOOST_DETAIL_CALL_TRAITS_HPP
 
-#ifndef BOOST_CONFIG_HPP
+#ifndef NDNBOOST_CONFIG_HPP
 #include <ndnboost/config.hpp>
 #endif
 #include <cstddef>
@@ -100,7 +100,7 @@
    typedef T& param_type;  // hh removed const
 };
 
-#if BOOST_WORKAROUND( __BORLANDC__,  < 0x5A0 )
+#if NDNBOOST_WORKAROUND( __BORLANDC__,  < 0x5A0 )
 // these are illegal specialisations; cv-qualifies applied to
 // references have no effect according to [8.3.2p1],
 // C++ Builder requires them though as it treats cv-qualified
@@ -139,7 +139,7 @@
    typedef T * const param_type;  // hh removed const
 };
 #endif
-#if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
+#if !defined(NDNBOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
 template <typename T, std::size_t N>
 struct call_traits<T [N]>
 {
@@ -169,4 +169,4 @@
 
 }
 
-#endif // BOOST_DETAIL_CALL_TRAITS_HPP
+#endif // NDNBOOST_DETAIL_CALL_TRAITS_HPP
diff --git a/include/ndnboost/detail/container_fwd.hpp b/include/ndnboost/detail/container_fwd.hpp
index 0254e7b..7081f07 100644
--- a/include/ndnboost/detail/container_fwd.hpp
+++ b/include/ndnboost/detail/container_fwd.hpp
@@ -5,11 +5,11 @@
 
 // Note: if you change this include guard, you also need to change
 // container_fwd_compile_fail.cpp
-#if !defined(BOOST_DETAIL_CONTAINER_FWD_HPP)
-#define BOOST_DETAIL_CONTAINER_FWD_HPP
+#if !defined(NDNBOOST_DETAIL_CONTAINER_FWD_HPP)
+#define NDNBOOST_DETAIL_CONTAINER_FWD_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1020) && \
-    !defined(BOOST_DETAIL_TEST_CONFIG_ONLY)
+    !defined(NDNBOOST_DETAIL_TEST_CONFIG_ONLY)
 # pragma once
 #endif
 
@@ -18,31 +18,31 @@
 
 ////////////////////////////////////////////////////////////////////////////////
 //                                                                            //
-// Define BOOST_DETAIL_NO_CONTAINER_FWD if you don't want this header to      //
+// Define NDNBOOST_DETAIL_NO_CONTAINER_FWD if you don't want this header to      //
 // forward declare standard containers.                                       //
 //                                                                            //
-// BOOST_DETAIL_CONTAINER_FWD to make it foward declare containers even if it //
+// NDNBOOST_DETAIL_CONTAINER_FWD to make it foward declare containers even if it //
 // normally doesn't.                                                          //
 //                                                                            //
-// BOOST_DETAIL_NO_CONTAINER_FWD overrides BOOST_DETAIL_CONTAINER_FWD.        //
+// NDNBOOST_DETAIL_NO_CONTAINER_FWD overrides NDNBOOST_DETAIL_CONTAINER_FWD.        //
 //                                                                            //
 ////////////////////////////////////////////////////////////////////////////////
 
-#if !defined(BOOST_DETAIL_NO_CONTAINER_FWD)
-#  if defined(BOOST_DETAIL_CONTAINER_FWD)
+#if !defined(NDNBOOST_DETAIL_NO_CONTAINER_FWD)
+#  if defined(NDNBOOST_DETAIL_CONTAINER_FWD)
      // Force forward declarations.
 #  elif defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
      // STLport
-#    define BOOST_DETAIL_NO_CONTAINER_FWD
+#    define NDNBOOST_DETAIL_NO_CONTAINER_FWD
 #  elif defined(__LIBCOMO__)
      // Comeau STL:
-#    define BOOST_DETAIL_NO_CONTAINER_FWD
+#    define NDNBOOST_DETAIL_NO_CONTAINER_FWD
 #  elif defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER)
      // Rogue Wave library:
-#    define BOOST_DETAIL_NO_CONTAINER_FWD
+#    define NDNBOOST_DETAIL_NO_CONTAINER_FWD
 #  elif defined(_LIBCPP_VERSION)
      // libc++
-#    define BOOST_DETAIL_NO_CONTAINER_FWD
+#    define NDNBOOST_DETAIL_NO_CONTAINER_FWD
 #  elif defined(__GLIBCPP__) || defined(__GLIBCXX__)
      // GNU libstdc++ 3
      //
@@ -52,10 +52,10 @@
         || defined(_GLIBCXX_DEBUG) \
         || defined(_GLIBCXX_PARALLEL) \
         || defined(_GLIBCXX_PROFILE)
-#      define BOOST_DETAIL_NO_CONTAINER_FWD
+#      define NDNBOOST_DETAIL_NO_CONTAINER_FWD
 #    else
 #      if defined(__GLIBCXX__) && __GLIBCXX__ >= 20040530
-#        define BOOST_CONTAINER_FWD_COMPLEX_STRUCT
+#        define NDNBOOST_CONTAINER_FWD_COMPLEX_STRUCT
 #      endif
 #    endif
 #  elif defined(__STL_CONFIG_H)
@@ -63,30 +63,30 @@
      //
      // Forward declaration seems to be okay, but it has a couple of odd
      // implementations.
-#    define BOOST_CONTAINER_FWD_BAD_BITSET
+#    define NDNBOOST_CONTAINER_FWD_BAD_BITSET
 #    if !defined(__STL_NON_TYPE_TMPL_PARAM_BUG)
-#      define BOOST_CONTAINER_FWD_BAD_DEQUE
+#      define NDNBOOST_CONTAINER_FWD_BAD_DEQUE
 #     endif
 #  elif defined(__MSL_CPP__)
      // MSL standard lib:
-#    define BOOST_DETAIL_NO_CONTAINER_FWD
+#    define NDNBOOST_DETAIL_NO_CONTAINER_FWD
 #  elif defined(__IBMCPP__)
      // The default VACPP std lib, forward declaration seems to be fine.
 #  elif defined(MSIPL_COMPILE_H)
      // Modena C++ standard library
-#    define BOOST_DETAIL_NO_CONTAINER_FWD
+#    define NDNBOOST_DETAIL_NO_CONTAINER_FWD
 #  elif (defined(_YVALS) && !defined(__IBMCPP__)) || defined(_CPPLIB_VER)
      // Dinkumware Library (this has to appear after any possible replacement
      // libraries)
 #  else
-#    define BOOST_DETAIL_NO_CONTAINER_FWD
+#    define NDNBOOST_DETAIL_NO_CONTAINER_FWD
 #  endif
 #endif
 
-#if !defined(BOOST_DETAIL_TEST_CONFIG_ONLY)
+#if !defined(NDNBOOST_DETAIL_TEST_CONFIG_ONLY)
 
-#if defined(BOOST_DETAIL_NO_CONTAINER_FWD) && \
-    !defined(BOOST_DETAIL_TEST_FORCE_CONTAINER_FWD)
+#if defined(NDNBOOST_DETAIL_NO_CONTAINER_FWD) && \
+    !defined(NDNBOOST_DETAIL_TEST_FORCE_CONTAINER_FWD)
 
 #include <deque>
 #include <list>
@@ -101,15 +101,15 @@
 
 #include <cstddef>
 
-#if defined(BOOST_CONTAINER_FWD_BAD_DEQUE)
+#if defined(NDNBOOST_CONTAINER_FWD_BAD_DEQUE)
 #include <deque>
 #endif
 
-#if defined(BOOST_CONTAINER_FWD_BAD_BITSET)
+#if defined(NDNBOOST_CONTAINER_FWD_BAD_BITSET)
 #include <bitset>
 #endif
 
-#if defined(BOOST_MSVC)
+#if defined(NDNBOOST_MSVC)
 #pragma warning(push)
 #pragma warning(disable:4099) // struct/class mismatch in fwd declarations
 #endif
@@ -119,20 +119,20 @@
     template <class T> class allocator;
     template <class charT, class traits, class Allocator> class basic_string;
 
-#if BOOST_WORKAROUND(__GNUC__, < 3) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
+#if NDNBOOST_WORKAROUND(__GNUC__, < 3) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
 
     template <class charT> struct string_char_traits;
 #else
     template <class charT> struct char_traits;
 #endif
 
-#if defined(BOOST_CONTAINER_FWD_COMPLEX_STRUCT)
+#if defined(NDNBOOST_CONTAINER_FWD_COMPLEX_STRUCT)
     template <class T> struct complex;
 #else
     template <class T> class complex;
 #endif
 
-#if !defined(BOOST_CONTAINER_FWD_BAD_DEQUE)
+#if !defined(NDNBOOST_CONTAINER_FWD_BAD_DEQUE)
     template <class T, class Allocator> class deque;
 #endif
 
@@ -144,19 +144,19 @@
     template <class Key, class Compare, class Allocator> class set;
     template <class Key, class Compare, class Allocator> class multiset;
 
-#if !defined(BOOST_CONTAINER_FWD_BAD_BITSET)
+#if !defined(NDNBOOST_CONTAINER_FWD_BAD_BITSET)
     template <size_t N> class bitset;
 #endif
     template <class T1, class T2> struct pair;
 }
 
-#if defined(BOOST_MSVC)
+#if defined(NDNBOOST_MSVC)
 #pragma warning(pop)
 #endif
 
-#endif // BOOST_DETAIL_NO_CONTAINER_FWD &&
-       // !defined(BOOST_DETAIL_TEST_FORCE_CONTAINER_FWD)
+#endif // NDNBOOST_DETAIL_NO_CONTAINER_FWD &&
+       // !defined(NDNBOOST_DETAIL_TEST_FORCE_CONTAINER_FWD)
 
-#endif // BOOST_DETAIL_TEST_CONFIG_ONLY
+#endif // NDNBOOST_DETAIL_TEST_CONFIG_ONLY
 
 #endif
diff --git a/include/ndnboost/detail/endian.hpp b/include/ndnboost/detail/endian.hpp
index 1dcb237..c07bd00 100644
--- a/include/ndnboost/detail/endian.hpp
+++ b/include/ndnboost/detail/endian.hpp
@@ -22,11 +22,11 @@
  * which this code was originally taken.
  *
  * Modified by Caleb Epstein to use <endian.h> with GNU libc and to
- * defined the BOOST_ENDIAN macro.
+ * defined the NDNBOOST_ENDIAN macro.
  */
 
-#ifndef BOOST_DETAIL_ENDIAN_HPP
-#define BOOST_DETAIL_ENDIAN_HPP
+#ifndef NDNBOOST_DETAIL_ENDIAN_HPP
+#define NDNBOOST_DETAIL_ENDIAN_HPP
 
 //
 // Special cases come first:
@@ -36,15 +36,15 @@
 // __BYTE_ORDER
 # include <endian.h>
 # if (__BYTE_ORDER == __LITTLE_ENDIAN)
-#  define BOOST_LITTLE_ENDIAN
+#  define NDNBOOST_LITTLE_ENDIAN
 # elif (__BYTE_ORDER == __BIG_ENDIAN)
-#  define BOOST_BIG_ENDIAN
+#  define NDNBOOST_BIG_ENDIAN
 # elif (__BYTE_ORDER == __PDP_ENDIAN)
-#  define BOOST_PDP_ENDIAN
+#  define NDNBOOST_PDP_ENDIAN
 # else
 #  error Unknown machine endianness detected.
 # endif
-# define BOOST_BYTE_ORDER __BYTE_ORDER
+# define NDNBOOST_BYTE_ORDER __BYTE_ORDER
 
 #elif defined(__NetBSD__) || defined(__FreeBSD__) || \
     defined(__OpenBSD__) || (__DragonFly__)
@@ -56,15 +56,15 @@
 #  include <sys/endian.h>
 #  endif
 # if (_BYTE_ORDER == _LITTLE_ENDIAN)
-#  define BOOST_LITTLE_ENDIAN
+#  define NDNBOOST_LITTLE_ENDIAN
 # elif (_BYTE_ORDER == _BIG_ENDIAN)
-#  define BOOST_BIG_ENDIAN
+#  define NDNBOOST_BIG_ENDIAN
 # elif (_BYTE_ORDER == _PDP_ENDIAN)
-#  define BOOST_PDP_ENDIAN
+#  define NDNBOOST_PDP_ENDIAN
 # else
 #  error Unknown machine endianness detected.
 # endif
-# define BOOST_BYTE_ORDER _BYTE_ORDER
+# define NDNBOOST_BYTE_ORDER _BYTE_ORDER
 
 #elif defined( __ANDROID__ )
 // Adroid specific code, see: https://svn.boost.org/trac/boost/ticket/7528
@@ -72,39 +72,39 @@
 // http://stackoverflow.com/questions/6212951/endianness-of-android-ndk
 # include "machine/_types.h"
 # ifdef __ARMEB__
-#  define BOOST_BIG_ENDIAN
-#  define BOOST_BYTE_ORDER 4321
+#  define NDNBOOST_BIG_ENDIAN
+#  define NDNBOOST_BYTE_ORDER 4321
 # else
-#  define BOOST_LITTLE_ENDIAN
-#  define BOOST_BYTE_ORDER 1234
+#  define NDNBOOST_LITTLE_ENDIAN
+#  define NDNBOOST_BYTE_ORDER 1234
 # endif // __ARMEB__
 
 #elif defined( _XBOX )
 //
 // XBox is always big endian??
 //
-# define BOOST_BIG_ENDIAN
-# define BOOST_BYTE_ORDER 4321
+# define NDNBOOST_BIG_ENDIAN
+# define NDNBOOST_BYTE_ORDER 4321
 
 #elif defined(_BIG_ENDIAN) && !defined(_LITTLE_ENDIAN) || \
     defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__) || \
     defined(__BIGENDIAN__) && !defined(__LITTLEENDIAN__) || \
     defined(_STLP_BIG_ENDIAN) && !defined(_STLP_LITTLE_ENDIAN)
-# define BOOST_BIG_ENDIAN
-# define BOOST_BYTE_ORDER 4321
+# define NDNBOOST_BIG_ENDIAN
+# define NDNBOOST_BYTE_ORDER 4321
 #elif defined(_LITTLE_ENDIAN) && !defined(_BIG_ENDIAN) || \
     defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__) || \
     defined(__LITTLEENDIAN__) && !defined(__BIGENDIAN__) || \
     defined(_STLP_LITTLE_ENDIAN) && !defined(_STLP_BIG_ENDIAN)
-# define BOOST_LITTLE_ENDIAN
-# define BOOST_BYTE_ORDER 1234
+# define NDNBOOST_LITTLE_ENDIAN
+# define NDNBOOST_BYTE_ORDER 1234
 #elif defined(__sparc) || defined(__sparc__) \
    || defined(_POWER) || defined(__powerpc__) \
    || defined(__ppc__) || defined(__hpux) || defined(__hppa) \
    || defined(_MIPSEB) || defined(_POWER) \
    || defined(__s390__) || defined(__ARMEB__)
-# define BOOST_BIG_ENDIAN
-# define BOOST_BYTE_ORDER 4321
+# define NDNBOOST_BIG_ENDIAN
+# define NDNBOOST_BYTE_ORDER 4321
 #elif defined(__i386__) || defined(__alpha__) \
    || defined(__ia64) || defined(__ia64__) \
    || defined(_M_IX86) || defined(_M_IA64) \
@@ -115,8 +115,8 @@
    || defined(__ARMEL__) \
    || (defined(_WIN32) && defined(__ARM__) && defined(_MSC_VER)) // ARM Windows CE don't define anything reasonably unique, but there are no big-endian Windows versions 
 
-# define BOOST_LITTLE_ENDIAN
-# define BOOST_BYTE_ORDER 1234
+# define NDNBOOST_LITTLE_ENDIAN
+# define NDNBOOST_BYTE_ORDER 1234
 #else
 # error The file ndnboost/detail/endian.hpp needs to be set up for your CPU type.
 #endif
diff --git a/include/ndnboost/detail/fenv.hpp b/include/ndnboost/detail/fenv.hpp
index 4618b54..90edcb0 100644
--- a/include/ndnboost/detail/fenv.hpp
+++ b/include/ndnboost/detail/fenv.hpp
@@ -7,12 +7,12 @@
 
 #include <ndnboost/config.hpp>
 
-#if defined(BOOST_NO_FENV_H)
+#if defined(NDNBOOST_NO_FENV_H)
   #error This platform does not have a floating point environment
 #endif
 
-#if !defined(BOOST_DETAIL_FENV_HPP)
-#define BOOST_DETAIL_FENV_HPP
+#if !defined(NDNBOOST_DETAIL_FENV_HPP)
+#define NDNBOOST_DETAIL_FENV_HPP
 
 /* If we're using clang + glibc, we have to get hacky. 
  * See http://llvm.org/bugs/show_bug.cgi?id=6907 */
@@ -70,5 +70,5 @@
 
 #endif
 
-#endif /* BOOST_DETAIL_FENV_HPP */
+#endif /* NDNBOOST_DETAIL_FENV_HPP */
  
diff --git a/include/ndnboost/detail/indirect_traits.hpp b/include/ndnboost/detail/indirect_traits.hpp
index fa2d671..95d95df 100644
--- a/include/ndnboost/detail/indirect_traits.hpp
+++ b/include/ndnboost/detail/indirect_traits.hpp
@@ -26,7 +26,7 @@
 # include <ndnboost/mpl/not.hpp>
 # include <ndnboost/mpl/aux_/lambda_support.hpp>
 
-#  ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#  ifdef NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 #   include <ndnboost/detail/is_function_ref_tester.hpp>
 #  endif 
 
@@ -34,7 +34,7 @@
 
 namespace indirect_traits {
 
-#  ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#  ifndef NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 template <class T>
 struct is_reference_to_const : mpl::false_
 {
@@ -45,7 +45,7 @@
 {
 };
 
-#   if defined(BOOST_MSVC) && _MSC_FULL_VER <= 13102140 // vc7.01 alpha workaround
+#   if defined(NDNBOOST_MSVC) && _MSC_FULL_VER <= 13102140 // vc7.01 alpha workaround
 template<class T>
 struct is_reference_to_const<T const volatile&> : mpl::true_
 {
@@ -90,7 +90,7 @@
 struct is_reference_to_member_function_pointer
     : is_reference_to_member_function_pointer_impl<T>
 {
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_member_function_pointer,(T))
+    NDNBOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_member_function_pointer,(T))
 };
 
 template <class T>
@@ -138,7 +138,7 @@
 {
 };
 
-#   if defined(BOOST_MSVC) && _MSC_FULL_VER <= 13102140 // vc7.01 alpha workaround
+#   if defined(NDNBOOST_MSVC) && _MSC_FULL_VER <= 13102140 // vc7.01 alpha workaround
 template <class T>
 struct is_reference_to_volatile<T const volatile&> : mpl::true_
 {
@@ -182,7 +182,7 @@
           >
       >
 {
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_class,(T))
+    NDNBOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_class,(T))
 };
 
 template <class T>
@@ -196,7 +196,7 @@
           >
       >
 {
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_pointer_to_class,(T))
+    NDNBOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_pointer_to_class,(T))
 };
 
 #  else
@@ -251,7 +251,7 @@
 struct is_reference_to_function_aux
 {
     static T t;
-    BOOST_STATIC_CONSTANT(
+    NDNBOOST_STATIC_CONSTANT(
         bool, value = sizeof(detail::is_function_ref_tester(t,0)) == sizeof(::ndnboost::type_traits::yes_type));
     typedef mpl::bool_<value> type;
  };
@@ -266,7 +266,7 @@
 struct is_pointer_to_function_aux
 {
     static T t;
-    BOOST_STATIC_CONSTANT(
+    NDNBOOST_STATIC_CONSTANT(
         bool, value
         = sizeof(::ndnboost::type_traits::is_function_ptr_tester(t)) == sizeof(::ndnboost::type_traits::yes_type));
     typedef mpl::bool_<value> type;
@@ -276,7 +276,7 @@
 struct is_pointer_to_function
     : mpl::if_<is_pointer<T>, is_pointer_to_function_aux<T>, mpl::bool_<false> >::type
 {
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_pointer_to_function,(T))
+    NDNBOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_pointer_to_function,(T))
 };
 
 struct false_helper1
@@ -298,7 +298,7 @@
     struct apply
     {
         static T t;
-        BOOST_STATIC_CONSTANT(
+        NDNBOOST_STATIC_CONSTANT(
             bool, value
             = sizeof(reference_to_const_helper(t)) == sizeof(inner_yes_type));
         typedef mpl::bool_<value> type;
@@ -330,7 +330,7 @@
     struct apply
     {
         static T t;
-        BOOST_STATIC_CONSTANT(
+        NDNBOOST_STATIC_CONSTANT(
             bool, value
             = sizeof(reference_to_const_helper(t)) == sizeof(inner_no_type));
         
@@ -348,7 +348,7 @@
 struct is_reference_to_non_const
     : is_reference_to_non_const_helper1<is_reference<T>::value>::template apply<T>
 {
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_non_const,(T))
+    NDNBOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_non_const,(T))
 };
 
 
@@ -364,7 +364,7 @@
     struct apply
     {
         static T t;
-        BOOST_STATIC_CONSTANT(
+        NDNBOOST_STATIC_CONSTANT(
             bool, value
             = sizeof(reference_to_volatile_helper(t)) == sizeof(inner_yes_type));
         typedef mpl::bool_<value> type;
@@ -391,7 +391,7 @@
 struct reference_to_pointer_impl
 {
     static T t;
-    BOOST_STATIC_CONSTANT(
+    NDNBOOST_STATIC_CONSTANT(
         bool, value
         = (sizeof((reference_to_pointer_helper)(t)) == sizeof(inner_yes_type))
         );
@@ -403,14 +403,14 @@
 struct is_reference_to_pointer
   : mpl::eval_if<is_reference<T>, reference_to_pointer_impl<T>, mpl::false_>::type
 {   
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_pointer,(T))
+    NDNBOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_pointer,(T))
 };
 
 template <class T>
 struct is_reference_to_function_pointer
   : mpl::eval_if<is_reference<T>, is_pointer_to_function_aux<T>, mpl::false_>::type
 {
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_function_pointer,(T))
+    NDNBOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_function_pointer,(T))
 };
 
 
@@ -427,7 +427,7 @@
 struct is_pointer_to_member_function_aux
 {
     static T t;
-    BOOST_STATIC_CONSTANT(
+    NDNBOOST_STATIC_CONSTANT(
         bool, value
         = sizeof((member_function_pointer_helper)(t)) == sizeof(inner_yes_type));
     typedef mpl::bool_<value> type;
@@ -441,7 +441,7 @@
         , mpl::bool_<false>
      >::type
 {
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_member_function_pointer,(T))
+    NDNBOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_member_function_pointer,(T))
 };
 
 template <typename V>
@@ -452,13 +452,13 @@
 struct is_reference_to_class
 {
     static T t;
-    BOOST_STATIC_CONSTANT(
+    NDNBOOST_STATIC_CONSTANT(
         bool, value
         = (is_reference<T>::value
            & (sizeof(reference_to_class_helper(t)) == sizeof(inner_yes_type)))
         );
     typedef mpl::bool_<value> type;
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_class,(T))
+    NDNBOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_class,(T))
 };
 
 template <typename V>
@@ -469,14 +469,14 @@
 struct is_pointer_to_class
 {
     static T t;
-    BOOST_STATIC_CONSTANT(
+    NDNBOOST_STATIC_CONSTANT(
         bool, value
         = (is_pointer<T>::value
            && sizeof(pointer_to_class_helper(t)) == sizeof(inner_yes_type))
         );
     typedef mpl::bool_<value> type;
 };
-#  endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION 
+#  endif // NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION 
 
 }
 
diff --git a/include/ndnboost/detail/interlocked.hpp b/include/ndnboost/detail/interlocked.hpp
index 1616414..5c480d5 100644
--- a/include/ndnboost/detail/interlocked.hpp
+++ b/include/ndnboost/detail/interlocked.hpp
@@ -1,5 +1,5 @@
-#ifndef BOOST_DETAIL_INTERLOCKED_HPP_INCLUDED
-#define BOOST_DETAIL_INTERLOCKED_HPP_INCLUDED
+#ifndef NDNBOOST_DETAIL_INTERLOCKED_HPP_INCLUDED
+#define NDNBOOST_DETAIL_INTERLOCKED_HPP_INCLUDED
 
 // MS compatible compilers support #pragma once
 
@@ -19,17 +19,17 @@
 
 #include <ndnboost/config.hpp>
 
-#if defined( BOOST_USE_WINDOWS_H )
+#if defined( NDNBOOST_USE_WINDOWS_H )
 
 # include <windows.h>
 
-# define BOOST_INTERLOCKED_INCREMENT InterlockedIncrement
-# define BOOST_INTERLOCKED_DECREMENT InterlockedDecrement
-# define BOOST_INTERLOCKED_COMPARE_EXCHANGE InterlockedCompareExchange
-# define BOOST_INTERLOCKED_EXCHANGE InterlockedExchange
-# define BOOST_INTERLOCKED_EXCHANGE_ADD InterlockedExchangeAdd
-# define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER InterlockedCompareExchangePointer
-# define BOOST_INTERLOCKED_EXCHANGE_POINTER InterlockedExchangePointer
+# define NDNBOOST_INTERLOCKED_INCREMENT InterlockedIncrement
+# define NDNBOOST_INTERLOCKED_DECREMENT InterlockedDecrement
+# define NDNBOOST_INTERLOCKED_COMPARE_EXCHANGE InterlockedCompareExchange
+# define NDNBOOST_INTERLOCKED_EXCHANGE InterlockedExchange
+# define NDNBOOST_INTERLOCKED_EXCHANGE_ADD InterlockedExchangeAdd
+# define NDNBOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER InterlockedCompareExchangePointer
+# define NDNBOOST_INTERLOCKED_EXCHANGE_POINTER InterlockedExchangePointer
 
 #elif defined(_WIN32_WCE)
 
@@ -41,11 +41,11 @@
 extern "C" long __cdecl _InterlockedExchange( long volatile *, long );
 extern "C" long __cdecl _InterlockedExchangeAdd( long volatile *, long );
 
-# define BOOST_INTERLOCKED_INCREMENT _InterlockedIncrement
-# define BOOST_INTERLOCKED_DECREMENT _InterlockedDecrement
-# define BOOST_INTERLOCKED_COMPARE_EXCHANGE _InterlockedCompareExchange
-# define BOOST_INTERLOCKED_EXCHANGE _InterlockedExchange
-# define BOOST_INTERLOCKED_EXCHANGE_ADD _InterlockedExchangeAdd
+# define NDNBOOST_INTERLOCKED_INCREMENT _InterlockedIncrement
+# define NDNBOOST_INTERLOCKED_DECREMENT _InterlockedDecrement
+# define NDNBOOST_INTERLOCKED_COMPARE_EXCHANGE _InterlockedCompareExchange
+# define NDNBOOST_INTERLOCKED_EXCHANGE _InterlockedExchange
+# define NDNBOOST_INTERLOCKED_EXCHANGE_ADD _InterlockedExchangeAdd
 
 #else
 // under Windows CE we still have old-style Interlocked* functions
@@ -56,22 +56,22 @@
 extern "C" long __cdecl InterlockedExchange( long*, long );
 extern "C" long __cdecl InterlockedExchangeAdd( long*, long );
 
-# define BOOST_INTERLOCKED_INCREMENT InterlockedIncrement
-# define BOOST_INTERLOCKED_DECREMENT InterlockedDecrement
-# define BOOST_INTERLOCKED_COMPARE_EXCHANGE InterlockedCompareExchange
-# define BOOST_INTERLOCKED_EXCHANGE InterlockedExchange
-# define BOOST_INTERLOCKED_EXCHANGE_ADD InterlockedExchangeAdd
+# define NDNBOOST_INTERLOCKED_INCREMENT InterlockedIncrement
+# define NDNBOOST_INTERLOCKED_DECREMENT InterlockedDecrement
+# define NDNBOOST_INTERLOCKED_COMPARE_EXCHANGE InterlockedCompareExchange
+# define NDNBOOST_INTERLOCKED_EXCHANGE InterlockedExchange
+# define NDNBOOST_INTERLOCKED_EXCHANGE_ADD InterlockedExchangeAdd
 
 #endif
 
-# define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest,exchange,compare) \
-    ((void*)BOOST_INTERLOCKED_COMPARE_EXCHANGE((long*)(dest),(long)(exchange),(long)(compare)))
-# define BOOST_INTERLOCKED_EXCHANGE_POINTER(dest,exchange) \
-    ((void*)BOOST_INTERLOCKED_EXCHANGE((long*)(dest),(long)(exchange)))
+# define NDNBOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest,exchange,compare) \
+    ((void*)NDNBOOST_INTERLOCKED_COMPARE_EXCHANGE((long*)(dest),(long)(exchange),(long)(compare)))
+# define NDNBOOST_INTERLOCKED_EXCHANGE_POINTER(dest,exchange) \
+    ((void*)NDNBOOST_INTERLOCKED_EXCHANGE((long*)(dest),(long)(exchange)))
 
-#elif defined( BOOST_MSVC ) || defined( BOOST_INTEL_WIN )
+#elif defined( NDNBOOST_MSVC ) || defined( NDNBOOST_INTEL_WIN )
 
-#if defined( BOOST_MSVC ) && BOOST_MSVC >= 1600
+#if defined( NDNBOOST_MSVC ) && NDNBOOST_MSVC >= 1600
 
 #include <intrin.h>
 
@@ -107,30 +107,30 @@
 #  pragma intrinsic( _InterlockedCompareExchangePointer )
 #  pragma intrinsic( _InterlockedExchangePointer )
 
-#  define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER _InterlockedCompareExchangePointer
-#  define BOOST_INTERLOCKED_EXCHANGE_POINTER _InterlockedExchangePointer
+#  define NDNBOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER _InterlockedCompareExchangePointer
+#  define NDNBOOST_INTERLOCKED_EXCHANGE_POINTER _InterlockedExchangePointer
 
 # else
 
-#  define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest,exchange,compare) \
-    ((void*)BOOST_INTERLOCKED_COMPARE_EXCHANGE((long volatile*)(dest),(long)(exchange),(long)(compare)))
-#  define BOOST_INTERLOCKED_EXCHANGE_POINTER(dest,exchange) \
-    ((void*)BOOST_INTERLOCKED_EXCHANGE((long volatile*)(dest),(long)(exchange)))
+#  define NDNBOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest,exchange,compare) \
+    ((void*)NDNBOOST_INTERLOCKED_COMPARE_EXCHANGE((long volatile*)(dest),(long)(exchange),(long)(compare)))
+#  define NDNBOOST_INTERLOCKED_EXCHANGE_POINTER(dest,exchange) \
+    ((void*)NDNBOOST_INTERLOCKED_EXCHANGE((long volatile*)(dest),(long)(exchange)))
 
 # endif
 
-# define BOOST_INTERLOCKED_INCREMENT _InterlockedIncrement
-# define BOOST_INTERLOCKED_DECREMENT _InterlockedDecrement
-# define BOOST_INTERLOCKED_COMPARE_EXCHANGE _InterlockedCompareExchange
-# define BOOST_INTERLOCKED_EXCHANGE _InterlockedExchange
-# define BOOST_INTERLOCKED_EXCHANGE_ADD _InterlockedExchangeAdd
+# define NDNBOOST_INTERLOCKED_INCREMENT _InterlockedIncrement
+# define NDNBOOST_INTERLOCKED_DECREMENT _InterlockedDecrement
+# define NDNBOOST_INTERLOCKED_COMPARE_EXCHANGE _InterlockedCompareExchange
+# define NDNBOOST_INTERLOCKED_EXCHANGE _InterlockedExchange
+# define NDNBOOST_INTERLOCKED_EXCHANGE_ADD _InterlockedExchangeAdd
 
 #elif defined( WIN32 ) || defined( _WIN32 ) || defined( __WIN32__ ) || defined( __CYGWIN__ )
 
 #if defined(__MINGW64__)
-#define BOOST_INTERLOCKED_IMPORT
+#define NDNBOOST_INTERLOCKED_IMPORT
 #else
-#define BOOST_INTERLOCKED_IMPORT __declspec(dllimport)
+#define NDNBOOST_INTERLOCKED_IMPORT __declspec(dllimport)
 #endif
 
 
@@ -140,35 +140,35 @@
 namespace detail
 {
 
-extern "C" BOOST_INTERLOCKED_IMPORT long __stdcall InterlockedIncrement( long volatile * );
-extern "C" BOOST_INTERLOCKED_IMPORT long __stdcall InterlockedDecrement( long volatile * );
-extern "C" BOOST_INTERLOCKED_IMPORT long __stdcall InterlockedCompareExchange( long volatile *, long, long );
-extern "C" BOOST_INTERLOCKED_IMPORT long __stdcall InterlockedExchange( long volatile *, long );
-extern "C" BOOST_INTERLOCKED_IMPORT long __stdcall InterlockedExchangeAdd( long volatile *, long );
+extern "C" NDNBOOST_INTERLOCKED_IMPORT long __stdcall InterlockedIncrement( long volatile * );
+extern "C" NDNBOOST_INTERLOCKED_IMPORT long __stdcall InterlockedDecrement( long volatile * );
+extern "C" NDNBOOST_INTERLOCKED_IMPORT long __stdcall InterlockedCompareExchange( long volatile *, long, long );
+extern "C" NDNBOOST_INTERLOCKED_IMPORT long __stdcall InterlockedExchange( long volatile *, long );
+extern "C" NDNBOOST_INTERLOCKED_IMPORT long __stdcall InterlockedExchangeAdd( long volatile *, long );
 
 # if defined(_M_IA64) || defined(_M_AMD64)
-extern "C" BOOST_INTERLOCKED_IMPORT void* __stdcall InterlockedCompareExchangePointer( void* volatile *, void*, void* );
-extern "C" BOOST_INTERLOCKED_IMPORT void* __stdcall InterlockedExchangePointer( void* volatile *, void* );
+extern "C" NDNBOOST_INTERLOCKED_IMPORT void* __stdcall InterlockedCompareExchangePointer( void* volatile *, void*, void* );
+extern "C" NDNBOOST_INTERLOCKED_IMPORT void* __stdcall InterlockedExchangePointer( void* volatile *, void* );
 # endif
 
 } // namespace detail
 
 } // namespace ndnboost
 
-# define BOOST_INTERLOCKED_INCREMENT ::ndnboost::detail::InterlockedIncrement
-# define BOOST_INTERLOCKED_DECREMENT ::ndnboost::detail::InterlockedDecrement
-# define BOOST_INTERLOCKED_COMPARE_EXCHANGE ::ndnboost::detail::InterlockedCompareExchange
-# define BOOST_INTERLOCKED_EXCHANGE ::ndnboost::detail::InterlockedExchange
-# define BOOST_INTERLOCKED_EXCHANGE_ADD ::ndnboost::detail::InterlockedExchangeAdd
+# define NDNBOOST_INTERLOCKED_INCREMENT ::ndnboost::detail::InterlockedIncrement
+# define NDNBOOST_INTERLOCKED_DECREMENT ::ndnboost::detail::InterlockedDecrement
+# define NDNBOOST_INTERLOCKED_COMPARE_EXCHANGE ::ndnboost::detail::InterlockedCompareExchange
+# define NDNBOOST_INTERLOCKED_EXCHANGE ::ndnboost::detail::InterlockedExchange
+# define NDNBOOST_INTERLOCKED_EXCHANGE_ADD ::ndnboost::detail::InterlockedExchangeAdd
 
 # if defined(_M_IA64) || defined(_M_AMD64)
-#  define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER ::ndnboost::detail::InterlockedCompareExchangePointer
-#  define BOOST_INTERLOCKED_EXCHANGE_POINTER ::ndnboost::detail::InterlockedExchangePointer
+#  define NDNBOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER ::ndnboost::detail::InterlockedCompareExchangePointer
+#  define NDNBOOST_INTERLOCKED_EXCHANGE_POINTER ::ndnboost::detail::InterlockedExchangePointer
 # else
-#  define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest,exchange,compare) \
-    ((void*)BOOST_INTERLOCKED_COMPARE_EXCHANGE((long volatile*)(dest),(long)(exchange),(long)(compare)))
-#  define BOOST_INTERLOCKED_EXCHANGE_POINTER(dest,exchange) \
-    ((void*)BOOST_INTERLOCKED_EXCHANGE((long volatile*)(dest),(long)(exchange)))
+#  define NDNBOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest,exchange,compare) \
+    ((void*)NDNBOOST_INTERLOCKED_COMPARE_EXCHANGE((long volatile*)(dest),(long)(exchange),(long)(compare)))
+#  define NDNBOOST_INTERLOCKED_EXCHANGE_POINTER(dest,exchange) \
+    ((void*)NDNBOOST_INTERLOCKED_EXCHANGE((long volatile*)(dest),(long)(exchange)))
 # endif
 
 #else
@@ -177,4 +177,4 @@
 
 #endif
 
-#endif // #ifndef BOOST_DETAIL_INTERLOCKED_HPP_INCLUDED
+#endif // #ifndef NDNBOOST_DETAIL_INTERLOCKED_HPP_INCLUDED
diff --git a/include/ndnboost/detail/is_function_ref_tester.hpp b/include/ndnboost/detail/is_function_ref_tester.hpp
index b8301ec..001ff5f 100644
--- a/include/ndnboost/detail/is_function_ref_tester.hpp
+++ b/include/ndnboost/detail/is_function_ref_tester.hpp
@@ -5,17 +5,17 @@
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
-#if !defined(BOOST_PP_IS_ITERATING)
+#if !defined(NDNBOOST_PP_IS_ITERATING)
 
 ///// header body
 
-#ifndef BOOST_DETAIL_IS_FUNCTION_REF_TESTER_HPP_INCLUDED
-#define BOOST_DETAIL_IS_FUNCTION_REF_TESTER_HPP_INCLUDED
+#ifndef NDNBOOST_DETAIL_IS_FUNCTION_REF_TESTER_HPP_INCLUDED
+#define NDNBOOST_DETAIL_IS_FUNCTION_REF_TESTER_HPP_INCLUDED
 
 #include "ndnboost/type_traits/detail/yes_no_type.hpp"
 #include "ndnboost/type_traits/config.hpp"
 
-#if defined(BOOST_TT_PREPROCESSING_MODE)
+#if defined(NDNBOOST_TT_PREPROCESSING_MODE)
 #   include "ndnboost/preprocessor/iterate.hpp"
 #   include "ndnboost/preprocessor/enum_params.hpp"
 #   include "ndnboost/preprocessor/comma_if.hpp"
@@ -26,9 +26,9 @@
 namespace is_function_ref_tester_ {
 
 template <class T>
-ndnboost::type_traits::no_type BOOST_TT_DECL is_function_ref_tester(T& ...);
+ndnboost::type_traits::no_type NDNBOOST_TT_DECL is_function_ref_tester(T& ...);
 
-#if !defined(BOOST_TT_PREPROCESSING_MODE)
+#if !defined(NDNBOOST_TT_PREPROCESSING_MODE)
 // preprocessor-generated part, don't edit by hand!
 
 template <class R>
@@ -111,26 +111,26 @@
 
 #else
 
-#define BOOST_PP_ITERATION_PARAMS_1 \
+#define NDNBOOST_PP_ITERATION_PARAMS_1 \
     (3, (0, 25, "ndnboost/detail/is_function_ref_tester.hpp"))
-#include BOOST_PP_ITERATE()
+#include NDNBOOST_PP_ITERATE()
 
-#endif // BOOST_TT_PREPROCESSING_MODE
+#endif // NDNBOOST_TT_PREPROCESSING_MODE
 
 } // namespace detail
 } // namespace python
 } // namespace ndnboost
 
-#endif // BOOST_DETAIL_IS_FUNCTION_REF_TESTER_HPP_INCLUDED
+#endif // NDNBOOST_DETAIL_IS_FUNCTION_REF_TESTER_HPP_INCLUDED
 
 ///// iteration
 
 #else
-#define i BOOST_PP_FRAME_ITERATION(1)
+#define i NDNBOOST_PP_FRAME_ITERATION(1)
 
-template <class R BOOST_PP_COMMA_IF(i) BOOST_PP_ENUM_PARAMS(i,class T) >
-ndnboost::type_traits::yes_type is_function_ref_tester(R (&)(BOOST_PP_ENUM_PARAMS(i,T)), int);
+template <class R NDNBOOST_PP_COMMA_IF(i) NDNBOOST_PP_ENUM_PARAMS(i,class T) >
+ndnboost::type_traits::yes_type is_function_ref_tester(R (&)(NDNBOOST_PP_ENUM_PARAMS(i,T)), int);
 
 #undef i
-#endif // BOOST_PP_IS_ITERATING
+#endif // NDNBOOST_PP_IS_ITERATING
 
diff --git a/include/ndnboost/detail/is_incrementable.hpp b/include/ndnboost/detail/is_incrementable.hpp
index a15ccb6..0471db9 100644
--- a/include/ndnboost/detail/is_incrementable.hpp
+++ b/include/ndnboost/detail/is_incrementable.hpp
@@ -34,7 +34,7 @@
   struct any { template <class T> any(T const&); };
 
   // This is a last-resort operator++ for when none other is found
-# if BOOST_WORKAROUND(__GNUC__, == 4) && __GNUC_MINOR__ == 0 && __GNUC_PATCHLEVEL__ == 2
+# if NDNBOOST_WORKAROUND(__GNUC__, == 4) && __GNUC_MINOR__ == 0 && __GNUC_PATCHLEVEL__ == 2
   
 }
 
@@ -55,16 +55,16 @@
   
 # endif 
 
-# if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3202)) \
-    || BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-#  define BOOST_comma(a,b) (a)
+# if NDNBOOST_WORKAROUND(__MWERKS__, NDNBOOST_TESTED_AT(0x3202)) \
+    || NDNBOOST_WORKAROUND(NDNBOOST_MSVC, <= 1300)
+#  define NDNBOOST_comma(a,b) (a)
 # else 
   // In case an operator++ is found that returns void, we'll use ++x,0
   tag operator,(tag,int);  
-#  define BOOST_comma(a,b) (a,b)
+#  define NDNBOOST_comma(a,b) (a,b)
 # endif 
 
-# if defined(BOOST_MSVC)
+# if defined(NDNBOOST_MSVC)
 #  pragma warning(push)
 #  pragma warning(disable:4913) // Warning about operator,
 # endif 
@@ -81,9 +81,9 @@
   {
       static typename ndnboost::remove_cv<T>::type& x;
 
-      BOOST_STATIC_CONSTANT(
+      NDNBOOST_STATIC_CONSTANT(
           bool
-        , value = sizeof(is_incrementable_::check_(BOOST_comma(++x,0))) == 1
+        , value = sizeof(is_incrementable_::check_(NDNBOOST_comma(++x,0))) == 1
       );
   };
 
@@ -92,40 +92,40 @@
   {
       static typename ndnboost::remove_cv<T>::type& x;
 
-      BOOST_STATIC_CONSTANT(
+      NDNBOOST_STATIC_CONSTANT(
           bool
-        , value = sizeof(is_incrementable_::check_(BOOST_comma(x++,0))) == 1
+        , value = sizeof(is_incrementable_::check_(NDNBOOST_comma(x++,0))) == 1
       );
   };
 
-# if defined(BOOST_MSVC)
+# if defined(NDNBOOST_MSVC)
 #  pragma warning(pop)
 # endif 
 
 }
 
-# undef BOOST_comma
+# undef NDNBOOST_comma
 
 template<typename T> 
 struct is_incrementable 
-BOOST_TT_AUX_BOOL_C_BASE(::ndnboost::detail::is_incrementable_::impl<T>::value)
+NDNBOOST_TT_AUX_BOOL_C_BASE(::ndnboost::detail::is_incrementable_::impl<T>::value)
 { 
-    BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(::ndnboost::detail::is_incrementable_::impl<T>::value)
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_incrementable,(T))
+    NDNBOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(::ndnboost::detail::is_incrementable_::impl<T>::value)
+    NDNBOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_incrementable,(T))
 };
 
 template<typename T> 
 struct is_postfix_incrementable 
-BOOST_TT_AUX_BOOL_C_BASE(::ndnboost::detail::is_incrementable_::impl<T>::value)
+NDNBOOST_TT_AUX_BOOL_C_BASE(::ndnboost::detail::is_incrementable_::impl<T>::value)
 { 
-    BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(::ndnboost::detail::is_incrementable_::postfix_impl<T>::value)
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_postfix_incrementable,(T))
+    NDNBOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(::ndnboost::detail::is_incrementable_::postfix_impl<T>::value)
+    NDNBOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_postfix_incrementable,(T))
 };
 
 } // namespace detail
 
-BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1, ::ndnboost::detail::is_incrementable)
-BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1, ::ndnboost::detail::is_postfix_incrementable)
+NDNBOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1, ::ndnboost::detail::is_incrementable)
+NDNBOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1, ::ndnboost::detail::is_postfix_incrementable)
 
 } // namespace ndnboost
 
diff --git a/include/ndnboost/detail/iterator.hpp b/include/ndnboost/detail/iterator.hpp
index 6cfb5aa..c2bb102 100644
--- a/include/ndnboost/detail/iterator.hpp
+++ b/include/ndnboost/detail/iterator.hpp
@@ -26,7 +26,7 @@
 // 03 Mar 2001 - Put all implementation into namespace
 //               ndnboost::detail::iterator_traits_. Some progress made on fixes
 //               for Intel compiler. (David Abrahams)
-// 02 Mar 2001 - Changed BOOST_MSVC to BOOST_MSVC_STD_ITERATOR in a few
+// 02 Mar 2001 - Changed NDNBOOST_MSVC to NDNBOOST_MSVC_STD_ITERATOR in a few
 //               places. (Jeremy Siek)
 // 19 Feb 2001 - Improved workarounds for stock MSVC6; use yes_type and
 //               no_type from type_traits.hpp; stopped trying to remove_cv
@@ -63,16 +63,16 @@
 # if defined(__SGI_STL_PORT)
 
 #  if (__SGI_STL_PORT <= 0x410) && !defined(__STL_CLASS_PARTIAL_SPECIALIZATION) && defined(__STL_DEBUG)
-#   define BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF
+#   define NDNBOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF
 #  endif
 
-#  define BOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION
+#  define NDNBOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION
 
 # endif // STLPort <= 4.1b4 && no partial specialization
 
-# if !defined(BOOST_NO_STD_ITERATOR_TRAITS)             \
-  && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
-  && !defined(BOOST_MSVC_STD_ITERATOR)
+# if !defined(NDNBOOST_NO_STD_ITERATOR_TRAITS)             \
+  && !defined(NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
+  && !defined(NDNBOOST_MSVC_STD_ITERATOR)
     
 namespace ndnboost { namespace detail {
 
@@ -87,10 +87,10 @@
 
 # else
 
-#  if  !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)  \
-    && !defined(BOOST_MSVC_STD_ITERATOR)
+#  if  !defined(NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)  \
+    && !defined(NDNBOOST_MSVC_STD_ITERATOR)
 
-// This is the case where everything conforms except BOOST_NO_STD_ITERATOR_TRAITS
+// This is the case where everything conforms except NDNBOOST_NO_STD_ITERATOR_TRAITS
 
 namespace ndnboost { namespace detail {
 
@@ -135,11 +135,11 @@
 # include <ndnboost/type_traits/detail/yes_no_type.hpp>
 # include <ndnboost/type_traits/is_pointer.hpp>
 
-# ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+# ifdef NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 #  include <ndnboost/type_traits/is_same.hpp>
 #  include <ndnboost/type_traits/remove_pointer.hpp>
 # endif
-# ifdef BOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION
+# ifdef NDNBOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION
 #  include <ndnboost/type_traits/is_base_and_derived.hpp>
 # endif
 
@@ -152,11 +152,11 @@
 
 namespace ndnboost { namespace detail {
 
-BOOST_MPL_HAS_XXX_TRAIT_DEF(value_type)
-BOOST_MPL_HAS_XXX_TRAIT_DEF(reference)
-BOOST_MPL_HAS_XXX_TRAIT_DEF(pointer)
-BOOST_MPL_HAS_XXX_TRAIT_DEF(difference_type)
-BOOST_MPL_HAS_XXX_TRAIT_DEF(iterator_category)
+NDNBOOST_MPL_HAS_XXX_TRAIT_DEF(value_type)
+NDNBOOST_MPL_HAS_XXX_TRAIT_DEF(reference)
+NDNBOOST_MPL_HAS_XXX_TRAIT_DEF(pointer)
+NDNBOOST_MPL_HAS_XXX_TRAIT_DEF(difference_type)
+NDNBOOST_MPL_HAS_XXX_TRAIT_DEF(iterator_category)
 
 // is_mutable_iterator --
 //
@@ -170,7 +170,7 @@
 // This one detects ordinary mutable iterators - the result of
 // operator* is convertible to the value_type.
 template <class T>
-type_traits::yes_type is_mutable_iterator_helper(T const*, BOOST_DEDUCED_TYPENAME T::value_type*);
+type_traits::yes_type is_mutable_iterator_helper(T const*, NDNBOOST_DEDUCED_TYPENAME T::value_type*);
 
 // Since you can't take the address of an rvalue, the guts of
 // is_mutable_iterator_impl will fail if we use &*t directly.  This
@@ -191,7 +191,7 @@
 {
     static T t;
     
-    BOOST_STATIC_CONSTANT(
+    NDNBOOST_STATIC_CONSTANT(
         bool, value = sizeof(
             detail::is_mutable_iterator_helper(
                 (T*)0
@@ -201,7 +201,7 @@
     );
 };
 
-BOOST_TT_AUX_BOOL_TRAIT_DEF1(
+NDNBOOST_TT_AUX_BOOL_TRAIT_DEF1(
     is_mutable_iterator,T,::ndnboost::detail::is_mutable_iterator_impl<T>::value)
 
 
@@ -222,12 +222,12 @@
     };
 };
 
-BOOST_TT_AUX_BOOL_TRAIT_DEF1(
+NDNBOOST_TT_AUX_BOOL_TRAIT_DEF1(
     is_full_iterator_traits,T,::ndnboost::detail::is_full_iterator_traits_impl<T>::value)
 
 
-#   ifdef BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF
-BOOST_MPL_HAS_XXX_TRAIT_DEF(_Iterator_category)
+#   ifdef NDNBOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF
+NDNBOOST_MPL_HAS_XXX_TRAIT_DEF(_Iterator_category)
     
 // is_stlport_40_debug_iterator --
 //
@@ -246,7 +246,7 @@
     };
 };
 
-BOOST_TT_AUX_BOOL_TRAIT_DEF1(
+NDNBOOST_TT_AUX_BOOL_TRAIT_DEF1(
     is_stlport_40_debug_iterator,T,::ndnboost::detail::is_stlport_40_debug_iterator_impl<T>::value)
 
 template <class T>
@@ -258,11 +258,11 @@
     typedef typename T::difference_type difference_type;
     typedef typename T::_Iterator_category iterator_category;
 };
-#   endif // BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF 
+#   endif // NDNBOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF 
 
 template <class T> struct pointer_iterator_traits;
 
-#   ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#   ifndef NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 template <class T>
 struct pointer_iterator_traits<T*>
 {
@@ -279,13 +279,13 @@
 // some basic types, remove_pointer is manually defined in
 // type_traits/broken_compiler_spec.hpp. For others, do it yourself.
 
-template<class P> class please_invoke_BOOST_TT_BROKEN_COMPILER_SPEC_on_cv_unqualified_pointee;
+template<class P> class please_invoke_NDNBOOST_TT_BROKEN_COMPILER_SPEC_on_cv_unqualified_pointee;
 
 template<class P>
 struct pointer_value_type
   : mpl::if_<
         is_same<P, typename remove_pointer<P>::type>
-      , please_invoke_BOOST_TT_BROKEN_COMPILER_SPEC_on_cv_unqualified_pointee<P>
+      , please_invoke_NDNBOOST_TT_BROKEN_COMPILER_SPEC_on_cv_unqualified_pointee<P>
       , typename remove_const<
             typename remove_pointer<P>::type
         >::type
@@ -298,7 +298,7 @@
 struct pointer_reference
   : mpl::if_<
         is_same<P, typename remove_pointer<P>::type>
-      , please_invoke_BOOST_TT_BROKEN_COMPILER_SPEC_on_cv_unqualified_pointee<P>
+      , please_invoke_NDNBOOST_TT_BROKEN_COMPILER_SPEC_on_cv_unqualified_pointee<P>
       , typename remove_pointer<P>::type&
     >
 {
@@ -315,7 +315,7 @@
     typedef typename pointer_reference<T>::type reference;
 };
 
-#   endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#   endif // NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
 // We'll sort iterator types into one of these classifications, from which we
 // can determine the difference_type, pointer, reference, and value_type
@@ -347,7 +347,7 @@
     typedef const typename std::iterator_traits<Iterator>::value_type& reference;
 };
 
-#   ifdef BOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION
+#   ifdef NDNBOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION
 template <class Iterator>
 struct is_bad_output_iterator
     : is_base_and_derived<
@@ -384,7 +384,7 @@
         is_full_iterator_traits<Iterator>
         // Use a standard iterator_traits implementation
         , standard_iterator_traits<Iterator>
-#   ifdef BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF
+#   ifdef NDNBOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF
         // Check for STLPort 4.0 broken _Iterator_category type
         , mpl::if_<
              is_stlport_40_debug_iterator<Iterator>
@@ -392,7 +392,7 @@
 #   endif
         // Otherwise, assume it's a Dinkum iterator
         , msvc_stdlib_iterator_traits<Iterator>
-#   ifdef BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF
+#   ifdef NDNBOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF
         >::type
 #   endif 
     >::type
@@ -415,7 +415,7 @@
     // Explicit forwarding from base class needed to keep MSVC6 happy
     // under some circumstances.
  private:
-#   ifdef BOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION
+#   ifdef NDNBOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION
     typedef 
     typename mpl::if_<
         is_bad_output_iterator<Iterator>
@@ -488,7 +488,7 @@
 # endif
 
 
-# undef BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF
-# undef BOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION
+# undef NDNBOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF
+# undef NDNBOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION
 
 #endif // ITERATOR_DWA122600_HPP_
diff --git a/include/ndnboost/detail/lcast_precision.hpp b/include/ndnboost/detail/lcast_precision.hpp
index b763a83..2b0b2aa 100644
--- a/include/ndnboost/detail/lcast_precision.hpp
+++ b/include/ndnboost/detail/lcast_precision.hpp
@@ -5,8 +5,8 @@
 // (See accompanying file LICENSE_1_0.txt
 // or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef BOOST_DETAIL_LCAST_PRECISION_HPP_INCLUDED
-#define BOOST_DETAIL_LCAST_PRECISION_HPP_INCLUDED
+#ifndef NDNBOOST_DETAIL_LCAST_PRECISION_HPP_INCLUDED
+#define NDNBOOST_DETAIL_LCAST_PRECISION_HPP_INCLUDED
 
 #include <climits>
 #include <ios>
@@ -15,19 +15,19 @@
 #include <ndnboost/config.hpp>
 #include <ndnboost/integer_traits.hpp>
 
-#ifndef BOOST_NO_IS_ABSTRACT
+#ifndef NDNBOOST_NO_IS_ABSTRACT
 // Fix for SF:1358600 - lexical_cast & pure virtual functions & VC 8 STL
 #include <ndnboost/mpl/if.hpp>
 #include <ndnboost/type_traits/is_abstract.hpp>
 #endif
 
-#if defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) || \
-  (defined(BOOST_MSVC) && (BOOST_MSVC<1310))
+#if defined(NDNBOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) || \
+  (defined(NDNBOOST_MSVC) && (NDNBOOST_MSVC<1310))
 
-#define BOOST_LCAST_NO_COMPILE_TIME_PRECISION
+#define NDNBOOST_LCAST_NO_COMPILE_TIME_PRECISION
 #endif
 
-#ifdef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
+#ifdef NDNBOOST_LCAST_NO_COMPILE_TIME_PRECISION
 #include <ndnboost/assert.hpp>
 #else
 #include <ndnboost/static_assert.hpp>
@@ -37,58 +37,58 @@
 
 class lcast_abstract_stub {};
 
-#ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
+#ifndef NDNBOOST_LCAST_NO_COMPILE_TIME_PRECISION
 // Calculate an argument to pass to std::ios_base::precision from
 // lexical_cast. See alternative implementation for broken standard
 // libraries in lcast_get_precision below. Keep them in sync, please.
 template<class T>
 struct lcast_precision
 {
-#ifdef BOOST_NO_IS_ABSTRACT
+#ifdef NDNBOOST_NO_IS_ABSTRACT
     typedef std::numeric_limits<T> limits; // No fix for SF:1358600.
 #else
-    typedef BOOST_DEDUCED_TYPENAME ndnboost::mpl::if_<
+    typedef NDNBOOST_DEDUCED_TYPENAME ndnboost::mpl::if_<
         ndnboost::is_abstract<T>
       , std::numeric_limits<lcast_abstract_stub>
       , std::numeric_limits<T>
       >::type limits;
 #endif
 
-    BOOST_STATIC_CONSTANT(bool, use_default_precision =
+    NDNBOOST_STATIC_CONSTANT(bool, use_default_precision =
             !limits::is_specialized || limits::is_exact
         );
 
-    BOOST_STATIC_CONSTANT(bool, is_specialized_bin =
+    NDNBOOST_STATIC_CONSTANT(bool, is_specialized_bin =
             !use_default_precision &&
             limits::radix == 2 && limits::digits > 0
         );
 
-    BOOST_STATIC_CONSTANT(bool, is_specialized_dec =
+    NDNBOOST_STATIC_CONSTANT(bool, is_specialized_dec =
             !use_default_precision &&
             limits::radix == 10 && limits::digits10 > 0
         );
 
-    BOOST_STATIC_CONSTANT(std::streamsize, streamsize_max =
+    NDNBOOST_STATIC_CONSTANT(std::streamsize, streamsize_max =
             ndnboost::integer_traits<std::streamsize>::const_max
         );
 
-    BOOST_STATIC_CONSTANT(unsigned int, precision_dec = limits::digits10 + 1U);
+    NDNBOOST_STATIC_CONSTANT(unsigned int, precision_dec = limits::digits10 + 1U);
 
-    BOOST_STATIC_ASSERT(!is_specialized_dec ||
+    NDNBOOST_STATIC_ASSERT(!is_specialized_dec ||
             precision_dec <= streamsize_max + 0UL
         );
 
-    BOOST_STATIC_CONSTANT(unsigned long, precision_bin =
+    NDNBOOST_STATIC_CONSTANT(unsigned long, precision_bin =
             2UL + limits::digits * 30103UL / 100000UL
         );
 
-    BOOST_STATIC_ASSERT(!is_specialized_bin ||
+    NDNBOOST_STATIC_ASSERT(!is_specialized_bin ||
             (limits::digits + 0UL < ULONG_MAX / 30103UL &&
             precision_bin > limits::digits10 + 0UL &&
             precision_bin <= streamsize_max + 0UL)
         );
 
-    BOOST_STATIC_CONSTANT(std::streamsize, value =
+    NDNBOOST_STATIC_CONSTANT(std::streamsize, value =
             is_specialized_bin ? precision_bin
                                : is_specialized_dec ? precision_dec : 6
         );
@@ -98,14 +98,14 @@
 template<class T>
 inline std::streamsize lcast_get_precision(T* = 0)
 {
-#ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
+#ifndef NDNBOOST_LCAST_NO_COMPILE_TIME_PRECISION
     return lcast_precision<T>::value;
 #else // Follow lcast_precision algorithm at run-time:
 
-#ifdef BOOST_NO_IS_ABSTRACT
+#ifdef NDNBOOST_NO_IS_ABSTRACT
     typedef std::numeric_limits<T> limits; // No fix for SF:1358600.
 #else
-    typedef BOOST_DEDUCED_TYPENAME ndnboost::mpl::if_<
+    typedef NDNBOOST_DEDUCED_TYPENAME ndnboost::mpl::if_<
         ndnboost::is_abstract<T>
       , std::numeric_limits<lcast_abstract_stub>
       , std::numeric_limits<T>
@@ -134,7 +134,7 @@
             unsigned long const precision = 2UL + digits * 30103UL / 100000UL;
             // unsigned long is selected because it is at least 32-bits
             // and thus ULONG_MAX / 30103UL is big enough for all types.
-            BOOST_ASSERT(
+            NDNBOOST_ASSERT(
                     digits < ULONG_MAX / 30103UL &&
                     precision > limits::digits10 + 0UL &&
                     precision <= streamsize_max + 0UL
@@ -145,7 +145,7 @@
         {   // Decimal Floating-point type, most likely a User Defined Type
             // rather than a real floating-point hardware type.
             unsigned int const precision = limits::digits10 + 1U;
-            BOOST_ASSERT(precision <= streamsize_max + 0UL);
+            NDNBOOST_ASSERT(precision <= streamsize_max + 0UL);
             return precision;
         }
     }
@@ -180,5 +180,5 @@
 
 }}
 
-#endif //  BOOST_DETAIL_LCAST_PRECISION_HPP_INCLUDED
+#endif //  NDNBOOST_DETAIL_LCAST_PRECISION_HPP_INCLUDED
 
diff --git a/include/ndnboost/detail/lightweight_mutex.hpp b/include/ndnboost/detail/lightweight_mutex.hpp
index 69e3e38..2860c1a 100644
--- a/include/ndnboost/detail/lightweight_mutex.hpp
+++ b/include/ndnboost/detail/lightweight_mutex.hpp
@@ -1,5 +1,5 @@
-#ifndef BOOST_DETAIL_LIGHTWEIGHT_MUTEX_HPP_INCLUDED
-#define BOOST_DETAIL_LIGHTWEIGHT_MUTEX_HPP_INCLUDED
+#ifndef NDNBOOST_DETAIL_LIGHTWEIGHT_MUTEX_HPP_INCLUDED
+#define NDNBOOST_DETAIL_LIGHTWEIGHT_MUTEX_HPP_INCLUDED
 
 // MS compatible compilers support #pragma once
 
@@ -19,4 +19,4 @@
 
 #include <ndnboost/smart_ptr/detail/lightweight_mutex.hpp>
 
-#endif // #ifndef BOOST_DETAIL_LIGHTWEIGHT_MUTEX_HPP_INCLUDED
+#endif // #ifndef NDNBOOST_DETAIL_LIGHTWEIGHT_MUTEX_HPP_INCLUDED
diff --git a/include/ndnboost/detail/lightweight_test.hpp b/include/ndnboost/detail/lightweight_test.hpp
index 252a2be..40e7cd6 100644
--- a/include/ndnboost/detail/lightweight_test.hpp
+++ b/include/ndnboost/detail/lightweight_test.hpp
@@ -1,5 +1,5 @@
-#ifndef BOOST_DETAIL_LIGHTWEIGHT_TEST_HPP_INCLUDED
-#define BOOST_DETAIL_LIGHTWEIGHT_TEST_HPP_INCLUDED
+#ifndef NDNBOOST_DETAIL_LIGHTWEIGHT_TEST_HPP_INCLUDED
+#define NDNBOOST_DETAIL_LIGHTWEIGHT_TEST_HPP_INCLUDED
 
 // MS compatible compilers support #pragma once
 
@@ -23,38 +23,38 @@
 //    If expression is false increases the error count 
 //    and outputs a message containing 'expression'
 //
-//  BOOST_TEST(expression)
+//  NDNBOOST_TEST(expression)
 //
 //    ---------------
 //
 //    Increases error count and outputs a message containing 'message'
 //
-//  BOOST_ERROR(message)
+//  NDNBOOST_ERROR(message)
 //
 //    ---------------
 //
 //    If 'expr1' != 'expr2' increases the error count 
 //    and outputs a message containing both expressions
 //
-//  BOOST_TEST_EQ(expr1, expr2)
+//  NDNBOOST_TEST_EQ(expr1, expr2)
 //
 //    ---------------
 //
 //    If 'expr1' == 'expr2' increases the error count 
 //    and outputs a message containing both expressions
 //
-//  BOOST_TEST_NE(expr1, expr2)
+//  NDNBOOST_TEST_NE(expr1, expr2)
 //
 //    ---------------
 //
-//    If BOOST_NO_EXCEPTIONS is NOT defined and if 'expr' does not
+//    If NDNBOOST_NO_EXCEPTIONS is NOT defined and if 'expr' does not
 //    throw an exception of type 'excep', increases the error count
 //    and outputs a message containing the expression.
 //
-//    If BOOST_NO_EXCEPTIONS is defined, this macro expands to nothing
+//    If NDNBOOST_NO_EXCEPTIONS is defined, this macro expands to nothing
 //    and 'expr' is not evaluated.
 //
-//  BOOST_TEST_THROWS(expr, excep)
+//  NDNBOOST_TEST_THROWS(expr, excep)
 //
 //    ---------------
 //
@@ -70,8 +70,8 @@
 
 //  IDE's like Visual Studio perform better if output goes to std::cout or
 //  some other stream, so allow user to configure output stream:
-#ifndef BOOST_LIGHTWEIGHT_TEST_OSTREAM
-# define BOOST_LIGHTWEIGHT_TEST_OSTREAM std::cerr
+#ifndef NDNBOOST_LIGHTWEIGHT_TEST_OSTREAM
+# define NDNBOOST_LIGHTWEIGHT_TEST_OSTREAM std::cerr
 #endif
 
 namespace ndnboost
@@ -86,7 +86,7 @@
   report_errors_reminder() : called_report_errors_function(false) {}
  ~report_errors_reminder()
   {
-    BOOST_ASSERT(called_report_errors_function);  // verify report_errors() was called  
+    NDNBOOST_ASSERT(called_report_errors_function);  // verify report_errors() was called  
   }
 };
 
@@ -105,7 +105,7 @@
 
 inline void test_failed_impl(char const * expr, char const * file, int line, char const * function)
 {
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM
+    NDNBOOST_LIGHTWEIGHT_TEST_OSTREAM
       << file << "(" << line << "): test '" << expr << "' failed in function '"
       << function << "'" << std::endl;
     ++test_errors();
@@ -113,7 +113,7 @@
 
 inline void error_impl(char const * msg, char const * file, int line, char const * function)
 {
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM
+    NDNBOOST_LIGHTWEIGHT_TEST_OSTREAM
       << file << "(" << line << "): " << msg << " in function '"
       << function << "'" << std::endl;
     ++test_errors();
@@ -121,7 +121,7 @@
 
 inline void throw_failed_impl(char const * excep, char const * file, int line, char const * function)
 {
-   BOOST_LIGHTWEIGHT_TEST_OSTREAM
+   NDNBOOST_LIGHTWEIGHT_TEST_OSTREAM
     << file << "(" << line << "): Exception '" << excep << "' not thrown in function '"
     << function << "'" << std::endl;
    ++test_errors();
@@ -135,7 +135,7 @@
     }
     else
     {
-        BOOST_LIGHTWEIGHT_TEST_OSTREAM
+        NDNBOOST_LIGHTWEIGHT_TEST_OSTREAM
             << file << "(" << line << "): test '" << expr1 << " == " << expr2
             << "' failed in function '" << function << "': "
             << "'" << t << "' != '" << u << "'" << std::endl;
@@ -151,7 +151,7 @@
     }
     else
     {
-        BOOST_LIGHTWEIGHT_TEST_OSTREAM
+        NDNBOOST_LIGHTWEIGHT_TEST_OSTREAM
             << file << "(" << line << "): test '" << expr1 << " != " << expr2
             << "' failed in function '" << function << "': "
             << "'" << t << "' == '" << u << "'" << std::endl;
@@ -169,13 +169,13 @@
 
     if( errors == 0 )
     {
-        BOOST_LIGHTWEIGHT_TEST_OSTREAM
+        NDNBOOST_LIGHTWEIGHT_TEST_OSTREAM
           << "No errors detected." << std::endl;
         return 0;
     }
     else
     {
-        BOOST_LIGHTWEIGHT_TEST_OSTREAM
+        NDNBOOST_LIGHTWEIGHT_TEST_OSTREAM
           << errors << " error" << (errors == 1? "": "s") << " detected." << std::endl;
         return 1;
     }
@@ -183,26 +183,26 @@
 
 } // namespace ndnboost
 
-#define BOOST_TEST(expr) ((expr)? (void)0: ::ndnboost::detail::test_failed_impl(#expr, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION))
-#define BOOST_ERROR(msg) ::ndnboost::detail::error_impl(msg, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION)
-#define BOOST_TEST_EQ(expr1,expr2) ( ::ndnboost::detail::test_eq_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
-#define BOOST_TEST_NE(expr1,expr2) ( ::ndnboost::detail::test_ne_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
-#ifndef BOOST_NO_EXCEPTIONS
-   #define BOOST_TEST_THROWS( EXPR, EXCEP )                    \
+#define NDNBOOST_TEST(expr) ((expr)? (void)0: ::ndnboost::detail::test_failed_impl(#expr, __FILE__, __LINE__, NDNBOOST_CURRENT_FUNCTION))
+#define NDNBOOST_ERROR(msg) ::ndnboost::detail::error_impl(msg, __FILE__, __LINE__, NDNBOOST_CURRENT_FUNCTION)
+#define NDNBOOST_TEST_EQ(expr1,expr2) ( ::ndnboost::detail::test_eq_impl(#expr1, #expr2, __FILE__, __LINE__, NDNBOOST_CURRENT_FUNCTION, expr1, expr2) )
+#define NDNBOOST_TEST_NE(expr1,expr2) ( ::ndnboost::detail::test_ne_impl(#expr1, #expr2, __FILE__, __LINE__, NDNBOOST_CURRENT_FUNCTION, expr1, expr2) )
+#ifndef NDNBOOST_NO_EXCEPTIONS
+   #define NDNBOOST_TEST_THROWS( EXPR, EXCEP )                    \
       try {                                                    \
          EXPR;                                                 \
          ::ndnboost::detail::throw_failed_impl                    \
-         (#EXCEP, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION); \
+         (#EXCEP, __FILE__, __LINE__, NDNBOOST_CURRENT_FUNCTION); \
       }                                                        \
       catch(EXCEP const&) {                                    \
       }                                                        \
       catch(...) {                                             \
          ::ndnboost::detail::throw_failed_impl                    \
-         (#EXCEP, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION); \
+         (#EXCEP, __FILE__, __LINE__, NDNBOOST_CURRENT_FUNCTION); \
       }                                                        \
    //
 #else
-   #define BOOST_TEST_THROWS( EXPR, EXCEP )
+   #define NDNBOOST_TEST_THROWS( EXPR, EXCEP )
 #endif
 
-#endif // #ifndef BOOST_DETAIL_LIGHTWEIGHT_TEST_HPP_INCLUDED
+#endif // #ifndef NDNBOOST_DETAIL_LIGHTWEIGHT_TEST_HPP_INCLUDED
diff --git a/include/ndnboost/detail/no_exceptions_support.hpp b/include/ndnboost/detail/no_exceptions_support.hpp
index a56958e..037b18c 100644
--- a/include/ndnboost/detail/no_exceptions_support.hpp
+++ b/include/ndnboost/detail/no_exceptions_support.hpp
@@ -1,5 +1,5 @@
-#ifndef BOOST_DETAIL_NO_EXCEPTIONS_SUPPORT_HPP_
-#define BOOST_DETAIL_NO_EXCEPTIONS_SUPPORT_HPP_
+#ifndef NDNBOOST_DETAIL_NO_EXCEPTIONS_SUPPORT_HPP_
+#define NDNBOOST_DETAIL_NO_EXCEPTIONS_SUPPORT_HPP_
 
 #if (defined _MSC_VER) && (_MSC_VER >= 1200)
 #  pragma once
@@ -13,7 +13,7 @@
 //
 //
 // This file contains helper macros used when exception support may be
-// disabled (as indicated by macro BOOST_NO_EXCEPTIONS).
+// disabled (as indicated by macro NDNBOOST_NO_EXCEPTIONS).
 //
 // Before picking up these macros you may consider using RAII techniques
 // to deal with exceptions - their syntax can be always the same with 
@@ -23,15 +23,15 @@
 /* Example of use:
 
 void foo() {
-  BOOST_TRY {
+  NDNBOOST_TRY {
     ...
-  } BOOST_CATCH(const std::bad_alloc&) {
+  } NDNBOOST_CATCH(const std::bad_alloc&) {
       ...
-      BOOST_RETHROW
-  } BOOST_CATCH(const std::exception& e) {
+      NDNBOOST_RETHROW
+  } NDNBOOST_CATCH(const std::exception& e) {
       ...
   }
-  BOOST_CATCH_END
+  NDNBOOST_CATCH_END
 }
 
 With exception support enabled it will expand into:
@@ -66,21 +66,21 @@
 #include <ndnboost/config.hpp>
 #include <ndnboost/detail/workaround.hpp>
 
-#if !(defined BOOST_NO_EXCEPTIONS)
-#    define BOOST_TRY { try
-#    define BOOST_CATCH(x) catch(x)
-#    define BOOST_RETHROW throw;
-#    define BOOST_CATCH_END }
+#if !(defined NDNBOOST_NO_EXCEPTIONS)
+#    define NDNBOOST_TRY { try
+#    define NDNBOOST_CATCH(x) catch(x)
+#    define NDNBOOST_RETHROW throw;
+#    define NDNBOOST_CATCH_END }
 #else
-#    if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-#        define BOOST_TRY { if ("")
-#        define BOOST_CATCH(x) else if (!"")
+#    if NDNBOOST_WORKAROUND(__BORLANDC__, NDNBOOST_TESTED_AT(0x564))
+#        define NDNBOOST_TRY { if ("")
+#        define NDNBOOST_CATCH(x) else if (!"")
 #    else
-#        define BOOST_TRY { if (true)
-#        define BOOST_CATCH(x) else if (false)
+#        define NDNBOOST_TRY { if (true)
+#        define NDNBOOST_CATCH(x) else if (false)
 #    endif
-#    define BOOST_RETHROW
-#    define BOOST_CATCH_END }
+#    define NDNBOOST_RETHROW
+#    define NDNBOOST_CATCH_END }
 #endif
 
 
diff --git a/include/ndnboost/detail/ob_call_traits.hpp b/include/ndnboost/detail/ob_call_traits.hpp
index 45f3743..ddbbb0c 100644
--- a/include/ndnboost/detail/ob_call_traits.hpp
+++ b/include/ndnboost/detail/ob_call_traits.hpp
@@ -16,23 +16,23 @@
       & Ulrich Eisenecker.
 */
 
-#ifndef BOOST_OB_CALL_TRAITS_HPP
-#define BOOST_OB_CALL_TRAITS_HPP
+#ifndef NDNBOOST_OB_CALL_TRAITS_HPP
+#define NDNBOOST_OB_CALL_TRAITS_HPP
 
-#ifndef BOOST_CONFIG_HPP
+#ifndef NDNBOOST_CONFIG_HPP
 #include <ndnboost/config.hpp>
 #endif
 
-#ifndef BOOST_ARITHMETIC_TYPE_TRAITS_HPP
+#ifndef NDNBOOST_ARITHMETIC_TYPE_TRAITS_HPP
 #include <ndnboost/type_traits/arithmetic_traits.hpp>
 #endif
-#ifndef BOOST_COMPOSITE_TYPE_TRAITS_HPP
+#ifndef NDNBOOST_COMPOSITE_TYPE_TRAITS_HPP
 #include <ndnboost/type_traits/composite_traits.hpp>
 #endif
 
 namespace ndnboost{
 
-#ifdef BOOST_MSVC6_MEMBER_TEMPLATES
+#ifdef NDNBOOST_MSVC6_MEMBER_TEMPLATES
 //
 // use member templates to emulate
 // partial specialisation:
@@ -165,4 +165,4 @@
 
 }
 
-#endif // BOOST_OB_CALL_TRAITS_HPP
+#endif // NDNBOOST_OB_CALL_TRAITS_HPP
diff --git a/include/ndnboost/detail/reference_content.hpp b/include/ndnboost/detail/reference_content.hpp
index 52d2c02..098d4ea 100644
--- a/include/ndnboost/detail/reference_content.hpp
+++ b/include/ndnboost/detail/reference_content.hpp
@@ -10,12 +10,12 @@
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef BOOST_DETAIL_REFERENCE_CONTENT_HPP
-#define BOOST_DETAIL_REFERENCE_CONTENT_HPP
+#ifndef NDNBOOST_DETAIL_REFERENCE_CONTENT_HPP
+#define NDNBOOST_DETAIL_REFERENCE_CONTENT_HPP
 
 #include "ndnboost/config.hpp"
 
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#if !defined(NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 #   include "ndnboost/mpl/bool.hpp"
 #   include "ndnboost/type_traits/has_nothrow_copy.hpp"
 #else
@@ -78,7 +78,7 @@
 
 template <typename T = mpl::void_> struct make_reference_content;
 
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#if !defined(NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 
 template <typename T>
 struct make_reference_content
@@ -92,7 +92,7 @@
     typedef reference_content<T&> type;
 };
 
-#else // defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#else // defined(NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 
 template <typename T>
 struct make_reference_content
@@ -104,7 +104,7 @@
 {
 };
 
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION workaround
+#endif // NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION workaround
 
 template <>
 struct make_reference_content< mpl::void_ >
@@ -124,7 +124,7 @@
 // reference_content<T&> type traits specializations
 //
 
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#if !defined(NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 
 template <typename T>
 struct has_nothrow_copy<
@@ -134,8 +134,8 @@
 {
 };
 
-#endif // !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#endif // !defined(NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 
 } // namespace ndnboost
 
-#endif // BOOST_DETAIL_REFERENCE_CONTENT_HPP
+#endif // NDNBOOST_DETAIL_REFERENCE_CONTENT_HPP
diff --git a/include/ndnboost/detail/sp_typeinfo.hpp b/include/ndnboost/detail/sp_typeinfo.hpp
index 2239709..7ed63aa 100644
--- a/include/ndnboost/detail/sp_typeinfo.hpp
+++ b/include/ndnboost/detail/sp_typeinfo.hpp
@@ -1,5 +1,5 @@
-#ifndef BOOST_DETAIL_SP_TYPEINFO_HPP_INCLUDED
-#define BOOST_DETAIL_SP_TYPEINFO_HPP_INCLUDED
+#ifndef NDNBOOST_DETAIL_SP_TYPEINFO_HPP_INCLUDED
+#define NDNBOOST_DETAIL_SP_TYPEINFO_HPP_INCLUDED
 
 // MS compatible compilers support #pragma once
 
@@ -17,7 +17,7 @@
 
 #include <ndnboost/config.hpp>
 
-#if defined( BOOST_NO_TYPEID )
+#if defined( NDNBOOST_NO_TYPEID )
 
 #include <ndnboost/current_function.hpp>
 #include <functional>
@@ -70,7 +70,7 @@
 
     static char const * name()
     {
-        return BOOST_CURRENT_FUNCTION;
+        return NDNBOOST_CURRENT_FUNCTION;
     }
 };
 
@@ -102,7 +102,7 @@
 
 } // namespace ndnboost
 
-#define BOOST_SP_TYPEID(T) (ndnboost::detail::sp_typeid_<T>::ti_)
+#define NDNBOOST_SP_TYPEID(T) (ndnboost::detail::sp_typeid_<T>::ti_)
 
 #else
 
@@ -114,7 +114,7 @@
 namespace detail
 {
 
-#if defined( BOOST_NO_STD_TYPEINFO )
+#if defined( NDNBOOST_NO_STD_TYPEINFO )
 
 typedef ::type_info sp_typeinfo;
 
@@ -128,8 +128,8 @@
 
 } // namespace ndnboost
 
-#define BOOST_SP_TYPEID(T) typeid(T)
+#define NDNBOOST_SP_TYPEID(T) typeid(T)
 
 #endif
 
-#endif  // #ifndef BOOST_DETAIL_SP_TYPEINFO_HPP_INCLUDED
+#endif  // #ifndef NDNBOOST_DETAIL_SP_TYPEINFO_HPP_INCLUDED
diff --git a/include/ndnboost/detail/workaround.hpp b/include/ndnboost/detail/workaround.hpp
index 6568e47..7e4ace0 100644
--- a/include/ndnboost/detail/workaround.hpp
+++ b/include/ndnboost/detail/workaround.hpp
@@ -9,34 +9,34 @@
 //
 // Usage:
 //
-//     #if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+//     #if NDNBOOST_WORKAROUND(NDNBOOST_MSVC, < 1300)
 //        // workaround for eVC4 and VC6
 //        ... // workaround code here
 //     #endif
 //
-// When BOOST_STRICT_CONFIG is defined, expands to 0. Otherwise, the
+// When NDNBOOST_STRICT_CONFIG is defined, expands to 0. Otherwise, the
 // first argument must be undefined or expand to a numeric
 // value. The above expands to:
 //
-//     (BOOST_MSVC) != 0 && (BOOST_MSVC) < 1300
+//     (NDNBOOST_MSVC) != 0 && (NDNBOOST_MSVC) < 1300
 //
 // When used for workarounds that apply to the latest known version 
 // and all earlier versions of a compiler, the following convention 
 // should be observed:
 //
-//     #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1301))
+//     #if NDNBOOST_WORKAROUND(NDNBOOST_MSVC, NDNBOOST_TESTED_AT(1301))
 //
 // The version number in this case corresponds to the last version in
 // which the workaround was known to have been required. When
-// BOOST_DETECT_OUTDATED_WORKAROUNDS is not the defined, the macro
-// BOOST_TESTED_AT(x) expands to "!= 0", which effectively activates
+// NDNBOOST_DETECT_OUTDATED_WORKAROUNDS is not the defined, the macro
+// NDNBOOST_TESTED_AT(x) expands to "!= 0", which effectively activates
 // the workaround for any version of the compiler. When
-// BOOST_DETECT_OUTDATED_WORKAROUNDS is defined, a compiler warning or
+// NDNBOOST_DETECT_OUTDATED_WORKAROUNDS is defined, a compiler warning or
 // error will be issued if the compiler version exceeds the argument
-// to BOOST_TESTED_AT().  This can be used to locate workarounds which
+// to NDNBOOST_TESTED_AT().  This can be used to locate workarounds which
 // may be obsoleted by newer versions.
 
-# ifndef BOOST_STRICT_CONFIG
+# ifndef NDNBOOST_STRICT_CONFIG
 
 #include <ndnboost/config.hpp>
 
@@ -60,15 +60,15 @@
 #else
 #define _MSC_FULL_VER_WORKAROUND_GUARD 0
 #endif
-#ifndef BOOST_MSVC
-#define BOOST_MSVC_WORKAROUND_GUARD 1
+#ifndef NDNBOOST_MSVC
+#define NDNBOOST_MSVC_WORKAROUND_GUARD 1
 #else
-#define BOOST_MSVC_WORKAROUND_GUARD 0
+#define NDNBOOST_MSVC_WORKAROUND_GUARD 0
 #endif
-#ifndef BOOST_MSVC_FULL_VER
-#define BOOST_MSVC_FULL_VER_WORKAROUND_GUARD 1
+#ifndef NDNBOOST_MSVC_FULL_VER
+#define NDNBOOST_MSVC_FULL_VER_WORKAROUND_GUARD 1
 #else
-#define BOOST_MSVC_FULL_VER_WORKAROUND_GUARD 0
+#define NDNBOOST_MSVC_FULL_VER_WORKAROUND_GUARD 0
 #endif
 #ifndef __GNUC__
 #define __GNUC___WORKAROUND_GUARD 1
@@ -171,10 +171,10 @@
 #else
 #define _RWSTD_VER_WORKAROUND_GUARD 0
 #endif
-#ifndef BOOST_RWSTD_VER
-#define BOOST_RWSTD_VER_WORKAROUND_GUARD 1
+#ifndef NDNBOOST_RWSTD_VER
+#define NDNBOOST_RWSTD_VER_WORKAROUND_GUARD 1
 #else
-#define BOOST_RWSTD_VER_WORKAROUND_GUARD 0
+#define NDNBOOST_RWSTD_VER_WORKAROUND_GUARD 0
 #endif
 #ifndef __GLIBCPP__
 #define __GLIBCPP___WORKAROUND_GUARD 1
@@ -207,60 +207,60 @@
 #define _CPPLIB_VER_WORKAROUND_GUARD 0
 #endif
 
-#ifndef BOOST_INTEL_CXX_VERSION
-#define BOOST_INTEL_CXX_VERSION_WORKAROUND_GUARD 1
+#ifndef NDNBOOST_INTEL_CXX_VERSION
+#define NDNBOOST_INTEL_CXX_VERSION_WORKAROUND_GUARD 1
 #else
-#define BOOST_INTEL_CXX_VERSION_WORKAROUND_GUARD 0
+#define NDNBOOST_INTEL_CXX_VERSION_WORKAROUND_GUARD 0
 #endif
-#ifndef BOOST_INTEL_WIN
-#define BOOST_INTEL_WIN_WORKAROUND_GUARD 1
+#ifndef NDNBOOST_INTEL_WIN
+#define NDNBOOST_INTEL_WIN_WORKAROUND_GUARD 1
 #else
-#define BOOST_INTEL_WIN_WORKAROUND_GUARD 0
+#define NDNBOOST_INTEL_WIN_WORKAROUND_GUARD 0
 #endif
-#ifndef BOOST_DINKUMWARE_STDLIB
-#define BOOST_DINKUMWARE_STDLIB_WORKAROUND_GUARD 1
+#ifndef NDNBOOST_DINKUMWARE_STDLIB
+#define NDNBOOST_DINKUMWARE_STDLIB_WORKAROUND_GUARD 1
 #else
-#define BOOST_DINKUMWARE_STDLIB_WORKAROUND_GUARD 0
+#define NDNBOOST_DINKUMWARE_STDLIB_WORKAROUND_GUARD 0
 #endif
-#ifndef BOOST_INTEL
-#define BOOST_INTEL_WORKAROUND_GUARD 1
+#ifndef NDNBOOST_INTEL
+#define NDNBOOST_INTEL_WORKAROUND_GUARD 1
 #else
-#define BOOST_INTEL_WORKAROUND_GUARD 0
+#define NDNBOOST_INTEL_WORKAROUND_GUARD 0
 #endif
 // Always define to zero, if it's used it'll be defined my MPL:
-#define BOOST_MPL_CFG_GCC_WORKAROUND_GUARD 0
+#define NDNBOOST_MPL_CFG_GCC_WORKAROUND_GUARD 0
 
-#  define BOOST_WORKAROUND(symbol, test)                \
+#  define NDNBOOST_WORKAROUND(symbol, test)                \
          ((symbol ## _WORKAROUND_GUARD + 0 == 0) &&     \
          (symbol != 0) && (1 % (( (symbol test) ) + 1)))
 //                              ^ ^           ^ ^
 // The extra level of parenthesis nesting above, along with the
-// BOOST_OPEN_PAREN indirection below, is required to satisfy the
+// NDNBOOST_OPEN_PAREN indirection below, is required to satisfy the
 // broken preprocessor in MWCW 8.3 and earlier.
 //
 // The basic mechanism works as follows:
 //      (symbol test) + 1        =>   if (symbol test) then 2 else 1
 //      1 % ((symbol test) + 1)  =>   if (symbol test) then 1 else 0
 //
-// The complication with % is for cooperation with BOOST_TESTED_AT().
-// When "test" is BOOST_TESTED_AT(x) and
-// BOOST_DETECT_OUTDATED_WORKAROUNDS is #defined,
+// The complication with % is for cooperation with NDNBOOST_TESTED_AT().
+// When "test" is NDNBOOST_TESTED_AT(x) and
+// NDNBOOST_DETECT_OUTDATED_WORKAROUNDS is #defined,
 //
 //      symbol test              =>   if (symbol <= x) then 1 else -1
 //      (symbol test) + 1        =>   if (symbol <= x) then 2 else 0
 //      1 % ((symbol test) + 1)  =>   if (symbol <= x) then 1 else divide-by-zero
 //
 
-#  ifdef BOOST_DETECT_OUTDATED_WORKAROUNDS
-#   define BOOST_OPEN_PAREN (
-#   define BOOST_TESTED_AT(value)  > value) ?(-1): BOOST_OPEN_PAREN 1
+#  ifdef NDNBOOST_DETECT_OUTDATED_WORKAROUNDS
+#   define NDNBOOST_OPEN_PAREN (
+#   define NDNBOOST_TESTED_AT(value)  > value) ?(-1): NDNBOOST_OPEN_PAREN 1
 #  else
-#   define BOOST_TESTED_AT(value) != ((value)-(value))
+#   define NDNBOOST_TESTED_AT(value) != ((value)-(value))
 #  endif
 
 # else
 
-#  define BOOST_WORKAROUND(symbol, test) 0
+#  define NDNBOOST_WORKAROUND(symbol, test) 0
 
 # endif