diff --git a/include/ndnboost/unordered/detail/allocate.hpp b/include/ndnboost/unordered/detail/allocate.hpp
index 4ad6724..4d6a8ed 100644
--- a/include/ndnboost/unordered/detail/allocate.hpp
+++ b/include/ndnboost/unordered/detail/allocate.hpp
@@ -6,8 +6,8 @@
 
 //  See http://www.boost.org/libs/unordered for documentation
 
-#ifndef BOOST_UNORDERED_ALLOCATE_HPP
-#define BOOST_UNORDERED_ALLOCATE_HPP
+#ifndef NDNBOOST_UNORDERED_ALLOCATE_HPP
+#define NDNBOOST_UNORDERED_ALLOCATE_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
@@ -31,11 +31,11 @@
 #include <ndnboost/assert.hpp>
 #include <utility>
 
-#if !defined(BOOST_NO_CXX11_HDR_TUPLE)
+#if !defined(NDNBOOST_NO_CXX11_HDR_TUPLE)
 #include <tuple>
 #endif
 
-#if defined(BOOST_MSVC)
+#if defined(NDNBOOST_MSVC)
 #pragma warning(push)
 #pragma warning(disable:4512) // assignment operator could not be generated.
 #pragma warning(disable:4345) // behavior change: an object of POD type
@@ -43,7 +43,7 @@
                               // will be default-initialized.
 #endif
 
-#define BOOST_UNORDERED_EMPLACE_LIMIT 10
+#define NDNBOOST_UNORDERED_EMPLACE_LIMIT 10
 
 namespace ndnboost { namespace unordered { namespace detail {
 
@@ -85,85 +85,85 @@
     // Either forwarding variadic arguments, or storing the arguments in
     // emplace_args##n
 
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#if !defined(NDNBOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
-#define BOOST_UNORDERED_EMPLACE_TEMPLATE typename... Args
-#define BOOST_UNORDERED_EMPLACE_ARGS BOOST_FWD_REF(Args)... args
-#define BOOST_UNORDERED_EMPLACE_FORWARD ndnboost::forward<Args>(args)...
+#define NDNBOOST_UNORDERED_EMPLACE_TEMPLATE typename... Args
+#define NDNBOOST_UNORDERED_EMPLACE_ARGS NDNBOOST_FWD_REF(Args)... args
+#define NDNBOOST_UNORDERED_EMPLACE_FORWARD ndnboost::forward<Args>(args)...
 
-#define BOOST_UNORDERED_EMPLACE_ARGS1(a0) a0
-#define BOOST_UNORDERED_EMPLACE_ARGS2(a0, a1) a0, a1
-#define BOOST_UNORDERED_EMPLACE_ARGS3(a0, a1, a2) a0, a1, a2
+#define NDNBOOST_UNORDERED_EMPLACE_ARGS1(a0) a0
+#define NDNBOOST_UNORDERED_EMPLACE_ARGS2(a0, a1) a0, a1
+#define NDNBOOST_UNORDERED_EMPLACE_ARGS3(a0, a1, a2) a0, a1, a2
 
 #else
 
-#define BOOST_UNORDERED_EMPLACE_TEMPLATE typename Args
-#define BOOST_UNORDERED_EMPLACE_ARGS Args const& args
-#define BOOST_UNORDERED_EMPLACE_FORWARD args
+#define NDNBOOST_UNORDERED_EMPLACE_TEMPLATE typename Args
+#define NDNBOOST_UNORDERED_EMPLACE_ARGS Args const& args
+#define NDNBOOST_UNORDERED_EMPLACE_FORWARD args
 
-#define BOOST_UNORDERED_FWD_PARAM(z, n, a) \
-    BOOST_FWD_REF(BOOST_PP_CAT(A, n)) BOOST_PP_CAT(a, n)
+#define NDNBOOST_UNORDERED_FWD_PARAM(z, n, a) \
+    NDNBOOST_FWD_REF(NDNBOOST_PP_CAT(A, n)) NDNBOOST_PP_CAT(a, n)
 
-#define BOOST_UNORDERED_CALL_FORWARD(z, i, a) \
-    ndnboost::forward<BOOST_PP_CAT(A,i)>(BOOST_PP_CAT(a,i))
+#define NDNBOOST_UNORDERED_CALL_FORWARD(z, i, a) \
+    ndnboost::forward<NDNBOOST_PP_CAT(A,i)>(NDNBOOST_PP_CAT(a,i))
 
-#define BOOST_UNORDERED_EARGS(z, n, _)                                      \
-    template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                     \
-    struct BOOST_PP_CAT(emplace_args, n)                                    \
+#define NDNBOOST_UNORDERED_EARGS(z, n, _)                                      \
+    template <NDNBOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                     \
+    struct NDNBOOST_PP_CAT(emplace_args, n)                                    \
     {                                                                       \
-        BOOST_PP_REPEAT_##z(n, BOOST_UNORDERED_EARGS_MEMBER, _)             \
-        BOOST_PP_CAT(emplace_args, n) (                                     \
-            BOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, Arg, b)                     \
-        ) : BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_EARGS_INIT, _)             \
+        NDNBOOST_PP_REPEAT_##z(n, NDNBOOST_UNORDERED_EARGS_MEMBER, _)             \
+        NDNBOOST_PP_CAT(emplace_args, n) (                                     \
+            NDNBOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, Arg, b)                     \
+        ) : NDNBOOST_PP_ENUM_##z(n, NDNBOOST_UNORDERED_EARGS_INIT, _)             \
         {}                                                                  \
                                                                             \
     };                                                                      \
                                                                             \
-    template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                     \
-    inline BOOST_PP_CAT(emplace_args, n) <                                  \
-        BOOST_PP_ENUM_PARAMS_Z(z, n, A)                                     \
+    template <NDNBOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                     \
+    inline NDNBOOST_PP_CAT(emplace_args, n) <                                  \
+        NDNBOOST_PP_ENUM_PARAMS_Z(z, n, A)                                     \
     > create_emplace_args(                                                  \
-        BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, b)                  \
+        NDNBOOST_PP_ENUM_##z(n, NDNBOOST_UNORDERED_FWD_PARAM, b)                  \
     )                                                                       \
     {                                                                       \
-        BOOST_PP_CAT(emplace_args, n) <                                     \
-            BOOST_PP_ENUM_PARAMS_Z(z, n, A)                                 \
-        > e(BOOST_PP_ENUM_PARAMS_Z(z, n, b));                               \
+        NDNBOOST_PP_CAT(emplace_args, n) <                                     \
+            NDNBOOST_PP_ENUM_PARAMS_Z(z, n, A)                                 \
+        > e(NDNBOOST_PP_ENUM_PARAMS_Z(z, n, b));                               \
         return e;                                                           \
     }
 
-#define BOOST_UNORDERED_EMPLACE_ARGS1 create_emplace_args
-#define BOOST_UNORDERED_EMPLACE_ARGS2 create_emplace_args
-#define BOOST_UNORDERED_EMPLACE_ARGS3 create_emplace_args
+#define NDNBOOST_UNORDERED_EMPLACE_ARGS1 create_emplace_args
+#define NDNBOOST_UNORDERED_EMPLACE_ARGS2 create_emplace_args
+#define NDNBOOST_UNORDERED_EMPLACE_ARGS3 create_emplace_args
 
-#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+#if defined(NDNBOOST_NO_CXX11_RVALUE_REFERENCES)
 
-#define BOOST_UNORDERED_EARGS_MEMBER(z, n, _)                               \
-    typedef BOOST_FWD_REF(BOOST_PP_CAT(A, n)) BOOST_PP_CAT(Arg, n);         \
-    BOOST_PP_CAT(Arg, n) BOOST_PP_CAT(a, n);
+#define NDNBOOST_UNORDERED_EARGS_MEMBER(z, n, _)                               \
+    typedef NDNBOOST_FWD_REF(NDNBOOST_PP_CAT(A, n)) NDNBOOST_PP_CAT(Arg, n);         \
+    NDNBOOST_PP_CAT(Arg, n) NDNBOOST_PP_CAT(a, n);
 
-#define BOOST_UNORDERED_EARGS_INIT(z, n, _)                                 \
-    BOOST_PP_CAT(a, n)(                                                     \
-        ndnboost::forward<BOOST_PP_CAT(A,n)>(BOOST_PP_CAT(b, n)))
+#define NDNBOOST_UNORDERED_EARGS_INIT(z, n, _)                                 \
+    NDNBOOST_PP_CAT(a, n)(                                                     \
+        ndnboost::forward<NDNBOOST_PP_CAT(A,n)>(NDNBOOST_PP_CAT(b, n)))
 
 #else
 
-#define BOOST_UNORDERED_EARGS_MEMBER(z, n, _)                               \
-    typedef typename ndnboost::add_lvalue_reference<BOOST_PP_CAT(A, n)>::type  \
-        BOOST_PP_CAT(Arg, n);                                               \
-    BOOST_PP_CAT(Arg, n) BOOST_PP_CAT(a, n);
+#define NDNBOOST_UNORDERED_EARGS_MEMBER(z, n, _)                               \
+    typedef typename ndnboost::add_lvalue_reference<NDNBOOST_PP_CAT(A, n)>::type  \
+        NDNBOOST_PP_CAT(Arg, n);                                               \
+    NDNBOOST_PP_CAT(Arg, n) NDNBOOST_PP_CAT(a, n);
 
-#define BOOST_UNORDERED_EARGS_INIT(z, n, _)                                 \
-    BOOST_PP_CAT(a, n)(BOOST_PP_CAT(b, n))
+#define NDNBOOST_UNORDERED_EARGS_INIT(z, n, _)                                 \
+    NDNBOOST_PP_CAT(a, n)(NDNBOOST_PP_CAT(b, n))
 
 #endif
 
-BOOST_PP_REPEAT_FROM_TO(1, BOOST_UNORDERED_EMPLACE_LIMIT, BOOST_UNORDERED_EARGS,
+NDNBOOST_PP_REPEAT_FROM_TO(1, NDNBOOST_UNORDERED_EMPLACE_LIMIT, NDNBOOST_UNORDERED_EARGS,
     _)
 
-#undef BOOST_UNORDERED_DEFINE_EMPLACE_ARGS
-#undef BOOST_UNORDERED_EARGS_MEMBER
-#undef BOOST_UNORDERED_EARGS_INIT
+#undef NDNBOOST_UNORDERED_DEFINE_EMPLACE_ARGS
+#undef NDNBOOST_UNORDERED_EARGS_MEMBER
+#undef NDNBOOST_UNORDERED_EARGS_INIT
 
 #endif
 
@@ -177,21 +177,21 @@
 // 1 = std::allocator_traits
 // 2 = ndnboost::container::allocator_traits
 
-#if !defined(BOOST_UNORDERED_USE_ALLOCATOR_TRAITS)
+#if !defined(NDNBOOST_UNORDERED_USE_ALLOCATOR_TRAITS)
 #   if defined(__GXX_EXPERIMENTAL_CXX0X__) && \
             (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7))
-#       define BOOST_UNORDERED_USE_ALLOCATOR_TRAITS 0
-#   elif defined(BOOST_MSVC)
-#       if BOOST_MSVC < 1400
+#       define NDNBOOST_UNORDERED_USE_ALLOCATOR_TRAITS 0
+#   elif defined(NDNBOOST_MSVC)
+#       if NDNBOOST_MSVC < 1400
             // Use container's allocator_traits for older versions of Visual
             // C++ as I don't test with them.
-#           define BOOST_UNORDERED_USE_ALLOCATOR_TRAITS 2
+#           define NDNBOOST_UNORDERED_USE_ALLOCATOR_TRAITS 2
 #       endif
 #   endif
 #endif
 
-#if !defined(BOOST_UNORDERED_USE_ALLOCATOR_TRAITS)
-#   define BOOST_UNORDERED_USE_ALLOCATOR_TRAITS 0
+#if !defined(NDNBOOST_UNORDERED_USE_ALLOCATOR_TRAITS)
+#   define NDNBOOST_UNORDERED_USE_ALLOCATOR_TRAITS 0
 #endif
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -199,7 +199,7 @@
 // Some utilities for implementing allocator_traits, but useful elsewhere so
 // they're always defined.
 
-#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
+#if !defined(NDNBOOST_NO_CXX11_HDR_TYPE_TRAITS)
 #  include <type_traits>
 #endif
 
@@ -210,7 +210,7 @@
     //
     // Uses the standard versions if available.
 
-#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
+#if !defined(NDNBOOST_NO_CXX11_HDR_TYPE_TRAITS)
 
     using std::integral_constant;
     using std::true_type;
@@ -229,7 +229,7 @@
     ////////////////////////////////////////////////////////////////////////////
     // Explicitly call a destructor
 
-#if defined(BOOST_MSVC)
+#if defined(NDNBOOST_MSVC)
 #pragma warning(push)
 #pragma warning(disable:4100) // unreferenced formal parameter
 #endif
@@ -239,7 +239,7 @@
         x->~T();
     }
 
-#if defined(BOOST_MSVC)
+#if defined(NDNBOOST_MSVC)
 #pragma warning(pop)
 #endif
 
@@ -247,38 +247,38 @@
     // Expression test mechanism
     //
     // When SFINAE expressions are available, define
-    // BOOST_UNORDERED_HAS_FUNCTION which can check if a function call is
-    // supported by a class, otherwise define BOOST_UNORDERED_HAS_MEMBER which
+    // NDNBOOST_UNORDERED_HAS_FUNCTION which can check if a function call is
+    // supported by a class, otherwise define NDNBOOST_UNORDERED_HAS_MEMBER which
     // can detect if a class has the specified member, but not that it has the
     // correct type, this is good enough for a passable impression of
     // allocator_traits.
 
-#if !defined(BOOST_NO_SFINAE_EXPR)
+#if !defined(NDNBOOST_NO_SFINAE_EXPR)
 
     template <typename T, unsigned int> struct expr_test;
     template <typename T> struct expr_test<T, sizeof(char)> : T {};
     template <typename U> static char for_expr_test(U const&);
 
-#   define BOOST_UNORDERED_CHECK_EXPRESSION(count, result, expression)      \
+#   define NDNBOOST_UNORDERED_CHECK_EXPRESSION(count, result, expression)      \
         template <typename U>                                               \
         static typename ndnboost::unordered::detail::expr_test<                \
-            BOOST_PP_CAT(choice, result),                                   \
+            NDNBOOST_PP_CAT(choice, result),                                   \
             sizeof(ndnboost::unordered::detail::for_expr_test((                \
                 (expression),                                               \
             0)))>::type test(                                               \
-            BOOST_PP_CAT(choice, count))
+            NDNBOOST_PP_CAT(choice, count))
 
-#   define BOOST_UNORDERED_DEFAULT_EXPRESSION(count, result)                \
+#   define NDNBOOST_UNORDERED_DEFAULT_EXPRESSION(count, result)                \
         template <typename U>                                               \
-        static BOOST_PP_CAT(choice, result)::type test(                     \
-            BOOST_PP_CAT(choice, count))
+        static NDNBOOST_PP_CAT(choice, result)::type test(                     \
+            NDNBOOST_PP_CAT(choice, count))
 
-#   define BOOST_UNORDERED_HAS_FUNCTION(name, thing, args, _)               \
-    struct BOOST_PP_CAT(has_, name)                                         \
+#   define NDNBOOST_UNORDERED_HAS_FUNCTION(name, thing, args, _)               \
+    struct NDNBOOST_PP_CAT(has_, name)                                         \
     {                                                                       \
-        BOOST_UNORDERED_CHECK_EXPRESSION(1, 1,                              \
+        NDNBOOST_UNORDERED_CHECK_EXPRESSION(1, 1,                              \
             ndnboost::unordered::detail::make< thing >().name args);           \
-        BOOST_UNORDERED_DEFAULT_EXPRESSION(2, 2);                           \
+        NDNBOOST_UNORDERED_DEFAULT_EXPRESSION(2, 2);                           \
                                                                             \
         enum { value = sizeof(test<T>(choose())) == sizeof(choice1::type) };\
     }
@@ -287,33 +287,33 @@
 
     template <typename T> struct identity { typedef T type; };
 
-#   define BOOST_UNORDERED_CHECK_MEMBER(count, result, name, member)        \
+#   define NDNBOOST_UNORDERED_CHECK_MEMBER(count, result, name, member)        \
                                                                             \
     typedef typename ndnboost::unordered::detail::identity<member>::type       \
-        BOOST_PP_CAT(check, count);                                         \
+        NDNBOOST_PP_CAT(check, count);                                         \
                                                                             \
-    template <BOOST_PP_CAT(check, count) e>                                 \
-    struct BOOST_PP_CAT(test, count) {                                      \
-        typedef BOOST_PP_CAT(choice, result) type;                          \
+    template <NDNBOOST_PP_CAT(check, count) e>                                 \
+    struct NDNBOOST_PP_CAT(test, count) {                                      \
+        typedef NDNBOOST_PP_CAT(choice, result) type;                          \
     };                                                                      \
                                                                             \
     template <class U> static typename                                      \
-        BOOST_PP_CAT(test, count)<&U::name>::type                           \
-        test(BOOST_PP_CAT(choice, count))
+        NDNBOOST_PP_CAT(test, count)<&U::name>::type                           \
+        test(NDNBOOST_PP_CAT(choice, count))
 
-#   define BOOST_UNORDERED_DEFAULT_MEMBER(count, result)                    \
-    template <class U> static BOOST_PP_CAT(choice, result)::type            \
-        test(BOOST_PP_CAT(choice, count))
+#   define NDNBOOST_UNORDERED_DEFAULT_MEMBER(count, result)                    \
+    template <class U> static NDNBOOST_PP_CAT(choice, result)::type            \
+        test(NDNBOOST_PP_CAT(choice, count))
 
-#   define BOOST_UNORDERED_HAS_MEMBER(name)                                 \
-    struct BOOST_PP_CAT(has_, name)                                         \
+#   define NDNBOOST_UNORDERED_HAS_MEMBER(name)                                 \
+    struct NDNBOOST_PP_CAT(has_, name)                                         \
     {                                                                       \
         struct impl {                                                       \
             struct base_mixin { int name; };                                \
             struct base : public T, public base_mixin {};                   \
                                                                             \
-            BOOST_UNORDERED_CHECK_MEMBER(1, 1, name, int base_mixin::*);    \
-            BOOST_UNORDERED_DEFAULT_MEMBER(2, 2);                           \
+            NDNBOOST_UNORDERED_CHECK_MEMBER(1, 1, name, int base_mixin::*);    \
+            NDNBOOST_UNORDERED_DEFAULT_MEMBER(2, 2);                           \
                                                                             \
             enum { value = sizeof(choice2::type) ==                         \
                 sizeof(test<base>(choose()))                                \
@@ -333,20 +333,20 @@
 //
 // First our implementation, then later light wrappers around the alternatives
 
-#if BOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 0
+#if NDNBOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 0
 
 #   include <ndnboost/limits.hpp>
 #   include <ndnboost/utility/enable_if.hpp>
 #   include <ndnboost/pointer_to_other.hpp>
-#   if defined(BOOST_NO_SFINAE_EXPR)
+#   if defined(NDNBOOST_NO_SFINAE_EXPR)
 #       include <ndnboost/type_traits/is_same.hpp>
 #   endif
 
-#   if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && \
-        !defined(BOOST_NO_SFINAE_EXPR)
-#       define BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT 1
+#   if !defined(NDNBOOST_NO_CXX11_VARIADIC_TEMPLATES) && \
+        !defined(NDNBOOST_NO_SFINAE_EXPR)
+#       define NDNBOOST_UNORDERED_DETAIL_FULL_CONSTRUCT 1
 #   else
-#       define BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT 0
+#       define NDNBOOST_UNORDERED_DETAIL_FULL_CONSTRUCT 0
 #   endif
 
 namespace ndnboost { namespace unordered { namespace detail {
@@ -355,12 +355,12 @@
     template <typename Alloc, typename T>
     struct rebind_wrap
     {
-        typedef typename Alloc::BOOST_NESTED_TEMPLATE rebind<T>::other type;
+        typedef typename Alloc::NDNBOOST_NESTED_TEMPLATE rebind<T>::other type;
     };
 
-#   if defined(BOOST_MSVC) && BOOST_MSVC <= 1400
+#   if defined(NDNBOOST_MSVC) && NDNBOOST_MSVC <= 1400
 
-#       define BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(tname)                    \
+#       define NDNBOOST_UNORDERED_DEFAULT_TYPE_TMPLT(tname)                    \
     template <typename Tp, typename Default>                                \
     struct default_type_ ## tname {                                         \
                                                                             \
@@ -375,7 +375,7 @@
         enum { value = (1 == sizeof(test<Tp>(choose()))) };                 \
                                                                             \
         typedef typename ndnboost::detail::if_true<value>::                    \
-            BOOST_NESTED_TEMPLATE then<Tp, DefaultWrap>                     \
+            NDNBOOST_NESTED_TEMPLATE then<Tp, DefaultWrap>                     \
             ::type::tname type;                                             \
     }
 
@@ -384,7 +384,7 @@
     template <typename T, typename T2>
     struct sfinae : T2 {};
 
-#       define BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(tname)                    \
+#       define NDNBOOST_UNORDERED_DEFAULT_TYPE_TMPLT(tname)                    \
     template <typename Tp, typename Default>                                \
     struct default_type_ ## tname {                                         \
                                                                             \
@@ -401,41 +401,41 @@
         enum { value = (1 == sizeof(test<Tp>(choose()))) };                 \
                                                                             \
         typedef typename ndnboost::detail::if_true<value>::                    \
-            BOOST_NESTED_TEMPLATE then<Tp, DefaultWrap>                     \
+            NDNBOOST_NESTED_TEMPLATE then<Tp, DefaultWrap>                     \
             ::type::tname type;                                             \
     }
 
 #   endif
 
-#   define BOOST_UNORDERED_DEFAULT_TYPE(T,tname, arg)                   \
+#   define NDNBOOST_UNORDERED_DEFAULT_TYPE(T,tname, arg)                   \
     typename default_type_ ## tname<T, arg>::type
 
-    BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(pointer);
-    BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(const_pointer);
-    BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(void_pointer);
-    BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(const_void_pointer);
-    BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(difference_type);
-    BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(size_type);
-    BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(propagate_on_container_copy_assignment);
-    BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(propagate_on_container_move_assignment);
-    BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(propagate_on_container_swap);
+    NDNBOOST_UNORDERED_DEFAULT_TYPE_TMPLT(pointer);
+    NDNBOOST_UNORDERED_DEFAULT_TYPE_TMPLT(const_pointer);
+    NDNBOOST_UNORDERED_DEFAULT_TYPE_TMPLT(void_pointer);
+    NDNBOOST_UNORDERED_DEFAULT_TYPE_TMPLT(const_void_pointer);
+    NDNBOOST_UNORDERED_DEFAULT_TYPE_TMPLT(difference_type);
+    NDNBOOST_UNORDERED_DEFAULT_TYPE_TMPLT(size_type);
+    NDNBOOST_UNORDERED_DEFAULT_TYPE_TMPLT(propagate_on_container_copy_assignment);
+    NDNBOOST_UNORDERED_DEFAULT_TYPE_TMPLT(propagate_on_container_move_assignment);
+    NDNBOOST_UNORDERED_DEFAULT_TYPE_TMPLT(propagate_on_container_swap);
 
-#   if !defined(BOOST_NO_SFINAE_EXPR)
+#   if !defined(NDNBOOST_NO_SFINAE_EXPR)
 
     template <typename T>
-    BOOST_UNORDERED_HAS_FUNCTION(
+    NDNBOOST_UNORDERED_HAS_FUNCTION(
         select_on_container_copy_construction, U const, (), 0
     );
 
     template <typename T>
-    BOOST_UNORDERED_HAS_FUNCTION(
+    NDNBOOST_UNORDERED_HAS_FUNCTION(
         max_size, U const, (), 0
     );
 
-#       if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#       if !defined(NDNBOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
     template <typename T, typename ValueType, typename... Args>
-    BOOST_UNORDERED_HAS_FUNCTION(
+    NDNBOOST_UNORDERED_HAS_FUNCTION(
     construct, U, (
         ndnboost::unordered::detail::make<ValueType*>(),
         ndnboost::unordered::detail::make<Args const>()...), 2
@@ -444,7 +444,7 @@
 #       else
 
     template <typename T, typename ValueType>
-    BOOST_UNORDERED_HAS_FUNCTION(
+    NDNBOOST_UNORDERED_HAS_FUNCTION(
     construct, U, (
         ndnboost::unordered::detail::make<ValueType*>(),
         ndnboost::unordered::detail::make<ValueType const>()), 2
@@ -453,23 +453,23 @@
 #       endif
 
     template <typename T, typename ValueType>
-    BOOST_UNORDERED_HAS_FUNCTION(
+    NDNBOOST_UNORDERED_HAS_FUNCTION(
         destroy, U, (ndnboost::unordered::detail::make<ValueType*>()), 1
     );
 
 #   else
 
     template <typename T>
-    BOOST_UNORDERED_HAS_MEMBER(select_on_container_copy_construction);
+    NDNBOOST_UNORDERED_HAS_MEMBER(select_on_container_copy_construction);
 
     template <typename T>
-    BOOST_UNORDERED_HAS_MEMBER(max_size);
+    NDNBOOST_UNORDERED_HAS_MEMBER(max_size);
 
     template <typename T, typename ValueType>
-    BOOST_UNORDERED_HAS_MEMBER(construct);
+    NDNBOOST_UNORDERED_HAS_MEMBER(construct);
 
     template <typename T, typename ValueType>
-    BOOST_UNORDERED_HAS_MEMBER(destroy);
+    NDNBOOST_UNORDERED_HAS_MEMBER(destroy);
 
 #   endif
 
@@ -516,28 +516,28 @@
         typedef Alloc allocator_type;
         typedef typename Alloc::value_type value_type;
 
-        typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, pointer, value_type*)
+        typedef NDNBOOST_UNORDERED_DEFAULT_TYPE(Alloc, pointer, value_type*)
             pointer;
 
         template <typename T>
         struct pointer_to_other : ndnboost::pointer_to_other<pointer, T> {};
 
-        typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, const_pointer,
+        typedef NDNBOOST_UNORDERED_DEFAULT_TYPE(Alloc, const_pointer,
             typename pointer_to_other<const value_type>::type)
             const_pointer;
 
-        //typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, void_pointer,
+        //typedef NDNBOOST_UNORDERED_DEFAULT_TYPE(Alloc, void_pointer,
         //    typename pointer_to_other<void>::type)
         //    void_pointer;
         //
-        //typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, const_void_pointer,
+        //typedef NDNBOOST_UNORDERED_DEFAULT_TYPE(Alloc, const_void_pointer,
         //    typename pointer_to_other<const void>::type)
         //    const_void_pointer;
 
-        typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, difference_type,
+        typedef NDNBOOST_UNORDERED_DEFAULT_TYPE(Alloc, difference_type,
             std::ptrdiff_t) difference_type;
 
-        typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, size_type, std::size_t)
+        typedef NDNBOOST_UNORDERED_DEFAULT_TYPE(Alloc, size_type, std::size_t)
             size_type;
 
         // TODO: rebind_alloc and rebind_traits
@@ -556,13 +556,13 @@
 
     public:
 
-#   if BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT
+#   if NDNBOOST_UNORDERED_DETAIL_FULL_CONSTRUCT
 
         template <typename T, typename... Args>
         static typename ndnboost::enable_if_c<
                 ndnboost::unordered::detail::has_construct<Alloc, T, Args...>
                 ::value>::type
-            construct(Alloc& a, T* p, BOOST_FWD_REF(Args)... x)
+            construct(Alloc& a, T* p, NDNBOOST_FWD_REF(Args)... x)
         {
             a.construct(p, ndnboost::forward<Args>(x)...);
         }
@@ -571,7 +571,7 @@
         static typename ndnboost::disable_if_c<
                 ndnboost::unordered::detail::has_construct<Alloc, T, Args...>
                 ::value>::type
-            construct(Alloc&, T* p, BOOST_FWD_REF(Args)... x)
+            construct(Alloc&, T* p, NDNBOOST_FWD_REF(Args)... x)
         {
             new ((void*) p) T(ndnboost::forward<Args>(x)...);
         }
@@ -592,7 +592,7 @@
             ndnboost::unordered::detail::destroy(p);
         }
 
-#   elif !defined(BOOST_NO_SFINAE_EXPR)
+#   elif !defined(NDNBOOST_NO_SFINAE_EXPR)
 
         template <typename T>
         static typename ndnboost::enable_if_c<
@@ -689,30 +689,30 @@
 
         // Allocator propagation on assignment and swap.
         // Return true if lhs is modified.
-        typedef BOOST_UNORDERED_DEFAULT_TYPE(
+        typedef NDNBOOST_UNORDERED_DEFAULT_TYPE(
             Alloc, propagate_on_container_copy_assignment, false_type)
             propagate_on_container_copy_assignment;
-        typedef BOOST_UNORDERED_DEFAULT_TYPE(
+        typedef NDNBOOST_UNORDERED_DEFAULT_TYPE(
             Alloc,propagate_on_container_move_assignment, false_type)
             propagate_on_container_move_assignment;
-        typedef BOOST_UNORDERED_DEFAULT_TYPE(
+        typedef NDNBOOST_UNORDERED_DEFAULT_TYPE(
             Alloc,propagate_on_container_swap,false_type)
             propagate_on_container_swap;
     };
 }}}
 
-#   undef BOOST_UNORDERED_DEFAULT_TYPE_TMPLT
-#   undef BOOST_UNORDERED_DEFAULT_TYPE
+#   undef NDNBOOST_UNORDERED_DEFAULT_TYPE_TMPLT
+#   undef NDNBOOST_UNORDERED_DEFAULT_TYPE
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // std::allocator_traits
 
-#elif BOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 1
+#elif NDNBOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 1
 
 #   include <memory>
 
-#   define BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT 1
+#   define NDNBOOST_UNORDERED_DETAIL_FULL_CONSTRUCT 1
 
 namespace ndnboost { namespace unordered { namespace detail {
 
@@ -731,11 +731,11 @@
 //
 // ndnboost::container::allocator_traits
 
-#elif BOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 2
+#elif NDNBOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 2
 
 #   include <ndnboost/container/allocator_traits.hpp>
 
-#   define BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT 0
+#   define NDNBOOST_UNORDERED_DETAIL_FULL_CONSTRUCT 0
 
 namespace ndnboost { namespace unordered { namespace detail {
 
@@ -753,7 +753,7 @@
 
 #else
 
-#error "Invalid BOOST_UNORDERED_USE_ALLOCATOR_TRAITS value."
+#error "Invalid NDNBOOST_UNORDERED_USE_ALLOCATOR_TRAITS value."
 
 #endif
 
@@ -763,13 +763,13 @@
     ////////////////////////////////////////////////////////////////////////////
     // call_construct
 
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#if !defined(NDNBOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
-#   if BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT
+#   if NDNBOOST_UNORDERED_DETAIL_FULL_CONSTRUCT
 
     template <typename Alloc, typename T, typename... Args>
     inline void call_construct(Alloc& alloc, T* address,
-        BOOST_FWD_REF(Args)... args)
+        NDNBOOST_FWD_REF(Args)... args)
     {
         ndnboost::unordered::detail::allocator_traits<Alloc>::construct(alloc,
             address, ndnboost::forward<Args>(args)...);
@@ -785,7 +785,7 @@
 
     template <typename Alloc, typename T, typename... Args>
     inline void call_construct(Alloc&, T* address,
-        BOOST_FWD_REF(Args)... args)
+        NDNBOOST_FWD_REF(Args)... args)
     {
         new((void*) address) T(ndnboost::forward<Args>(args)...);
     }
@@ -812,63 +812,63 @@
     //
     // Used for piecewise construction.
 
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#if !defined(NDNBOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
-#   define BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(n, namespace_)              \
+#   define NDNBOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(n, namespace_)              \
     template<typename Alloc, typename T>                                    \
     void construct_from_tuple(Alloc& alloc, T* ptr, namespace_ tuple<>)     \
     {                                                                       \
         ndnboost::unordered::detail::call_construct(alloc, ptr);               \
     }                                                                       \
                                                                             \
-    BOOST_PP_REPEAT_FROM_TO(1, n,                                           \
-        BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL, namespace_)
+    NDNBOOST_PP_REPEAT_FROM_TO(1, n,                                           \
+        NDNBOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL, namespace_)
 
-#   define BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL(z, n, namespace_)      \
+#   define NDNBOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL(z, n, namespace_)      \
     template<typename Alloc, typename T,                                    \
-        BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                           \
+        NDNBOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                           \
     void construct_from_tuple(Alloc& alloc, T* ptr,                         \
-            namespace_ tuple<BOOST_PP_ENUM_PARAMS_Z(z, n, A)> const& x)     \
+            namespace_ tuple<NDNBOOST_PP_ENUM_PARAMS_Z(z, n, A)> const& x)     \
     {                                                                       \
         ndnboost::unordered::detail::call_construct(alloc, ptr,                \
-            BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_GET_TUPLE_ARG, namespace_) \
+            NDNBOOST_PP_ENUM_##z(n, NDNBOOST_UNORDERED_GET_TUPLE_ARG, namespace_) \
         );                                                                  \
     }
 
-#   define BOOST_UNORDERED_GET_TUPLE_ARG(z, n, namespace_)                  \
+#   define NDNBOOST_UNORDERED_GET_TUPLE_ARG(z, n, namespace_)                  \
     namespace_ get<n>(x)
 
 #elif !defined(__SUNPRO_CC)
 
-#   define BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(n, namespace_)              \
+#   define NDNBOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(n, namespace_)              \
     template<typename Alloc, typename T>                                    \
     void construct_from_tuple(Alloc&, T* ptr, namespace_ tuple<>)           \
     {                                                                       \
         new ((void*) ptr) T();                                              \
     }                                                                       \
                                                                             \
-    BOOST_PP_REPEAT_FROM_TO(1, n,                                           \
-        BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL, namespace_)
+    NDNBOOST_PP_REPEAT_FROM_TO(1, n,                                           \
+        NDNBOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL, namespace_)
 
-#   define BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL(z, n, namespace_)      \
+#   define NDNBOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL(z, n, namespace_)      \
     template<typename Alloc, typename T,                                    \
-        BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                           \
+        NDNBOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                           \
     void construct_from_tuple(Alloc&, T* ptr,                               \
-            namespace_ tuple<BOOST_PP_ENUM_PARAMS_Z(z, n, A)> const& x)     \
+            namespace_ tuple<NDNBOOST_PP_ENUM_PARAMS_Z(z, n, A)> const& x)     \
     {                                                                       \
         new ((void*) ptr) T(                                                \
-            BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_GET_TUPLE_ARG, namespace_) \
+            NDNBOOST_PP_ENUM_##z(n, NDNBOOST_UNORDERED_GET_TUPLE_ARG, namespace_) \
         );                                                                  \
     }
 
-#   define BOOST_UNORDERED_GET_TUPLE_ARG(z, n, namespace_)                  \
+#   define NDNBOOST_UNORDERED_GET_TUPLE_ARG(z, n, namespace_)                  \
     namespace_ get<n>(x)
 
 #else
 
     template <int N> struct length {};
 
-#   define BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(n, namespace_)              \
+#   define NDNBOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(n, namespace_)              \
     template<typename Alloc, typename T>                                    \
     void construct_from_tuple_impl(                                         \
             ndnboost::unordered::detail::length<0>, Alloc&, T* ptr,            \
@@ -877,35 +877,35 @@
         new ((void*) ptr) T();                                              \
     }                                                                       \
                                                                             \
-    BOOST_PP_REPEAT_FROM_TO(1, n,                                           \
-        BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL, namespace_)
+    NDNBOOST_PP_REPEAT_FROM_TO(1, n,                                           \
+        NDNBOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL, namespace_)
 
-#   define BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL(z, n, namespace_)      \
+#   define NDNBOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL(z, n, namespace_)      \
     template<typename Alloc, typename T,                                    \
-        BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                           \
+        NDNBOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                           \
     void construct_from_tuple_impl(                                         \
             ndnboost::unordered::detail::length<n>, Alloc&, T* ptr,            \
-            namespace_ tuple<BOOST_PP_ENUM_PARAMS_Z(z, n, A)> const& x)     \
+            namespace_ tuple<NDNBOOST_PP_ENUM_PARAMS_Z(z, n, A)> const& x)     \
     {                                                                       \
         new ((void*) ptr) T(                                                \
-            BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_GET_TUPLE_ARG, namespace_) \
+            NDNBOOST_PP_ENUM_##z(n, NDNBOOST_UNORDERED_GET_TUPLE_ARG, namespace_) \
         );                                                                  \
     }
 
-#   define BOOST_UNORDERED_GET_TUPLE_ARG(z, n, namespace_)                  \
+#   define NDNBOOST_UNORDERED_GET_TUPLE_ARG(z, n, namespace_)                  \
     namespace_ get<n>(x)
 
 #endif
 
-BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(10, ndnboost::)
+NDNBOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(10, ndnboost::)
 
-#if !defined(__SUNPRO_CC) && !defined(BOOST_NO_CXX11_HDR_TUPLE)
-   BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(10, std::)
+#if !defined(__SUNPRO_CC) && !defined(NDNBOOST_NO_CXX11_HDR_TUPLE)
+   NDNBOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(10, std::)
 #endif
 
-#undef BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE
-#undef BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL
-#undef BOOST_UNORDERED_GET_TUPLE_ARG
+#undef NDNBOOST_UNORDERED_CONSTRUCT_FROM_TUPLE
+#undef NDNBOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL
+#undef NDNBOOST_UNORDERED_GET_TUPLE_ARG
 
 #if defined(__SUNPRO_CC)
 
@@ -934,7 +934,7 @@
             sizeof(test(choose(), ndnboost::unordered::detail::make<A0>())) };
     };
 
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#if !defined(NDNBOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
     ////////////////////////////////////////////////////////////////////////////
     // Construct from variadic parameters
@@ -943,7 +943,7 @@
 
     template <typename Alloc, typename T, typename... Args>
     inline void construct_value_impl(Alloc& alloc, T* address,
-        BOOST_FWD_REF(Args)... args)
+        NDNBOOST_FWD_REF(Args)... args)
     {
         ndnboost::unordered::detail::call_construct(alloc,
             address, ndnboost::forward<Args>(args)...);
@@ -958,7 +958,7 @@
         typename A0, typename A1, typename A2>
     inline typename enable_if<use_piecewise<A0>, void>::type
         construct_value_impl(Alloc& alloc, std::pair<A, B>* address,
-            BOOST_FWD_REF(A0), BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2)
+            NDNBOOST_FWD_REF(A0), NDNBOOST_FWD_REF(A1) a1, NDNBOOST_FWD_REF(A2) a2)
     {
         ndnboost::unordered::detail::construct_from_tuple(alloc,
             ndnboost::addressof(address->first), ndnboost::forward<A1>(a1));
@@ -966,7 +966,7 @@
             ndnboost::addressof(address->second), ndnboost::forward<A2>(a2));
     }
 
-#else // BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#else // NDNBOOST_NO_CXX11_VARIADIC_TEMPLATES
 
 ////////////////////////////////////////////////////////////////////////////////
 // Construct from emplace_args
@@ -1004,25 +1004,25 @@
 
     // Use a macro for the rest.
 
-#define BOOST_UNORDERED_CONSTRUCT_IMPL(z, num_params, _)                    \
+#define NDNBOOST_UNORDERED_CONSTRUCT_IMPL(z, num_params, _)                    \
     template <                                                              \
         typename Alloc, typename T,                                         \
-        BOOST_PP_ENUM_PARAMS_Z(z, num_params, typename A)                   \
+        NDNBOOST_PP_ENUM_PARAMS_Z(z, num_params, typename A)                   \
     >                                                                       \
     inline void construct_value_impl(Alloc&, T* address,                    \
-        ndnboost::unordered::detail::BOOST_PP_CAT(emplace_args,num_params) <   \
-            BOOST_PP_ENUM_PARAMS_Z(z, num_params, A)                        \
+        ndnboost::unordered::detail::NDNBOOST_PP_CAT(emplace_args,num_params) <   \
+            NDNBOOST_PP_ENUM_PARAMS_Z(z, num_params, A)                        \
         > const& args)                                                      \
     {                                                                       \
         new((void*) address) T(                                             \
-            BOOST_PP_ENUM_##z(num_params, BOOST_UNORDERED_CALL_FORWARD,     \
+            NDNBOOST_PP_ENUM_##z(num_params, NDNBOOST_UNORDERED_CALL_FORWARD,     \
                 args.a));                                                   \
     }
 
-    BOOST_PP_REPEAT_FROM_TO(4, BOOST_UNORDERED_EMPLACE_LIMIT,
-        BOOST_UNORDERED_CONSTRUCT_IMPL, _)
+    NDNBOOST_PP_REPEAT_FROM_TO(4, NDNBOOST_UNORDERED_EMPLACE_LIMIT,
+        NDNBOOST_UNORDERED_CONSTRUCT_IMPL, _)
 
-#undef BOOST_UNORDERED_CONSTRUCT_IMPL
+#undef NDNBOOST_UNORDERED_CONSTRUCT_IMPL
 
     // Construct with piece_construct
 
@@ -1038,7 +1038,7 @@
             ndnboost::addressof(address->second), args.a2);
     }
 
-#endif // BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#endif // NDNBOOST_NO_CXX11_VARIADIC_TEMPLATES
 
 }}}
 
@@ -1086,7 +1086,7 @@
         template <typename V>
         void construct(V const& v, std::size_t l)
         {
-            BOOST_ASSERT(!ptr_);
+            NDNBOOST_ASSERT(!ptr_);
             length_ = l;
             ptr_ = traits::allocate(alloc_, length_);
             pointer end = ptr_ + static_cast<std::ptrdiff_t>(length_);
@@ -1113,7 +1113,7 @@
     };
 }}}
 
-#if defined(BOOST_MSVC)
+#if defined(NDNBOOST_MSVC)
 #pragma warning(pop)
 #endif
 
diff --git a/include/ndnboost/unordered/detail/buckets.hpp b/include/ndnboost/unordered/detail/buckets.hpp
index df44e70..322df49 100644
--- a/include/ndnboost/unordered/detail/buckets.hpp
+++ b/include/ndnboost/unordered/detail/buckets.hpp
@@ -4,8 +4,8 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef BOOST_UNORDERED_DETAIL_MANAGER_HPP_INCLUDED
-#define BOOST_UNORDERED_DETAIL_MANAGER_HPP_INCLUDED
+#ifndef NDNBOOST_UNORDERED_DETAIL_MANAGER_HPP_INCLUDED
+#define NDNBOOST_UNORDERED_DETAIL_MANAGER_HPP_INCLUDED
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
@@ -58,7 +58,7 @@
             typename Node::node_pointer,
             typename Node::value_type&>
     {
-#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+#if !defined(NDNBOOST_NO_MEMBER_TEMPLATE_FRIENDS)
         template <typename Node2, typename ConstNodePointer, typename Policy2>
         friend struct ndnboost::unordered::iterator_detail::cl_iterator;
     private:
@@ -182,7 +182,7 @@
             typename Node::node_pointer,
             typename Node::value_type&>
     {
-#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+#if !defined(NDNBOOST_NO_MEMBER_TEMPLATE_FRIENDS)
         template <typename, typename>
         friend struct ndnboost::unordered::iterator_detail::c_iterator;
         template <typename, typename>
@@ -248,7 +248,7 @@
     {
         friend struct ndnboost::unordered::iterator_detail::iterator<Node>;
 
-#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+#if !defined(NDNBOOST_NO_MEMBER_TEMPLATE_FRIENDS)
         template <typename>
         friend struct ndnboost::unordered::detail::table;
         template <typename>
@@ -341,34 +341,34 @@
 
         void construct();
 
-        template <BOOST_UNORDERED_EMPLACE_TEMPLATE>
-        void construct_with_value(BOOST_UNORDERED_EMPLACE_ARGS)
+        template <NDNBOOST_UNORDERED_EMPLACE_TEMPLATE>
+        void construct_with_value(NDNBOOST_UNORDERED_EMPLACE_ARGS)
         {
             construct();
             ndnboost::unordered::detail::construct_value_impl(
-                alloc_, node_->value_ptr(), BOOST_UNORDERED_EMPLACE_FORWARD);
+                alloc_, node_->value_ptr(), NDNBOOST_UNORDERED_EMPLACE_FORWARD);
             value_constructed_ = true;
         }
 
         template <typename A0>
-        void construct_with_value2(BOOST_FWD_REF(A0) a0)
+        void construct_with_value2(NDNBOOST_FWD_REF(A0) a0)
         {
             construct();
             ndnboost::unordered::detail::construct_value_impl(
                 alloc_, node_->value_ptr(),
-                BOOST_UNORDERED_EMPLACE_ARGS1(ndnboost::forward<A0>(a0)));
+                NDNBOOST_UNORDERED_EMPLACE_ARGS1(ndnboost::forward<A0>(a0)));
             value_constructed_ = true;
         }
 
         value_type const& value() const {
-            BOOST_ASSERT(node_ && node_constructed_ && value_constructed_);
+            NDNBOOST_ASSERT(node_ && node_constructed_ && value_constructed_);
             return node_->value();
         }
 
         // no throw
         node_pointer release()
         {
-            BOOST_ASSERT(node_ && node_constructed_);
+            NDNBOOST_ASSERT(node_ && node_constructed_);
             node_pointer p = node_;
             node_ = node_pointer();
             return p;
@@ -412,7 +412,7 @@
             node_constructed_ = true;
         }
         else {
-            BOOST_ASSERT(node_constructed_);
+            NDNBOOST_ASSERT(node_constructed_);
 
             if (value_constructed_)
             {
@@ -843,11 +843,11 @@
     };
     
     ////////////////////////////////////////////////////////////////////////////
-    // rvalue parameters when type can't be a BOOST_RV_REF(T) parameter
+    // rvalue parameters when type can't be a NDNBOOST_RV_REF(T) parameter
     // e.g. for int
 
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-#   define BOOST_UNORDERED_RV_REF(T) BOOST_RV_REF(T)
+#if !defined(NDNBOOST_NO_CXX11_RVALUE_REFERENCES)
+#   define NDNBOOST_UNORDERED_RV_REF(T) NDNBOOST_RV_REF(T)
 #else
     struct please_ignore_this_overload {
         typedef please_ignore_this_overload type;
@@ -855,20 +855,20 @@
 
     template <typename T>
     struct rv_ref_impl {
-        typedef BOOST_RV_REF(T) type;
+        typedef NDNBOOST_RV_REF(T) type;
     };
 
     template <typename T>
     struct rv_ref :
         ndnboost::detail::if_true<
             ndnboost::is_class<T>::value
-        >::BOOST_NESTED_TEMPLATE then <
+        >::NDNBOOST_NESTED_TEMPLATE then <
             ndnboost::unordered::detail::rv_ref_impl<T>,
             please_ignore_this_overload
         >::type
     {};
 
-#   define BOOST_UNORDERED_RV_REF(T) \
+#   define NDNBOOST_UNORDERED_RV_REF(T) \
         typename ndnboost::unordered::detail::rv_ref<T>::type
 #endif
 }}}
diff --git a/include/ndnboost/unordered/detail/equivalent.hpp b/include/ndnboost/unordered/detail/equivalent.hpp
index 511fa0c..8b62d59 100644
--- a/include/ndnboost/unordered/detail/equivalent.hpp
+++ b/include/ndnboost/unordered/detail/equivalent.hpp
@@ -4,8 +4,8 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef BOOST_UNORDERED_DETAIL_EQUIVALENT_HPP_INCLUDED
-#define BOOST_UNORDERED_DETAIL_EQUIVALENT_HPP_INCLUDED
+#ifndef NDNBOOST_UNORDERED_DETAIL_EQUIVALENT_HPP_INCLUDED
+#define NDNBOOST_UNORDERED_DETAIL_EQUIVALENT_HPP_INCLUDED
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
@@ -438,29 +438,29 @@
             this->add_node(a, key_hash, this->find_node(key_hash, k));
         }
 
-#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-#   if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#if defined(NDNBOOST_NO_CXX11_RVALUE_REFERENCES)
+#   if defined(NDNBOOST_NO_CXX11_VARIADIC_TEMPLATES)
         iterator emplace(ndnboost::unordered::detail::emplace_args1<
                 ndnboost::unordered::detail::please_ignore_this_overload> const&)
         {
-            BOOST_ASSERT(false);
+            NDNBOOST_ASSERT(false);
             return iterator();
         }
 #   else
         iterator emplace(
                 ndnboost::unordered::detail::please_ignore_this_overload const&)
         {
-            BOOST_ASSERT(false);
+            NDNBOOST_ASSERT(false);
             return iterator();
         }
 #   endif
 #endif
 
-        template <BOOST_UNORDERED_EMPLACE_TEMPLATE>
-        iterator emplace(BOOST_UNORDERED_EMPLACE_ARGS)
+        template <NDNBOOST_UNORDERED_EMPLACE_TEMPLATE>
+        iterator emplace(NDNBOOST_UNORDERED_EMPLACE_ARGS)
         {
             node_constructor a(this->node_alloc());
-            a.construct_with_value(BOOST_UNORDERED_EMPLACE_FORWARD);
+            a.construct_with_value(NDNBOOST_UNORDERED_EMPLACE_FORWARD);
 
             return iterator(emplace_impl(a));
         }
@@ -543,7 +543,7 @@
 
         iterator erase(c_iterator r)
         {
-            BOOST_ASSERT(r.node_);
+            NDNBOOST_ASSERT(r.node_);
             iterator next(r.node_);
             ++next;
             erase_nodes(r.node_, next.node_);
@@ -646,7 +646,7 @@
         // strong otherwise exception safety
         void rehash_impl(std::size_t num_buckets)
         {
-            BOOST_ASSERT(this->buckets_);
+            NDNBOOST_ASSERT(this->buckets_);
 
             this->create_buckets(num_buckets);
             link_pointer prev = this->get_previous_start();
diff --git a/include/ndnboost/unordered/detail/extract_key.hpp b/include/ndnboost/unordered/detail/extract_key.hpp
index 74dfdab..37e7aba 100644
--- a/include/ndnboost/unordered/detail/extract_key.hpp
+++ b/include/ndnboost/unordered/detail/extract_key.hpp
@@ -3,8 +3,8 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef BOOST_UNORDERED_DETAIL_EXTRACT_KEY_HPP_INCLUDED
-#define BOOST_UNORDERED_DETAIL_EXTRACT_KEY_HPP_INCLUDED
+#ifndef NDNBOOST_UNORDERED_DETAIL_EXTRACT_KEY_HPP_INCLUDED
+#define NDNBOOST_UNORDERED_DETAIL_EXTRACT_KEY_HPP_INCLUDED
 
 #include <ndnboost/unordered/detail/table.hpp>
 
@@ -37,7 +37,7 @@
             sizeof(choice2::type) };
         
         typedef typename ndnboost::detail::if_true<value>::
-            BOOST_NESTED_TEMPLATE then<Key const&, no_key>::type type;
+            NDNBOOST_NESTED_TEMPLATE then<Key const&, no_key>::type type;
     };
 
     template <class ValueType>
@@ -56,7 +56,7 @@
             return no_key();
         }
         
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#if !defined(NDNBOOST_NO_CXX11_VARIADIC_TEMPLATES)
         template <class... Args>
         static no_key extract(Args const&...)
         {
@@ -107,7 +107,7 @@
             return k;
         }
 
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#if !defined(NDNBOOST_NO_CXX11_VARIADIC_TEMPLATES)
         template <class... Args>
         static no_key extract(Args const&...)
         {
@@ -133,9 +133,9 @@
         }
 #endif
 
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#if !defined(NDNBOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
-#define BOOST_UNORDERED_KEY_FROM_TUPLE(namespace_)                          \
+#define NDNBOOST_UNORDERED_KEY_FROM_TUPLE(namespace_)                          \
         template <typename T2>                                              \
         static no_key extract(ndnboost::unordered::piecewise_construct_t,      \
                 namespace_ tuple<> const&, T2 const&)                       \
@@ -154,7 +154,7 @@
 
 #else
 
-#define BOOST_UNORDERED_KEY_FROM_TUPLE(namespace_)                          \
+#define NDNBOOST_UNORDERED_KEY_FROM_TUPLE(namespace_)                          \
         static no_key extract(ndnboost::unordered::piecewise_construct_t,      \
                 namespace_ tuple<> const&)                                  \
         {                                                                   \
@@ -172,10 +172,10 @@
 
 #endif
 
-BOOST_UNORDERED_KEY_FROM_TUPLE(ndnboost::)
+NDNBOOST_UNORDERED_KEY_FROM_TUPLE(ndnboost::)
 
-#if !defined(BOOST_NO_CXX11_HDR_TUPLE)
-BOOST_UNORDERED_KEY_FROM_TUPLE(std::)
+#if !defined(NDNBOOST_NO_CXX11_HDR_TUPLE)
+NDNBOOST_UNORDERED_KEY_FROM_TUPLE(std::)
 #endif
     };
 }}}
diff --git a/include/ndnboost/unordered/detail/fwd.hpp b/include/ndnboost/unordered/detail/fwd.hpp
index 929466f..c4f4cda 100644
--- a/include/ndnboost/unordered/detail/fwd.hpp
+++ b/include/ndnboost/unordered/detail/fwd.hpp
@@ -3,8 +3,8 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef BOOST_UNORDERED_FWD_HPP_INCLUDED
-#define BOOST_UNORDERED_FWD_HPP_INCLUDED
+#ifndef NDNBOOST_UNORDERED_FWD_HPP_INCLUDED
+#define NDNBOOST_UNORDERED_FWD_HPP_INCLUDED
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
diff --git a/include/ndnboost/unordered/detail/table.hpp b/include/ndnboost/unordered/detail/table.hpp
index 3d2cf86..7641483 100644
--- a/include/ndnboost/unordered/detail/table.hpp
+++ b/include/ndnboost/unordered/detail/table.hpp
@@ -4,8 +4,8 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef BOOST_UNORDERED_DETAIL_ALL_HPP_INCLUDED
-#define BOOST_UNORDERED_DETAIL_ALL_HPP_INCLUDED
+#ifndef NDNBOOST_UNORDERED_DETAIL_ALL_HPP_INCLUDED
+#define NDNBOOST_UNORDERED_DETAIL_ALL_HPP_INCLUDED
 
 #include <ndnboost/unordered/detail/buckets.hpp>
 #include <ndnboost/unordered/detail/util.hpp>
@@ -13,19 +13,19 @@
 #include <ndnboost/type_traits/alignment_of.hpp>
 #include <cmath>
 
-#if defined(BOOST_MSVC)
+#if defined(NDNBOOST_MSVC)
 #pragma warning(push)
 #pragma warning(disable:4127) // conditional expression is constant
 #endif
 
-#if defined(BOOST_UNORDERED_DEPRECATED_EQUALITY)
+#if defined(NDNBOOST_UNORDERED_DEPRECATED_EQUALITY)
 
 #if defined(__EDG__)
 #elif defined(_MSC_VER) || defined(__BORLANDC__) || defined(__DMC__)
-#pragma message("Warning: BOOST_UNORDERED_DEPRECATED_EQUALITY is no longer supported.")
+#pragma message("Warning: NDNBOOST_UNORDERED_DEPRECATED_EQUALITY is no longer supported.")
 #elif defined(__GNUC__) || defined(__HP_aCC) || \
     defined(__SUNPRO_CC) || defined(__IBMCPP__)
-#warning "BOOST_UNORDERED_DEPRECATED_EQUALITY is no longer supported."
+#warning "NDNBOOST_UNORDERED_DEPRECATED_EQUALITY is no longer supported."
 #endif
 
 #endif
@@ -231,7 +231,7 @@
 
         bucket_pointer get_bucket(std::size_t bucket_index) const
         {
-            BOOST_ASSERT(buckets_);
+            NDNBOOST_ASSERT(buckets_);
             return buckets_ + static_cast<std::ptrdiff_t>(bucket_index);
         }
 
@@ -264,7 +264,7 @@
 
         float load_factor() const
         {
-            BOOST_ASSERT(bucket_count_ != 0);
+            NDNBOOST_ASSERT(bucket_count_ != 0);
             return static_cast<float>(size_)
                 / static_cast<float>(bucket_count_);
         }
@@ -313,14 +313,14 @@
 
         void max_load_factor(float z)
         {
-            BOOST_ASSERT(z > 0);
+            NDNBOOST_ASSERT(z > 0);
             mlf_ = (std::max)(z, minimum_max_load_factor);
             recalculate_max_load();
         }
 
         std::size_t min_buckets_for_size(std::size_t size) const
         {
-            BOOST_ASSERT(mlf_ >= minimum_max_load_factor);
+            NDNBOOST_ASSERT(mlf_ >= minimum_max_load_factor);
     
             using namespace std;
     
@@ -459,7 +459,7 @@
             // According to 23.2.1.8, if propagate_on_container_swap is
             // false the behaviour is undefined unless the allocators
             // are equal.
-            BOOST_ASSERT(node_alloc() == other.node_alloc());
+            NDNBOOST_ASSERT(node_alloc() == other.node_alloc());
         }
 
         void swap_allocators(table& other, true_type)
@@ -491,8 +491,8 @@
 
         void move_buckets_from(table& other)
         {
-            BOOST_ASSERT(node_alloc() == other.node_alloc());
-            BOOST_ASSERT(!buckets_);
+            NDNBOOST_ASSERT(node_alloc() == other.node_alloc());
+            NDNBOOST_ASSERT(!buckets_);
             buckets_ = other.buckets_;
             bucket_count_ = other.bucket_count_;
             size_ = other.size_;
@@ -524,7 +524,7 @@
 
         std::size_t delete_nodes(link_pointer prev, link_pointer end)
         {
-            BOOST_ASSERT(prev->next_ != end);
+            NDNBOOST_ASSERT(prev->next_ != end);
 
             std::size_t count = 0;
 
@@ -554,7 +554,7 @@
                 max_load_ = 0;
             }
 
-            BOOST_ASSERT(!size_);
+            NDNBOOST_ASSERT(!size_);
         }
 
         void clear()
@@ -564,7 +564,7 @@
             delete_nodes(get_previous_start(), link_pointer());
             clear_buckets();
 
-            BOOST_ASSERT(!size_);
+            NDNBOOST_ASSERT(!size_);
         }
 
         void clear_buckets()
@@ -854,7 +854,7 @@
     }
 }}}
 
-#if defined(BOOST_MSVC)
+#if defined(NDNBOOST_MSVC)
 #pragma warning(pop)
 #endif
 
diff --git a/include/ndnboost/unordered/detail/unique.hpp b/include/ndnboost/unordered/detail/unique.hpp
index 44fc04d..d413255 100644
--- a/include/ndnboost/unordered/detail/unique.hpp
+++ b/include/ndnboost/unordered/detail/unique.hpp
@@ -4,8 +4,8 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef BOOST_UNORDERED_DETAIL_UNIQUE_HPP_INCLUDED
-#define BOOST_UNORDERED_DETAIL_UNIQUE_HPP_INCLUDED
+#ifndef NDNBOOST_UNORDERED_DETAIL_UNIQUE_HPP_INCLUDED
+#define NDNBOOST_UNORDERED_DETAIL_UNIQUE_HPP_INCLUDED
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
@@ -344,7 +344,7 @@
             // Create the node before rehashing in case it throws an
             // exception (need strong safety in such a case).
             node_constructor a(this->node_alloc());
-            a.construct_with_value(BOOST_UNORDERED_EMPLACE_ARGS3(
+            a.construct_with_value(NDNBOOST_UNORDERED_EMPLACE_ARGS3(
                 ndnboost::unordered::piecewise_construct,
                 ndnboost::make_tuple(k),
                 ndnboost::make_tuple()));
@@ -353,39 +353,39 @@
             return *add_node(a, key_hash);
         }
 
-#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-#   if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#if defined(NDNBOOST_NO_CXX11_RVALUE_REFERENCES)
+#   if defined(NDNBOOST_NO_CXX11_VARIADIC_TEMPLATES)
         emplace_return emplace(ndnboost::unordered::detail::emplace_args1<
                 ndnboost::unordered::detail::please_ignore_this_overload> const&)
         {
-            BOOST_ASSERT(false);
+            NDNBOOST_ASSERT(false);
             return emplace_return(this->begin(), false);
         }
 #   else
         emplace_return emplace(
                 ndnboost::unordered::detail::please_ignore_this_overload const&)
         {
-            BOOST_ASSERT(false);
+            NDNBOOST_ASSERT(false);
             return emplace_return(this->begin(), false);
         }
 #   endif
 #endif
 
-        template <BOOST_UNORDERED_EMPLACE_TEMPLATE>
-        emplace_return emplace(BOOST_UNORDERED_EMPLACE_ARGS)
+        template <NDNBOOST_UNORDERED_EMPLACE_TEMPLATE>
+        emplace_return emplace(NDNBOOST_UNORDERED_EMPLACE_ARGS)
         {
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#if !defined(NDNBOOST_NO_CXX11_VARIADIC_TEMPLATES)
             return emplace_impl(
-                extractor::extract(BOOST_UNORDERED_EMPLACE_FORWARD),
-                BOOST_UNORDERED_EMPLACE_FORWARD);
+                extractor::extract(NDNBOOST_UNORDERED_EMPLACE_FORWARD),
+                NDNBOOST_UNORDERED_EMPLACE_FORWARD);
 #else
             return emplace_impl(
                 extractor::extract(args.a0, args.a1),
-                BOOST_UNORDERED_EMPLACE_FORWARD);
+                NDNBOOST_UNORDERED_EMPLACE_FORWARD);
 #endif
         }
 
-#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#if defined(NDNBOOST_NO_CXX11_VARIADIC_TEMPLATES)
         template <typename A0>
         emplace_return emplace(
                 ndnboost::unordered::detail::emplace_args1<A0> const& args)
@@ -394,9 +394,9 @@
         }
 #endif
 
-        template <BOOST_UNORDERED_EMPLACE_TEMPLATE>
+        template <NDNBOOST_UNORDERED_EMPLACE_TEMPLATE>
         emplace_return emplace_impl(key_type const& k,
-            BOOST_UNORDERED_EMPLACE_ARGS)
+            NDNBOOST_UNORDERED_EMPLACE_ARGS)
         {
             std::size_t key_hash = this->hash(k);
             iterator pos = this->find_node(key_hash, k);
@@ -406,7 +406,7 @@
             // Create the node before rehashing in case it throws an
             // exception (need strong safety in such a case).
             node_constructor a(this->node_alloc());
-            a.construct_with_value(BOOST_UNORDERED_EMPLACE_FORWARD);
+            a.construct_with_value(NDNBOOST_UNORDERED_EMPLACE_FORWARD);
     
             // reserve has basic exception safety if the hash function
             // throws, strong otherwise.
@@ -428,13 +428,13 @@
             return emplace_return(this->add_node(a, key_hash), true);
         }
 
-        template <BOOST_UNORDERED_EMPLACE_TEMPLATE>
-        emplace_return emplace_impl(no_key, BOOST_UNORDERED_EMPLACE_ARGS)
+        template <NDNBOOST_UNORDERED_EMPLACE_TEMPLATE>
+        emplace_return emplace_impl(no_key, NDNBOOST_UNORDERED_EMPLACE_ARGS)
         {
             // Don't have a key, so construct the node first in order
             // to be able to lookup the position.
             node_constructor a(this->node_alloc());
-            a.construct_with_value(BOOST_UNORDERED_EMPLACE_FORWARD);
+            a.construct_with_value(NDNBOOST_UNORDERED_EMPLACE_FORWARD);
             return emplace_impl_with_node(a);
         }
 
@@ -538,7 +538,7 @@
 
         iterator erase(c_iterator r)
         {
-            BOOST_ASSERT(r.node_);
+            NDNBOOST_ASSERT(r.node_);
             iterator next(r.node_);
             ++next;
             erase_nodes(r.node_, next.node_);
@@ -590,7 +590,7 @@
         // strong otherwise exception safety
         void rehash_impl(std::size_t num_buckets)
         {
-            BOOST_ASSERT(this->buckets_);
+            NDNBOOST_ASSERT(this->buckets_);
 
             this->create_buckets(num_buckets);
             link_pointer prev = this->get_previous_start();
diff --git a/include/ndnboost/unordered/detail/util.hpp b/include/ndnboost/unordered/detail/util.hpp
index 41f8e42..0e1db85 100644
--- a/include/ndnboost/unordered/detail/util.hpp
+++ b/include/ndnboost/unordered/detail/util.hpp
@@ -4,8 +4,8 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef BOOST_UNORDERED_DETAIL_UTIL_HPP_INCLUDED
-#define BOOST_UNORDERED_DETAIL_UTIL_HPP_INCLUDED
+#ifndef NDNBOOST_UNORDERED_DETAIL_UTIL_HPP_INCLUDED
+#define NDNBOOST_UNORDERED_DETAIL_UTIL_HPP_INCLUDED
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
@@ -55,7 +55,7 @@
     ////////////////////////////////////////////////////////////////////////////
     // primes
 
-#define BOOST_UNORDERED_PRIMES \
+#define NDNBOOST_UNORDERED_PRIMES \
     (17ul)(29ul)(37ul)(53ul)(67ul)(79ul) \
     (97ul)(131ul)(193ul)(257ul)(389ul)(521ul)(769ul) \
     (1031ul)(1543ul)(2053ul)(3079ul)(6151ul)(12289ul)(24593ul) \
@@ -72,22 +72,22 @@
         static std::ptrdiff_t const length;
 #else
         static std::ptrdiff_t const length
-            = BOOST_PP_SEQ_SIZE(BOOST_UNORDERED_PRIMES);
+            = NDNBOOST_PP_SEQ_SIZE(NDNBOOST_UNORDERED_PRIMES);
 #endif
     };
 
     template<class T>
     std::size_t const prime_list_template<T>::value[] = {
-        BOOST_PP_SEQ_ENUM(BOOST_UNORDERED_PRIMES)
+        NDNBOOST_PP_SEQ_ENUM(NDNBOOST_UNORDERED_PRIMES)
     };
 
 #if !defined(SUNPRO_CC)
     template<class T>
     std::ptrdiff_t const prime_list_template<T>::length
-        = BOOST_PP_SEQ_SIZE(BOOST_UNORDERED_PRIMES);
+        = NDNBOOST_PP_SEQ_SIZE(NDNBOOST_UNORDERED_PRIMES);
 #endif
 
-#undef BOOST_UNORDERED_PRIMES
+#undef NDNBOOST_UNORDERED_PRIMES
 
     typedef prime_list_template<std::size_t> prime_list;
 
@@ -118,7 +118,7 @@
     ////////////////////////////////////////////////////////////////////////////
     // insert_size/initial_size
 
-#if !defined(BOOST_NO_STD_DISTANCE)
+#if !defined(NDNBOOST_NO_STD_DISTANCE)
 
     using ::std::distance;
 
@@ -189,7 +189,7 @@
     struct generate_base
       : ndnboost::detail::if_true<
             ndnboost::is_empty<T>::value
-        >:: BOOST_NESTED_TEMPLATE then<
+        >:: NDNBOOST_NESTED_TEMPLATE then<
             ndnboost::unordered::detail::compressed_base<T, Index>,
             ndnboost::unordered::detail::uncompressed_base<T, Index>
         >