diff --git a/include/ndnboost/iterator/detail/config_def.hpp b/include/ndnboost/iterator/detail/config_def.hpp
index 861072b..f4af926 100644
--- a/include/ndnboost/iterator/detail/config_def.hpp
+++ b/include/ndnboost/iterator/detail/config_def.hpp
@@ -16,18 +16,18 @@
 #include <ndnboost/config.hpp> // for prior
 #include <ndnboost/detail/workaround.hpp>
 
-#ifdef BOOST_ITERATOR_CONFIG_DEF
+#ifdef NDNBOOST_ITERATOR_CONFIG_DEF
 # error you have nested config_def #inclusion.
 #else 
-# define BOOST_ITERATOR_CONFIG_DEF
+# define NDNBOOST_ITERATOR_CONFIG_DEF
 #endif 
 
 // We enable this always now.  Otherwise, the simple case in
 // libs/iterator/test/constant_iterator_arrow.cpp fails to compile
 // because the operator-> return is improperly deduced as a non-const
 // pointer.
-#if 1 || defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)           \
-    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x531))
+#if 1 || defined(NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)           \
+    || NDNBOOST_WORKAROUND(__BORLANDC__, NDNBOOST_TESTED_AT(0x531))
 
 // Recall that in general, compilers without partial specialization
 // can't strip constness.  Consider counting_iterator, which normally
@@ -42,17 +42,17 @@
 // return the value_type from operator[] directly, but is not
 // strictly necessary.  Not sure how best to resolve this one.
 
-# define BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY 1
+# define NDNBOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY 1
 
 #endif
 
-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)                                       \
-    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x5A0))                   \
-    || (BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 700) && defined(_MSC_VER)) \
-    || BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042))                \
-    || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
+#if NDNBOOST_WORKAROUND(NDNBOOST_MSVC, <= 1300)                                       \
+    || NDNBOOST_WORKAROUND(__BORLANDC__, NDNBOOST_TESTED_AT(0x5A0))                   \
+    || (NDNBOOST_WORKAROUND(NDNBOOST_INTEL_CXX_VERSION, <= 700) && defined(_MSC_VER)) \
+    || NDNBOOST_WORKAROUND(__DECCXX_VER, NDNBOOST_TESTED_AT(60590042))                \
+    || NDNBOOST_WORKAROUND(__SUNPRO_CC, NDNBOOST_TESTED_AT(0x590))
     
-# define BOOST_NO_LVALUE_RETURN_DETECTION
+# define NDNBOOST_NO_LVALUE_RETURN_DETECTION
 
 # if 0 // test code
   struct v  {};
@@ -84,14 +84,14 @@
 
 #endif
 
-#if BOOST_WORKAROUND(__MWERKS__, <=0x2407)
-#  define BOOST_NO_IS_CONVERTIBLE // "is_convertible doesn't work for simple types"
+#if NDNBOOST_WORKAROUND(__MWERKS__, <=0x2407)
+#  define NDNBOOST_NO_IS_CONVERTIBLE // "is_convertible doesn't work for simple types"
 #endif
 
-#if BOOST_WORKAROUND(__GNUC__, == 2)                                                                            \
-    || BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, < 4) && !defined(__EDG_VERSION__)   \
-    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
-#  define BOOST_NO_IS_CONVERTIBLE_TEMPLATE // The following program fails to compile:
+#if NDNBOOST_WORKAROUND(__GNUC__, == 2)                                                                            \
+    || NDNBOOST_WORKAROUND(__GNUC__, == 3) && NDNBOOST_WORKAROUND(__GNUC_MINOR__, < 4) && !defined(__EDG_VERSION__)   \
+    || NDNBOOST_WORKAROUND(__BORLANDC__, NDNBOOST_TESTED_AT(0x551))
+#  define NDNBOOST_NO_IS_CONVERTIBLE_TEMPLATE // The following program fails to compile:
 
 #  if 0 // test code
     #include <ndnboost/type_traits/is_convertible.hpp>
@@ -112,18 +112,18 @@
 #endif
 
 
-#if !defined(BOOST_MSVC) && (defined(BOOST_NO_SFINAE) || defined(BOOST_NO_IS_CONVERTIBLE) || defined(BOOST_NO_IS_CONVERTIBLE_TEMPLATE))
-# define BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
+#if !defined(NDNBOOST_MSVC) && (defined(NDNBOOST_NO_SFINAE) || defined(NDNBOOST_NO_IS_CONVERTIBLE) || defined(NDNBOOST_NO_IS_CONVERTIBLE_TEMPLATE))
+# define NDNBOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
 #endif 
 
-# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-#  define BOOST_ARG_DEPENDENT_TYPENAME typename
+# if !NDNBOOST_WORKAROUND(NDNBOOST_MSVC, <= 1300)
+#  define NDNBOOST_ARG_DEPENDENT_TYPENAME typename
 # else
-#  define BOOST_ARG_DEPENDENT_TYPENAME
+#  define NDNBOOST_ARG_DEPENDENT_TYPENAME
 # endif
 
-# if BOOST_WORKAROUND(__GNUC__, == 2) && BOOST_WORKAROUND(__GNUC_MINOR__, BOOST_TESTED_AT(95)) \
-    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+# if NDNBOOST_WORKAROUND(__GNUC__, == 2) && NDNBOOST_WORKAROUND(__GNUC_MINOR__, NDNBOOST_TESTED_AT(95)) \
+    || NDNBOOST_WORKAROUND(__BORLANDC__, NDNBOOST_TESTED_AT(0x564))
 
 // GCC-2.95 eagerly instantiates templated constructors and conversion
 // operators in convertibility checks, causing premature errors.
@@ -131,7 +131,7 @@
 // Borland's problems are harder to diagnose due to lack of an
 // instantiation stack backtrace.  They may be due in part to the fact
 // that it drops cv-qualification willy-nilly in templates.
-#  define BOOST_NO_ONE_WAY_ITERATOR_INTEROP
+#  define NDNBOOST_NO_ONE_WAY_ITERATOR_INTEROP
 # endif 
 
 // no include guard; multiple inclusion intended
diff --git a/include/ndnboost/iterator/detail/config_undef.hpp b/include/ndnboost/iterator/detail/config_undef.hpp
index 9dcd1d5..0e828aa 100644
--- a/include/ndnboost/iterator/detail/config_undef.hpp
+++ b/include/ndnboost/iterator/detail/config_undef.hpp
@@ -11,15 +11,15 @@
 // 23/02/03 thw
 //
 
-#undef BOOST_NO_IS_CONVERTIBLE
-#undef BOOST_NO_IS_CONVERTIBLE_TEMPLATE
-#undef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
-#undef BOOST_ARG_DEPENDENT_TYPENAME
-#undef BOOST_NO_LVALUE_RETURN_DETECTION
-#undef BOOST_NO_ONE_WAY_ITERATOR_INTEROP
+#undef NDNBOOST_NO_IS_CONVERTIBLE
+#undef NDNBOOST_NO_IS_CONVERTIBLE_TEMPLATE
+#undef NDNBOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
+#undef NDNBOOST_ARG_DEPENDENT_TYPENAME
+#undef NDNBOOST_NO_LVALUE_RETURN_DETECTION
+#undef NDNBOOST_NO_ONE_WAY_ITERATOR_INTEROP
 
-#ifdef BOOST_ITERATOR_CONFIG_DEF
-# undef BOOST_ITERATOR_CONFIG_DEF
+#ifdef NDNBOOST_ITERATOR_CONFIG_DEF
+# undef NDNBOOST_ITERATOR_CONFIG_DEF
 #else
 # error missing or nested #include config_def
 #endif 
diff --git a/include/ndnboost/iterator/detail/enable_if.hpp b/include/ndnboost/iterator/detail/enable_if.hpp
index 1b26330..2b041ab 100644
--- a/include/ndnboost/iterator/detail/enable_if.hpp
+++ b/include/ndnboost/iterator/detail/enable_if.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_ENABLE_IF_23022003THW_HPP
-#define BOOST_ENABLE_IF_23022003THW_HPP
+#ifndef NDNBOOST_ENABLE_IF_23022003THW_HPP
+#define NDNBOOST_ENABLE_IF_23022003THW_HPP
 
 #include <ndnboost/detail/workaround.hpp>
 #include <ndnboost/mpl/identity.hpp>
@@ -47,7 +47,7 @@
       template<typename T>
       struct base
       {
-#ifdef BOOST_NO_SFINAE
+#ifdef NDNBOOST_NO_SFINAE
 
         typedef T type;
 
@@ -66,13 +66,13 @@
     template <class Cond,
               class Return>
     struct enable_if
-# if !defined(BOOST_NO_SFINAE) && !defined(BOOST_NO_IS_CONVERTIBLE)
+# if !defined(NDNBOOST_NO_SFINAE) && !defined(NDNBOOST_NO_IS_CONVERTIBLE)
       : enabled<(Cond::value)>::template base<Return>
 # else
       : mpl::identity<Return>
 # endif 
     {
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+# if NDNBOOST_WORKAROUND(NDNBOOST_MSVC, < 1300)
         typedef Return type;
 # endif 
     };
@@ -83,4 +83,4 @@
 
 #include <ndnboost/iterator/detail/config_undef.hpp>
 
-#endif // BOOST_ENABLE_IF_23022003THW_HPP
+#endif // NDNBOOST_ENABLE_IF_23022003THW_HPP
diff --git a/include/ndnboost/iterator/detail/facade_iterator_category.hpp b/include/ndnboost/iterator/detail/facade_iterator_category.hpp
index fa21f5a..c658c9f 100644
--- a/include/ndnboost/iterator/detail/facade_iterator_category.hpp
+++ b/include/ndnboost/iterator/detail/facade_iterator_category.hpp
@@ -22,7 +22,7 @@
 
 # include <ndnboost/iterator/detail/config_def.hpp> // try to keep this last
 
-# ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
+# ifdef NDNBOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
 #  include <ndnboost/detail/indirect_traits.hpp>
 # endif
 
@@ -57,7 +57,7 @@
 //
 template <class ValueParam, class Reference>
 struct iterator_writability_disabled
-# ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY // Adding Thomas' logic?
+# ifdef NDNBOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY // Adding Thomas' logic?
   : mpl::or_<
         is_const<Reference>
       , ndnboost::detail::indirect_traits::is_reference_to_const<Reference>
@@ -138,21 +138,21 @@
 struct iterator_category_with_traversal
   : Category, Traversal
 {
-# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+# if !NDNBOOST_WORKAROUND(NDNBOOST_MSVC, <= 1300)
     // Make sure this isn't used to build any categories where
     // convertibility to Traversal is redundant.  Should just use the
     // Category element in that case.
-    BOOST_MPL_ASSERT_NOT((
+    NDNBOOST_MPL_ASSERT_NOT((
         is_convertible<
               typename iterator_category_to_traversal<Category>::type
             , Traversal
           >));
 
-    BOOST_MPL_ASSERT((is_iterator_category<Category>));
-    BOOST_MPL_ASSERT_NOT((is_iterator_category<Traversal>));
-    BOOST_MPL_ASSERT_NOT((is_iterator_traversal<Category>));
-#  if !BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
-    BOOST_MPL_ASSERT((is_iterator_traversal<Traversal>));
+    NDNBOOST_MPL_ASSERT((is_iterator_category<Category>));
+    NDNBOOST_MPL_ASSERT_NOT((is_iterator_category<Traversal>));
+    NDNBOOST_MPL_ASSERT_NOT((is_iterator_traversal<Category>));
+#  if !NDNBOOST_WORKAROUND(NDNBOOST_MSVC, NDNBOOST_TESTED_AT(1310))
+    NDNBOOST_MPL_ASSERT((is_iterator_traversal<Traversal>));
 #  endif 
 # endif 
 };
@@ -162,8 +162,8 @@
 template <class Traversal, class ValueParam, class Reference>
 struct facade_iterator_category_impl
 {
-# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-    BOOST_MPL_ASSERT_NOT((is_iterator_category<Traversal>));
+# if !NDNBOOST_WORKAROUND(NDNBOOST_MSVC, <= 1300)
+    NDNBOOST_MPL_ASSERT_NOT((is_iterator_category<Traversal>));
 # endif 
     
     typedef typename iterator_facade_default_category<
diff --git a/include/ndnboost/iterator/interoperable.hpp b/include/ndnboost/iterator/interoperable.hpp
index daede1c..25b2104 100644
--- a/include/ndnboost/iterator/interoperable.hpp
+++ b/include/ndnboost/iterator/interoperable.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_INTEROPERABLE_23022003THW_HPP
-# define BOOST_INTEROPERABLE_23022003THW_HPP
+#ifndef NDNBOOST_INTEROPERABLE_23022003THW_HPP
+# define NDNBOOST_INTEROPERABLE_23022003THW_HPP
 
 # include <ndnboost/mpl/bool.hpp>
 # include <ndnboost/mpl/or.hpp>
@@ -33,7 +33,7 @@
   //
   template <typename A, typename B>
   struct is_interoperable
-# ifdef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
+# ifdef NDNBOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
     : mpl::true_
 # else
     : mpl::or_<
@@ -47,4 +47,4 @@
 
 # include <ndnboost/iterator/detail/config_undef.hpp>
 
-#endif // BOOST_INTEROPERABLE_23022003THW_HPP
+#endif // NDNBOOST_INTEROPERABLE_23022003THW_HPP
diff --git a/include/ndnboost/iterator/iterator_adaptor.hpp b/include/ndnboost/iterator/iterator_adaptor.hpp
index 59aafbf..1a9bd54 100644
--- a/include/ndnboost/iterator/iterator_adaptor.hpp
+++ b/include/ndnboost/iterator/iterator_adaptor.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_ITERATOR_ADAPTOR_23022003THW_HPP
-#define BOOST_ITERATOR_ADAPTOR_23022003THW_HPP
+#ifndef NDNBOOST_ITERATOR_ADAPTOR_23022003THW_HPP
+#define NDNBOOST_ITERATOR_ADAPTOR_23022003THW_HPP
 
 #include <ndnboost/static_assert.hpp>
 #include <ndnboost/iterator.hpp>
@@ -22,7 +22,7 @@
 #include <ndnboost/type_traits/is_same.hpp>
 #include <ndnboost/type_traits/is_convertible.hpp>
 
-#ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
+#ifdef NDNBOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
 # include <ndnboost/type_traits/remove_reference.hpp>
 #endif
 
@@ -38,7 +38,7 @@
   // explicitly in order to specify that the default should be used.
   struct use_default;
   
-# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+# ifndef NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
   // the incompleteness of use_default causes massive problems for
   // is_convertible (naturally).  This workaround is fortunately not
   // needed for vc6/vc7.
@@ -99,7 +99,7 @@
   // false positives for user/library defined iterator types. See comments
   // on operator implementation for consequences.
   //
-#  if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+#  if NDNBOOST_WORKAROUND(NDNBOOST_MSVC, <= 1300)
   
   template<typename From, typename To>
   struct enable_if_convertible
@@ -114,7 +114,7 @@
      >::type type;
   };
   
-#  elif defined(BOOST_NO_IS_CONVERTIBLE) || defined(BOOST_NO_SFINAE)
+#  elif defined(NDNBOOST_NO_IS_CONVERTIBLE) || defined(NDNBOOST_NO_SFINAE)
   
   template <class From, class To>
   struct enable_if_convertible
@@ -122,7 +122,7 @@
       typedef ndnboost::detail::enable_type type;
   };
   
-#  elif BOOST_WORKAROUND(_MSC_FULL_VER, BOOST_TESTED_AT(13102292)) && BOOST_MSVC > 1300
+#  elif NDNBOOST_WORKAROUND(_MSC_FULL_VER, NDNBOOST_TESTED_AT(13102292)) && NDNBOOST_MSVC > 1300
   
   // For some reason vc7.1 needs us to "cut off" instantiation
   // of is_convertible in a few cases.
@@ -181,7 +181,7 @@
         typedef iterator_facade<
             Derived
             
-# ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
+# ifdef NDNBOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
           , typename ndnboost::detail::ia_dflt_help<
                 Value
               , mpl::eval_if<
@@ -221,7 +221,7 @@
     template <class Tr1, class Tr2>
     inline void iterator_adaptor_assert_traversal ()
     {
-      BOOST_STATIC_ASSERT((is_convertible<Tr1, Tr2>::value));
+      NDNBOOST_STATIC_ASSERT((is_convertible<Tr1, Tr2>::value));
     }
   }
   
@@ -311,7 +311,7 @@
       bool equal(iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& x) const
       {
         // Maybe readd with same_distance
-        //           BOOST_STATIC_ASSERT(
+        //           NDNBOOST_STATIC_ASSERT(
         //               (detail::same_category_and_difference<Derived,OtherDerived>::value)
         //               );
           return m_iterator == x.base();
@@ -321,12 +321,12 @@
           typename super_t::iterator_category
       >::type my_traversal;
 
-# define BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(cat) \
+# define NDNBOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(cat) \
       ndnboost::detail::iterator_adaptor_assert_traversal<my_traversal, cat>();
 
       void advance(typename super_t::difference_type n)
       {
-          BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(random_access_traversal_tag)
+          NDNBOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(random_access_traversal_tag)
           m_iterator += n;
       }
   
@@ -334,7 +334,7 @@
 
       void decrement() 
       {
-          BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(bidirectional_traversal_tag)
+          NDNBOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(bidirectional_traversal_tag)
            --m_iterator;
       }
 
@@ -344,15 +344,15 @@
       typename super_t::difference_type distance_to(
           iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& y) const
       {
-          BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(random_access_traversal_tag)
+          NDNBOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(random_access_traversal_tag)
           // Maybe readd with same_distance
-          //           BOOST_STATIC_ASSERT(
+          //           NDNBOOST_STATIC_ASSERT(
           //               (detail::same_category_and_difference<Derived,OtherDerived>::value)
           //               );
           return y.base() - m_iterator;
       }
 
-# undef BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL
+# undef NDNBOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL
       
    private: // data members
       Base m_iterator;
@@ -362,4 +362,4 @@
 
 #include <ndnboost/iterator/detail/config_undef.hpp>
 
-#endif // BOOST_ITERATOR_ADAPTOR_23022003THW_HPP
+#endif // NDNBOOST_ITERATOR_ADAPTOR_23022003THW_HPP
diff --git a/include/ndnboost/iterator/iterator_categories.hpp b/include/ndnboost/iterator/iterator_categories.hpp
index 9adc13d..1602e54 100644
--- a/include/ndnboost/iterator/iterator_categories.hpp
+++ b/include/ndnboost/iterator/iterator_categories.hpp
@@ -3,8 +3,8 @@
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef BOOST_ITERATOR_CATEGORIES_HPP
-# define BOOST_ITERATOR_CATEGORIES_HPP
+#ifndef NDNBOOST_ITERATOR_CATEGORIES_HPP
+# define NDNBOOST_ITERATOR_CATEGORIES_HPP
 
 # include <ndnboost/config.hpp>
 # include <ndnboost/detail/iterator.hpp>
@@ -97,7 +97,7 @@
       >
   {};
 
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+# if NDNBOOST_WORKAROUND(NDNBOOST_MSVC, < 1300)
   template <>
   struct old_category_to_traversal<int>
   {
@@ -131,7 +131,7 @@
   {
   };
   
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+# if NDNBOOST_WORKAROUND(NDNBOOST_MSVC, < 1300)
   template <>
   struct pure_traversal_tag<int>
   {
@@ -162,8 +162,8 @@
     >
 {};
 
-# ifdef BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT
-// Hack because BOOST_MPL_AUX_LAMBDA_SUPPORT doesn't seem to work
+# ifdef NDNBOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT
+// Hack because NDNBOOST_MPL_AUX_LAMBDA_SUPPORT doesn't seem to work
 // out well.  Instantiating the nested apply template also
 // requires instantiating iterator_traits on the
 // placeholder. Instead we just specialize it as a metafunction
@@ -185,4 +185,4 @@
 
 #include <ndnboost/iterator/detail/config_undef.hpp>
 
-#endif // BOOST_ITERATOR_CATEGORIES_HPP
+#endif // NDNBOOST_ITERATOR_CATEGORIES_HPP
diff --git a/include/ndnboost/iterator/iterator_concepts.hpp b/include/ndnboost/iterator/iterator_concepts.hpp
index cbfba5e..58d4589 100644
--- a/include/ndnboost/iterator/iterator_concepts.hpp
+++ b/include/ndnboost/iterator/iterator_concepts.hpp
@@ -3,8 +3,8 @@
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef BOOST_ITERATOR_CONCEPTS_HPP
-#define BOOST_ITERATOR_CONCEPTS_HPP
+#ifndef NDNBOOST_ITERATOR_CONCEPTS_HPP
+#define NDNBOOST_ITERATOR_CONCEPTS_HPP
 
 #include <ndnboost/concept_check.hpp>
 #include <ndnboost/iterator/iterator_categories.hpp>
@@ -39,15 +39,15 @@
   //===========================================================================
   // Iterator Access Concepts
 
-  BOOST_concept(ReadableIterator,(Iterator))
+  NDNBOOST_concept(ReadableIterator,(Iterator))
     : ndnboost::Assignable<Iterator>
     , ndnboost::CopyConstructible<Iterator>
 
   {
-      typedef BOOST_DEDUCED_TYPENAME ndnboost::detail::iterator_traits<Iterator>::value_type value_type;
-      typedef BOOST_DEDUCED_TYPENAME ndnboost::detail::iterator_traits<Iterator>::reference reference;
+      typedef NDNBOOST_DEDUCED_TYPENAME ndnboost::detail::iterator_traits<Iterator>::value_type value_type;
+      typedef NDNBOOST_DEDUCED_TYPENAME ndnboost::detail::iterator_traits<Iterator>::reference reference;
 
-      BOOST_CONCEPT_USAGE(ReadableIterator)
+      NDNBOOST_CONCEPT_USAGE(ReadableIterator)
       {
 
           value_type v = *i;
@@ -59,12 +59,12 @@
   
   template <
       typename Iterator
-    , typename ValueType = BOOST_DEDUCED_TYPENAME ndnboost::detail::iterator_traits<Iterator>::value_type
+    , typename ValueType = NDNBOOST_DEDUCED_TYPENAME ndnboost::detail::iterator_traits<Iterator>::value_type
   >
   struct WritableIterator
     : ndnboost::CopyConstructible<Iterator>
   {
-      BOOST_CONCEPT_USAGE(WritableIterator)
+      NDNBOOST_CONCEPT_USAGE(WritableIterator)
       {
           *i = v;
       }
@@ -75,13 +75,13 @@
 
   template <
       typename Iterator
-    , typename ValueType = BOOST_DEDUCED_TYPENAME ndnboost::detail::iterator_traits<Iterator>::value_type
+    , typename ValueType = NDNBOOST_DEDUCED_TYPENAME ndnboost::detail::iterator_traits<Iterator>::value_type
   >
   struct WritableIteratorConcept : WritableIterator<Iterator,ValueType> {};
   
-  BOOST_concept(SwappableIterator,(Iterator))
+  NDNBOOST_concept(SwappableIterator,(Iterator))
   {
-      BOOST_CONCEPT_USAGE(SwappableIterator)
+      NDNBOOST_CONCEPT_USAGE(SwappableIterator)
       {
           std::iter_swap(i1, i2);
       }
@@ -90,11 +90,11 @@
       Iterator i2;
   };
 
-  BOOST_concept(LvalueIterator,(Iterator))
+  NDNBOOST_concept(LvalueIterator,(Iterator))
   {
       typedef typename ndnboost::detail::iterator_traits<Iterator>::value_type value_type;
       
-      BOOST_CONCEPT_USAGE(LvalueIterator)
+      NDNBOOST_CONCEPT_USAGE(LvalueIterator)
       {
         value_type& r = const_cast<value_type&>(*i);
         ndnboost::ignore_unused_variable_warning(r);
@@ -107,19 +107,19 @@
   //===========================================================================
   // Iterator Traversal Concepts
 
-  BOOST_concept(IncrementableIterator,(Iterator))
+  NDNBOOST_concept(IncrementableIterator,(Iterator))
     : ndnboost::Assignable<Iterator>
     , ndnboost::CopyConstructible<Iterator>
   {
       typedef typename ndnboost::iterator_traversal<Iterator>::type traversal_category;
 
-      BOOST_CONCEPT_ASSERT((
+      NDNBOOST_CONCEPT_ASSERT((
         ndnboost::Convertible<
             traversal_category
           , ndnboost::incrementable_traversal_tag
         >));
 
-      BOOST_CONCEPT_USAGE(IncrementableIterator)
+      NDNBOOST_CONCEPT_USAGE(IncrementableIterator)
       {
           ++i;
           (void)i++;
@@ -128,44 +128,44 @@
       Iterator i;
   };
 
-  BOOST_concept(SinglePassIterator,(Iterator))
+  NDNBOOST_concept(SinglePassIterator,(Iterator))
     : IncrementableIterator<Iterator>
     , ndnboost::EqualityComparable<Iterator>
 
   {
-      BOOST_CONCEPT_ASSERT((
+      NDNBOOST_CONCEPT_ASSERT((
           ndnboost::Convertible<
-             BOOST_DEDUCED_TYPENAME SinglePassIterator::traversal_category
+             NDNBOOST_DEDUCED_TYPENAME SinglePassIterator::traversal_category
            , ndnboost::single_pass_traversal_tag
           > ));
   };
 
-  BOOST_concept(ForwardTraversal,(Iterator))
+  NDNBOOST_concept(ForwardTraversal,(Iterator))
     : SinglePassIterator<Iterator>
     , ndnboost::DefaultConstructible<Iterator>
   {
       typedef typename ndnboost::detail::iterator_traits<Iterator>::difference_type difference_type;
       
-      BOOST_MPL_ASSERT((ndnboost::is_integral<difference_type>));
-      BOOST_MPL_ASSERT_RELATION(std::numeric_limits<difference_type>::is_signed, ==, true);
+      NDNBOOST_MPL_ASSERT((ndnboost::is_integral<difference_type>));
+      NDNBOOST_MPL_ASSERT_RELATION(std::numeric_limits<difference_type>::is_signed, ==, true);
 
-      BOOST_CONCEPT_ASSERT((
+      NDNBOOST_CONCEPT_ASSERT((
           ndnboost::Convertible<
-             BOOST_DEDUCED_TYPENAME ForwardTraversal::traversal_category
+             NDNBOOST_DEDUCED_TYPENAME ForwardTraversal::traversal_category
            , ndnboost::forward_traversal_tag
           > ));
   };
   
-  BOOST_concept(BidirectionalTraversal,(Iterator))
+  NDNBOOST_concept(BidirectionalTraversal,(Iterator))
     : ForwardTraversal<Iterator>
   {
-      BOOST_CONCEPT_ASSERT((
+      NDNBOOST_CONCEPT_ASSERT((
           ndnboost::Convertible<
-             BOOST_DEDUCED_TYPENAME BidirectionalTraversal::traversal_category
+             NDNBOOST_DEDUCED_TYPENAME BidirectionalTraversal::traversal_category
            , ndnboost::bidirectional_traversal_tag
           > ));
 
-      BOOST_CONCEPT_USAGE(BidirectionalTraversal)
+      NDNBOOST_CONCEPT_USAGE(BidirectionalTraversal)
       {
           --i;
           (void)i--;
@@ -174,16 +174,16 @@
       Iterator i;
   };
 
-  BOOST_concept(RandomAccessTraversal,(Iterator))
+  NDNBOOST_concept(RandomAccessTraversal,(Iterator))
     : BidirectionalTraversal<Iterator>
   {
-      BOOST_CONCEPT_ASSERT((
+      NDNBOOST_CONCEPT_ASSERT((
           ndnboost::Convertible<
-             BOOST_DEDUCED_TYPENAME RandomAccessTraversal::traversal_category
+             NDNBOOST_DEDUCED_TYPENAME RandomAccessTraversal::traversal_category
            , ndnboost::random_access_traversal_tag
           > ));
 
-      BOOST_CONCEPT_USAGE(RandomAccessTraversal)
+      NDNBOOST_CONCEPT_USAGE(RandomAccessTraversal)
       {
           i += n;
           i = i + n;
@@ -245,7 +245,7 @@
 
   } // namespace detail
 
-  BOOST_concept(InteroperableIterator,(Iterator)(ConstIterator))
+  NDNBOOST_concept(InteroperableIterator,(Iterator)(ConstIterator))
   {
    private:
       typedef typename ndnboost::detail::pure_traversal_tag<
@@ -261,10 +261,10 @@
       >::type const_traversal_category;
       
   public:
-      BOOST_CONCEPT_ASSERT((SinglePassIterator<Iterator>));
-      BOOST_CONCEPT_ASSERT((SinglePassIterator<ConstIterator>));
+      NDNBOOST_CONCEPT_ASSERT((SinglePassIterator<Iterator>));
+      NDNBOOST_CONCEPT_ASSERT((SinglePassIterator<ConstIterator>));
 
-      BOOST_CONCEPT_USAGE(InteroperableIterator)
+      NDNBOOST_CONCEPT_USAGE(InteroperableIterator)
       {
           detail::interop_single_pass_constraints(i, ci);
           detail::interop_rand_access_constraints(i, ci, traversal_category(), const_traversal_category());
@@ -281,4 +281,4 @@
 
 #include <ndnboost/concept/detail/concept_undef.hpp>
 
-#endif // BOOST_ITERATOR_CONCEPTS_HPP
+#endif // NDNBOOST_ITERATOR_CONCEPTS_HPP
diff --git a/include/ndnboost/iterator/iterator_facade.hpp b/include/ndnboost/iterator/iterator_facade.hpp
index c61f3ad..eca6466 100644
--- a/include/ndnboost/iterator/iterator_facade.hpp
+++ b/include/ndnboost/iterator/iterator_facade.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_ITERATOR_FACADE_23022003THW_HPP
-#define BOOST_ITERATOR_FACADE_23022003THW_HPP
+#ifndef NDNBOOST_ITERATOR_FACADE_23022003THW_HPP
+#define NDNBOOST_ITERATOR_FACADE_23022003THW_HPP
 
 #include <ndnboost/iterator.hpp>
 #include <ndnboost/iterator/interoperable.hpp>
@@ -65,7 +65,7 @@
       , class Return
     >
     struct enable_if_interoperable
-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+#if NDNBOOST_WORKAROUND(NDNBOOST_MSVC, <= 1300)
     {
         typedef typename mpl::if_<
             mpl::or_<
@@ -112,17 +112,17 @@
           , add_pointer<value_type>
         >::type pointer;
       
-# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)                          \
-    && (BOOST_WORKAROUND(_STLPORT_VERSION, BOOST_TESTED_AT(0x452))              \
-        || BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, BOOST_TESTED_AT(310)))     \
-    || BOOST_WORKAROUND(BOOST_RWSTD_VER, BOOST_TESTED_AT(0x20101))              \
-    || BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, <= 310)
+# if defined(NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)                          \
+    && (NDNBOOST_WORKAROUND(_STLPORT_VERSION, NDNBOOST_TESTED_AT(0x452))              \
+        || NDNBOOST_WORKAROUND(NDNBOOST_DINKUMWARE_STDLIB, NDNBOOST_TESTED_AT(310)))     \
+    || NDNBOOST_WORKAROUND(NDNBOOST_RWSTD_VER, NDNBOOST_TESTED_AT(0x20101))              \
+    || NDNBOOST_WORKAROUND(NDNBOOST_DINKUMWARE_STDLIB, <= 310)
 
         // To interoperate with some broken library/compiler
         // combinations, user-defined iterators must be derived from
         // std::iterator.  It is possible to implement a standard
         // library for broken compilers without this limitation.
-#  define BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE 1
+#  define NDNBOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE 1
 
         typedef
            iterator<iterator_category, value_type, Difference, pointer, Reference>
@@ -215,7 +215,7 @@
         Iterator stored_iterator;
     };
 
-# ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+# ifdef NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
     template <class Reference, class Value>
     struct is_non_proxy_reference_impl
@@ -232,7 +232,7 @@
           , char[2]
         >::type& helper(R const&);
         
-        BOOST_STATIC_CONSTANT(bool, value = sizeof(helper(r)) == 1);
+        NDNBOOST_STATIC_CONSTANT(bool, value = sizeof(helper(r)) == 1);
     };
         
     template <class Reference, class Value>
@@ -325,7 +325,7 @@
         }
     };
 
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+# if NDNBOOST_WORKAROUND(NDNBOOST_MSVC, < 1300)
     // Deal with ETI
     template<>
     struct operator_arrow_dispatch<int, int>
@@ -406,9 +406,9 @@
         template <class I1, class I2>
         struct apply
           :
-# ifdef BOOST_NO_ONE_WAY_ITERATOR_INTEROP
+# ifdef NDNBOOST_NO_ONE_WAY_ITERATOR_INTEROP
           iterator_difference<I1>
-# elif BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+# elif NDNBOOST_WORKAROUND(NDNBOOST_MSVC, < 1300)
           mpl::if_<
               is_convertible<I2,I1>
             , typename I1::difference_type
@@ -428,8 +428,8 @@
 
 
   // Macros which describe the declarations of binary operators
-# ifdef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
-#  define BOOST_ITERATOR_FACADE_INTEROP_HEAD(prefix, op, result_type)       \
+# ifdef NDNBOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
+#  define NDNBOOST_ITERATOR_FACADE_INTEROP_HEAD(prefix, op, result_type)       \
     template <                                                              \
         class Derived1, class V1, class TC1, class Reference1, class Difference1 \
       , class Derived2, class V2, class TC2, class Reference2, class Difference2 \
@@ -439,7 +439,7 @@
         iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs   \
       , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs)
 # else 
-#  define BOOST_ITERATOR_FACADE_INTEROP_HEAD(prefix, op, result_type)   \
+#  define NDNBOOST_ITERATOR_FACADE_INTEROP_HEAD(prefix, op, result_type)   \
     template <                                                          \
         class Derived1, class V1, class TC1, class Reference1, class Difference1 \
       , class Derived2, class V2, class TC2, class Reference2, class Difference2 \
@@ -453,7 +453,7 @@
       , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs)
 # endif 
 
-#  define BOOST_ITERATOR_FACADE_PLUS_HEAD(prefix,args)              \
+#  define NDNBOOST_ITERATOR_FACADE_PLUS_HEAD(prefix,args)              \
     template <class Derived, class V, class TC, class R, class D>   \
     prefix Derived operator+ args
 
@@ -468,7 +468,7 @@
   //
   class iterator_core_access
   {
-# if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)                  
+# if defined(NDNBOOST_NO_MEMBER_TEMPLATE_FRIENDS)                  
       // Tasteless as this may seem, making all members public allows member templates
       // to work in the absence of member template friends.
    public:
@@ -476,30 +476,30 @@
       
       template <class I, class V, class TC, class R, class D> friend class iterator_facade;
 
-#  define BOOST_ITERATOR_FACADE_RELATION(op)                                \
-      BOOST_ITERATOR_FACADE_INTEROP_HEAD(friend,op, ndnboost::detail::always_bool2);
+#  define NDNBOOST_ITERATOR_FACADE_RELATION(op)                                \
+      NDNBOOST_ITERATOR_FACADE_INTEROP_HEAD(friend,op, ndnboost::detail::always_bool2);
 
-      BOOST_ITERATOR_FACADE_RELATION(==)
-      BOOST_ITERATOR_FACADE_RELATION(!=)
+      NDNBOOST_ITERATOR_FACADE_RELATION(==)
+      NDNBOOST_ITERATOR_FACADE_RELATION(!=)
 
-      BOOST_ITERATOR_FACADE_RELATION(<)
-      BOOST_ITERATOR_FACADE_RELATION(>)
-      BOOST_ITERATOR_FACADE_RELATION(<=)
-      BOOST_ITERATOR_FACADE_RELATION(>=)
-#  undef BOOST_ITERATOR_FACADE_RELATION
+      NDNBOOST_ITERATOR_FACADE_RELATION(<)
+      NDNBOOST_ITERATOR_FACADE_RELATION(>)
+      NDNBOOST_ITERATOR_FACADE_RELATION(<=)
+      NDNBOOST_ITERATOR_FACADE_RELATION(>=)
+#  undef NDNBOOST_ITERATOR_FACADE_RELATION
 
-      BOOST_ITERATOR_FACADE_INTEROP_HEAD(
+      NDNBOOST_ITERATOR_FACADE_INTEROP_HEAD(
           friend, -, ndnboost::detail::choose_difference_type)
       ;
 
-      BOOST_ITERATOR_FACADE_PLUS_HEAD(
+      NDNBOOST_ITERATOR_FACADE_PLUS_HEAD(
           friend inline
           , (iterator_facade<Derived, V, TC, R, D> const&
            , typename Derived::difference_type)
       )
       ;
 
-      BOOST_ITERATOR_FACADE_PLUS_HEAD(
+      NDNBOOST_ITERATOR_FACADE_PLUS_HEAD(
           friend inline
         , (typename Derived::difference_type
            , iterator_facade<Derived, V, TC, R, D> const&)
@@ -590,11 +590,11 @@
     , class Difference  = std::ptrdiff_t
   >
   class iterator_facade
-# ifdef BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE
+# ifdef NDNBOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE
     : public ndnboost::detail::iterator_facade_types<
          Value, CategoryOrTraversal, Reference, Difference
       >::base
-#  undef BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE
+#  undef NDNBOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE
 # endif
   {
    private:
@@ -661,7 +661,7 @@
           return this->derived();
       }
 
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+# if NDNBOOST_WORKAROUND(NDNBOOST_MSVC, < 1300)
       typename ndnboost::detail::postfix_increment_result<Derived,Value,Reference,CategoryOrTraversal>::type
       operator++(int)
       {
@@ -703,7 +703,7 @@
           return result -= x;
       }
 
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+# if NDNBOOST_WORKAROUND(NDNBOOST_MSVC, < 1300)
       // There appears to be a bug which trashes the data of classes
       // derived from iterator_facade when they are assigned unless we
       // define this assignment operator.  This bug is only revealed
@@ -716,7 +716,7 @@
 # endif
   };
 
-# if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+# if !NDNBOOST_WORKAROUND(NDNBOOST_MSVC, < 1300)
   template <class I, class V, class TC, class R, class D>
   inline typename ndnboost::detail::postfix_increment_result<I,V,R,TC>::type
   operator++(
@@ -748,7 +748,7 @@
   // that do not provide them. (Actually it's even worse, they do not provide
   // them for only a few iterators.)
   //
-  // ?? Maybe a BOOST_ITERATOR_NO_FULL_INTEROPERABILITY macro should
+  // ?? Maybe a NDNBOOST_ITERATOR_NO_FULL_INTEROPERABILITY macro should
   //    enable the user to turn off mixed type operators
   //
   // The library takes care to provide only the right operator overloads.
@@ -801,74 +801,74 @@
   // ----------------
   //
 
-# ifdef BOOST_NO_ONE_WAY_ITERATOR_INTEROP
-#  define BOOST_ITERATOR_CONVERTIBLE(a,b) mpl::true_()
+# ifdef NDNBOOST_NO_ONE_WAY_ITERATOR_INTEROP
+#  define NDNBOOST_ITERATOR_CONVERTIBLE(a,b) mpl::true_()
 # else
-#  define BOOST_ITERATOR_CONVERTIBLE(a,b) is_convertible<a,b>()
+#  define NDNBOOST_ITERATOR_CONVERTIBLE(a,b) is_convertible<a,b>()
 # endif
 
-# define BOOST_ITERATOR_FACADE_INTEROP(op, result_type, return_prefix, base_op) \
-  BOOST_ITERATOR_FACADE_INTEROP_HEAD(inline, op, result_type)                   \
+# define NDNBOOST_ITERATOR_FACADE_INTEROP(op, result_type, return_prefix, base_op) \
+  NDNBOOST_ITERATOR_FACADE_INTEROP_HEAD(inline, op, result_type)                   \
   {                                                                             \
       /* For those compilers that do not support enable_if */                   \
-      BOOST_STATIC_ASSERT((                                                     \
+      NDNBOOST_STATIC_ASSERT((                                                     \
           is_interoperable< Derived1, Derived2 >::value                         \
       ));                                                                       \
       return_prefix iterator_core_access::base_op(                              \
           *static_cast<Derived1 const*>(&lhs)                                   \
         , *static_cast<Derived2 const*>(&rhs)                                   \
-        , BOOST_ITERATOR_CONVERTIBLE(Derived2,Derived1)                         \
+        , NDNBOOST_ITERATOR_CONVERTIBLE(Derived2,Derived1)                         \
       );                                                                        \
   }
 
-# define BOOST_ITERATOR_FACADE_RELATION(op, return_prefix, base_op) \
-  BOOST_ITERATOR_FACADE_INTEROP(                                    \
+# define NDNBOOST_ITERATOR_FACADE_RELATION(op, return_prefix, base_op) \
+  NDNBOOST_ITERATOR_FACADE_INTEROP(                                    \
       op                                                            \
     , ndnboost::detail::always_bool2                                   \
     , return_prefix                                                 \
     , base_op                                                       \
   )
 
-  BOOST_ITERATOR_FACADE_RELATION(==, return, equal)
-  BOOST_ITERATOR_FACADE_RELATION(!=, return !, equal)
+  NDNBOOST_ITERATOR_FACADE_RELATION(==, return, equal)
+  NDNBOOST_ITERATOR_FACADE_RELATION(!=, return !, equal)
 
-  BOOST_ITERATOR_FACADE_RELATION(<, return 0 >, distance_from)
-  BOOST_ITERATOR_FACADE_RELATION(>, return 0 <, distance_from)
-  BOOST_ITERATOR_FACADE_RELATION(<=, return 0 >=, distance_from)
-  BOOST_ITERATOR_FACADE_RELATION(>=, return 0 <=, distance_from)
-# undef BOOST_ITERATOR_FACADE_RELATION
+  NDNBOOST_ITERATOR_FACADE_RELATION(<, return 0 >, distance_from)
+  NDNBOOST_ITERATOR_FACADE_RELATION(>, return 0 <, distance_from)
+  NDNBOOST_ITERATOR_FACADE_RELATION(<=, return 0 >=, distance_from)
+  NDNBOOST_ITERATOR_FACADE_RELATION(>=, return 0 <=, distance_from)
+# undef NDNBOOST_ITERATOR_FACADE_RELATION
 
   // operator- requires an additional part in the static assertion
-  BOOST_ITERATOR_FACADE_INTEROP(
+  NDNBOOST_ITERATOR_FACADE_INTEROP(
       -
     , ndnboost::detail::choose_difference_type
     , return
     , distance_from
   )
-# undef BOOST_ITERATOR_FACADE_INTEROP
-# undef BOOST_ITERATOR_FACADE_INTEROP_HEAD
+# undef NDNBOOST_ITERATOR_FACADE_INTEROP
+# undef NDNBOOST_ITERATOR_FACADE_INTEROP_HEAD
 
-# define BOOST_ITERATOR_FACADE_PLUS(args)           \
-  BOOST_ITERATOR_FACADE_PLUS_HEAD(inline, args)     \
+# define NDNBOOST_ITERATOR_FACADE_PLUS(args)           \
+  NDNBOOST_ITERATOR_FACADE_PLUS_HEAD(inline, args)     \
   {                                                 \
       Derived tmp(static_cast<Derived const&>(i));  \
       return tmp += n;                              \
   }
 
-BOOST_ITERATOR_FACADE_PLUS((
+NDNBOOST_ITERATOR_FACADE_PLUS((
   iterator_facade<Derived, V, TC, R, D> const& i
   , typename Derived::difference_type n
 ))
 
-BOOST_ITERATOR_FACADE_PLUS((
+NDNBOOST_ITERATOR_FACADE_PLUS((
     typename Derived::difference_type n
     , iterator_facade<Derived, V, TC, R, D> const& i
 ))
-# undef BOOST_ITERATOR_FACADE_PLUS
-# undef BOOST_ITERATOR_FACADE_PLUS_HEAD
+# undef NDNBOOST_ITERATOR_FACADE_PLUS
+# undef NDNBOOST_ITERATOR_FACADE_PLUS_HEAD
 
 } // namespace ndnboost
 
 #include <ndnboost/iterator/detail/config_undef.hpp>
 
-#endif // BOOST_ITERATOR_FACADE_23022003THW_HPP
+#endif // NDNBOOST_ITERATOR_FACADE_23022003THW_HPP
diff --git a/include/ndnboost/iterator/iterator_traits.hpp b/include/ndnboost/iterator/iterator_traits.hpp
index 78565d3..39735b3 100644
--- a/include/ndnboost/iterator/iterator_traits.hpp
+++ b/include/ndnboost/iterator/iterator_traits.hpp
@@ -14,13 +14,13 @@
 // iterator_category which has the same name as its
 // std::iterator_category() function, probably due in part to the
 // "std:: is visible globally" hack it uses.  Use
-// BOOST_ITERATOR_CATEGORY to write code that's portable to older
+// NDNBOOST_ITERATOR_CATEGORY to write code that's portable to older
 // GCCs.
 
-# if BOOST_WORKAROUND(__GNUC__, <= 2)
-#  define BOOST_ITERATOR_CATEGORY iterator_category_
+# if NDNBOOST_WORKAROUND(__GNUC__, <= 2)
+#  define NDNBOOST_ITERATOR_CATEGORY iterator_category_
 # else
-#  define BOOST_ITERATOR_CATEGORY iterator_category
+#  define NDNBOOST_ITERATOR_CATEGORY iterator_category
 # endif
 
 
@@ -50,12 +50,12 @@
 };
 
 template <class Iterator>
-struct BOOST_ITERATOR_CATEGORY
+struct NDNBOOST_ITERATOR_CATEGORY
 {
     typedef typename ndnboost::detail::iterator_traits<Iterator>::iterator_category type;
 };
 
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+# if NDNBOOST_WORKAROUND(NDNBOOST_MSVC, < 1300)
 template <>
 struct iterator_value<int>
 {
@@ -81,7 +81,7 @@
 };
   
 template <>
-struct BOOST_ITERATOR_CATEGORY<int>
+struct NDNBOOST_ITERATOR_CATEGORY<int>
 {
     typedef void type;
 };
diff --git a/include/ndnboost/iterator/reverse_iterator.hpp b/include/ndnboost/iterator/reverse_iterator.hpp
index 924112f..c9b765d 100644
--- a/include/ndnboost/iterator/reverse_iterator.hpp
+++ b/include/ndnboost/iterator/reverse_iterator.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_REVERSE_ITERATOR_23022003THW_HPP
-#define BOOST_REVERSE_ITERATOR_23022003THW_HPP
+#ifndef NDNBOOST_REVERSE_ITERATOR_23022003THW_HPP
+#define NDNBOOST_REVERSE_ITERATOR_23022003THW_HPP
 
 #include <ndnboost/next_prior.hpp>
 #include <ndnboost/iterator.hpp>
@@ -66,4 +66,4 @@
 
 } // namespace ndnboost
 
-#endif // BOOST_REVERSE_ITERATOR_23022003THW_HPP
+#endif // NDNBOOST_REVERSE_ITERATOR_23022003THW_HPP