diff --git a/include/ndnboost/tuple/detail/tuple_basic.hpp b/include/ndnboost/tuple/detail/tuple_basic.hpp
index 75f7d80..cbb6774 100644
--- a/include/ndnboost/tuple/detail/tuple_basic.hpp
+++ b/include/ndnboost/tuple/detail/tuple_basic.hpp
@@ -29,8 +29,8 @@
 //      Added default constructor for cons<>.
 // -----------------------------------------------------------------
 
-#ifndef BOOST_TUPLE_BASIC_HPP
-#define BOOST_TUPLE_BASIC_HPP
+#ifndef NDNBOOST_TUPLE_BASIC_HPP
+#define NDNBOOST_TUPLE_BASIC_HPP
 
 
 #include <utility> // needed for the assignment from pair to tuple
@@ -39,7 +39,7 @@
 #include "ndnboost/type_traits/function_traits.hpp"
 #include "ndnboost/utility/swap.hpp"
 
-#include "ndnboost/detail/workaround.hpp" // needed for BOOST_WORKAROUND
+#include "ndnboost/detail/workaround.hpp" // needed for NDNBOOST_WORKAROUND
 
 namespace ndnboost {
 namespace tuples {
@@ -91,9 +91,9 @@
 struct drop_front {
     template<class Tuple>
     struct apply {
-        typedef BOOST_DEDUCED_TYPENAME drop_front<N-1>::BOOST_NESTED_TEMPLATE
+        typedef NDNBOOST_DEDUCED_TYPENAME drop_front<N-1>::NDNBOOST_NESTED_TEMPLATE
             apply<Tuple> next;
-        typedef BOOST_DEDUCED_TYPENAME next::type::tail_type type;
+        typedef NDNBOOST_DEDUCED_TYPENAME next::type::tail_type type;
         static const type& call(const Tuple& tup) {
             return next::call(tup).tail;
         }
@@ -119,12 +119,12 @@
 // Nth element ot T, first element is at index 0
 // -------------------------------------------------------
 
-#ifndef BOOST_NO_CV_SPECIALIZATIONS
+#ifndef NDNBOOST_NO_CV_SPECIALIZATIONS
 
 template<int N, class T>
 struct element
 {
-  typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
+  typedef NDNBOOST_DEDUCED_TYPENAME detail::drop_front<N>::NDNBOOST_NESTED_TEMPLATE
       apply<T>::type::head_type type;
 };
 
@@ -132,30 +132,30 @@
 struct element<N, const T>
 {
 private:
-  typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
+  typedef NDNBOOST_DEDUCED_TYPENAME detail::drop_front<N>::NDNBOOST_NESTED_TEMPLATE
       apply<T>::type::head_type unqualified_type;
 public:
-#if BOOST_WORKAROUND(__BORLANDC__,<0x600)
+#if NDNBOOST_WORKAROUND(__BORLANDC__,<0x600)
   typedef const unqualified_type type;
 #else
-  typedef BOOST_DEDUCED_TYPENAME ndnboost::add_const<unqualified_type>::type type;
+  typedef NDNBOOST_DEDUCED_TYPENAME ndnboost::add_const<unqualified_type>::type type;
 #endif
 };
-#else // def BOOST_NO_CV_SPECIALIZATIONS
+#else // def NDNBOOST_NO_CV_SPECIALIZATIONS
 
 namespace detail {
 
 template<int N, class T, bool IsConst>
 struct element_impl
 {
-  typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
+  typedef NDNBOOST_DEDUCED_TYPENAME detail::drop_front<N>::NDNBOOST_NESTED_TEMPLATE
       apply<T>::type::head_type type;
 };
 
 template<int N, class T>
 struct element_impl<N, T, true /* IsConst */>
 {
-  typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
+  typedef NDNBOOST_DEDUCED_TYPENAME detail::drop_front<N>::NDNBOOST_NESTED_TEMPLATE
       apply<T>::type::head_type unqualified_type;
   typedef const unqualified_type type;
 };
@@ -208,10 +208,10 @@
 inline typename access_traits<
                   typename element<N, cons<HT, TT> >::type
                 >::non_const_type
-get(cons<HT, TT>& c BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) {
-  typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
+get(cons<HT, TT>& c NDNBOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) {
+  typedef NDNBOOST_DEDUCED_TYPENAME detail::drop_front<N>::NDNBOOST_NESTED_TEMPLATE
       apply<cons<HT, TT> > impl;
-  typedef BOOST_DEDUCED_TYPENAME impl::type cons_element;
+  typedef NDNBOOST_DEDUCED_TYPENAME impl::type cons_element;
   return const_cast<cons_element&>(impl::call(c)).head;
 }
 
@@ -222,10 +222,10 @@
 inline typename access_traits<
                   typename element<N, cons<HT, TT> >::type
                 >::const_type
-get(const cons<HT, TT>& c BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) {
-  typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
+get(const cons<HT, TT>& c NDNBOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) {
+  typedef NDNBOOST_DEDUCED_TYPENAME detail::drop_front<N>::NDNBOOST_NESTED_TEMPLATE
       apply<cons<HT, TT> > impl;
-  typedef BOOST_DEDUCED_TYPENAME impl::type cons_element;
+  typedef NDNBOOST_DEDUCED_TYPENAME impl::type cons_element;
   return impl::call(c).head;
 }
 
@@ -322,7 +322,7 @@
 
   template <class T1, class T2>
   cons& operator=( const std::pair<T1, T2>& u ) {
-    BOOST_STATIC_ASSERT(length<cons>::value == 2); // check length = 2
+    NDNBOOST_STATIC_ASSERT(length<cons>::value == 2); // check length = 2
     head = u.first; tail.head = u.second; return *this;
   }
 
@@ -399,7 +399,7 @@
   typename access_traits<
              typename element<N, self_type>::type
             >::non_const_type
-  get(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) {
+  get(NDNBOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) {
     return ndnboost::tuples::get<N>(*this);
   }
 
@@ -407,7 +407,7 @@
   typename access_traits<
              typename element<N, self_type>::type
            >::const_type
-  get(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) const {
+  get(NDNBOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) const {
     return ndnboost::tuples::get<N>(*this);
   }
 
@@ -417,27 +417,27 @@
 
 template<class T>
 struct length  {
-  BOOST_STATIC_CONSTANT(int, value = 1 + length<typename T::tail_type>::value);
+  NDNBOOST_STATIC_CONSTANT(int, value = 1 + length<typename T::tail_type>::value);
 };
 
 template<>
 struct length<tuple<> > {
-  BOOST_STATIC_CONSTANT(int, value = 0);
+  NDNBOOST_STATIC_CONSTANT(int, value = 0);
 };
 
 template<>
 struct length<tuple<> const> {
-  BOOST_STATIC_CONSTANT(int, value = 0);
+  NDNBOOST_STATIC_CONSTANT(int, value = 0);
 };
 
 template<>
 struct length<null_type> {
-  BOOST_STATIC_CONSTANT(int, value = 0);
+  NDNBOOST_STATIC_CONSTANT(int, value = 0);
 };
 
 template<>
 struct length<null_type const> {
-  BOOST_STATIC_CONSTANT(int, value = 0);
+  NDNBOOST_STATIC_CONSTANT(int, value = 0);
 };
 
 namespace detail {
@@ -579,7 +579,7 @@
 
   template <class U1, class U2>
   tuple& operator=(const std::pair<U1, U2>& k) {
-    BOOST_STATIC_ASSERT(length<tuple>::value == 2);// check_length = 2
+    NDNBOOST_STATIC_ASSERT(length<tuple>::value == 2);// check_length = 2
     this->head = k.first;
     this->tail.head = k.second;
     return *this;
@@ -975,6 +975,6 @@
 } // end of namespace ndnboost
 
 
-#endif // BOOST_TUPLE_BASIC_HPP
+#endif // NDNBOOST_TUPLE_BASIC_HPP
 
 
diff --git a/include/ndnboost/tuple/detail/tuple_basic_no_partial_spec.hpp b/include/ndnboost/tuple/detail/tuple_basic_no_partial_spec.hpp
index 5f89415..59222b7 100644
--- a/include/ndnboost/tuple/detail/tuple_basic_no_partial_spec.hpp
+++ b/include/ndnboost/tuple/detail/tuple_basic_no_partial_spec.hpp
@@ -23,14 +23,14 @@
 
 // -----------------------------------------------------------------
 
-#ifndef BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP
-#define BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP
+#ifndef NDNBOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP
+#define NDNBOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP
 
 #include "ndnboost/type_traits.hpp"
 #include "ndnboost/utility/swap.hpp"
 #include <utility>
 
-#if defined BOOST_MSVC
+#if defined NDNBOOST_MSVC
 #pragma warning(disable:4518) // storage-class or type specifier(s) unexpected here; ignored
 #pragma warning(disable:4181) // qualifier applied to reference type ignored
 #pragma warning(disable:4227) // qualifier applied to reference type ignored
@@ -106,7 +106,7 @@
         // Each of vc6 and vc7 seem to require a different formulation
         // of this return type
         template <class H, class T>
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+#if NDNBOOST_WORKAROUND(NDNBOOST_MSVC, < 1300)
         static typename add_reference<typename add_const<T>::type>::type
 #else
         static typename add_const_reference<T>::type
@@ -179,7 +179,7 @@
 
      cons() : head(), tail() {}
 
-#if defined BOOST_MSVC
+#if defined NDNBOOST_MSVC
       template<typename Tail>
       cons(head_cref h /* = head_type() */, // causes MSVC 6.5 to barf.
                     const Tail& t) : head(h), tail(t.head, t.tail)
@@ -314,7 +314,7 @@
 
     namespace detail {
 
-#if defined(BOOST_MSVC) && (BOOST_MSVC == 1300)
+#if defined(NDNBOOST_MSVC) && (NDNBOOST_MSVC == 1300)
       // special workaround for vc7:
 
       template <bool x>
@@ -397,17 +397,17 @@
     template<typename Tuple>
     struct length
     {
-      BOOST_STATIC_CONSTANT(int, value = 1 + length<typename Tuple::tail_type>::value);
+      NDNBOOST_STATIC_CONSTANT(int, value = 1 + length<typename Tuple::tail_type>::value);
     };
 
     template<> struct length<tuple<> > {
-      BOOST_STATIC_CONSTANT(int, value = 0);
+      NDNBOOST_STATIC_CONSTANT(int, value = 0);
     };
 
     template<>
     struct length<null_type>
     {
-      BOOST_STATIC_CONSTANT(int, value = 0);
+      NDNBOOST_STATIC_CONSTANT(int, value = 0);
     };
 
     namespace detail {
@@ -862,4 +862,4 @@
 
 } // namespace tuples
 } // namespace ndnboost
-#endif // BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP
+#endif // NDNBOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP
diff --git a/include/ndnboost/tuple/tuple.hpp b/include/ndnboost/tuple/tuple.hpp
index 06689bd..40b5804 100644
--- a/include/ndnboost/tuple/tuple.hpp
+++ b/include/ndnboost/tuple/tuple.hpp
@@ -10,8 +10,8 @@
 
 // ----------------------------------------------------------------- 
 
-#ifndef BOOST_TUPLE_HPP
-#define BOOST_TUPLE_HPP
+#ifndef NDNBOOST_TUPLE_HPP
+#define NDNBOOST_TUPLE_HPP
 
 #if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730
 // Work around a compiler bug.
@@ -23,7 +23,7 @@
 #include "ndnboost/config.hpp"
 #include "ndnboost/static_assert.hpp"
 
-#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#if defined(NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 // The MSVC version
 #include "ndnboost/tuple/detail/tuple_basic_no_partial_spec.hpp"
 
@@ -32,16 +32,16 @@
 #include "ndnboost/ref.hpp"
 #include "ndnboost/tuple/detail/tuple_basic.hpp"
 
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#endif // NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
 namespace ndnboost {    
 
 using tuples::tuple;
 using tuples::make_tuple;
 using tuples::tie;
-#if !defined(BOOST_NO_USING_TEMPLATE)
+#if !defined(NDNBOOST_NO_USING_TEMPLATE)
 using tuples::get;
-#elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#elif !defined(NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 //
 // The "using tuples::get" statement causes the
 // Borland compiler to ICE, use forwarding
@@ -64,7 +64,7 @@
 get(const tuples::cons<HT, TT>& c) {
   return tuples::get<N,HT,TT>(c);
 }
-#else  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#else  // NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 //
 // MSVC, using declarations don't mix with templates well,
 // so use forwarding functions instead:
@@ -82,9 +82,9 @@
 {
    return tuples::detail::get_class<N>::get(t);
 }
-#endif // BOOST_NO_USING_TEMPLATE
+#endif // NDNBOOST_NO_USING_TEMPLATE
    
 } // end namespace ndnboost
 
 
-#endif // BOOST_TUPLE_HPP
+#endif // NDNBOOST_TUPLE_HPP