diff --git a/include/ndnboost/function_types/detail/pp_tags/cc_tag.hpp b/include/ndnboost/function_types/detail/pp_tags/cc_tag.hpp
index 81f1d89..5b80a07 100644
--- a/include/ndnboost/function_types/detail/pp_tags/cc_tag.hpp
+++ b/include/ndnboost/function_types/detail/pp_tags/cc_tag.hpp
@@ -8,10 +8,10 @@
 
 // no include guards, this file is intended for multiple inclusions
 
-  struct BOOST_FT_cc_name
+  struct NDNBOOST_FT_cc_name
   {
-    typedef detail::encode_bits<0,BOOST_FT_cc_id> bits;
-    typedef detail::constant<BOOST_FT_cc_mask> mask;
+    typedef detail::encode_bits<0,NDNBOOST_FT_cc_id> bits;
+    typedef detail::constant<NDNBOOST_FT_cc_mask> mask;
   };
 
 
diff --git a/include/ndnboost/function_types/detail/pp_tags/master.hpp b/include/ndnboost/function_types/detail/pp_tags/master.hpp
index 8d45ea4..5e86342 100644
--- a/include/ndnboost/function_types/detail/pp_tags/master.hpp
+++ b/include/ndnboost/function_types/detail/pp_tags/master.hpp
@@ -13,7 +13,7 @@
 #   pragma wave option(preserve: 0)
 #endif
 
-#if !defined(BOOST_FT_PREPROCESSING_MODE) || defined(BOOST_FT_CONFIG_HPP_INCLUDED)
+#if !defined(NDNBOOST_FT_PREPROCESSING_MODE) || defined(NDNBOOST_FT_CONFIG_HPP_INCLUDED)
 #   error "this file used with two-pass preprocessing, only"
 #endif
 
@@ -22,103 +22,103 @@
 
 namespace ndnboost { namespace function_types {
 
-typedef detail::property_tag<BOOST_FT_non_variadic,BOOST_FT_variadic_mask> non_variadic;
-typedef detail::property_tag<BOOST_FT_variadic,BOOST_FT_variadic_mask>     variadic;
+typedef detail::property_tag<NDNBOOST_FT_non_variadic,NDNBOOST_FT_variadic_mask> non_variadic;
+typedef detail::property_tag<NDNBOOST_FT_variadic,NDNBOOST_FT_variadic_mask>     variadic;
                                                                        
-typedef detail::property_tag<0,BOOST_FT_const>                     non_const;
-typedef detail::property_tag<BOOST_FT_const,BOOST_FT_const>        const_qualified;
+typedef detail::property_tag<0,NDNBOOST_FT_const>                     non_const;
+typedef detail::property_tag<NDNBOOST_FT_const,NDNBOOST_FT_const>        const_qualified;
                                                                        
-typedef detail::property_tag<0,BOOST_FT_volatile>                  non_volatile;
-typedef detail::property_tag<BOOST_FT_volatile,BOOST_FT_volatile>  volatile_qualified; 
+typedef detail::property_tag<0,NDNBOOST_FT_volatile>                  non_volatile;
+typedef detail::property_tag<NDNBOOST_FT_volatile,NDNBOOST_FT_volatile>  volatile_qualified; 
 
-typedef detail::property_tag<BOOST_FT_default_cc,BOOST_FT_cc_mask> default_cc;
+typedef detail::property_tag<NDNBOOST_FT_default_cc,NDNBOOST_FT_cc_mask> default_cc;
 
-#define BOOST_PP_VALUE BOOST_FT_const|BOOST_FT_volatile 
-#include BOOST_PP_ASSIGN_SLOT(1)
+#define NDNBOOST_PP_VALUE NDNBOOST_FT_const|NDNBOOST_FT_volatile 
+#include NDNBOOST_PP_ASSIGN_SLOT(1)
 
-typedef detail::property_tag<0                , BOOST_PP_SLOT(1)> non_cv;
-typedef detail::property_tag<BOOST_FT_const   , BOOST_PP_SLOT(1)> const_non_volatile;
-typedef detail::property_tag<BOOST_FT_volatile, BOOST_PP_SLOT(1)> volatile_non_const;
-typedef detail::property_tag<BOOST_PP_SLOT(1) , BOOST_PP_SLOT(1)> cv_qualified;
+typedef detail::property_tag<0                , NDNBOOST_PP_SLOT(1)> non_cv;
+typedef detail::property_tag<NDNBOOST_FT_const   , NDNBOOST_PP_SLOT(1)> const_non_volatile;
+typedef detail::property_tag<NDNBOOST_FT_volatile, NDNBOOST_PP_SLOT(1)> volatile_non_const;
+typedef detail::property_tag<NDNBOOST_PP_SLOT(1) , NDNBOOST_PP_SLOT(1)> cv_qualified;
 
 namespace detail {
 
-  typedef constant<BOOST_FT_full_mask> full_mask;
+  typedef constant<NDNBOOST_FT_full_mask> full_mask;
 
   template <bits_t Flags, bits_t CCID> struct encode_bits_impl
   {
-    BOOST_STATIC_CONSTANT( bits_t, value = 
-      Flags | (BOOST_FT_default_cc * CCID) << 1 );
+    NDNBOOST_STATIC_CONSTANT( bits_t, value = 
+      Flags | (NDNBOOST_FT_default_cc * CCID) << 1 );
   };
 
   template <bits_t Flags, bits_t CCID, std::size_t Arity> 
   struct encode_charr_impl
   {
-    BOOST_STATIC_CONSTANT(std::size_t, value = (std::size_t)(1+
-      Flags | (BOOST_FT_default_cc * CCID) << 1 | Arity << BOOST_FT_arity_shift
+    NDNBOOST_STATIC_CONSTANT(std::size_t, value = (std::size_t)(1+
+      Flags | (NDNBOOST_FT_default_cc * CCID) << 1 | Arity << NDNBOOST_FT_arity_shift
     ));
   };
 
   template <bits_t Bits> struct decode_bits
   {
-    BOOST_STATIC_CONSTANT(bits_t, flags = Bits & BOOST_FT_flags_mask);
+    NDNBOOST_STATIC_CONSTANT(bits_t, flags = Bits & NDNBOOST_FT_flags_mask);
 
-    BOOST_STATIC_CONSTANT(bits_t, cc_id = 
-      ( (Bits & BOOST_FT_full_mask) / BOOST_FT_default_cc) >> 1 
+    NDNBOOST_STATIC_CONSTANT(bits_t, cc_id = 
+      ( (Bits & NDNBOOST_FT_full_mask) / NDNBOOST_FT_default_cc) >> 1 
     );
 
-    BOOST_STATIC_CONSTANT(bits_t, tag_bits = (Bits & BOOST_FT_full_mask));
+    NDNBOOST_STATIC_CONSTANT(bits_t, tag_bits = (Bits & NDNBOOST_FT_full_mask));
 
-    BOOST_STATIC_CONSTANT(std::size_t, arity = (std::size_t)
-      (Bits >> BOOST_FT_arity_shift) 
+    NDNBOOST_STATIC_CONSTANT(std::size_t, arity = (std::size_t)
+      (Bits >> NDNBOOST_FT_arity_shift) 
     );
   };
 
   template <bits_t LHS_bits, bits_t LHS_mask, bits_t RHS_bits, bits_t RHS_mask>
   struct tag_ice
   {
-    BOOST_STATIC_CONSTANT(bool, match =
-      RHS_bits == (LHS_bits & RHS_mask & (RHS_bits |~BOOST_FT_type_mask))
+    NDNBOOST_STATIC_CONSTANT(bool, match =
+      RHS_bits == (LHS_bits & RHS_mask & (RHS_bits |~NDNBOOST_FT_type_mask))
     );
 
-    BOOST_STATIC_CONSTANT(bits_t, combined_bits = 
+    NDNBOOST_STATIC_CONSTANT(bits_t, combined_bits = 
       (LHS_bits & ~RHS_mask) | RHS_bits
     );
 
-    BOOST_STATIC_CONSTANT(bits_t, combined_mask =
+    NDNBOOST_STATIC_CONSTANT(bits_t, combined_mask =
       LHS_mask | RHS_mask
     );
 
-    BOOST_STATIC_CONSTANT(bits_t, extracted_bits =
+    NDNBOOST_STATIC_CONSTANT(bits_t, extracted_bits =
       LHS_bits & RHS_mask
     );
 
   };
 
-#define BOOST_FT_mask BOOST_FT_type_mask
-  typedef property_tag<BOOST_FT_callable_builtin,BOOST_FT_mask>            callable_builtin_tag;
-  typedef property_tag<BOOST_FT_non_member_callable_builtin,BOOST_FT_mask> nonmember_callable_builtin_tag;
-  typedef property_tag<BOOST_FT_function,BOOST_FT_mask>       function_tag;
-  typedef property_tag<BOOST_FT_reference,BOOST_FT_mask>      reference_tag;
-  typedef property_tag<BOOST_FT_pointer,BOOST_FT_mask>        pointer_tag;
-  typedef property_tag<BOOST_FT_member_function_pointer,BOOST_FT_mask> member_function_pointer_tag;
-  typedef property_tag<BOOST_FT_member_object_pointer,BOOST_FT_mask> member_object_pointer_tag;
-  typedef property_tag<BOOST_FT_member_object_pointer_flags,BOOST_FT_full_mask> member_object_pointer_base;
-  typedef property_tag<BOOST_FT_member_pointer,BOOST_FT_mask> member_pointer_tag;
-#undef  BOOST_FT_mask 
+#define NDNBOOST_FT_mask NDNBOOST_FT_type_mask
+  typedef property_tag<NDNBOOST_FT_callable_builtin,NDNBOOST_FT_mask>            callable_builtin_tag;
+  typedef property_tag<NDNBOOST_FT_non_member_callable_builtin,NDNBOOST_FT_mask> nonmember_callable_builtin_tag;
+  typedef property_tag<NDNBOOST_FT_function,NDNBOOST_FT_mask>       function_tag;
+  typedef property_tag<NDNBOOST_FT_reference,NDNBOOST_FT_mask>      reference_tag;
+  typedef property_tag<NDNBOOST_FT_pointer,NDNBOOST_FT_mask>        pointer_tag;
+  typedef property_tag<NDNBOOST_FT_member_function_pointer,NDNBOOST_FT_mask> member_function_pointer_tag;
+  typedef property_tag<NDNBOOST_FT_member_object_pointer,NDNBOOST_FT_mask> member_object_pointer_tag;
+  typedef property_tag<NDNBOOST_FT_member_object_pointer_flags,NDNBOOST_FT_full_mask> member_object_pointer_base;
+  typedef property_tag<NDNBOOST_FT_member_pointer,NDNBOOST_FT_mask> member_pointer_tag;
+#undef  NDNBOOST_FT_mask 
 
-#define BOOST_PP_VALUE BOOST_FT_function|BOOST_FT_non_variadic|BOOST_FT_default_cc
-#include BOOST_PP_ASSIGN_SLOT(1)
-#define BOOST_PP_VALUE BOOST_FT_type_mask|BOOST_FT_variadic_mask|BOOST_FT_cc_mask
-#include BOOST_PP_ASSIGN_SLOT(2)
+#define NDNBOOST_PP_VALUE NDNBOOST_FT_function|NDNBOOST_FT_non_variadic|NDNBOOST_FT_default_cc
+#include NDNBOOST_PP_ASSIGN_SLOT(1)
+#define NDNBOOST_PP_VALUE NDNBOOST_FT_type_mask|NDNBOOST_FT_variadic_mask|NDNBOOST_FT_cc_mask
+#include NDNBOOST_PP_ASSIGN_SLOT(2)
 
-  typedef property_tag< BOOST_PP_SLOT(1) , BOOST_PP_SLOT(2) > nv_dcc_func;
+  typedef property_tag< NDNBOOST_PP_SLOT(1) , NDNBOOST_PP_SLOT(2) > nv_dcc_func;
 
-#define BOOST_PP_VALUE \
-    BOOST_FT_member_function_pointer|BOOST_FT_non_variadic|BOOST_FT_default_cc
-#include BOOST_PP_ASSIGN_SLOT(1)
+#define NDNBOOST_PP_VALUE \
+    NDNBOOST_FT_member_function_pointer|NDNBOOST_FT_non_variadic|NDNBOOST_FT_default_cc
+#include NDNBOOST_PP_ASSIGN_SLOT(1)
 
-  typedef property_tag< BOOST_PP_SLOT(1) , BOOST_PP_SLOT(2) > nv_dcc_mfp;
+  typedef property_tag< NDNBOOST_PP_SLOT(1) , NDNBOOST_PP_SLOT(2) > nv_dcc_mfp;
 
 } // namespace detail
 
diff --git a/include/ndnboost/function_types/detail/pp_tags/preprocessed.hpp b/include/ndnboost/function_types/detail/pp_tags/preprocessed.hpp
index 8aa1c36..f449959 100644
--- a/include/ndnboost/function_types/detail/pp_tags/preprocessed.hpp
+++ b/include/ndnboost/function_types/detail/pp_tags/preprocessed.hpp
@@ -25,40 +25,40 @@
 typedef constant<0x00ff0fff> full_mask;
 template <bits_t Flags, bits_t CCID> struct encode_bits_impl
 {
-BOOST_STATIC_CONSTANT( bits_t, value = 
+NDNBOOST_STATIC_CONSTANT( bits_t, value = 
 Flags | (0x00008000 * CCID) << 1 );
 };
 template <bits_t Flags, bits_t CCID, std::size_t Arity> 
 struct encode_charr_impl
 {
-BOOST_STATIC_CONSTANT(std::size_t, value = (std::size_t)(1+
+NDNBOOST_STATIC_CONSTANT(std::size_t, value = (std::size_t)(1+
 Flags | (0x00008000 * CCID) << 1 | Arity << 24
 ));
 };
 template <bits_t Bits> struct decode_bits
 {
-BOOST_STATIC_CONSTANT(bits_t, flags = Bits & 0x00000fff);
-BOOST_STATIC_CONSTANT(bits_t, cc_id = 
+NDNBOOST_STATIC_CONSTANT(bits_t, flags = Bits & 0x00000fff);
+NDNBOOST_STATIC_CONSTANT(bits_t, cc_id = 
 ( (Bits & 0x00ff0fff) / 0x00008000) >> 1 
 );
-BOOST_STATIC_CONSTANT(bits_t, tag_bits = (Bits & 0x00ff0fff));
-BOOST_STATIC_CONSTANT(std::size_t, arity = (std::size_t)
+NDNBOOST_STATIC_CONSTANT(bits_t, tag_bits = (Bits & 0x00ff0fff));
+NDNBOOST_STATIC_CONSTANT(std::size_t, arity = (std::size_t)
 (Bits >> 24) 
 );
 };
 template <bits_t LHS_bits, bits_t LHS_mask, bits_t RHS_bits, bits_t RHS_mask>
 struct tag_ice
 {
-BOOST_STATIC_CONSTANT(bool, match =
+NDNBOOST_STATIC_CONSTANT(bool, match =
 RHS_bits == (LHS_bits & RHS_mask & (RHS_bits | ~0x000000ff))
 );
-BOOST_STATIC_CONSTANT(bits_t, combined_bits = 
+NDNBOOST_STATIC_CONSTANT(bits_t, combined_bits = 
 (LHS_bits & ~RHS_mask) | RHS_bits
 );
-BOOST_STATIC_CONSTANT(bits_t, combined_mask =
+NDNBOOST_STATIC_CONSTANT(bits_t, combined_mask =
 LHS_mask | RHS_mask
 );
-BOOST_STATIC_CONSTANT(bits_t, extracted_bits =
+NDNBOOST_STATIC_CONSTANT(bits_t, extracted_bits =
 LHS_bits & RHS_mask
 );
 };