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