diff --git a/include/ndnboost/range/algorithm/equal.hpp b/include/ndnboost/range/algorithm/equal.hpp
index 27b741d..7091035 100644
--- a/include/ndnboost/range/algorithm/equal.hpp
+++ b/include/ndnboost/range/algorithm/equal.hpp
@@ -7,8 +7,8 @@
 //
 // For more information, see http://www.boost.org/libs/range/
 //
-#ifndef BOOST_RANGE_ALGORITHM_EQUAL_HPP_INCLUDED
-#define BOOST_RANGE_ALGORITHM_EQUAL_HPP_INCLUDED
+#ifndef NDNBOOST_RANGE_ALGORITHM_EQUAL_HPP_INCLUDED
+#define NDNBOOST_RANGE_ALGORITHM_EQUAL_HPP_INCLUDED
 
 #include <ndnboost/config.hpp>
 #include <ndnboost/range/concepts.hpp>
@@ -133,8 +133,8 @@
                            SinglePassTraversalReadableIterator2 first2,
                            SinglePassTraversalReadableIterator2 last2 )
         {
-            BOOST_DEDUCED_TYPENAME std::iterator_traits< SinglePassTraversalReadableIterator1 >::iterator_category tag1;
-            BOOST_DEDUCED_TYPENAME std::iterator_traits< SinglePassTraversalReadableIterator2 >::iterator_category tag2;
+            NDNBOOST_DEDUCED_TYPENAME std::iterator_traits< SinglePassTraversalReadableIterator1 >::iterator_category tag1;
+            NDNBOOST_DEDUCED_TYPENAME std::iterator_traits< SinglePassTraversalReadableIterator2 >::iterator_category tag2;
 
             return equal_impl(first1, last1, first2, last2, tag1, tag2);
         }
@@ -148,8 +148,8 @@
                            SinglePassTraversalReadableIterator2 last2,
                            BinaryPredicate                      pred )
         {
-            BOOST_DEDUCED_TYPENAME std::iterator_traits< SinglePassTraversalReadableIterator1 >::iterator_category tag1;
-            BOOST_DEDUCED_TYPENAME std::iterator_traits< SinglePassTraversalReadableIterator2 >::iterator_category tag2;
+            NDNBOOST_DEDUCED_TYPENAME std::iterator_traits< SinglePassTraversalReadableIterator1 >::iterator_category tag1;
+            NDNBOOST_DEDUCED_TYPENAME std::iterator_traits< SinglePassTraversalReadableIterator2 >::iterator_category tag2;
 
             return equal_impl(first1, last1, first2, last2, pred, tag1, tag2);
         }
@@ -169,8 +169,8 @@
         template< class SinglePassRange1, class SinglePassRange2 >
         inline bool equal( const SinglePassRange1& rng1, const SinglePassRange2& rng2 )
         {
-            BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
-            BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+            NDNBOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+            NDNBOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
 
             return ::ndnboost::range_detail::equal(
                 ::ndnboost::begin(rng1), ::ndnboost::end(rng1),
@@ -182,8 +182,8 @@
         inline bool equal( const SinglePassRange1& rng1, const SinglePassRange2& rng2,
                            BinaryPredicate pred )
         {
-            BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
-            BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+            NDNBOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+            NDNBOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
 
             return ::ndnboost::range_detail::equal(
                 ::ndnboost::begin(rng1), ::ndnboost::end(rng1),
diff --git a/include/ndnboost/range/as_literal.hpp b/include/ndnboost/range/as_literal.hpp
index 82babd8..997ed2e 100644
--- a/include/ndnboost/range/as_literal.hpp
+++ b/include/ndnboost/range/as_literal.hpp
@@ -8,14 +8,14 @@
 // For more information, see http://www.boost.org/libs/range/
 //
 
-#ifndef BOOST_RANGE_AS_LITERAL_HPP
-#define BOOST_RANGE_AS_LITERAL_HPP
+#ifndef NDNBOOST_RANGE_AS_LITERAL_HPP
+#define NDNBOOST_RANGE_AS_LITERAL_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif
 
-#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+#ifdef NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING
 #include <ndnboost/range/detail/as_literal.hpp>
 #else
 
@@ -25,7 +25,7 @@
 #include <ndnboost/detail/workaround.hpp>
 
 #include <cstring>
-#ifndef BOOST_NO_CWCHAR
+#ifndef NDNBOOST_NO_CWCHAR
 #include <cwchar>
 #endif
 
@@ -38,7 +38,7 @@
             return strlen( s );
         }
 
-#ifndef BOOST_NO_CWCHAR
+#ifndef NDNBOOST_NO_CWCHAR
         inline std::size_t length( const wchar_t* s )
         {
             return wcslen( s );
@@ -61,7 +61,7 @@
             return true;
         }
 
-#ifndef BOOST_NO_CWCHAR
+#ifndef NDNBOOST_NO_CWCHAR
         inline bool is_char_ptr( wchar_t* )
         {
             return true;
@@ -87,7 +87,7 @@
         }
 
         template< class T >
-        inline iterator_range<BOOST_DEDUCED_TYPENAME range_iterator<T>::type>
+        inline iterator_range<NDNBOOST_DEDUCED_TYPENAME range_iterator<T>::type>
         make_range( T& r, long )
         {
             return ndnboost::make_iterator_range( r );
@@ -96,14 +96,14 @@
     }
 
     template< class Range >
-    inline iterator_range<BOOST_DEDUCED_TYPENAME range_iterator<Range>::type>
+    inline iterator_range<NDNBOOST_DEDUCED_TYPENAME range_iterator<Range>::type>
     as_literal( Range& r )
     {
         return range_detail::make_range( r, range_detail::is_char_ptr(r) );
     }
 
     template< class Range >
-    inline iterator_range<BOOST_DEDUCED_TYPENAME range_iterator<const Range>::type>
+    inline iterator_range<NDNBOOST_DEDUCED_TYPENAME range_iterator<const Range>::type>
     as_literal( const Range& r )
     {
         return range_detail::make_range( r, range_detail::is_char_ptr(r) );
@@ -122,6 +122,6 @@
     }
 }
 
-#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+#endif // NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING
 
 #endif
diff --git a/include/ndnboost/range/begin.hpp b/include/ndnboost/range/begin.hpp
index 0143261..5001f35 100644
--- a/include/ndnboost/range/begin.hpp
+++ b/include/ndnboost/range/begin.hpp
@@ -8,8 +8,8 @@
 // For more information, see http://www.boost.org/libs/range/
 //
 
-#ifndef BOOST_RANGE_BEGIN_HPP
-#define BOOST_RANGE_BEGIN_HPP
+#ifndef NDNBOOST_RANGE_BEGIN_HPP
+#define NDNBOOST_RANGE_BEGIN_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
@@ -17,7 +17,7 @@
 
 #include <ndnboost/range/config.hpp>
 
-#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+#ifdef NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING
 #include <ndnboost/range/detail/begin.hpp>
 #else
 
@@ -26,8 +26,8 @@
 namespace ndnboost
 {
 
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
-    !BOOST_WORKAROUND(__GNUC__, < 3) \
+#if !NDNBOOST_WORKAROUND(__BORLANDC__, NDNBOOST_TESTED_AT(0x564)) && \
+    !NDNBOOST_WORKAROUND(__GNUC__, < 3) \
     /**/
 namespace range_detail
 {
@@ -38,7 +38,7 @@
     //////////////////////////////////////////////////////////////////////
 
     template< typename C >
-    inline BOOST_DEDUCED_TYPENAME range_iterator<C>::type
+    inline NDNBOOST_DEDUCED_TYPENAME range_iterator<C>::type
     range_begin( C& c )
     {
         //
@@ -85,8 +85,8 @@
     }
 
 
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
-    !BOOST_WORKAROUND(__GNUC__, < 3) \
+#if !NDNBOOST_WORKAROUND(__BORLANDC__, NDNBOOST_TESTED_AT(0x564)) && \
+    !NDNBOOST_WORKAROUND(__GNUC__, < 3) \
     /**/
 } // namespace 'range_detail'
 #endif
@@ -98,10 +98,10 @@
 {
 
 template< class T >
-inline BOOST_DEDUCED_TYPENAME range_iterator<T>::type begin( T& r )
+inline NDNBOOST_DEDUCED_TYPENAME range_iterator<T>::type begin( T& r )
 {
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
-    !BOOST_WORKAROUND(__GNUC__, < 3) \
+#if !NDNBOOST_WORKAROUND(__BORLANDC__, NDNBOOST_TESTED_AT(0x564)) && \
+    !NDNBOOST_WORKAROUND(__GNUC__, < 3) \
     /**/
     using namespace range_detail;
 #endif
@@ -109,10 +109,10 @@
 }
 
 template< class T >
-inline BOOST_DEDUCED_TYPENAME range_iterator<const T>::type begin( const T& r )
+inline NDNBOOST_DEDUCED_TYPENAME range_iterator<const T>::type begin( const T& r )
 {
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
-    !BOOST_WORKAROUND(__GNUC__, < 3) \
+#if !NDNBOOST_WORKAROUND(__BORLANDC__, NDNBOOST_TESTED_AT(0x564)) && \
+    !NDNBOOST_WORKAROUND(__GNUC__, < 3) \
     /**/
     using namespace range_detail;
 #endif
@@ -122,14 +122,14 @@
     } // namespace range_adl_barrier
 } // namespace ndnboost
 
-#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+#endif // NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING
 
 namespace ndnboost
 {
     namespace range_adl_barrier
     {
         template< class T >
-        inline BOOST_DEDUCED_TYPENAME range_iterator<const T>::type
+        inline NDNBOOST_DEDUCED_TYPENAME range_iterator<const T>::type
         const_begin( const T& r )
         {
             return ndnboost::range_adl_barrier::begin( r );
diff --git a/include/ndnboost/range/concepts.hpp b/include/ndnboost/range/concepts.hpp
index a8d4790..c990c16 100644
--- a/include/ndnboost/range/concepts.hpp
+++ b/include/ndnboost/range/concepts.hpp
@@ -13,8 +13,8 @@
 // For more information, see http://www.boost.org/libs/range/
 //
 
-#ifndef BOOST_RANGE_CONCEPTS_HPP
-#define BOOST_RANGE_CONCEPTS_HPP
+#ifndef NDNBOOST_RANGE_CONCEPTS_HPP
+#define NDNBOOST_RANGE_CONCEPTS_HPP
 
 #include <ndnboost/concept_check.hpp>
 #include <ndnboost/iterator/iterator_concepts.hpp>
@@ -37,7 +37,7 @@
  * concept.
  *
  * \code
- * BOOST_CONCEPT_ASSERT((ForwardRangeConcept<T>));
+ * NDNBOOST_CONCEPT_ASSERT((ForwardRangeConcept<T>));
  * \endcode
  *
  * A different concept check is required to ensure writeable value
@@ -45,7 +45,7 @@
  * to, the following code is required.
  *
  * \code
- * BOOST_CONCEPT_ASSERT((WriteableForwardRangeConcept<T>));
+ * NDNBOOST_CONCEPT_ASSERT((WriteableForwardRangeConcept<T>));
  * \endcode
  *
  * \see http://www.boost.org/libs/range/doc/range.html for details
@@ -60,7 +60,7 @@
 
     namespace range_detail {
 
-#ifndef BOOST_RANGE_ENABLE_CONCEPT_ASSERT
+#ifndef NDNBOOST_RANGE_ENABLE_CONCEPT_ASSERT
 
 // List broken compiler versions here:
     #ifdef __GNUC__
@@ -68,30 +68,30 @@
         // hence the least disruptive approach is to turn-off the concept checking for
         // this version of the compiler.
         #if __GNUC__ == 4 && __GNUC_MINOR__ == 2
-            #define BOOST_RANGE_ENABLE_CONCEPT_ASSERT 0
+            #define NDNBOOST_RANGE_ENABLE_CONCEPT_ASSERT 0
         #endif
     #endif
 
     #ifdef __BORLANDC__
-        #define BOOST_RANGE_ENABLE_CONCEPT_ASSERT 0
+        #define NDNBOOST_RANGE_ENABLE_CONCEPT_ASSERT 0
     #endif
 
     #ifdef __PATHCC__
-        #define BOOST_RANGE_ENABLE_CONCEPT_ASSERT 0
+        #define NDNBOOST_RANGE_ENABLE_CONCEPT_ASSERT 0
     #endif
 
 // Default to using the concept asserts unless we have defined it off
 // during the search for black listed compilers.
-    #ifndef BOOST_RANGE_ENABLE_CONCEPT_ASSERT
-        #define BOOST_RANGE_ENABLE_CONCEPT_ASSERT 1
+    #ifndef NDNBOOST_RANGE_ENABLE_CONCEPT_ASSERT
+        #define NDNBOOST_RANGE_ENABLE_CONCEPT_ASSERT 1
     #endif
 
 #endif
 
-#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
-    #define BOOST_RANGE_CONCEPT_ASSERT( x ) BOOST_CONCEPT_ASSERT( x )
+#if NDNBOOST_RANGE_ENABLE_CONCEPT_ASSERT
+    #define NDNBOOST_RANGE_CONCEPT_ASSERT( x ) NDNBOOST_CONCEPT_ASSERT( x )
 #else
-    #define BOOST_RANGE_CONCEPT_ASSERT( x )
+    #define NDNBOOST_RANGE_CONCEPT_ASSERT( x )
 #endif
 
         // Rationale for the inclusion of redefined iterator concept
@@ -112,16 +112,16 @@
         template<class Iterator>
         struct IncrementableIteratorConcept : CopyConstructible<Iterator>
         {
-#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
-            typedef BOOST_DEDUCED_TYPENAME iterator_traversal<Iterator>::type traversal_category;
+#if NDNBOOST_RANGE_ENABLE_CONCEPT_ASSERT
+            typedef NDNBOOST_DEDUCED_TYPENAME iterator_traversal<Iterator>::type traversal_category;
 
-            BOOST_RANGE_CONCEPT_ASSERT((
+            NDNBOOST_RANGE_CONCEPT_ASSERT((
                 Convertible<
                     traversal_category,
                     incrementable_traversal_tag
                 >));
 
-            BOOST_CONCEPT_USAGE(IncrementableIteratorConcept)
+            NDNBOOST_CONCEPT_USAGE(IncrementableIteratorConcept)
             {
                 ++i;
                 (void)i++;
@@ -136,14 +136,14 @@
             : IncrementableIteratorConcept<Iterator>
             , EqualityComparable<Iterator>
         {
-#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
-            BOOST_RANGE_CONCEPT_ASSERT((
+#if NDNBOOST_RANGE_ENABLE_CONCEPT_ASSERT
+            NDNBOOST_RANGE_CONCEPT_ASSERT((
                 Convertible<
-                    BOOST_DEDUCED_TYPENAME SinglePassIteratorConcept::traversal_category,
+                    NDNBOOST_DEDUCED_TYPENAME SinglePassIteratorConcept::traversal_category,
                     single_pass_traversal_tag
                 >));
 
-            BOOST_CONCEPT_USAGE(SinglePassIteratorConcept)
+            NDNBOOST_CONCEPT_USAGE(SinglePassIteratorConcept)
             {
                 Iterator i2(++i);
                 ndnboost::ignore_unused_variable_warning(i2);
@@ -154,10 +154,10 @@
                 // work
                 (void)(i++);
 
-                BOOST_DEDUCED_TYPENAME ndnboost::detail::iterator_traits<Iterator>::reference r1(*i);
+                NDNBOOST_DEDUCED_TYPENAME ndnboost::detail::iterator_traits<Iterator>::reference r1(*i);
                 ndnboost::ignore_unused_variable_warning(r1);
 
-                BOOST_DEDUCED_TYPENAME ndnboost::detail::iterator_traits<Iterator>::reference r2(*(++i));
+                NDNBOOST_DEDUCED_TYPENAME ndnboost::detail::iterator_traits<Iterator>::reference r2(*(++i));
                 ndnboost::ignore_unused_variable_warning(r2);
             }
         private:
@@ -170,19 +170,19 @@
             : SinglePassIteratorConcept<Iterator>
             , DefaultConstructible<Iterator>
         {
-#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
-            typedef BOOST_DEDUCED_TYPENAME ndnboost::detail::iterator_traits<Iterator>::difference_type difference_type;
+#if NDNBOOST_RANGE_ENABLE_CONCEPT_ASSERT
+            typedef NDNBOOST_DEDUCED_TYPENAME ndnboost::detail::iterator_traits<Iterator>::difference_type difference_type;
 
-            BOOST_MPL_ASSERT((is_integral<difference_type>));
-            BOOST_MPL_ASSERT_RELATION(std::numeric_limits<difference_type>::is_signed, ==, true);
+            NDNBOOST_MPL_ASSERT((is_integral<difference_type>));
+            NDNBOOST_MPL_ASSERT_RELATION(std::numeric_limits<difference_type>::is_signed, ==, true);
 
-            BOOST_RANGE_CONCEPT_ASSERT((
+            NDNBOOST_RANGE_CONCEPT_ASSERT((
                 Convertible<
-                    BOOST_DEDUCED_TYPENAME ForwardIteratorConcept::traversal_category,
+                    NDNBOOST_DEDUCED_TYPENAME ForwardIteratorConcept::traversal_category,
                     forward_traversal_tag
                 >));
 
-            BOOST_CONCEPT_USAGE(ForwardIteratorConcept)
+            NDNBOOST_CONCEPT_USAGE(ForwardIteratorConcept)
             {
                 // See the above note in the SinglePassIteratorConcept about the handling of the
                 // postfix increment. Since with forward and better iterators there is no need
@@ -190,7 +190,7 @@
                 // is convertible to reference.
                 Iterator i2(i++);
                 ndnboost::ignore_unused_variable_warning(i2);
-                BOOST_DEDUCED_TYPENAME ndnboost::detail::iterator_traits<Iterator>::reference r(*(i++));
+                NDNBOOST_DEDUCED_TYPENAME ndnboost::detail::iterator_traits<Iterator>::reference r(*(i++));
                 ndnboost::ignore_unused_variable_warning(r);
             }
         private:
@@ -202,14 +202,14 @@
          struct BidirectionalIteratorConcept
              : ForwardIteratorConcept<Iterator>
          {
- #if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
-             BOOST_RANGE_CONCEPT_ASSERT((
+ #if NDNBOOST_RANGE_ENABLE_CONCEPT_ASSERT
+             NDNBOOST_RANGE_CONCEPT_ASSERT((
                  Convertible<
-                     BOOST_DEDUCED_TYPENAME BidirectionalIteratorConcept::traversal_category,
+                     NDNBOOST_DEDUCED_TYPENAME BidirectionalIteratorConcept::traversal_category,
                      bidirectional_traversal_tag
                  >));
 
-             BOOST_CONCEPT_USAGE(BidirectionalIteratorConcept)
+             NDNBOOST_CONCEPT_USAGE(BidirectionalIteratorConcept)
              {
                  --i;
                  (void)i--;
@@ -223,14 +223,14 @@
          struct RandomAccessIteratorConcept
              : BidirectionalIteratorConcept<Iterator>
          {
- #if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
-             BOOST_RANGE_CONCEPT_ASSERT((
+ #if NDNBOOST_RANGE_ENABLE_CONCEPT_ASSERT
+             NDNBOOST_RANGE_CONCEPT_ASSERT((
                  Convertible<
-                     BOOST_DEDUCED_TYPENAME RandomAccessIteratorConcept::traversal_category,
+                     NDNBOOST_DEDUCED_TYPENAME RandomAccessIteratorConcept::traversal_category,
                      random_access_traversal_tag
                  >));
 
-             BOOST_CONCEPT_USAGE(RandomAccessIteratorConcept)
+             NDNBOOST_CONCEPT_USAGE(RandomAccessIteratorConcept)
              {
                  i += n;
                  i = i + n;
@@ -240,7 +240,7 @@
                  n = i - j;
              }
          private:
-             BOOST_DEDUCED_TYPENAME RandomAccessIteratorConcept::difference_type n;
+             NDNBOOST_DEDUCED_TYPENAME RandomAccessIteratorConcept::difference_type n;
              Iterator i;
              Iterator j;
  #endif
@@ -252,14 +252,14 @@
     template<class T>
     struct SinglePassRangeConcept
     {
-#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
-         typedef BOOST_DEDUCED_TYPENAME range_iterator<T const>::type  const_iterator;
-         typedef BOOST_DEDUCED_TYPENAME range_iterator<T>::type        iterator;
+#if NDNBOOST_RANGE_ENABLE_CONCEPT_ASSERT
+         typedef NDNBOOST_DEDUCED_TYPENAME range_iterator<T const>::type  const_iterator;
+         typedef NDNBOOST_DEDUCED_TYPENAME range_iterator<T>::type        iterator;
 
-         BOOST_RANGE_CONCEPT_ASSERT((range_detail::SinglePassIteratorConcept<iterator>));
-         BOOST_RANGE_CONCEPT_ASSERT((range_detail::SinglePassIteratorConcept<const_iterator>));
+         NDNBOOST_RANGE_CONCEPT_ASSERT((range_detail::SinglePassIteratorConcept<iterator>));
+         NDNBOOST_RANGE_CONCEPT_ASSERT((range_detail::SinglePassIteratorConcept<const_iterator>));
 
-         BOOST_CONCEPT_USAGE(SinglePassRangeConcept)
+         NDNBOOST_CONCEPT_USAGE(SinglePassRangeConcept)
          {
             // This has been modified from assigning to this->i
             // (where i was a member variable) to improve
@@ -295,25 +295,25 @@
     template<class T>
     struct ForwardRangeConcept : SinglePassRangeConcept<T>
     {
-#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
-        BOOST_RANGE_CONCEPT_ASSERT((range_detail::ForwardIteratorConcept<BOOST_DEDUCED_TYPENAME ForwardRangeConcept::iterator>));
-        BOOST_RANGE_CONCEPT_ASSERT((range_detail::ForwardIteratorConcept<BOOST_DEDUCED_TYPENAME ForwardRangeConcept::const_iterator>));
+#if NDNBOOST_RANGE_ENABLE_CONCEPT_ASSERT
+        NDNBOOST_RANGE_CONCEPT_ASSERT((range_detail::ForwardIteratorConcept<NDNBOOST_DEDUCED_TYPENAME ForwardRangeConcept::iterator>));
+        NDNBOOST_RANGE_CONCEPT_ASSERT((range_detail::ForwardIteratorConcept<NDNBOOST_DEDUCED_TYPENAME ForwardRangeConcept::const_iterator>));
 #endif
     };
 
     template<class Range>
     struct WriteableRangeConcept
     {
-#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
-        typedef BOOST_DEDUCED_TYPENAME range_iterator<Range>::type iterator;
+#if NDNBOOST_RANGE_ENABLE_CONCEPT_ASSERT
+        typedef NDNBOOST_DEDUCED_TYPENAME range_iterator<Range>::type iterator;
 
-        BOOST_CONCEPT_USAGE(WriteableRangeConcept)
+        NDNBOOST_CONCEPT_USAGE(WriteableRangeConcept)
         {
             *i = v;
         }
     private:
         iterator i;
-        BOOST_DEDUCED_TYPENAME range_value<Range>::type v;
+        NDNBOOST_DEDUCED_TYPENAME range_value<Range>::type v;
 #endif
     };
 
@@ -329,9 +329,9 @@
     template<class T>
     struct BidirectionalRangeConcept : ForwardRangeConcept<T>
     {
-#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
-        BOOST_RANGE_CONCEPT_ASSERT((range_detail::BidirectionalIteratorConcept<BOOST_DEDUCED_TYPENAME BidirectionalRangeConcept::iterator>));
-        BOOST_RANGE_CONCEPT_ASSERT((range_detail::BidirectionalIteratorConcept<BOOST_DEDUCED_TYPENAME BidirectionalRangeConcept::const_iterator>));
+#if NDNBOOST_RANGE_ENABLE_CONCEPT_ASSERT
+        NDNBOOST_RANGE_CONCEPT_ASSERT((range_detail::BidirectionalIteratorConcept<NDNBOOST_DEDUCED_TYPENAME BidirectionalRangeConcept::iterator>));
+        NDNBOOST_RANGE_CONCEPT_ASSERT((range_detail::BidirectionalIteratorConcept<NDNBOOST_DEDUCED_TYPENAME BidirectionalRangeConcept::const_iterator>));
 #endif
     };
 
@@ -347,9 +347,9 @@
     template<class T>
     struct RandomAccessRangeConcept : BidirectionalRangeConcept<T>
     {
-#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
-        BOOST_RANGE_CONCEPT_ASSERT((range_detail::RandomAccessIteratorConcept<BOOST_DEDUCED_TYPENAME RandomAccessRangeConcept::iterator>));
-        BOOST_RANGE_CONCEPT_ASSERT((range_detail::RandomAccessIteratorConcept<BOOST_DEDUCED_TYPENAME RandomAccessRangeConcept::const_iterator>));
+#if NDNBOOST_RANGE_ENABLE_CONCEPT_ASSERT
+        NDNBOOST_RANGE_CONCEPT_ASSERT((range_detail::RandomAccessIteratorConcept<NDNBOOST_DEDUCED_TYPENAME RandomAccessRangeConcept::iterator>));
+        NDNBOOST_RANGE_CONCEPT_ASSERT((range_detail::RandomAccessIteratorConcept<NDNBOOST_DEDUCED_TYPENAME RandomAccessRangeConcept::const_iterator>));
 #endif
     };
 
@@ -363,4 +363,4 @@
 
 } // namespace ndnboost
 
-#endif // BOOST_RANGE_CONCEPTS_HPP
+#endif // NDNBOOST_RANGE_CONCEPTS_HPP
diff --git a/include/ndnboost/range/config.hpp b/include/ndnboost/range/config.hpp
index 449007c..b372d6a 100644
--- a/include/ndnboost/range/config.hpp
+++ b/include/ndnboost/range/config.hpp
@@ -8,8 +8,8 @@
 // For more information, see http://www.boost.org/libs/range/
 //
 
-#ifndef BOOST_RANGE_CONFIG_HPP
-#define BOOST_RANGE_CONFIG_HPP
+#ifndef NDNBOOST_RANGE_CONFIG_HPP
+#define NDNBOOST_RANGE_CONFIG_HPP
 
 #include <ndnboost/detail/workaround.hpp>
 
@@ -19,33 +19,33 @@
 
 #include <ndnboost/config.hpp>
 
-#ifdef BOOST_RANGE_DEDUCED_TYPENAME
+#ifdef NDNBOOST_RANGE_DEDUCED_TYPENAME
 #error "macro already defined!"
 #endif
 
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-# define BOOST_RANGE_DEDUCED_TYPENAME typename
+#if NDNBOOST_WORKAROUND(__BORLANDC__, NDNBOOST_TESTED_AT(0x564))
+# define NDNBOOST_RANGE_DEDUCED_TYPENAME typename
 #else
-# if BOOST_WORKAROUND(BOOST_MSVC, == 1300) && !defined(_MSC_EXTENSIONS)
-#  define BOOST_RANGE_DEDUCED_TYPENAME typename
+# if NDNBOOST_WORKAROUND(NDNBOOST_MSVC, == 1300) && !defined(_MSC_EXTENSIONS)
+#  define NDNBOOST_RANGE_DEDUCED_TYPENAME typename
 # else
-#  define BOOST_RANGE_DEDUCED_TYPENAME BOOST_DEDUCED_TYPENAME
+#  define NDNBOOST_RANGE_DEDUCED_TYPENAME NDNBOOST_DEDUCED_TYPENAME
 # endif
 #endif
 
-#ifdef BOOST_RANGE_NO_ARRAY_SUPPORT
+#ifdef NDNBOOST_RANGE_NO_ARRAY_SUPPORT
 #error "macro already defined!"
 #endif
 
-#if BOOST_WORKAROUND( BOOST_MSVC, < 1300 ) || BOOST_WORKAROUND( __MWERKS__, <= 0x3003 )
-#define BOOST_RANGE_NO_ARRAY_SUPPORT 1
+#if NDNBOOST_WORKAROUND( NDNBOOST_MSVC, < 1300 ) || NDNBOOST_WORKAROUND( __MWERKS__, <= 0x3003 )
+#define NDNBOOST_RANGE_NO_ARRAY_SUPPORT 1
 #endif
 
-#ifdef BOOST_RANGE_NO_ARRAY_SUPPORT
-#define BOOST_RANGE_ARRAY_REF() (boost_range_array)
-#define BOOST_RANGE_NO_STATIC_ASSERT
+#ifdef NDNBOOST_RANGE_NO_ARRAY_SUPPORT
+#define NDNBOOST_RANGE_ARRAY_REF() (boost_range_array)
+#define NDNBOOST_RANGE_NO_STATIC_ASSERT
 #else
-#define BOOST_RANGE_ARRAY_REF() (&boost_range_array)
+#define NDNBOOST_RANGE_ARRAY_REF() (&boost_range_array)
 #endif
 
 
diff --git a/include/ndnboost/range/const_iterator.hpp b/include/ndnboost/range/const_iterator.hpp
index 2b78e60..61ed3e8 100644
--- a/include/ndnboost/range/const_iterator.hpp
+++ b/include/ndnboost/range/const_iterator.hpp
@@ -8,8 +8,8 @@
 // For more information, see http://www.boost.org/libs/range/
 //
 
-#ifndef BOOST_RANGE_CONST_ITERATOR_HPP
-#define BOOST_RANGE_CONST_ITERATOR_HPP
+#ifndef NDNBOOST_RANGE_CONST_ITERATOR_HPP
+#define NDNBOOST_RANGE_CONST_ITERATOR_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
@@ -17,7 +17,7 @@
 
 #include <ndnboost/range/config.hpp>
 
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#ifdef NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 #include <ndnboost/range/detail/const_iterator.hpp>
 #else
 
@@ -33,7 +33,7 @@
     //////////////////////////////////////////////////////////////////////////
     
     namespace range_detail {
-        BOOST_RANGE_EXTRACT_OPTIONAL_TYPE( const_iterator )
+        NDNBOOST_RANGE_EXTRACT_OPTIONAL_TYPE( const_iterator )
     }
 
     template< typename C >
@@ -62,6 +62,6 @@
 
 } // namespace ndnboost
 
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#endif // NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
 #endif
diff --git a/include/ndnboost/range/detail/as_literal.hpp b/include/ndnboost/range/detail/as_literal.hpp
index 94b1b6e..223ae18 100644
--- a/include/ndnboost/range/detail/as_literal.hpp
+++ b/include/ndnboost/range/detail/as_literal.hpp
@@ -8,8 +8,8 @@
 // For more information, see http://www.boost.org/libs/range/
 //
 
-#ifndef BOOST_RANGE_DETAIL_AS_LITERAL_HPP
-#define BOOST_RANGE_DETAIL_AS_LITERAL_HPP
+#ifndef NDNBOOST_RANGE_DETAIL_AS_LITERAL_HPP
+#define NDNBOOST_RANGE_DETAIL_AS_LITERAL_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
@@ -21,7 +21,7 @@
 namespace ndnboost
 {
     template< class Range >
-    inline iterator_range<BOOST_DEDUCED_TYPENAME range_iterator<Range>::type> 
+    inline iterator_range<NDNBOOST_DEDUCED_TYPENAME range_iterator<Range>::type> 
     as_literal( Range& r )
     {
         return ::ndnboost::make_iterator_range( ::ndnboost::range_detail::str_begin(r),
diff --git a/include/ndnboost/range/detail/begin.hpp b/include/ndnboost/range/detail/begin.hpp
index aea43cf..f2b5e59 100644
--- a/include/ndnboost/range/detail/begin.hpp
+++ b/include/ndnboost/range/detail/begin.hpp
@@ -8,14 +8,14 @@
 // For more information, see http://www.boost.org/libs/range/
 //
 
-#ifndef BOOST_RANGE_DETAIL_BEGIN_HPP
-#define BOOST_RANGE_DETAIL_BEGIN_HPP
+#ifndef NDNBOOST_RANGE_DETAIL_BEGIN_HPP
+#define NDNBOOST_RANGE_DETAIL_BEGIN_HPP
 
-#include <ndnboost/config.hpp> // BOOST_MSVC
+#include <ndnboost/config.hpp> // NDNBOOST_MSVC
 #include <ndnboost/detail/workaround.hpp>
 #include <ndnboost/range/iterator.hpp>
 #include <ndnboost/range/detail/common.hpp>
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1310)
+#if NDNBOOST_WORKAROUND(NDNBOOST_MSVC, < 1310)
 # include <ndnboost/range/value_type.hpp>
 #endif
 
@@ -35,7 +35,7 @@
         struct range_begin<std_container_>
         {
             template< typename C >
-            static BOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type fun( C& c )
+            static NDNBOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type fun( C& c )
             {
                 return c.begin();
             };
@@ -49,7 +49,7 @@
         struct range_begin<std_pair_>
         {
             template< typename P >
-            static BOOST_RANGE_DEDUCED_TYPENAME range_iterator<P>::type fun( const P& p )
+            static NDNBOOST_RANGE_DEDUCED_TYPENAME range_iterator<P>::type fun( const P& p )
             {
                 return p.first;
             }
@@ -62,15 +62,15 @@
         template<>
         struct range_begin<array_>
         {
-        #if !BOOST_WORKAROUND(BOOST_MSVC, < 1310)
+        #if !NDNBOOST_WORKAROUND(NDNBOOST_MSVC, < 1310)
             template< typename T, std::size_t sz >
-            static T* fun( T BOOST_RANGE_ARRAY_REF()[sz] )
+            static T* fun( T NDNBOOST_RANGE_ARRAY_REF()[sz] )
             {
                 return boost_range_array;
             }
         #else
             template<typename T>
-            static BOOST_RANGE_DEDUCED_TYPENAME range_value<T>::type* fun(T& t)
+            static NDNBOOST_RANGE_DEDUCED_TYPENAME range_value<T>::type* fun(T& t)
             {
                 return t;
             }
@@ -82,10 +82,10 @@
     namespace range_adl_barrier
     {
         template< typename C >
-        inline BOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type
+        inline NDNBOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type
         begin( C& c )
         {
-            return range_detail::range_begin< BOOST_RANGE_DEDUCED_TYPENAME range_detail::range<C>::type >::fun( c );
+            return range_detail::range_begin< NDNBOOST_RANGE_DEDUCED_TYPENAME range_detail::range<C>::type >::fun( c );
         }
     }
 } // namespace 'boost'
diff --git a/include/ndnboost/range/detail/common.hpp b/include/ndnboost/range/detail/common.hpp
index f607721..6eff9db 100644
--- a/include/ndnboost/range/detail/common.hpp
+++ b/include/ndnboost/range/detail/common.hpp
@@ -8,8 +8,8 @@
 // For more information, see http://www.boost.org/libs/range/
 //
 
-#ifndef BOOST_RANGE_DETAIL_COMMON_HPP
-#define BOOST_RANGE_DETAIL_COMMON_HPP
+#ifndef NDNBOOST_RANGE_DETAIL_COMMON_HPP
+#define NDNBOOST_RANGE_DETAIL_COMMON_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
@@ -63,50 +63,50 @@
             static C* c;
             static C  ptr;
 
-            BOOST_STATIC_CONSTANT( bool, is_pair_                = sizeof( ndnboost::range_detail::is_pair_impl( c ) ) == sizeof( yes_type ) );
-            BOOST_STATIC_CONSTANT( bool, is_char_ptr_            = sizeof( ndnboost::range_detail::is_char_ptr_impl( ptr ) ) == sizeof( yes_type ) );
-            BOOST_STATIC_CONSTANT( bool, is_const_char_ptr_      = sizeof( ndnboost::range_detail::is_const_char_ptr_impl( ptr ) ) == sizeof( yes_type ) );
-            BOOST_STATIC_CONSTANT( bool, is_wchar_t_ptr_         = sizeof( ndnboost::range_detail::is_wchar_t_ptr_impl( ptr ) ) == sizeof( yes_type ) );
-            BOOST_STATIC_CONSTANT( bool, is_const_wchar_t_ptr_   = sizeof( ndnboost::range_detail::is_const_wchar_t_ptr_impl( ptr ) ) == sizeof( yes_type ) );
-            BOOST_STATIC_CONSTANT( bool, is_char_array_          = sizeof( ndnboost::range_detail::is_char_array_impl( ptr ) ) == sizeof( yes_type ) );
-            BOOST_STATIC_CONSTANT( bool, is_wchar_t_array_       = sizeof( ndnboost::range_detail::is_wchar_t_array_impl( ptr ) ) == sizeof( yes_type ) );
-            BOOST_STATIC_CONSTANT( bool, is_string_              = (ndnboost::type_traits::ice_or<is_const_char_ptr_, is_const_wchar_t_ptr_>::value ));
-            BOOST_STATIC_CONSTANT( bool, is_array_               = ndnboost::is_array<C>::value );
+            NDNBOOST_STATIC_CONSTANT( bool, is_pair_                = sizeof( ndnboost::range_detail::is_pair_impl( c ) ) == sizeof( yes_type ) );
+            NDNBOOST_STATIC_CONSTANT( bool, is_char_ptr_            = sizeof( ndnboost::range_detail::is_char_ptr_impl( ptr ) ) == sizeof( yes_type ) );
+            NDNBOOST_STATIC_CONSTANT( bool, is_const_char_ptr_      = sizeof( ndnboost::range_detail::is_const_char_ptr_impl( ptr ) ) == sizeof( yes_type ) );
+            NDNBOOST_STATIC_CONSTANT( bool, is_wchar_t_ptr_         = sizeof( ndnboost::range_detail::is_wchar_t_ptr_impl( ptr ) ) == sizeof( yes_type ) );
+            NDNBOOST_STATIC_CONSTANT( bool, is_const_wchar_t_ptr_   = sizeof( ndnboost::range_detail::is_const_wchar_t_ptr_impl( ptr ) ) == sizeof( yes_type ) );
+            NDNBOOST_STATIC_CONSTANT( bool, is_char_array_          = sizeof( ndnboost::range_detail::is_char_array_impl( ptr ) ) == sizeof( yes_type ) );
+            NDNBOOST_STATIC_CONSTANT( bool, is_wchar_t_array_       = sizeof( ndnboost::range_detail::is_wchar_t_array_impl( ptr ) ) == sizeof( yes_type ) );
+            NDNBOOST_STATIC_CONSTANT( bool, is_string_              = (ndnboost::type_traits::ice_or<is_const_char_ptr_, is_const_wchar_t_ptr_>::value ));
+            NDNBOOST_STATIC_CONSTANT( bool, is_array_               = ndnboost::is_array<C>::value );
             
         };
         
         template< typename C >
         class range
         {
-            typedef BOOST_RANGE_DEDUCED_TYPENAME   ndnboost::mpl::if_c< ::ndnboost::range_detail::range_helper<C>::is_pair_,
+            typedef NDNBOOST_RANGE_DEDUCED_TYPENAME   ndnboost::mpl::if_c< ::ndnboost::range_detail::range_helper<C>::is_pair_,
                                                                   ndnboost::range_detail::std_pair_,
                                                                   void >::type pair_t;
-            typedef BOOST_RANGE_DEDUCED_TYPENAME   ndnboost::mpl::if_c< ::ndnboost::range_detail::range_helper<C>::is_array_,
+            typedef NDNBOOST_RANGE_DEDUCED_TYPENAME   ndnboost::mpl::if_c< ::ndnboost::range_detail::range_helper<C>::is_array_,
                                                                     ndnboost::range_detail::array_,
                                                                     pair_t >::type array_t;
-            typedef BOOST_RANGE_DEDUCED_TYPENAME   ndnboost::mpl::if_c< ::ndnboost::range_detail::range_helper<C>::is_string_,
+            typedef NDNBOOST_RANGE_DEDUCED_TYPENAME   ndnboost::mpl::if_c< ::ndnboost::range_detail::range_helper<C>::is_string_,
                                                                     ndnboost::range_detail::string_,
                                                                     array_t >::type string_t;
-            typedef BOOST_RANGE_DEDUCED_TYPENAME   ndnboost::mpl::if_c< ::ndnboost::range_detail::range_helper<C>::is_const_char_ptr_,
+            typedef NDNBOOST_RANGE_DEDUCED_TYPENAME   ndnboost::mpl::if_c< ::ndnboost::range_detail::range_helper<C>::is_const_char_ptr_,
                                                                     ndnboost::range_detail::const_char_ptr_,
                                                                     string_t >::type const_char_ptr_t;
-            typedef BOOST_RANGE_DEDUCED_TYPENAME   ndnboost::mpl::if_c< ::ndnboost::range_detail::range_helper<C>::is_char_ptr_,
+            typedef NDNBOOST_RANGE_DEDUCED_TYPENAME   ndnboost::mpl::if_c< ::ndnboost::range_detail::range_helper<C>::is_char_ptr_,
                                                                     ndnboost::range_detail::char_ptr_,
                                                                     const_char_ptr_t >::type char_ptr_t;
-            typedef BOOST_RANGE_DEDUCED_TYPENAME   ndnboost::mpl::if_c< ::ndnboost::range_detail::range_helper<C>::is_const_wchar_t_ptr_,
+            typedef NDNBOOST_RANGE_DEDUCED_TYPENAME   ndnboost::mpl::if_c< ::ndnboost::range_detail::range_helper<C>::is_const_wchar_t_ptr_,
                                                                     ndnboost::range_detail::const_wchar_t_ptr_,
                                                                     char_ptr_t >::type const_wchar_ptr_t;
-            typedef BOOST_RANGE_DEDUCED_TYPENAME   ndnboost::mpl::if_c< ::ndnboost::range_detail::range_helper<C>::is_wchar_t_ptr_,
+            typedef NDNBOOST_RANGE_DEDUCED_TYPENAME   ndnboost::mpl::if_c< ::ndnboost::range_detail::range_helper<C>::is_wchar_t_ptr_,
                                                                     ndnboost::range_detail::wchar_t_ptr_,
                                                                     const_wchar_ptr_t >::type wchar_ptr_t;
-            typedef BOOST_RANGE_DEDUCED_TYPENAME   ndnboost::mpl::if_c< ::ndnboost::range_detail::range_helper<C>::is_wchar_t_array_,
+            typedef NDNBOOST_RANGE_DEDUCED_TYPENAME   ndnboost::mpl::if_c< ::ndnboost::range_detail::range_helper<C>::is_wchar_t_array_,
                                                                     ndnboost::range_detail::wchar_t_array_,
                                                                     wchar_ptr_t >::type wchar_array_t;
-            typedef BOOST_RANGE_DEDUCED_TYPENAME   ndnboost::mpl::if_c< ::ndnboost::range_detail::range_helper<C>::is_char_array_,
+            typedef NDNBOOST_RANGE_DEDUCED_TYPENAME   ndnboost::mpl::if_c< ::ndnboost::range_detail::range_helper<C>::is_char_array_,
                                                                     ndnboost::range_detail::char_array_,
                                                                     wchar_array_t >::type char_array_t;
         public:
-            typedef BOOST_RANGE_DEDUCED_TYPENAME   ndnboost::mpl::if_c< ::ndnboost::is_void<char_array_t>::value,
+            typedef NDNBOOST_RANGE_DEDUCED_TYPENAME   ndnboost::mpl::if_c< ::ndnboost::is_void<char_array_t>::value,
                                                                     ndnboost::range_detail::std_container_,
                                                                     char_array_t >::type type;  
         }; // class 'range' 
diff --git a/include/ndnboost/range/detail/const_iterator.hpp b/include/ndnboost/range/detail/const_iterator.hpp
index a23c25a..eb75292 100644
--- a/include/ndnboost/range/detail/const_iterator.hpp
+++ b/include/ndnboost/range/detail/const_iterator.hpp
@@ -8,8 +8,8 @@
 // For more information, see http://www.boost.org/libs/range/
 //
 
-#ifndef BOOST_RANGE_DETAIL_CONST_ITERATOR_HPP
-#define BOOST_RANGE_DETAIL_CONST_ITERATOR_HPP
+#ifndef NDNBOOST_RANGE_DETAIL_CONST_ITERATOR_HPP
+#define NDNBOOST_RANGE_DETAIL_CONST_ITERATOR_HPP
 
 #include <ndnboost/range/detail/common.hpp>
 #include <ndnboost/range/detail/remove_extent.hpp>
@@ -31,7 +31,7 @@
             template< typename C >
             struct pts
             {
-                typedef BOOST_RANGE_DEDUCED_TYPENAME C::const_iterator type;
+                typedef NDNBOOST_RANGE_DEDUCED_TYPENAME C::const_iterator type;
             };
         };
 
@@ -41,7 +41,7 @@
             template< typename P >
             struct pts
             {
-                typedef BOOST_RANGE_DEDUCED_TYPENAME P::first_type type;
+                typedef NDNBOOST_RANGE_DEDUCED_TYPENAME P::first_type type;
             };
         };
 
@@ -52,7 +52,7 @@
             template< typename T >
             struct pts
             {
-                typedef const BOOST_RANGE_DEDUCED_TYPENAME 
+                typedef const NDNBOOST_RANGE_DEDUCED_TYPENAME 
                     remove_extent<T>::type* type;
             };
         };
@@ -61,9 +61,9 @@
     template< typename C >
     class range_const_iterator
     {
-        typedef BOOST_DEDUCED_TYPENAME range_detail::range<C>::type c_type;
+        typedef NDNBOOST_DEDUCED_TYPENAME range_detail::range<C>::type c_type;
     public:
-        typedef BOOST_DEDUCED_TYPENAME range_detail::range_const_iterator_<c_type>::BOOST_NESTED_TEMPLATE pts<C>::type type; 
+        typedef NDNBOOST_DEDUCED_TYPENAME range_detail::range_const_iterator_<c_type>::NDNBOOST_NESTED_TEMPLATE pts<C>::type type; 
     };
 
 }
diff --git a/include/ndnboost/range/detail/detail_str.hpp b/include/ndnboost/range/detail/detail_str.hpp
index 5519996..cad0754 100644
--- a/include/ndnboost/range/detail/detail_str.hpp
+++ b/include/ndnboost/range/detail/detail_str.hpp
@@ -8,10 +8,10 @@
 // For more information, see http://www.boost.org/libs/range/
 //
 
-#ifndef BOOST_RANGE_DETAIL_DETAIL_STR_HPP
-#define BOOST_RANGE_DETAIL_DETAIL_STR_HPP
+#ifndef NDNBOOST_RANGE_DETAIL_DETAIL_STR_HPP
+#define NDNBOOST_RANGE_DETAIL_DETAIL_STR_HPP
 
-#include <ndnboost/config.hpp> // BOOST_MSVC
+#include <ndnboost/config.hpp> // NDNBOOST_MSVC
 #include <ndnboost/range/iterator.hpp>
 
 namespace ndnboost 
@@ -29,7 +29,7 @@
             template< typename T >
             struct pts
             {
-                 typedef BOOST_RANGE_DEDUCED_TYPENAME 
+                 typedef NDNBOOST_RANGE_DEDUCED_TYPENAME 
                     remove_extent<T>::type* type;
             };
         };
@@ -85,7 +85,7 @@
             template< typename T >
             struct pts
             {
-                typedef const BOOST_RANGE_DEDUCED_TYPENAME 
+                typedef const NDNBOOST_RANGE_DEDUCED_TYPENAME 
                     remove_extent<T>::type* type;
             };
         };
@@ -184,10 +184,10 @@
         };
         
         template< typename C >
-        inline BOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type 
+        inline NDNBOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type 
         str_begin( C& c )
         {
-            return range_detail::range_begin< BOOST_RANGE_DEDUCED_TYPENAME 
+            return range_detail::range_begin< NDNBOOST_RANGE_DEDUCED_TYPENAME 
                 range_detail::range<C>::type >::fun( c );
         }
 
@@ -199,7 +199,7 @@
         struct range_end<char_array_>
         {
             template< typename T, std::size_t sz >
-            static T* fun( T BOOST_RANGE_ARRAY_REF()[sz] )
+            static T* fun( T NDNBOOST_RANGE_ARRAY_REF()[sz] )
             {
                 return ndnboost::range_detail::array_end( boost_range_array );
             }
@@ -209,7 +209,7 @@
         struct range_end<wchar_t_array_>
         {
             template< typename T, std::size_t sz >
-            static T* fun( T BOOST_RANGE_ARRAY_REF()[sz] )
+            static T* fun( T NDNBOOST_RANGE_ARRAY_REF()[sz] )
             {
                 return ndnboost::range_detail::array_end( boost_range_array );
             }
@@ -253,10 +253,10 @@
         };
 
         template< typename C >
-        inline BOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type 
+        inline NDNBOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type 
         str_end( C& c )
         {
-            return range_detail::range_end< BOOST_RANGE_DEDUCED_TYPENAME 
+            return range_detail::range_end< NDNBOOST_RANGE_DEDUCED_TYPENAME 
                 range_detail::range<C>::type >::fun( c );
         }
 
diff --git a/include/ndnboost/range/detail/end.hpp b/include/ndnboost/range/detail/end.hpp
index a16cf73..87f848c 100644
--- a/include/ndnboost/range/detail/end.hpp
+++ b/include/ndnboost/range/detail/end.hpp
@@ -8,19 +8,19 @@
 // For more information, see http://www.boost.org/libs/range/
 //
 
-#ifndef BOOST_RANGE_DETAIL_END_HPP
-#define BOOST_RANGE_DETAIL_END_HPP
+#ifndef NDNBOOST_RANGE_DETAIL_END_HPP
+#define NDNBOOST_RANGE_DETAIL_END_HPP
 
-#include <ndnboost/config.hpp> // BOOST_MSVC
+#include <ndnboost/config.hpp> // NDNBOOST_MSVC
 #include <ndnboost/detail/workaround.hpp>
 
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+#if NDNBOOST_WORKAROUND(NDNBOOST_MSVC, < 1300)
 # include <ndnboost/range/detail/vc6/end.hpp>
 #else
 # include <ndnboost/range/detail/implementation_help.hpp>
 # include <ndnboost/range/iterator.hpp>
 # include <ndnboost/range/detail/common.hpp>
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1310)
+# if NDNBOOST_WORKAROUND(NDNBOOST_MSVC, < 1310)
 #  include <ndnboost/range/detail/remove_extent.hpp>
 # endif
 
@@ -39,7 +39,7 @@
         struct range_end<std_container_>
         {
             template< typename C >
-            static BOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type
+            static NDNBOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type
             fun( C& c )
             {
                 return c.end();
@@ -54,7 +54,7 @@
         struct range_end<std_pair_>
         {
             template< typename P >
-            static BOOST_RANGE_DEDUCED_TYPENAME range_iterator<P>::type
+            static NDNBOOST_RANGE_DEDUCED_TYPENAME range_iterator<P>::type
             fun( const P& p )
             {
                 return p.second;
@@ -68,15 +68,15 @@
         template<>
         struct range_end<array_>
         {
-        #if !BOOST_WORKAROUND(BOOST_MSVC, < 1310)
+        #if !NDNBOOST_WORKAROUND(NDNBOOST_MSVC, < 1310)
             template< typename T, std::size_t sz >
-            static T* fun( T BOOST_RANGE_ARRAY_REF()[sz] )
+            static T* fun( T NDNBOOST_RANGE_ARRAY_REF()[sz] )
             {
                 return ndnboost::range_detail::array_end( boost_range_array );
             }
         #else
             template<typename T>
-            static BOOST_RANGE_DEDUCED_TYPENAME remove_extent<T>::type* fun(T& t)
+            static NDNBOOST_RANGE_DEDUCED_TYPENAME remove_extent<T>::type* fun(T& t)
             {
                 return t + remove_extent<T>::size;
             }
@@ -88,10 +88,10 @@
     namespace range_adl_barrier
     {
         template< typename C >
-        inline BOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type
+        inline NDNBOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type
         end( C& c )
         {
-            return range_detail::range_end< BOOST_RANGE_DEDUCED_TYPENAME range_detail::range<C>::type >::fun( c );
+            return range_detail::range_end< NDNBOOST_RANGE_DEDUCED_TYPENAME range_detail::range<C>::type >::fun( c );
         }
     } // namespace range_adl_barrier
 
diff --git a/include/ndnboost/range/detail/extract_optional_type.hpp b/include/ndnboost/range/detail/extract_optional_type.hpp
index e77f37c..86a47b5 100644
--- a/include/ndnboost/range/detail/extract_optional_type.hpp
+++ b/include/ndnboost/range/detail/extract_optional_type.hpp
@@ -7,8 +7,8 @@
 //
 // For more information, see http://www.boost.org/libs/range/
 //
-#ifndef BOOST_RANGE_DETAIL_EXTRACT_OPTIONAL_TYPE_HPP_INCLUDED
-#define BOOST_RANGE_DETAIL_EXTRACT_OPTIONAL_TYPE_HPP_INCLUDED
+#ifndef NDNBOOST_RANGE_DETAIL_EXTRACT_OPTIONAL_TYPE_HPP_INCLUDED
+#define NDNBOOST_RANGE_DETAIL_EXTRACT_OPTIONAL_TYPE_HPP_INCLUDED
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
@@ -16,13 +16,13 @@
 
 #include <ndnboost/config.hpp>
 
-#ifdef BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS
+#ifdef NDNBOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS
 
-#define BOOST_RANGE_EXTRACT_OPTIONAL_TYPE( a_typedef )                         \
+#define NDNBOOST_RANGE_EXTRACT_OPTIONAL_TYPE( a_typedef )                         \
     template< typename C >                                                     \
     struct extract_ ## a_typedef                                               \
     {                                                                          \
-        typedef BOOST_DEDUCED_TYPENAME C::a_typedef type;                      \
+        typedef NDNBOOST_DEDUCED_TYPENAME C::a_typedef type;                      \
     };
 
 #else
@@ -36,15 +36,15 @@
 // Defines extract_some_typedef<T> which exposes T::some_typedef as
 // extract_some_typedef<T>::type if T::some_typedef exists. Otherwise
 // extract_some_typedef<T> is empty.
-#define BOOST_RANGE_EXTRACT_OPTIONAL_TYPE( a_typedef )                         \
+#define NDNBOOST_RANGE_EXTRACT_OPTIONAL_TYPE( a_typedef )                         \
     template< typename C, typename Enable=void >                               \
     struct extract_ ## a_typedef                                               \
     {};                                                                        \
     template< typename C >                                                     \
     struct extract_ ## a_typedef< C                                            \
-    , BOOST_DEDUCED_TYPENAME ndnboost::range_detail::exists< BOOST_DEDUCED_TYPENAME C::a_typedef >::type \
+    , NDNBOOST_DEDUCED_TYPENAME ndnboost::range_detail::exists< NDNBOOST_DEDUCED_TYPENAME C::a_typedef >::type \
     > {                                                                        \
-        typedef BOOST_DEDUCED_TYPENAME C::a_typedef type;                      \
+        typedef NDNBOOST_DEDUCED_TYPENAME C::a_typedef type;                      \
     };
 
 #endif
diff --git a/include/ndnboost/range/detail/implementation_help.hpp b/include/ndnboost/range/detail/implementation_help.hpp
index 9e80d6b..f310b44 100644
--- a/include/ndnboost/range/detail/implementation_help.hpp
+++ b/include/ndnboost/range/detail/implementation_help.hpp
@@ -8,8 +8,8 @@
 // For more information, see http://www.boost.org/libs/range/
 //
 
-#ifndef BOOST_RANGE_DETAIL_IMPLEMENTATION_HELP_HPP
-#define BOOST_RANGE_DETAIL_IMPLEMENTATION_HELP_HPP
+#ifndef NDNBOOST_RANGE_DETAIL_IMPLEMENTATION_HELP_HPP
+#define NDNBOOST_RANGE_DETAIL_IMPLEMENTATION_HELP_HPP
 
 #include <ndnboost/range/config.hpp>
 #include <ndnboost/range/detail/common.hpp>
@@ -17,7 +17,7 @@
 #include <cstddef>
 #include <string.h>
 
-#ifndef BOOST_NO_CWCHAR
+#ifndef NDNBOOST_NO_CWCHAR
 #include <wchar.h>
 #endif
 
@@ -37,7 +37,7 @@
             return s + strlen( s );
         }
 
-#ifndef BOOST_NO_CWCHAR
+#ifndef NDNBOOST_NO_CWCHAR
         inline const wchar_t* str_end( const wchar_t* s, const wchar_t* )
         {
             return s + wcslen( s );
@@ -60,13 +60,13 @@
         }
 
         template< class T, std::size_t sz >
-        inline T* array_end( T BOOST_RANGE_ARRAY_REF()[sz] )
+        inline T* array_end( T NDNBOOST_RANGE_ARRAY_REF()[sz] )
         {
             return boost_range_array + sz;
         }
 
         template< class T, std::size_t sz >
-        inline const T* array_end( const T BOOST_RANGE_ARRAY_REF()[sz] )
+        inline const T* array_end( const T NDNBOOST_RANGE_ARRAY_REF()[sz] )
         {
             return boost_range_array + sz;
         }
@@ -82,14 +82,14 @@
         }
 
         template< class T, std::size_t sz >
-        inline std::size_t array_size( T BOOST_RANGE_ARRAY_REF()[sz] )
+        inline std::size_t array_size( T NDNBOOST_RANGE_ARRAY_REF()[sz] )
         {
             boost_range_silence_warning( boost_range_array );
             return sz;
         }
 
         template< class T, std::size_t sz >
-        inline std::size_t array_size( const T BOOST_RANGE_ARRAY_REF()[sz] )
+        inline std::size_t array_size( const T NDNBOOST_RANGE_ARRAY_REF()[sz] )
         {
             boost_range_silence_warning( boost_range_array );
             return sz;
diff --git a/include/ndnboost/range/detail/iterator.hpp b/include/ndnboost/range/detail/iterator.hpp
index c58b5ad..947b83e 100644
--- a/include/ndnboost/range/detail/iterator.hpp
+++ b/include/ndnboost/range/detail/iterator.hpp
@@ -8,8 +8,8 @@
 // For more information, see http://www.boost.org/libs/range/
 //
 
-#ifndef BOOST_RANGE_DETAIL_ITERATOR_HPP
-#define BOOST_RANGE_DETAIL_ITERATOR_HPP
+#ifndef NDNBOOST_RANGE_DETAIL_ITERATOR_HPP
+#define NDNBOOST_RANGE_DETAIL_ITERATOR_HPP
 
 #include <ndnboost/range/detail/common.hpp>
 #include <ndnboost/range/detail/remove_extent.hpp>
@@ -39,7 +39,7 @@
             template< typename C >
             struct pts
             {
-                typedef BOOST_RANGE_DEDUCED_TYPENAME C::iterator type;
+                typedef NDNBOOST_RANGE_DEDUCED_TYPENAME C::iterator type;
             };
         };
 
@@ -49,7 +49,7 @@
             template< typename P >
             struct pts
             {
-                typedef BOOST_RANGE_DEDUCED_TYPENAME P::first_type type;
+                typedef NDNBOOST_RANGE_DEDUCED_TYPENAME P::first_type type;
             };
         };
 
@@ -59,7 +59,7 @@
             template< typename T >
             struct pts
             {
-                typedef BOOST_RANGE_DEDUCED_TYPENAME 
+                typedef NDNBOOST_RANGE_DEDUCED_TYPENAME 
                     remove_extent<T>::type* type;
             };
         };
@@ -69,9 +69,9 @@
     template< typename C >
     class range_mutable_iterator
     {
-        typedef BOOST_RANGE_DEDUCED_TYPENAME range_detail::range<C>::type c_type;
+        typedef NDNBOOST_RANGE_DEDUCED_TYPENAME range_detail::range<C>::type c_type;
     public:
-        typedef typename range_detail::range_iterator_<c_type>::BOOST_NESTED_TEMPLATE pts<C>::type type; 
+        typedef typename range_detail::range_iterator_<c_type>::NDNBOOST_NESTED_TEMPLATE pts<C>::type type; 
     };
 }
 
diff --git a/include/ndnboost/range/detail/misc_concept.hpp b/include/ndnboost/range/detail/misc_concept.hpp
index fb2a39c..b50de38 100644
--- a/include/ndnboost/range/detail/misc_concept.hpp
+++ b/include/ndnboost/range/detail/misc_concept.hpp
@@ -5,8 +5,8 @@
 //  accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
 //
-#ifndef BOOST_RANGE_DETAIL_MISC_CONCEPT_HPP_INCLUDED
-#define BOOST_RANGE_DETAIL_MISC_CONCEPT_HPP_INCLUDED
+#ifndef NDNBOOST_RANGE_DETAIL_MISC_CONCEPT_HPP_INCLUDED
+#define NDNBOOST_RANGE_DETAIL_MISC_CONCEPT_HPP_INCLUDED
 
 #include <ndnboost/concept_check.hpp>
 
@@ -18,7 +18,7 @@
         class SameTypeConcept
         {
         public:
-            BOOST_CONCEPT_USAGE(SameTypeConcept)
+            NDNBOOST_CONCEPT_USAGE(SameTypeConcept)
             {
                 same_type(a,b);
             }
diff --git a/include/ndnboost/range/detail/remove_extent.hpp b/include/ndnboost/range/detail/remove_extent.hpp
index 9d89ed7..dee0e34 100644
--- a/include/ndnboost/range/detail/remove_extent.hpp
+++ b/include/ndnboost/range/detail/remove_extent.hpp
@@ -9,8 +9,8 @@
 //
 
 
-#ifndef BOOST_RANGE_DETAIL_REMOVE_BOUNDS_HPP
-#define BOOST_RANGE_DETAIL_REMOVE_BOUNDS_HPP
+#ifndef NDNBOOST_RANGE_DETAIL_REMOVE_BOUNDS_HPP
+#define NDNBOOST_RANGE_DETAIL_REMOVE_BOUNDS_HPP
 
 #include <ndnboost/config.hpp>  // MSVC, NO_INTRINSIC_WCHAR_T, put size_t in std.
 #include <cstddef>
@@ -101,7 +101,7 @@
         template<typename T>
         struct remove_extent {
             static T* ar;
-            BOOST_STATIC_CONSTANT(std::size_t, size = sizeof(*ar) / sizeof((*ar)[0]));
+            NDNBOOST_STATIC_CONSTANT(std::size_t, size = sizeof(*ar) / sizeof((*ar)[0]));
 
             typedef typename
                     select<
@@ -109,7 +109,7 @@
                         is_same<T, char[size]>,                  char,
                         is_same<T, signed char[size]>,           signed char,
                         is_same<T, unsigned char[size]>,         unsigned char,
-                    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+                    #ifndef NDNBOOST_NO_INTRINSIC_WCHAR_T
                         is_same<T, wchar_t[size]>,               wchar_t,
                     #endif
                         is_same<T, short[size]>,                 short,
@@ -128,7 +128,7 @@
                         is_same<T, const char[size]>,            const char,
                         is_same<T, const signed char[size]>,     const signed char,
                         is_same<T, const unsigned char[size]>,   const unsigned char,
-                    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+                    #ifndef NDNBOOST_NO_INTRINSIC_WCHAR_T
                         is_same<T, const wchar_t[size]>,         const wchar_t,
                     #endif
                         is_same<T, const short[size]>,           const short,
diff --git a/include/ndnboost/range/detail/safe_bool.hpp b/include/ndnboost/range/detail/safe_bool.hpp
index fad34c4..c5a0731 100644
--- a/include/ndnboost/range/detail/safe_bool.hpp
+++ b/include/ndnboost/range/detail/safe_bool.hpp
@@ -7,8 +7,8 @@
 //
 // This code utilises the experience gained during the evolution of
 // <ndnboost/smart_ptr/operator_bool.hpp>
-#ifndef BOOST_RANGE_SAFE_BOOL_INCLUDED_HPP
-#define BOOST_RANGE_SAFE_BOOL_INCLUDED_HPP
+#ifndef NDNBOOST_RANGE_SAFE_BOOL_INCLUDED_HPP
+#define NDNBOOST_RANGE_SAFE_BOOL_INCLUDED_HPP
 
 #include <ndnboost/config.hpp>
 #include <ndnboost/range/config.hpp>
@@ -24,7 +24,7 @@
 public:
     typedef safe_bool this_type;
 
-#if (defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, < 0x570)) || defined(__CINT_)
+#if (defined(__SUNPRO_CC) && NDNBOOST_WORKAROUND(__SUNPRO_CC, < 0x570)) || defined(__CINT_)
     typedef bool unspecified_bool_type;
     static unspecified_bool_type to_unspecified_bool(const bool x, DataMemberPtr)
     {
@@ -40,9 +40,9 @@
         return x ? unspecified_bool : 0;
     }
 #elif \
-    ( defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, < 0x3200) ) || \
+    ( defined(__MWERKS__) && NDNBOOST_WORKAROUND(__MWERKS__, < 0x3200) ) || \
     ( defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ < 304) ) || \
-    ( defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x590) )
+    ( defined(__SUNPRO_CC) && NDNBOOST_WORKAROUND(__SUNPRO_CC, <= 0x590) )
 
     typedef bool (this_type::*unspecified_bool_type)() const;
 
diff --git a/include/ndnboost/range/detail/sfinae.hpp b/include/ndnboost/range/detail/sfinae.hpp
index d940c3a..1ad1c23 100644
--- a/include/ndnboost/range/detail/sfinae.hpp
+++ b/include/ndnboost/range/detail/sfinae.hpp
@@ -8,8 +8,8 @@
 // For more information, see http://www.boost.org/libs/range/
 //
 
-#ifndef BOOST_RANGE_DETAIL_SFINAE_HPP
-#define BOOST_RANGE_DETAIL_SFINAE_HPP
+#ifndef NDNBOOST_RANGE_DETAIL_SFINAE_HPP
+#define NDNBOOST_RANGE_DETAIL_SFINAE_HPP
 
 #include <ndnboost/range/config.hpp>
 #include <ndnboost/type_traits/is_array.hpp>
@@ -33,15 +33,15 @@
         no_type  is_string_impl( ... );
         
         template< std::size_t sz >
-        yes_type is_char_array_impl( char BOOST_RANGE_ARRAY_REF()[sz] );
+        yes_type is_char_array_impl( char NDNBOOST_RANGE_ARRAY_REF()[sz] );
         template< std::size_t sz >
-        yes_type is_char_array_impl( const char BOOST_RANGE_ARRAY_REF()[sz] );
+        yes_type is_char_array_impl( const char NDNBOOST_RANGE_ARRAY_REF()[sz] );
         no_type  is_char_array_impl( ... );
         
         template< std::size_t sz >
-        yes_type is_wchar_t_array_impl( wchar_t BOOST_RANGE_ARRAY_REF()[sz] );
+        yes_type is_wchar_t_array_impl( wchar_t NDNBOOST_RANGE_ARRAY_REF()[sz] );
         template< std::size_t sz >
-        yes_type is_wchar_t_array_impl( const wchar_t BOOST_RANGE_ARRAY_REF()[sz] );
+        yes_type is_wchar_t_array_impl( const wchar_t NDNBOOST_RANGE_ARRAY_REF()[sz] );
         no_type  is_wchar_t_array_impl( ... );
                                      
         yes_type is_char_ptr_impl( char* const );
diff --git a/include/ndnboost/range/detail/size_type.hpp b/include/ndnboost/range/detail/size_type.hpp
index 3314922..1444d06 100644
--- a/include/ndnboost/range/detail/size_type.hpp
+++ b/include/ndnboost/range/detail/size_type.hpp
@@ -8,8 +8,8 @@
 // For more information, see http://www.boost.org/libs/range/
 //
 
-#ifndef BOOST_RANGE_DETAIL_SIZE_TYPE_HPP
-#define BOOST_RANGE_DETAIL_SIZE_TYPE_HPP
+#ifndef NDNBOOST_RANGE_DETAIL_SIZE_TYPE_HPP
+#define NDNBOOST_RANGE_DETAIL_SIZE_TYPE_HPP
 
 #include <ndnboost/range/detail/common.hpp>
 
@@ -37,7 +37,7 @@
             template< typename C >
             struct pts
             {
-                typedef BOOST_RANGE_DEDUCED_TYPENAME C::size_type type;
+                typedef NDNBOOST_RANGE_DEDUCED_TYPENAME C::size_type type;
             };
         };
     }
@@ -47,7 +47,7 @@
     {
         typedef typename range_detail::range<C>::type c_type;
     public:
-        typedef typename range_detail::range_size_type_<c_type>::BOOST_NESTED_TEMPLATE pts<C>::type type;
+        typedef typename range_detail::range_size_type_<c_type>::NDNBOOST_NESTED_TEMPLATE pts<C>::type type;
     };
 }
 
diff --git a/include/ndnboost/range/detail/str_types.hpp b/include/ndnboost/range/detail/str_types.hpp
index 1829762..57ed311 100644
--- a/include/ndnboost/range/detail/str_types.hpp
+++ b/include/ndnboost/range/detail/str_types.hpp
@@ -8,8 +8,8 @@
 // For more information, see http://www.boost.org/libs/range/
 //
 
-#ifndef BOOST_RANGE_DETAIL_STR_TYPES_HPP
-#define BOOST_RANGE_DETAIL_STR_TYPES_HPP
+#ifndef NDNBOOST_RANGE_DETAIL_STR_TYPES_HPP
+#define NDNBOOST_RANGE_DETAIL_STR_TYPES_HPP
 
 #include <ndnboost/range/size_type.hpp>
 #include <ndnboost/range/iterator.hpp>
diff --git a/include/ndnboost/range/detail/value_type.hpp b/include/ndnboost/range/detail/value_type.hpp
index f5c919b..0febe4f 100644
--- a/include/ndnboost/range/detail/value_type.hpp
+++ b/include/ndnboost/range/detail/value_type.hpp
@@ -8,8 +8,8 @@
 // For more information, see http://www.boost.org/libs/range/
 //
 
-#ifndef BOOST_RANGE_DETAIL_VALUE_TYPE_HPP
-#define BOOST_RANGE_DETAIL_VALUE_TYPE_HPP
+#ifndef NDNBOOST_RANGE_DETAIL_VALUE_TYPE_HPP
+#define NDNBOOST_RANGE_DETAIL_VALUE_TYPE_HPP
 
 #include <ndnboost/range/detail/common.hpp>
 #include <ndnboost/range/detail/remove_extent.hpp>
@@ -32,7 +32,7 @@
             template< typename C >
             struct pts
             {
-                typedef BOOST_RANGE_DEDUCED_TYPENAME C::value_type type;
+                typedef NDNBOOST_RANGE_DEDUCED_TYPENAME C::value_type type;
             };
         };
 
@@ -42,7 +42,7 @@
             template< typename P >
             struct pts
             {
-                typedef BOOST_RANGE_DEDUCED_TYPENAME ndnboost::iterator_value< BOOST_RANGE_DEDUCED_TYPENAME P::first_type >::type type;
+                typedef NDNBOOST_RANGE_DEDUCED_TYPENAME ndnboost::iterator_value< NDNBOOST_RANGE_DEDUCED_TYPENAME P::first_type >::type type;
             };
         };
 
@@ -52,7 +52,7 @@
             template< typename T >
             struct pts
             {
-                typedef BOOST_DEDUCED_TYPENAME remove_extent<T>::type type;
+                typedef NDNBOOST_DEDUCED_TYPENAME remove_extent<T>::type type;
             };
         };
         
@@ -61,9 +61,9 @@
     template< typename C >
     class range_value
     {
-        typedef BOOST_DEDUCED_TYPENAME range_detail::range<C>::type c_type;
+        typedef NDNBOOST_DEDUCED_TYPENAME range_detail::range<C>::type c_type;
     public:
-        typedef BOOST_DEDUCED_TYPENAME range_detail::range_value_type_<c_type>::BOOST_NESTED_TEMPLATE pts<C>::type type; 
+        typedef NDNBOOST_DEDUCED_TYPENAME range_detail::range_value_type_<c_type>::NDNBOOST_NESTED_TEMPLATE pts<C>::type type; 
     };
 
 }
diff --git a/include/ndnboost/range/detail/vc6/end.hpp b/include/ndnboost/range/detail/vc6/end.hpp
index 1853de8..ed9a1b0 100644
--- a/include/ndnboost/range/detail/vc6/end.hpp
+++ b/include/ndnboost/range/detail/vc6/end.hpp
@@ -8,8 +8,8 @@
 // For more information, see http://www.boost.org/libs/range/
 //
 
-#ifndef BOOST_RANGE_DETAIL_VC6_END_HPP
-#define BOOST_RANGE_DETAIL_VC6_END_HPP
+#ifndef NDNBOOST_RANGE_DETAIL_VC6_END_HPP
+#define NDNBOOST_RANGE_DETAIL_VC6_END_HPP
 
 #include <ndnboost/range/detail/implementation_help.hpp>
 #include <ndnboost/range/detail/implementation_help.hpp>
@@ -33,7 +33,7 @@
         {
             template< typename C >
             struct inner {
-                static BOOST_RANGE_DEDUCED_TYPENAME range_result_iterator<C>::type 
+                static NDNBOOST_RANGE_DEDUCED_TYPENAME range_result_iterator<C>::type 
                 fun( C& c )
                 {
                     return c.end();
@@ -50,7 +50,7 @@
         {
             template< typename P >
             struct inner {
-                static BOOST_RANGE_DEDUCED_TYPENAME range_result_iterator<P>::type 
+                static NDNBOOST_RANGE_DEDUCED_TYPENAME range_result_iterator<P>::type 
                 fun( const P& p )
                 {
                     return p.second;
@@ -67,7 +67,7 @@
         {
             template< typename T >
             struct inner {
-                static BOOST_DEDUCED_TYPENAME remove_extent<T>::type*
+                static NDNBOOST_DEDUCED_TYPENAME remove_extent<T>::type*
                 fun(T& t)
                 {
                     return t + remove_extent<T>::size;
@@ -81,7 +81,7 @@
         {
             template< typename T >
             struct inner {
-                static BOOST_DEDUCED_TYPENAME remove_extent<T>::type*
+                static NDNBOOST_DEDUCED_TYPENAME remove_extent<T>::type*
                 fun(T& t)
                 {
                     return t + remove_extent<T>::size;
@@ -94,7 +94,7 @@
         {
             template< typename T >
             struct inner {
-                static BOOST_DEDUCED_TYPENAME remove_extent<T>::type*
+                static NDNBOOST_DEDUCED_TYPENAME remove_extent<T>::type*
                 fun(T& t)
                 {
                     return t + remove_extent<T>::size;
@@ -158,7 +158,7 @@
     } // namespace 'range_detail'
     
     template< typename C >
-    inline BOOST_DEDUCED_TYPENAME range_result_iterator<C>::type 
+    inline NDNBOOST_DEDUCED_TYPENAME range_result_iterator<C>::type 
     end( C& c )
     {
         return range_detail::range_end<range_detail::range<C>::type>::inner<C>::fun( c );
diff --git a/include/ndnboost/range/difference_type.hpp b/include/ndnboost/range/difference_type.hpp
index b26058a..f4e1c16 100644
--- a/include/ndnboost/range/difference_type.hpp
+++ b/include/ndnboost/range/difference_type.hpp
@@ -8,8 +8,8 @@
 // For more information, see http://www.boost.org/libs/range/
 //
 
-#ifndef BOOST_RANGE_DIFFERENCE_TYPE_HPP
-#define BOOST_RANGE_DIFFERENCE_TYPE_HPP
+#ifndef NDNBOOST_RANGE_DIFFERENCE_TYPE_HPP
+#define NDNBOOST_RANGE_DIFFERENCE_TYPE_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
diff --git a/include/ndnboost/range/distance.hpp b/include/ndnboost/range/distance.hpp
index 12d93fa..f43aada 100644
--- a/include/ndnboost/range/distance.hpp
+++ b/include/ndnboost/range/distance.hpp
@@ -8,8 +8,8 @@
 // For more information, see http://www.boost.org/libs/range/
 //
 
-#ifndef BOOST_RANGE_DISTANCE_HPP
-#define BOOST_RANGE_DISTANCE_HPP
+#ifndef NDNBOOST_RANGE_DISTANCE_HPP
+#define NDNBOOST_RANGE_DISTANCE_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
@@ -23,7 +23,7 @@
 {
 
     template< class T >
-    inline BOOST_DEDUCED_TYPENAME range_difference<T>::type 
+    inline NDNBOOST_DEDUCED_TYPENAME range_difference<T>::type 
     distance( const T& r )
     {
         return std::distance( ndnboost::begin( r ), ndnboost::end( r ) );
diff --git a/include/ndnboost/range/empty.hpp b/include/ndnboost/range/empty.hpp
index 6fdd177..fc3dff1 100644
--- a/include/ndnboost/range/empty.hpp
+++ b/include/ndnboost/range/empty.hpp
@@ -8,8 +8,8 @@
 // For more information, see http://www.boost.org/libs/range/
 //
 
-#ifndef BOOST_RANGE_EMPTY_HPP
-#define BOOST_RANGE_EMPTY_HPP
+#ifndef NDNBOOST_RANGE_EMPTY_HPP
+#define NDNBOOST_RANGE_EMPTY_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
diff --git a/include/ndnboost/range/end.hpp b/include/ndnboost/range/end.hpp
index 9a7cb11..ec7d54d 100644
--- a/include/ndnboost/range/end.hpp
+++ b/include/ndnboost/range/end.hpp
@@ -8,8 +8,8 @@
 // For more information, see http://www.boost.org/libs/range/
 //
 
-#ifndef BOOST_RANGE_END_HPP
-#define BOOST_RANGE_END_HPP
+#ifndef NDNBOOST_RANGE_END_HPP
+#define NDNBOOST_RANGE_END_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
@@ -17,7 +17,7 @@
 
 #include <ndnboost/range/config.hpp>
 
-#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+#ifdef NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING
 #include <ndnboost/range/detail/end.hpp>
 #else
 
@@ -28,8 +28,8 @@
 namespace ndnboost
 {
 
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
-    !BOOST_WORKAROUND(__GNUC__, < 3) \
+#if !NDNBOOST_WORKAROUND(__BORLANDC__, NDNBOOST_TESTED_AT(0x564)) && \
+    !NDNBOOST_WORKAROUND(__GNUC__, < 3) \
     /**/
 namespace range_detail
 {
@@ -39,7 +39,7 @@
         // primary template
         //////////////////////////////////////////////////////////////////////
         template< typename C >
-        inline BOOST_DEDUCED_TYPENAME range_iterator<C>::type
+        inline NDNBOOST_DEDUCED_TYPENAME range_iterator<C>::type
         range_end( C& c )
         {
             //
@@ -82,8 +82,8 @@
             return range_detail::array_end<T,sz>( a );
         }
 
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
-    !BOOST_WORKAROUND(__GNUC__, < 3) \
+#if !NDNBOOST_WORKAROUND(__BORLANDC__, NDNBOOST_TESTED_AT(0x564)) && \
+    !NDNBOOST_WORKAROUND(__GNUC__, < 3) \
     /**/
 } // namespace 'range_detail'
 #endif
@@ -92,10 +92,10 @@
 {
 
 template< class T >
-inline BOOST_DEDUCED_TYPENAME range_iterator<T>::type end( T& r )
+inline NDNBOOST_DEDUCED_TYPENAME range_iterator<T>::type end( T& r )
 {
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
-    !BOOST_WORKAROUND(__GNUC__, < 3) \
+#if !NDNBOOST_WORKAROUND(__BORLANDC__, NDNBOOST_TESTED_AT(0x564)) && \
+    !NDNBOOST_WORKAROUND(__GNUC__, < 3) \
     /**/
     using namespace range_detail;
 #endif
@@ -103,10 +103,10 @@
 }
 
 template< class T >
-inline BOOST_DEDUCED_TYPENAME range_iterator<const T>::type end( const T& r )
+inline NDNBOOST_DEDUCED_TYPENAME range_iterator<const T>::type end( const T& r )
 {
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
-    !BOOST_WORKAROUND(__GNUC__, < 3) \
+#if !NDNBOOST_WORKAROUND(__BORLANDC__, NDNBOOST_TESTED_AT(0x564)) && \
+    !NDNBOOST_WORKAROUND(__GNUC__, < 3) \
     /**/
     using namespace range_detail;
 #endif
@@ -116,14 +116,14 @@
     } // namespace range_adl_barrier
 } // namespace 'boost'
 
-#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+#endif // NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING
 
 namespace ndnboost
 {
     namespace range_adl_barrier
     {
         template< class T >
-        inline BOOST_DEDUCED_TYPENAME range_iterator<const T>::type
+        inline NDNBOOST_DEDUCED_TYPENAME range_iterator<const T>::type
         const_end( const T& r )
         {
             return ndnboost::range_adl_barrier::end( r );
diff --git a/include/ndnboost/range/functions.hpp b/include/ndnboost/range/functions.hpp
index 7fa535f..6aa2124 100644
--- a/include/ndnboost/range/functions.hpp
+++ b/include/ndnboost/range/functions.hpp
@@ -8,8 +8,8 @@
 // For more information, see http://www.boost.org/libs/range/
 //
 
-#ifndef BOOST_RANGE_FUNCTIONS_HPP
-#define BOOST_RANGE_FUNCTIONS_HPP
+#ifndef NDNBOOST_RANGE_FUNCTIONS_HPP
+#define NDNBOOST_RANGE_FUNCTIONS_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
diff --git a/include/ndnboost/range/iterator.hpp b/include/ndnboost/range/iterator.hpp
index 8710a2e..b2a110c 100644
--- a/include/ndnboost/range/iterator.hpp
+++ b/include/ndnboost/range/iterator.hpp
@@ -8,8 +8,8 @@
 // For more information, see http://www.boost.org/libs/range/
 //
 
-#ifndef BOOST_RANGE_ITERATOR_HPP
-#define BOOST_RANGE_ITERATOR_HPP
+#ifndef NDNBOOST_RANGE_ITERATOR_HPP
+#define NDNBOOST_RANGE_ITERATOR_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
@@ -25,14 +25,14 @@
 namespace ndnboost
 {
 
-#if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
+#if NDNBOOST_WORKAROUND(NDNBOOST_MSVC, == 1310)
 
     namespace range_detail_vc7_1
     {
        template< typename C, typename Sig = void(C) >
        struct range_iterator
        {
-           typedef BOOST_RANGE_DEDUCED_TYPENAME
+           typedef NDNBOOST_RANGE_DEDUCED_TYPENAME
                mpl::eval_if_c< is_const<C>::value,
                                range_const_iterator< typename remove_const<C>::type >,
                                range_mutable_iterator<C> >::type type;
@@ -50,14 +50,14 @@
     template< typename C >
     struct range_iterator
     {
-#if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
+#if NDNBOOST_WORKAROUND(NDNBOOST_MSVC, == 1310)
 
-        typedef BOOST_RANGE_DEDUCED_TYPENAME
+        typedef NDNBOOST_RANGE_DEDUCED_TYPENAME
                range_detail_vc7_1::range_iterator<C>::type type;
 
 #else
 
-        typedef BOOST_RANGE_DEDUCED_TYPENAME
+        typedef NDNBOOST_RANGE_DEDUCED_TYPENAME
             mpl::eval_if_c< is_const<C>::value,
                             range_const_iterator< typename remove_const<C>::type >,
                             range_mutable_iterator<C> >::type type;
@@ -67,6 +67,6 @@
 
 } // namespace ndnboost
 
-//#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+//#endif // NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
 #endif
diff --git a/include/ndnboost/range/iterator_range.hpp b/include/ndnboost/range/iterator_range.hpp
index 26a9016..1108aaa 100644
--- a/include/ndnboost/range/iterator_range.hpp
+++ b/include/ndnboost/range/iterator_range.hpp
@@ -7,8 +7,8 @@
 //
 // For more information, see http://www.boost.org/libs/range/
 //
-#ifndef BOOST_RANGE_ITERATOR_RANGE_HPP_INCLUDED
-#define BOOST_RANGE_ITERATOR_RANGE_HPP_INCLUDED
+#ifndef NDNBOOST_RANGE_ITERATOR_RANGE_HPP_INCLUDED
+#define NDNBOOST_RANGE_ITERATOR_RANGE_HPP_INCLUDED
 
 #include "ndnboost/range/iterator_range_core.hpp"
 #include "ndnboost/range/iterator_range_io.hpp"
diff --git a/include/ndnboost/range/iterator_range_core.hpp b/include/ndnboost/range/iterator_range_core.hpp
index e4ca4ea..be97e2b 100644
--- a/include/ndnboost/range/iterator_range_core.hpp
+++ b/include/ndnboost/range/iterator_range_core.hpp
@@ -7,13 +7,13 @@
 //
 // For more information, see http://www.boost.org/libs/range/
 //
-#ifndef BOOST_RANGE_ITERATOR_RANGE_CORE_HPP_INCLUDED
-#define BOOST_RANGE_ITERATOR_RANGE_CORE_HPP_INCLUDED
+#ifndef NDNBOOST_RANGE_ITERATOR_RANGE_CORE_HPP_INCLUDED
+#define NDNBOOST_RANGE_ITERATOR_RANGE_CORE_HPP_INCLUDED
 
 #include <ndnboost/config.hpp> // Define __STL_CONFIG_H, if appropriate.
 #include <ndnboost/detail/workaround.hpp>
 
-#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500))
+#if NDNBOOST_WORKAROUND(NDNBOOST_MSVC, NDNBOOST_TESTED_AT(1500))
     #pragma warning( push )
     #pragma warning( disable : 4996 )
 #endif
@@ -133,15 +133,15 @@
         public:
             //! this type
             typedef iterator_range<IteratorT> type;
-            typedef BOOST_DEDUCED_TYPENAME safe_bool_t::unspecified_bool_type unspecified_bool_type;
-            //BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(value_type);
+            typedef NDNBOOST_DEDUCED_TYPENAME safe_bool_t::unspecified_bool_type unspecified_bool_type;
+            //NDNBOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(value_type);
 
             //! Encapsulated value type
-            typedef BOOST_DEDUCED_TYPENAME
+            typedef NDNBOOST_DEDUCED_TYPENAME
                 iterator_value<IteratorT>::type value_type;
 
             //! Difference type
-            typedef BOOST_DEDUCED_TYPENAME
+            typedef NDNBOOST_DEDUCED_TYPENAME
                 iterator_difference<IteratorT>::type difference_type;
 
             //! Size type
@@ -155,7 +155,7 @@
             // Needed because value-type is the same for
             // const and non-const iterators
             //
-            typedef BOOST_DEDUCED_TYPENAME
+            typedef NDNBOOST_DEDUCED_TYPENAME
                 iterator_reference<IteratorT>::type reference;
 
             //! const_iterator type
@@ -168,7 +168,7 @@
             typedef IteratorT iterator;
 
         private: // for return value of operator()()
-            typedef BOOST_DEDUCED_TYPENAME
+            typedef NDNBOOST_DEDUCED_TYPENAME
                 ndnboost::mpl::if_< ndnboost::mpl::or_< ndnboost::is_abstract< value_type >, 
                                                   ndnboost::is_array< value_type > >,
                                  reference, value_type >::type abstract_value_type;
@@ -207,7 +207,7 @@
                 m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )
             {}
 
-            #if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+            #if !NDNBOOST_WORKAROUND(NDNBOOST_MSVC, < 1300)
             this_type& operator=( const this_type& r )
             {
                 m_Begin  = r.begin();
@@ -276,7 +276,7 @@
             }
 
 
-#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+#ifdef NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING
 
             bool operator==( const iterator_range& r ) const
             {
@@ -313,13 +313,13 @@
         public: // convenience
            reference front() const
            {
-               BOOST_ASSERT( !empty() );
+               NDNBOOST_ASSERT( !empty() );
                return *m_Begin;
            }
 
            reference back() const
            {
-               BOOST_ASSERT( !empty() );
+               NDNBOOST_ASSERT( !empty() );
                IteratorT last( m_End );
                return *--last;
            }
@@ -327,20 +327,20 @@
            // pop_front() - added to model the SinglePassRangePrimitiveConcept
            void pop_front()
            {
-               BOOST_ASSERT( !empty() );
+               NDNBOOST_ASSERT( !empty() );
                ++m_Begin;
            }
 
            // pop_back() - added to model the BidirectionalRangePrimitiveConcept
            void pop_back()
            {
-               BOOST_ASSERT( !empty() );
+               NDNBOOST_ASSERT( !empty() );
                --m_End;
            }
 
            reference operator[]( difference_type at ) const
            {
-               BOOST_ASSERT( at >= 0 && at < size() );
+               NDNBOOST_ASSERT( at >= 0 && at < size() );
                return m_Begin[at];
            }
 
@@ -351,7 +351,7 @@
            //
            abstract_value_type operator()( difference_type at ) const
            {
-               BOOST_ASSERT( at >= 0 && at < size() );
+               NDNBOOST_ASSERT( at >= 0 && at < size() );
                return m_Begin[at];
            }
 
@@ -428,7 +428,7 @@
             return iterator_range_detail::greater_or_equal_than( l, r );
         }
 
-#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+#ifdef NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING
 #else
         template< class Iterator1T, class Iterator2T >
         inline bool operator==( const iterator_range<Iterator1T>& l,
@@ -516,7 +516,7 @@
             return iterator_range_detail::greater_or_equal_than( l, r );
         }
 
-#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+#endif // NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING
 
 //  iterator range utilities -----------------------------------------//
 
@@ -535,13 +535,13 @@
             return iterator_range<IteratorT>( Begin, End );
         }
 
-#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+#ifdef NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING
 
         template< typename Range >
-        inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<Range>::type >
+        inline iterator_range< NDNBOOST_DEDUCED_TYPENAME range_iterator<Range>::type >
         make_iterator_range( Range& r )
         {
-            return iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<Range>::type >
+            return iterator_range< NDNBOOST_DEDUCED_TYPENAME range_iterator<Range>::type >
                 ( ndnboost::begin( r ), ndnboost::end( r ) );
         }
 
@@ -552,30 +552,30 @@
             and end iterators.
         */
         template< class ForwardRange >
-        inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type >
+        inline iterator_range< NDNBOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type >
         make_iterator_range( ForwardRange& r )
         {
-           return iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type >
+           return iterator_range< NDNBOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type >
                 ( r, iterator_range_detail::range_tag() );
         }
 
         template< class ForwardRange >
-        inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type >
+        inline iterator_range< NDNBOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type >
         make_iterator_range( const ForwardRange& r )
         {
-           return iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type >
+           return iterator_range< NDNBOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type >
                 ( r, iterator_range_detail::const_range_tag() );
         }
 
-#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+#endif // NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING
 
         namespace iterator_range_detail
         {
             template< class Range >
-            inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<Range>::type >
+            inline iterator_range< NDNBOOST_DEDUCED_TYPENAME range_iterator<Range>::type >
             make_range_impl( Range& r,
-                             BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_begin,
-                             BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_end )
+                             NDNBOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_begin,
+                             NDNBOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_end )
             {
                 //
                 // Not worth the effort
@@ -584,7 +584,7 @@
                 //    return make_iterator_range( r );
                 //
 
-                BOOST_DEDUCED_TYPENAME range_iterator<Range>::type
+                NDNBOOST_DEDUCED_TYPENAME range_iterator<Range>::type
                     new_begin = ndnboost::begin( r ),
                     new_end   = ndnboost::end( r );
                 std::advance( new_begin, advance_begin );
@@ -593,41 +593,41 @@
             }
         }
 
-#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+#ifdef NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING
 
         template< class Range >
-        inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<Range>::type >
+        inline iterator_range< NDNBOOST_DEDUCED_TYPENAME range_iterator<Range>::type >
         make_iterator_range( Range& r,
-                    BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_begin,
-                    BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_end )
+                    NDNBOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_begin,
+                    NDNBOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_end )
         {
-            //BOOST_ASSERT( advance_begin - advance_end <= size(r) && "creating invalid range" );
+            //NDNBOOST_ASSERT( advance_begin - advance_end <= size(r) && "creating invalid range" );
             return iterator_range_detail::make_range_impl( r, advance_begin, advance_end );
         }
 
 #else
 
         template< class Range >
-        inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<Range>::type >
+        inline iterator_range< NDNBOOST_DEDUCED_TYPENAME range_iterator<Range>::type >
         make_iterator_range( Range& r,
-                    BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_begin,
-                    BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_end )
+                    NDNBOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_begin,
+                    NDNBOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_end )
         {
-            //BOOST_ASSERT( advance_begin - advance_end <= size(r) && "creating invalid range" );
+            //NDNBOOST_ASSERT( advance_begin - advance_end <= size(r) && "creating invalid range" );
             return iterator_range_detail::make_range_impl( r, advance_begin, advance_end );
         }
 
         template< class Range >
-        inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<const Range>::type >
+        inline iterator_range< NDNBOOST_DEDUCED_TYPENAME range_iterator<const Range>::type >
         make_iterator_range( const Range& r,
-                    BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_begin,
-                    BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_end )
+                    NDNBOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_begin,
+                    NDNBOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_end )
         {
-            //BOOST_ASSERT( advance_begin - advance_end <= size(r) && "creating invalid range" );
+            //NDNBOOST_ASSERT( advance_begin - advance_end <= size(r) && "creating invalid range" );
             return iterator_range_detail::make_range_impl( r, advance_begin, advance_end );
         }
 
-#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+#endif // NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING
 
         //! copy a range into a sequence
         /*!
@@ -645,7 +645,7 @@
 
 } // namespace 'boost'
 
-#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500))
+#if NDNBOOST_WORKAROUND(NDNBOOST_MSVC, NDNBOOST_TESTED_AT(1500))
     #pragma warning( pop )
 #endif
 
diff --git a/include/ndnboost/range/iterator_range_io.hpp b/include/ndnboost/range/iterator_range_io.hpp
index faa3657..3786623 100644
--- a/include/ndnboost/range/iterator_range_io.hpp
+++ b/include/ndnboost/range/iterator_range_io.hpp
@@ -7,28 +7,28 @@
 //
 // For more information, see http://www.boost.org/libs/range/
 //
-#ifndef BOOST_RANGE_ITERATOR_RANGE_IO_HPP_INCLUDED
-#define BOOST_RANGE_ITERATOR_RANGE_IO_HPP_INCLUDED
+#ifndef NDNBOOST_RANGE_ITERATOR_RANGE_IO_HPP_INCLUDED
+#define NDNBOOST_RANGE_ITERATOR_RANGE_IO_HPP_INCLUDED
 
 #include <ndnboost/config.hpp>
 #include <ndnboost/detail/workaround.hpp>
 
-#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500))
+#if NDNBOOST_WORKAROUND(NDNBOOST_MSVC, NDNBOOST_TESTED_AT(1500))
     #pragma warning( push )
     #pragma warning( disable : 4996 )
 #endif
 
 // From ndnboost/dynamic_bitset.hpp; thanks to Matthias Troyer for Cray X1 patch.
-#ifndef BOOST_OLD_IOSTREAMS 
+#ifndef NDNBOOST_OLD_IOSTREAMS 
 # if defined(__STL_CONFIG_H) && \
     !defined (__STL_USE_NEW_IOSTREAMS) && !defined(__crayx1) \
     /**/
-#  define BOOST_OLD_IOSTREAMS
+#  define NDNBOOST_OLD_IOSTREAMS
 # endif
-#endif // #ifndef BOOST_OLD_IOSTREAMS
+#endif // #ifndef NDNBOOST_OLD_IOSTREAMS
 
 #ifndef _STLP_NO_IOSTREAMS
-# ifndef BOOST_OLD_IOSTREAMS
+# ifndef NDNBOOST_OLD_IOSTREAMS
 #  include <ostream>
 # else
 #  include <ostream.h>
@@ -44,7 +44,7 @@
 {
 
 #ifndef _STLP_NO_IOSTREAMS
-# ifndef BOOST_OLD_IOSTREAMS   
+# ifndef NDNBOOST_OLD_IOSTREAMS   
 
         //! iterator_range output operator
         /*!
@@ -57,7 +57,7 @@
                     const iterator_range<IteratorT>& r )
         {
             std::copy( r.begin(), r.end(), 
-                       std::ostream_iterator< BOOST_DEDUCED_TYPENAME 
+                       std::ostream_iterator< NDNBOOST_DEDUCED_TYPENAME 
                                               iterator_value<IteratorT>::type, 
                                               Elem, Traits>(Os) );
             return Os;
@@ -84,9 +84,9 @@
 
 } // namespace ndnboost
 
-#undef BOOST_OLD_IOSTREAMS
+#undef NDNBOOST_OLD_IOSTREAMS
 
-#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500))
+#if NDNBOOST_WORKAROUND(NDNBOOST_MSVC, NDNBOOST_TESTED_AT(1500))
     #pragma warning(pop)
 #endif
 
diff --git a/include/ndnboost/range/mutable_iterator.hpp b/include/ndnboost/range/mutable_iterator.hpp
index e45d86d..b5183b0 100644
--- a/include/ndnboost/range/mutable_iterator.hpp
+++ b/include/ndnboost/range/mutable_iterator.hpp
@@ -8,8 +8,8 @@
 // For more information, see http://www.boost.org/libs/range/
 //
 
-#ifndef BOOST_RANGE_MUTABLE_ITERATOR_HPP
-#define BOOST_RANGE_MUTABLE_ITERATOR_HPP
+#ifndef NDNBOOST_RANGE_MUTABLE_ITERATOR_HPP
+#define NDNBOOST_RANGE_MUTABLE_ITERATOR_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
@@ -17,7 +17,7 @@
 
 #include <ndnboost/range/config.hpp>
 
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#ifdef NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 #include <ndnboost/range/detail/iterator.hpp>
 #else
 
@@ -33,7 +33,7 @@
     //////////////////////////////////////////////////////////////////////////
     
     namespace range_detail {
-        BOOST_RANGE_EXTRACT_OPTIONAL_TYPE( iterator )
+        NDNBOOST_RANGE_EXTRACT_OPTIONAL_TYPE( iterator )
     }
 
     template< typename C >
@@ -62,6 +62,6 @@
 
 } // namespace ndnboost
 
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#endif // NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
 #endif
diff --git a/include/ndnboost/range/rbegin.hpp b/include/ndnboost/range/rbegin.hpp
index 8ab2456..68858f1 100644
--- a/include/ndnboost/range/rbegin.hpp
+++ b/include/ndnboost/range/rbegin.hpp
@@ -8,8 +8,8 @@
 // For more information, see http://www.boost.org/libs/range/
 //
 
-#ifndef BOOST_RANGE_RBEGIN_HPP
-#define BOOST_RANGE_RBEGIN_HPP
+#ifndef NDNBOOST_RANGE_RBEGIN_HPP
+#define NDNBOOST_RANGE_RBEGIN_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
@@ -21,39 +21,39 @@
 namespace ndnboost
 {
 
-#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+#ifdef NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING
 
 template< class C >
-inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type
+inline NDNBOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type
 rbegin( C& c )
 {
-    return BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type( ndnboost::end( c ) );
+    return NDNBOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type( ndnboost::end( c ) );
 }
 
 #else
 
 template< class C >
-inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type
+inline NDNBOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type
 rbegin( C& c )
 {
-    typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type
+    typedef NDNBOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type
         iter_type;
     return iter_type( ndnboost::end( c ) );
 }
 
 template< class C >
-inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<const C>::type
+inline NDNBOOST_DEDUCED_TYPENAME range_reverse_iterator<const C>::type
 rbegin( const C& c )
 {
-    typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator<const C>::type
+    typedef NDNBOOST_DEDUCED_TYPENAME range_reverse_iterator<const C>::type
         iter_type;
     return iter_type( ndnboost::end( c ) );
 }
 
-#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+#endif // NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING
 
 template< class T >
-inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<const T>::type
+inline NDNBOOST_DEDUCED_TYPENAME range_reverse_iterator<const T>::type
 const_rbegin( const T& r )
 {
     return ndnboost::rbegin( r );
diff --git a/include/ndnboost/range/rend.hpp b/include/ndnboost/range/rend.hpp
index 715ae6b..c680ca6 100644
--- a/include/ndnboost/range/rend.hpp
+++ b/include/ndnboost/range/rend.hpp
@@ -8,8 +8,8 @@
 // For more information, see http://www.boost.org/libs/range/
 //
 
-#ifndef BOOST_RANGE_REND_HPP
-#define BOOST_RANGE_REND_HPP
+#ifndef NDNBOOST_RANGE_REND_HPP
+#define NDNBOOST_RANGE_REND_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
@@ -21,31 +21,31 @@
 namespace ndnboost
 {
 
-#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+#ifdef NDNBOOST_NO_FUNCTION_TEMPLATE_ORDERING
 
 template< class C >
-inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type
+inline NDNBOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type
 rend( C& c )
 {
-    return BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type( ndnboost::begin( c ) );
+    return NDNBOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type( ndnboost::begin( c ) );
 }
 
 #else
 
 template< class C >
-inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type
+inline NDNBOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type
 rend( C& c )
 {
-    typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type
+    typedef NDNBOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type
                iter_type;
     return iter_type( ndnboost::begin( c ) );
 }
 
 template< class C >
-inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<const C>::type
+inline NDNBOOST_DEDUCED_TYPENAME range_reverse_iterator<const C>::type
 rend( const C& c )
 {
-    typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator<const C>::type
+    typedef NDNBOOST_DEDUCED_TYPENAME range_reverse_iterator<const C>::type
         iter_type;
     return iter_type( ndnboost::begin( c ) );
 }
@@ -53,7 +53,7 @@
 #endif
 
 template< class T >
-inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<const T>::type
+inline NDNBOOST_DEDUCED_TYPENAME range_reverse_iterator<const T>::type
 const_rend( const T& r )
 {
     return ndnboost::rend( r );
diff --git a/include/ndnboost/range/result_iterator.hpp b/include/ndnboost/range/result_iterator.hpp
index 5c0dd75..006e77d 100644
--- a/include/ndnboost/range/result_iterator.hpp
+++ b/include/ndnboost/range/result_iterator.hpp
@@ -8,8 +8,8 @@
 // For more information, see http://www.boost.org/libs/range/
 //
 
-#ifndef BOOST_RANGE_RESULT_ITERATOR_HPP
-#define BOOST_RANGE_RESULT_ITERATOR_HPP
+#ifndef NDNBOOST_RANGE_RESULT_ITERATOR_HPP
+#define NDNBOOST_RANGE_RESULT_ITERATOR_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
diff --git a/include/ndnboost/range/reverse_iterator.hpp b/include/ndnboost/range/reverse_iterator.hpp
index 68fe03d..a50f78b 100644
--- a/include/ndnboost/range/reverse_iterator.hpp
+++ b/include/ndnboost/range/reverse_iterator.hpp
@@ -8,8 +8,8 @@
 // For more information, see http://www.boost.org/libs/range/
 //
 
-#ifndef BOOST_RANGE_REVERSE_ITERATOR_HPP
-#define BOOST_RANGE_REVERSE_ITERATOR_HPP
+#ifndef NDNBOOST_RANGE_REVERSE_ITERATOR_HPP
+#define NDNBOOST_RANGE_REVERSE_ITERATOR_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
@@ -30,7 +30,7 @@
     struct range_reverse_iterator
     {
         typedef reverse_iterator< 
-            BOOST_DEDUCED_TYPENAME range_iterator<C>::type > type;
+            NDNBOOST_DEDUCED_TYPENAME range_iterator<C>::type > type;
     };
     
 
diff --git a/include/ndnboost/range/size.hpp b/include/ndnboost/range/size.hpp
index 9164e02..1952550 100644
--- a/include/ndnboost/range/size.hpp
+++ b/include/ndnboost/range/size.hpp
@@ -8,8 +8,8 @@
 // For more information, see http://www.boost.org/libs/range/
 //
 
-#ifndef BOOST_RANGE_SIZE_HPP
-#define BOOST_RANGE_SIZE_HPP
+#ifndef NDNBOOST_RANGE_SIZE_HPP
+#define NDNBOOST_RANGE_SIZE_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
@@ -26,21 +26,21 @@
     namespace range_detail
     {
         template<class SinglePassRange>
-        inline BOOST_DEDUCED_TYPENAME range_size<const SinglePassRange>::type
+        inline NDNBOOST_DEDUCED_TYPENAME range_size<const SinglePassRange>::type
         range_calculate_size(const SinglePassRange& rng)
         {
-            BOOST_ASSERT( (ndnboost::end(rng) - ndnboost::begin(rng)) >= 0 &&
+            NDNBOOST_ASSERT( (ndnboost::end(rng) - ndnboost::begin(rng)) >= 0 &&
                           "reachability invariant broken!" );
             return ndnboost::end(rng) - ndnboost::begin(rng);
         }
     }
 
     template<class SinglePassRange>
-    inline BOOST_DEDUCED_TYPENAME range_size<const SinglePassRange>::type
+    inline NDNBOOST_DEDUCED_TYPENAME range_size<const SinglePassRange>::type
     size(const SinglePassRange& rng)
     {
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
-    !BOOST_WORKAROUND(__GNUC__, < 3) \
+#if !NDNBOOST_WORKAROUND(__BORLANDC__, NDNBOOST_TESTED_AT(0x564)) && \
+    !NDNBOOST_WORKAROUND(__GNUC__, < 3) \
     /**/
         using namespace range_detail;
 #endif
diff --git a/include/ndnboost/range/size_type.hpp b/include/ndnboost/range/size_type.hpp
index 0ae8a87..ce48639 100644
--- a/include/ndnboost/range/size_type.hpp
+++ b/include/ndnboost/range/size_type.hpp
@@ -8,8 +8,8 @@
 // For more information, see http://www.boost.org/libs/range/
 //
 
-#ifndef BOOST_RANGE_SIZE_TYPE_HPP
-#define BOOST_RANGE_SIZE_TYPE_HPP
+#ifndef NDNBOOST_RANGE_SIZE_TYPE_HPP
+#define NDNBOOST_RANGE_SIZE_TYPE_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
@@ -17,7 +17,7 @@
 
 #include <ndnboost/range/config.hpp>
 #include <ndnboost/range/difference_type.hpp>
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#ifdef NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 #include <ndnboost/range/detail/size_type.hpp>
 #else
 
@@ -43,7 +43,7 @@
             struct yes_type { char dummy[2]; };
 
             template<typename C>
-            static yes_type test(BOOST_DEDUCED_TYPENAME C::size_type x);
+            static yes_type test(NDNBOOST_DEDUCED_TYPENAME C::size_type x);
 
             template<typename C, typename Arg>
             static no_type test(Arg x);
@@ -55,18 +55,18 @@
         template<typename C, typename Enabler=void>
         struct range_size
         {
-            typedef BOOST_DEDUCED_TYPENAME make_unsigned<
-                BOOST_DEDUCED_TYPENAME range_difference<C>::type
+            typedef NDNBOOST_DEDUCED_TYPENAME make_unsigned<
+                NDNBOOST_DEDUCED_TYPENAME range_difference<C>::type
             >::type type;
         };
 
         template<typename C>
         struct range_size<
             C,
-            BOOST_DEDUCED_TYPENAME enable_if<has_size_type<C>, void>::type
+            NDNBOOST_DEDUCED_TYPENAME enable_if<has_size_type<C>, void>::type
         >
         {
-            typedef BOOST_DEDUCED_TYPENAME C::size_type type;
+            typedef NDNBOOST_DEDUCED_TYPENAME C::size_type type;
         };
 
     }
@@ -83,7 +83,7 @@
 
 } // namespace ndnboost
 
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#endif // NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
 
 #endif
diff --git a/include/ndnboost/range/value_type.hpp b/include/ndnboost/range/value_type.hpp
index 855ed05..655ea60 100644
--- a/include/ndnboost/range/value_type.hpp
+++ b/include/ndnboost/range/value_type.hpp
@@ -8,8 +8,8 @@
 // For more information, see http://www.boost.org/libs/range/
 //
 
-#ifndef BOOST_RANGE_VALUE_TYPE_HPP
-#define BOOST_RANGE_VALUE_TYPE_HPP
+#ifndef NDNBOOST_RANGE_VALUE_TYPE_HPP
+#define NDNBOOST_RANGE_VALUE_TYPE_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
@@ -18,7 +18,7 @@
 #include <ndnboost/range/config.hpp>
 #include <ndnboost/range/iterator.hpp>
 
-//#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+//#ifdef NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 //#include <ndnboost/range/detail/value_type.hpp>
 //#else