diff --git a/include/ndnboost/typeof/vector.hpp b/include/ndnboost/typeof/vector.hpp
index 0673d1c..dfb1dfd 100644
--- a/include/ndnboost/typeof/vector.hpp
+++ b/include/ndnboost/typeof/vector.hpp
@@ -6,60 +6,60 @@
 // Use, modification and distribution is subject to the Boost Software
 // License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef BOOST_TYPEOF_VECTOR_HPP_INCLUDED
+#ifndef NDNBOOST_TYPEOF_VECTOR_HPP_INCLUDED
 
 #include <ndnboost/mpl/int.hpp>
 #include <ndnboost/preprocessor/iteration/self.hpp>
 
-#ifndef BOOST_TYPEOF_LIMIT_SIZE
-#   define BOOST_TYPEOF_LIMIT_SIZE 50
+#ifndef NDNBOOST_TYPEOF_LIMIT_SIZE
+#   define NDNBOOST_TYPEOF_LIMIT_SIZE 50
 #endif
 
 //
 // To recreate the preprocessed versions of this file preprocess and run
 //
-//   $(BOOST_ROOT)/libs/typeof/tools/preprocess.pl
+//   $(NDNBOOST_ROOT)/libs/typeof/tools/preprocess.pl
 //
 
-#if defined(BOOST_TYPEOF_PP_INCLUDE_EXTERNAL)
+#if defined(NDNBOOST_TYPEOF_PP_INCLUDE_EXTERNAL)
 
-#   undef BOOST_TYPEOF_PP_INCLUDE_EXTERNAL
+#   undef NDNBOOST_TYPEOF_PP_INCLUDE_EXTERNAL
 
-#elif !defined(BOOST_TYPEOF_PREPROCESSING_MODE) && !BOOST_PP_IS_SELFISH
+#elif !defined(NDNBOOST_TYPEOF_PREPROCESSING_MODE) && !NDNBOOST_PP_IS_SELFISH
 
-#   define BOOST_PP_INDIRECT_SELF <ndnboost/typeof/vector.hpp>
-#   if   BOOST_TYPEOF_LIMIT_SIZE < 50
-#     include BOOST_PP_INCLUDE_SELF()
-#   elif BOOST_TYPEOF_LIMIT_SIZE < 100
+#   define NDNBOOST_PP_INDIRECT_SELF <ndnboost/typeof/vector.hpp>
+#   if   NDNBOOST_TYPEOF_LIMIT_SIZE < 50
+#     include NDNBOOST_PP_INCLUDE_SELF()
+#   elif NDNBOOST_TYPEOF_LIMIT_SIZE < 100
 #     include <ndnboost/typeof/vector50.hpp>
-#     define  BOOST_TYPEOF_PP_START_SIZE 51
-#     include BOOST_PP_INCLUDE_SELF()
-#   elif BOOST_TYPEOF_LIMIT_SIZE < 150
+#     define  NDNBOOST_TYPEOF_PP_START_SIZE 51
+#     include NDNBOOST_PP_INCLUDE_SELF()
+#   elif NDNBOOST_TYPEOF_LIMIT_SIZE < 150
 #     include <ndnboost/typeof/vector100.hpp>
-#     define  BOOST_TYPEOF_PP_START_SIZE 101
-#     include BOOST_PP_INCLUDE_SELF()
-#   elif BOOST_TYPEOF_LIMIT_SIZE < 200
+#     define  NDNBOOST_TYPEOF_PP_START_SIZE 101
+#     include NDNBOOST_PP_INCLUDE_SELF()
+#   elif NDNBOOST_TYPEOF_LIMIT_SIZE < 200
 #     include <ndnboost/typeof/vector150.hpp>
-#     define  BOOST_TYPEOF_PP_START_SIZE 151
-#     include BOOST_PP_INCLUDE_SELF()
-#   elif BOOST_TYPEOF_LIMIT_SIZE <= 250
+#     define  NDNBOOST_TYPEOF_PP_START_SIZE 151
+#     include NDNBOOST_PP_INCLUDE_SELF()
+#   elif NDNBOOST_TYPEOF_LIMIT_SIZE <= 250
 #     include <ndnboost/typeof/vector200.hpp>
-#     define  BOOST_TYPEOF_PP_START_SIZE 201
-#     include BOOST_PP_INCLUDE_SELF()
+#     define  NDNBOOST_TYPEOF_PP_START_SIZE 201
+#     include NDNBOOST_PP_INCLUDE_SELF()
 #   else
-#     error "BOOST_TYPEOF_LIMIT_SIZE too high"
+#     error "NDNBOOST_TYPEOF_LIMIT_SIZE too high"
 #   endif
 
-#else// defined(BOOST_TYPEOF_PREPROCESSING_MODE) || BOOST_PP_IS_SELFISH
+#else// defined(NDNBOOST_TYPEOF_PREPROCESSING_MODE) || NDNBOOST_PP_IS_SELFISH
 
-#   ifndef BOOST_TYPEOF_PP_NEXT_SIZE
-#     define BOOST_TYPEOF_PP_NEXT_SIZE BOOST_TYPEOF_LIMIT_SIZE
+#   ifndef NDNBOOST_TYPEOF_PP_NEXT_SIZE
+#     define NDNBOOST_TYPEOF_PP_NEXT_SIZE NDNBOOST_TYPEOF_LIMIT_SIZE
 #   endif
-#   ifndef BOOST_TYPEOF_PP_START_SIZE
-#     define BOOST_TYPEOF_PP_START_SIZE 0
+#   ifndef NDNBOOST_TYPEOF_PP_START_SIZE
+#     define NDNBOOST_TYPEOF_PP_START_SIZE 0
 #   endif
 
-#   if BOOST_TYPEOF_PP_START_SIZE <= BOOST_TYPEOF_LIMIT_SIZE
+#   if NDNBOOST_TYPEOF_PP_START_SIZE <= NDNBOOST_TYPEOF_LIMIT_SIZE
 
 #     include <ndnboost/preprocessor/enum_params.hpp>
 #     include <ndnboost/preprocessor/repeat.hpp>
@@ -74,7 +74,7 @@
 
 // iterator
 
-#     define BOOST_TYPEOF_spec_iter(n)\
+#     define NDNBOOST_TYPEOF_spec_iter(n)\
         template<class V>\
         struct v_iter<V, mpl::int_<n> >\
         {\
@@ -84,83 +84,83 @@
 
 namespace ndnboost { namespace type_of {
 
-    template<class V, class Increase_BOOST_TYPEOF_LIMIT_SIZE> struct v_iter; // not defined
-#     define  BOOST_PP_LOCAL_MACRO  BOOST_TYPEOF_spec_iter
-#     define  BOOST_PP_LOCAL_LIMITS \
-        (BOOST_PP_DEC(BOOST_TYPEOF_PP_START_SIZE), \
-         BOOST_PP_DEC(BOOST_TYPEOF_LIMIT_SIZE))
-#     include BOOST_PP_LOCAL_ITERATE()
+    template<class V, class Increase_NDNBOOST_TYPEOF_LIMIT_SIZE> struct v_iter; // not defined
+#     define  NDNBOOST_PP_LOCAL_MACRO  NDNBOOST_TYPEOF_spec_iter
+#     define  NDNBOOST_PP_LOCAL_LIMITS \
+        (NDNBOOST_PP_DEC(NDNBOOST_TYPEOF_PP_START_SIZE), \
+         NDNBOOST_PP_DEC(NDNBOOST_TYPEOF_LIMIT_SIZE))
+#     include NDNBOOST_PP_LOCAL_ITERATE()
 
 }}
 
-#     undef BOOST_TYPEOF_spec_iter
+#     undef NDNBOOST_TYPEOF_spec_iter
 
 // vector
 
-#     define BOOST_TYPEOF_typedef_item(z, n, _)\
+#     define NDNBOOST_TYPEOF_typedef_item(z, n, _)\
         typedef P ## n item ## n;
 
-#     define BOOST_TYPEOF_typedef_fake_item(z, n, _)\
+#     define NDNBOOST_TYPEOF_typedef_fake_item(z, n, _)\
         typedef mpl::int_<1> item ## n;
 
-#     define BOOST_TYPEOF_define_vector(n)\
-        template<BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IIF(BOOST_PP_NOT(n), class T = void)>\
+#     define NDNBOOST_TYPEOF_define_vector(n)\
+        template<NDNBOOST_PP_ENUM_PARAMS(n, class P) NDNBOOST_PP_EXPR_IIF(NDNBOOST_PP_NOT(n), class T = void)>\
         struct vector ## n\
         {\
-            typedef v_iter<vector ## n<BOOST_PP_ENUM_PARAMS(n,P)>, ndnboost::mpl::int_<0> > begin;\
-            BOOST_PP_REPEAT(n, BOOST_TYPEOF_typedef_item, ~)\
-            BOOST_PP_REPEAT_FROM_TO(n, BOOST_TYPEOF_PP_NEXT_SIZE, BOOST_TYPEOF_typedef_fake_item, ~)\
+            typedef v_iter<vector ## n<NDNBOOST_PP_ENUM_PARAMS(n,P)>, ndnboost::mpl::int_<0> > begin;\
+            NDNBOOST_PP_REPEAT(n, NDNBOOST_TYPEOF_typedef_item, ~)\
+            NDNBOOST_PP_REPEAT_FROM_TO(n, NDNBOOST_TYPEOF_PP_NEXT_SIZE, NDNBOOST_TYPEOF_typedef_fake_item, ~)\
         };
 
 namespace ndnboost { namespace type_of {
 
-#     define  BOOST_PP_LOCAL_MACRO  BOOST_TYPEOF_define_vector
-#     define  BOOST_PP_LOCAL_LIMITS \
-        (BOOST_TYPEOF_PP_START_SIZE,BOOST_TYPEOF_LIMIT_SIZE)
-#     include BOOST_PP_LOCAL_ITERATE()
+#     define  NDNBOOST_PP_LOCAL_MACRO  NDNBOOST_TYPEOF_define_vector
+#     define  NDNBOOST_PP_LOCAL_LIMITS \
+        (NDNBOOST_TYPEOF_PP_START_SIZE,NDNBOOST_TYPEOF_LIMIT_SIZE)
+#     include NDNBOOST_PP_LOCAL_ITERATE()
 
 }}
 
-#     undef BOOST_TYPEOF_typedef_item
-#     undef BOOST_TYPEOF_typedef_fake_item
-#     undef BOOST_TYPEOF_define_vector
+#     undef NDNBOOST_TYPEOF_typedef_item
+#     undef NDNBOOST_TYPEOF_typedef_fake_item
+#     undef NDNBOOST_TYPEOF_define_vector
 
 // push_back
 
-#     define BOOST_TYPEOF_spec_push_back(n)\
-        template<BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_COMMA_IF(n) class T>\
-        struct push_back<BOOST_PP_CAT(ndnboost::type_of::vector, n)<BOOST_PP_ENUM_PARAMS(n, P)>, T>\
+#     define NDNBOOST_TYPEOF_spec_push_back(n)\
+        template<NDNBOOST_PP_ENUM_PARAMS(n, class P) NDNBOOST_PP_COMMA_IF(n) class T>\
+        struct push_back<NDNBOOST_PP_CAT(ndnboost::type_of::vector, n)<NDNBOOST_PP_ENUM_PARAMS(n, P)>, T>\
         {\
-            typedef BOOST_PP_CAT(ndnboost::type_of::vector, BOOST_PP_INC(n))<\
-                BOOST_PP_ENUM_PARAMS(n, P) BOOST_PP_COMMA_IF(n) T\
+            typedef NDNBOOST_PP_CAT(ndnboost::type_of::vector, NDNBOOST_PP_INC(n))<\
+                NDNBOOST_PP_ENUM_PARAMS(n, P) NDNBOOST_PP_COMMA_IF(n) T\
             > type;\
         };
 
 namespace ndnboost { namespace type_of {
 
-#   if   BOOST_TYPEOF_LIMIT_SIZE < 50
+#   if   NDNBOOST_TYPEOF_LIMIT_SIZE < 50
     template<class V, class T> struct push_back {
         typedef V type;
     };
 #   endif
     //default behaviour is to let push_back ignore T, and return the input vector.
-    //This is to let BOOST_TYPEOF_NESTED_TYPEDEF work properly with the default vector.
-#     define  BOOST_PP_LOCAL_MACRO  BOOST_TYPEOF_spec_push_back
-#     define  BOOST_PP_LOCAL_LIMITS \
-        (BOOST_PP_DEC(BOOST_TYPEOF_PP_START_SIZE), \
-         BOOST_PP_DEC(BOOST_TYPEOF_LIMIT_SIZE))
-#     include BOOST_PP_LOCAL_ITERATE()
+    //This is to let NDNBOOST_TYPEOF_NESTED_TYPEDEF work properly with the default vector.
+#     define  NDNBOOST_PP_LOCAL_MACRO  NDNBOOST_TYPEOF_spec_push_back
+#     define  NDNBOOST_PP_LOCAL_LIMITS \
+        (NDNBOOST_PP_DEC(NDNBOOST_TYPEOF_PP_START_SIZE), \
+         NDNBOOST_PP_DEC(NDNBOOST_TYPEOF_LIMIT_SIZE))
+#     include NDNBOOST_PP_LOCAL_ITERATE()
 
 }}
 
-#     undef BOOST_TYPEOF_spec_push_back
+#     undef NDNBOOST_TYPEOF_spec_push_back
 
-#   endif//BOOST_TYPEOF_PP_START_SIZE<=BOOST_TYPEOF_LIMIT_SIZE
-#   undef  BOOST_TYPEOF_PP_START_SIZE
-#   undef  BOOST_TYPEOF_PP_NEXT_SIZE
+#   endif//NDNBOOST_TYPEOF_PP_START_SIZE<=NDNBOOST_TYPEOF_LIMIT_SIZE
+#   undef  NDNBOOST_TYPEOF_PP_START_SIZE
+#   undef  NDNBOOST_TYPEOF_PP_NEXT_SIZE
 
-#endif//BOOST_TYPEOF_PREPROCESSING_MODE || BOOST_PP_IS_SELFISH
+#endif//NDNBOOST_TYPEOF_PREPROCESSING_MODE || NDNBOOST_PP_IS_SELFISH
 
-#define BOOST_TYPEOF_VECTOR_HPP_INCLUDED
-#endif//BOOST_TYPEOF_VECTOR_HPP_INCLUDED
+#define NDNBOOST_TYPEOF_VECTOR_HPP_INCLUDED
+#endif//NDNBOOST_TYPEOF_VECTOR_HPP_INCLUDED