ndnboost: Also rename BOOST_ to NDNBOOST_
diff --git a/include/ndnboost/typeof/dmc/typeof_impl.hpp b/include/ndnboost/typeof/dmc/typeof_impl.hpp
index ff77ab0..3b40f76 100644
--- a/include/ndnboost/typeof/dmc/typeof_impl.hpp
+++ b/include/ndnboost/typeof/dmc/typeof_impl.hpp
@@ -3,8 +3,8 @@
// 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_MSVC_TYPEOF_IMPL_HPP_INCLUDED
-# define BOOST_TYPEOF_MSVC_TYPEOF_IMPL_HPP_INCLUDED
+#ifndef NDNBOOST_TYPEOF_MSVC_TYPEOF_IMPL_HPP_INCLUDED
+# define NDNBOOST_TYPEOF_MSVC_TYPEOF_IMPL_HPP_INCLUDED
# include <ndnboost/config.hpp>
# include <ndnboost/detail/workaround.hpp>
@@ -20,8 +20,8 @@
char (*encode_index(...))[1];
-# define BOOST_TYPEOF_INDEX(T) (sizeof(*ndnboost::type_of::encode_index((ndnboost::type_of::encode_counter<1000>*)0)))
-# define BOOST_TYPEOF_NEXT_INDEX(next) friend char (*encode_index(encode_counter<next>*))[next];
+# define NDNBOOST_TYPEOF_INDEX(T) (sizeof(*ndnboost::type_of::encode_index((ndnboost::type_of::encode_counter<1000>*)0)))
+# define NDNBOOST_TYPEOF_NEXT_INDEX(next) friend char (*encode_index(encode_counter<next>*))[next];
//Typeof code
@@ -54,13 +54,13 @@
struct encode_type
{
//Get the next available compile time constants index
- BOOST_STATIC_CONSTANT(unsigned,value=BOOST_TYPEOF_INDEX(T));
+ NDNBOOST_STATIC_CONSTANT(unsigned,value=NDNBOOST_TYPEOF_INDEX(T));
//Instantiate the template
typedef typename msvc_register_type<T,mpl::int_<value> >::id2type type;
//Set the next compile time constants index
- BOOST_STATIC_CONSTANT(unsigned,next=value+1);
+ NDNBOOST_STATIC_CONSTANT(unsigned,next=value+1);
//Increment the compile time constant (only needed when extensions are not active
- BOOST_TYPEOF_NEXT_INDEX(next);
+ NDNBOOST_TYPEOF_NEXT_INDEX(next);
};
template<class T>
@@ -75,21 +75,21 @@
template<typename Organizer, typename T>
msvc_register_type<T,Organizer> typeof_register_type(const T&,Organizer* =0);
-# define BOOST_TYPEOF(expr) \
+# define NDNBOOST_TYPEOF(expr) \
ndnboost::type_of::msvc_typeid_wrapper<sizeof(*ndnboost::type_of::encode_start(expr))>::type
-# define BOOST_TYPEOF_TPL(expr) typename BOOST_TYPEOF(expr)
+# define NDNBOOST_TYPEOF_TPL(expr) typename NDNBOOST_TYPEOF(expr)
-# define BOOST_TYPEOF_NESTED_TYPEDEF_TPL(name,expr) \
+# define NDNBOOST_TYPEOF_NESTED_TYPEDEF_TPL(name,expr) \
struct name {\
- BOOST_STATIC_CONSTANT(int,_typeof_register_value=sizeof(ndnboost::type_of::typeof_register_type<name>(expr)));\
+ NDNBOOST_STATIC_CONSTANT(int,_typeof_register_value=sizeof(ndnboost::type_of::typeof_register_type<name>(expr)));\
typedef typename ndnboost::type_of::msvc_extract_type<name>::id2type id2type;\
typedef typename id2type::type type;\
};
-# define BOOST_TYPEOF_NESTED_TYPEDEF(name,expr) \
+# define NDNBOOST_TYPEOF_NESTED_TYPEDEF(name,expr) \
struct name {\
- BOOST_STATIC_CONSTANT(int,_typeof_register_value=sizeof(ndnboost::type_of::typeof_register_type<name>(expr)));\
+ NDNBOOST_STATIC_CONSTANT(int,_typeof_register_value=sizeof(ndnboost::type_of::typeof_register_type<name>(expr)));\
typedef ndnboost::type_of::msvc_extract_type<name>::id2type id2type;\
typedef id2type::type type;\
};
@@ -97,4 +97,4 @@
}
}
-#endif//BOOST_TYPEOF_MSVC_TYPEOF_IMPL_HPP_INCLUDED
+#endif//NDNBOOST_TYPEOF_MSVC_TYPEOF_IMPL_HPP_INCLUDED
diff --git a/include/ndnboost/typeof/encode_decode.hpp b/include/ndnboost/typeof/encode_decode.hpp
index 5a1d62a..d5a1160 100644
--- a/include/ndnboost/typeof/encode_decode.hpp
+++ b/include/ndnboost/typeof/encode_decode.hpp
@@ -5,30 +5,30 @@
// boostinspect:nounnamed
-#ifndef BOOST_TYPEOF_ENCODE_DECODE_HPP_INCLUDED
-#define BOOST_TYPEOF_ENCODE_DECODE_HPP_INCLUDED
+#ifndef NDNBOOST_TYPEOF_ENCODE_DECODE_HPP_INCLUDED
+#define NDNBOOST_TYPEOF_ENCODE_DECODE_HPP_INCLUDED
#include <ndnboost/mpl/deref.hpp>
#include <ndnboost/mpl/next.hpp>
-#ifndef BOOST_TYPEOF_SUPPRESS_UNNAMED_NAMESPACE
+#ifndef NDNBOOST_TYPEOF_SUPPRESS_UNNAMED_NAMESPACE
-# define BOOST_TYPEOF_BEGIN_ENCODE_NS namespace { namespace ndnboost_typeof {
-# define BOOST_TYPEOF_END_ENCODE_NS }}
-# define BOOST_TYPEOF_ENCODE_NS_QUALIFIER ndnboost_typeof
+# define NDNBOOST_TYPEOF_BEGIN_ENCODE_NS namespace { namespace ndnboost_typeof {
+# define NDNBOOST_TYPEOF_END_ENCODE_NS }}
+# define NDNBOOST_TYPEOF_ENCODE_NS_QUALIFIER ndnboost_typeof
#else
-# define BOOST_TYPEOF_BEGIN_ENCODE_NS namespace ndnboost { namespace type_of {
-# define BOOST_TYPEOF_END_ENCODE_NS }}
-# define BOOST_TYPEOF_ENCODE_NS_QUALIFIER ndnboost::type_of
+# define NDNBOOST_TYPEOF_BEGIN_ENCODE_NS namespace ndnboost { namespace type_of {
+# define NDNBOOST_TYPEOF_END_ENCODE_NS }}
+# define NDNBOOST_TYPEOF_ENCODE_NS_QUALIFIER ndnboost::type_of
-# define BOOST_TYPEOF_TEXT "unnamed namespace is off"
+# define NDNBOOST_TYPEOF_TEXT "unnamed namespace is off"
# include <ndnboost/typeof/message.hpp>
#endif
-BOOST_TYPEOF_BEGIN_ENCODE_NS
+NDNBOOST_TYPEOF_BEGIN_ENCODE_NS
template<class V, class Type_Not_Registered_With_Typeof_System>
struct encode_type_impl;
@@ -42,20 +42,20 @@
template<class T>
struct decode_nested_template_helper_impl;
-BOOST_TYPEOF_END_ENCODE_NS
+NDNBOOST_TYPEOF_END_ENCODE_NS
namespace ndnboost { namespace type_of {
template<class V, class T>
- struct encode_type : BOOST_TYPEOF_ENCODE_NS_QUALIFIER::encode_type_impl<V, T>
+ struct encode_type : NDNBOOST_TYPEOF_ENCODE_NS_QUALIFIER::encode_type_impl<V, T>
{};
template<class Iter>
- struct decode_type : BOOST_TYPEOF_ENCODE_NS_QUALIFIER::decode_type_impl<
+ struct decode_type : NDNBOOST_TYPEOF_ENCODE_NS_QUALIFIER::decode_type_impl<
typename Iter::type,
typename Iter::next
>
{};
}}
-#endif//BOOST_TYPEOF_ENCODE_DECODE_HPP_INCLUDED
+#endif//NDNBOOST_TYPEOF_ENCODE_DECODE_HPP_INCLUDED
diff --git a/include/ndnboost/typeof/encode_decode_params.hpp b/include/ndnboost/typeof/encode_decode_params.hpp
index 2e57a84..622b476 100644
--- a/include/ndnboost/typeof/encode_decode_params.hpp
+++ b/include/ndnboost/typeof/encode_decode_params.hpp
@@ -2,33 +2,33 @@
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#ifndef BOOST_TYPEOF_ENCODE_DECODE_PARAMS_HPP_INCLUDED
-#define BOOST_TYPEOF_ENCODE_DECODE_PARAMS_HPP_INCLUDED
+#ifndef NDNBOOST_TYPEOF_ENCODE_DECODE_PARAMS_HPP_INCLUDED
+#define NDNBOOST_TYPEOF_ENCODE_DECODE_PARAMS_HPP_INCLUDED
#include <ndnboost/preprocessor/cat.hpp>
#include <ndnboost/preprocessor/repetition/repeat.hpp>
// Assumes iter0 contains initial iterator
-#define BOOST_TYPEOF_DECODE_PARAM(z, n, text) \
+#define NDNBOOST_TYPEOF_DECODE_PARAM(z, n, text) \
typedef ndnboost::type_of::decode_type<iter##n> decode##n; \
typedef typename decode##n::type p##n; \
- typedef typename decode##n::iter BOOST_PP_CAT(iter, BOOST_PP_INC(n));
+ typedef typename decode##n::iter NDNBOOST_PP_CAT(iter, NDNBOOST_PP_INC(n));
-#define BOOST_TYPEOF_DECODE_PARAMS(n)\
- BOOST_PP_REPEAT(n, BOOST_TYPEOF_DECODE_PARAM, ~)
+#define NDNBOOST_TYPEOF_DECODE_PARAMS(n)\
+ NDNBOOST_PP_REPEAT(n, NDNBOOST_TYPEOF_DECODE_PARAM, ~)
// The P0, P1, ... PN are encoded and added to V
-#define BOOST_TYPEOF_ENCODE_PARAMS_BEGIN(z, n, text)\
+#define NDNBOOST_TYPEOF_ENCODE_PARAMS_BEGIN(z, n, text)\
typename ndnboost::type_of::encode_type<
-#define BOOST_TYPEOF_ENCODE_PARAMS_END(z, n, text)\
- , BOOST_PP_CAT(P, n)>::type
+#define NDNBOOST_TYPEOF_ENCODE_PARAMS_END(z, n, text)\
+ , NDNBOOST_PP_CAT(P, n)>::type
-#define BOOST_TYPEOF_ENCODE_PARAMS(n, ID) \
- BOOST_PP_REPEAT(n, BOOST_TYPEOF_ENCODE_PARAMS_BEGIN, ~) \
+#define NDNBOOST_TYPEOF_ENCODE_PARAMS(n, ID) \
+ NDNBOOST_PP_REPEAT(n, NDNBOOST_TYPEOF_ENCODE_PARAMS_BEGIN, ~) \
typename ndnboost::type_of::push_back<V, ndnboost::mpl::size_t<ID> >::type \
- BOOST_PP_REPEAT(n, BOOST_TYPEOF_ENCODE_PARAMS_END, ~)
+ NDNBOOST_PP_REPEAT(n, NDNBOOST_TYPEOF_ENCODE_PARAMS_END, ~)
-#endif//BOOST_TYPEOF_ENCODE_DECODE_PARAMS_HPP_INCLUDED
+#endif//NDNBOOST_TYPEOF_ENCODE_DECODE_PARAMS_HPP_INCLUDED
diff --git a/include/ndnboost/typeof/int_encoding.hpp b/include/ndnboost/typeof/int_encoding.hpp
index faccdda..037277c 100644
--- a/include/ndnboost/typeof/int_encoding.hpp
+++ b/include/ndnboost/typeof/int_encoding.hpp
@@ -2,8 +2,8 @@
// 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_INT_ENCODING_HPP_INCLUDED
-#define BOOST_TYPEOF_INT_ENCODING_HPP_INCLUDED
+#ifndef NDNBOOST_TYPEOF_INT_ENCODING_HPP_INCLUDED
+#define NDNBOOST_TYPEOF_INT_ENCODING_HPP_INCLUDED
#include <ndnboost/mpl/if.hpp>
#include <ndnboost/mpl/size_t.hpp>
@@ -41,14 +41,14 @@
template<std::size_t n, bool Overflow>
struct pack
{
- BOOST_STATIC_CONSTANT(std::size_t , value=((n + 1) * 2 + (Overflow ? 1 : 0)));
+ NDNBOOST_STATIC_CONSTANT(std::size_t , value=((n + 1) * 2 + (Overflow ? 1 : 0)));
};
template<std::size_t m>
struct unpack
{
- BOOST_STATIC_CONSTANT(std::size_t, value = (m / 2) - 1);
- BOOST_STATIC_CONSTANT(std::size_t, overflow = (m % 2 == 1));
+ NDNBOOST_STATIC_CONSTANT(std::size_t, value = (m / 2) - 1);
+ NDNBOOST_STATIC_CONSTANT(std::size_t, overflow = (m % 2 == 1));
};
////////////////////////////////
@@ -83,16 +83,16 @@
template<std::size_t n, class Iter>
struct decode_size_t<n, Iter, false>
{
- BOOST_STATIC_CONSTANT(std::size_t,value = n);
+ NDNBOOST_STATIC_CONSTANT(std::size_t,value = n);
typedef Iter iter;
};
template<std::size_t n, class Iter>
struct decode_size_t<n, Iter, true>
{
- BOOST_STATIC_CONSTANT(std::size_t,m = Iter::type::value);
+ NDNBOOST_STATIC_CONSTANT(std::size_t,m = Iter::type::value);
- BOOST_STATIC_CONSTANT(std::size_t,value = (std::size_t)m * 0x3ffffffe + n);
+ NDNBOOST_STATIC_CONSTANT(std::size_t,value = (std::size_t)m * 0x3ffffffe + n);
typedef typename Iter::next iter;
};
@@ -100,11 +100,11 @@
struct decode_integral
{
typedef decode_integral<T,Iter> self_t;
- BOOST_STATIC_CONSTANT(std::size_t,m = Iter::type::value);
+ NDNBOOST_STATIC_CONSTANT(std::size_t,m = Iter::type::value);
- BOOST_STATIC_CONSTANT(std::size_t,n = unpack<m>::value);
+ NDNBOOST_STATIC_CONSTANT(std::size_t,n = unpack<m>::value);
- BOOST_STATIC_CONSTANT(std::size_t,overflow = unpack<m>::overflow);
+ NDNBOOST_STATIC_CONSTANT(std::size_t,overflow = unpack<m>::overflow);
typedef typename Iter::next nextpos;
@@ -115,4 +115,4 @@
}}//namespace
-#endif//BOOST_TYPEOF_INT_ENCODING_HPP_INCLUDED
+#endif//NDNBOOST_TYPEOF_INT_ENCODING_HPP_INCLUDED
diff --git a/include/ndnboost/typeof/integral_template_param.hpp b/include/ndnboost/typeof/integral_template_param.hpp
index 446a3d1..1e418f3 100644
--- a/include/ndnboost/typeof/integral_template_param.hpp
+++ b/include/ndnboost/typeof/integral_template_param.hpp
@@ -2,79 +2,79 @@
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#ifndef BOOST_TYPEOF_INTEGRAL_TEMPLATE_PARAM_HPP_INCLUDED
-#define BOOST_TYPEOF_INTEGRAL_TEMPLATE_PARAM_HPP_INCLUDED
+#ifndef NDNBOOST_TYPEOF_INTEGRAL_TEMPLATE_PARAM_HPP_INCLUDED
+#define NDNBOOST_TYPEOF_INTEGRAL_TEMPLATE_PARAM_HPP_INCLUDED
-#define BOOST_TYPEOF_unsigned (unsigned)
-#define BOOST_TYPEOF_signed (signed)
+#define NDNBOOST_TYPEOF_unsigned (unsigned)
+#define NDNBOOST_TYPEOF_signed (signed)
-#define char_BOOST_TYPEOF (char)
-#define short_BOOST_TYPEOF (short)
-#define int_BOOST_TYPEOF (int)
-#define long_BOOST_TYPEOF (long)
+#define char_NDNBOOST_TYPEOF (char)
+#define short_NDNBOOST_TYPEOF (short)
+#define int_NDNBOOST_TYPEOF (int)
+#define long_NDNBOOST_TYPEOF (long)
-#define BOOST_TYPEOF_char_BOOST_TYPEOF (char)
-#define BOOST_TYPEOF_short_BOOST_TYPEOF (short)
-#define BOOST_TYPEOF_int_BOOST_TYPEOF (int)
-#define BOOST_TYPEOF_long_BOOST_TYPEOF (long)
-#define BOOST_TYPEOF_bool_BOOST_TYPEOF (bool)
-#define BOOST_TYPEOF_unsigned_BOOST_TYPEOF (unsigned)
-#define BOOST_TYPEOF_size_t_BOOST_TYPEOF (size_t)
+#define NDNBOOST_TYPEOF_char_NDNBOOST_TYPEOF (char)
+#define NDNBOOST_TYPEOF_short_NDNBOOST_TYPEOF (short)
+#define NDNBOOST_TYPEOF_int_NDNBOOST_TYPEOF (int)
+#define NDNBOOST_TYPEOF_long_NDNBOOST_TYPEOF (long)
+#define NDNBOOST_TYPEOF_bool_NDNBOOST_TYPEOF (bool)
+#define NDNBOOST_TYPEOF_unsigned_NDNBOOST_TYPEOF (unsigned)
+#define NDNBOOST_TYPEOF_size_t_NDNBOOST_TYPEOF (size_t)
-#define BOOST_TYPEOF_MAKE_OBJ_char BOOST_TYPEOF_INTEGRAL_PARAM(char)
-#define BOOST_TYPEOF_MAKE_OBJ_short BOOST_TYPEOF_INTEGRAL_PARAM(short)
-#define BOOST_TYPEOF_MAKE_OBJ_int BOOST_TYPEOF_INTEGRAL_PARAM(int)
-#define BOOST_TYPEOF_MAKE_OBJ_long BOOST_TYPEOF_INTEGRAL_PARAM(long)
-#define BOOST_TYPEOF_MAKE_OBJ_bool BOOST_TYPEOF_INTEGRAL_PARAM(bool)
-#define BOOST_TYPEOF_MAKE_OBJ_unsigned BOOST_TYPEOF_INTEGRAL_PARAM(unsigned)
-#define BOOST_TYPEOF_MAKE_OBJ_size_t BOOST_TYPEOF_INTEGRAL_PARAM(size_t)
-#define BOOST_TYPEOF_MAKE_OBJ_unsignedchar BOOST_TYPEOF_INTEGRAL_PARAM(unsigned char)
-#define BOOST_TYPEOF_MAKE_OBJ_unsignedshort BOOST_TYPEOF_INTEGRAL_PARAM(unsigned short)
-#define BOOST_TYPEOF_MAKE_OBJ_unsignedint BOOST_TYPEOF_INTEGRAL_PARAM(unsigned int)
-#define BOOST_TYPEOF_MAKE_OBJ_unsignedlong BOOST_TYPEOF_INTEGRAL_PARAM(unsigned long)
-#define BOOST_TYPEOF_MAKE_OBJ_signedchar BOOST_TYPEOF_INTEGRAL_PARAM(signed char)
-#define BOOST_TYPEOF_MAKE_OBJ_signedshort BOOST_TYPEOF_INTEGRAL_PARAM(signed short)
-#define BOOST_TYPEOF_MAKE_OBJ_signedint BOOST_TYPEOF_INTEGRAL_PARAM(signed int)
-#define BOOST_TYPEOF_MAKE_OBJ_signedlong BOOST_TYPEOF_INTEGRAL_PARAM(signed long)
-#define BOOST_TYPEOF_MAKE_OBJ_integral(x) BOOST_TYPEOF_INTEGRAL_PARAM(x)
+#define NDNBOOST_TYPEOF_MAKE_OBJ_char NDNBOOST_TYPEOF_INTEGRAL_PARAM(char)
+#define NDNBOOST_TYPEOF_MAKE_OBJ_short NDNBOOST_TYPEOF_INTEGRAL_PARAM(short)
+#define NDNBOOST_TYPEOF_MAKE_OBJ_int NDNBOOST_TYPEOF_INTEGRAL_PARAM(int)
+#define NDNBOOST_TYPEOF_MAKE_OBJ_long NDNBOOST_TYPEOF_INTEGRAL_PARAM(long)
+#define NDNBOOST_TYPEOF_MAKE_OBJ_bool NDNBOOST_TYPEOF_INTEGRAL_PARAM(bool)
+#define NDNBOOST_TYPEOF_MAKE_OBJ_unsigned NDNBOOST_TYPEOF_INTEGRAL_PARAM(unsigned)
+#define NDNBOOST_TYPEOF_MAKE_OBJ_size_t NDNBOOST_TYPEOF_INTEGRAL_PARAM(size_t)
+#define NDNBOOST_TYPEOF_MAKE_OBJ_unsignedchar NDNBOOST_TYPEOF_INTEGRAL_PARAM(unsigned char)
+#define NDNBOOST_TYPEOF_MAKE_OBJ_unsignedshort NDNBOOST_TYPEOF_INTEGRAL_PARAM(unsigned short)
+#define NDNBOOST_TYPEOF_MAKE_OBJ_unsignedint NDNBOOST_TYPEOF_INTEGRAL_PARAM(unsigned int)
+#define NDNBOOST_TYPEOF_MAKE_OBJ_unsignedlong NDNBOOST_TYPEOF_INTEGRAL_PARAM(unsigned long)
+#define NDNBOOST_TYPEOF_MAKE_OBJ_signedchar NDNBOOST_TYPEOF_INTEGRAL_PARAM(signed char)
+#define NDNBOOST_TYPEOF_MAKE_OBJ_signedshort NDNBOOST_TYPEOF_INTEGRAL_PARAM(signed short)
+#define NDNBOOST_TYPEOF_MAKE_OBJ_signedint NDNBOOST_TYPEOF_INTEGRAL_PARAM(signed int)
+#define NDNBOOST_TYPEOF_MAKE_OBJ_signedlong NDNBOOST_TYPEOF_INTEGRAL_PARAM(signed long)
+#define NDNBOOST_TYPEOF_MAKE_OBJ_integral(x) NDNBOOST_TYPEOF_INTEGRAL_PARAM(x)
-#define BOOST_TYPEOF_INTEGRAL(X) integral(X) BOOST_TYPEOF_EAT
-#define BOOST_TYPEOF_EAT_BOOST_TYPEOF
-#define BOOST_TYPEOF_integral(X) (integral(X))
+#define NDNBOOST_TYPEOF_INTEGRAL(X) integral(X) NDNBOOST_TYPEOF_EAT
+#define NDNBOOST_TYPEOF_EAT_NDNBOOST_TYPEOF
+#define NDNBOOST_TYPEOF_integral(X) (integral(X))
-#define BOOST_TYPEOF_INTEGRAL_PARAM(Type)\
+#define NDNBOOST_TYPEOF_INTEGRAL_PARAM(Type)\
(INTEGRAL_PARAM)\
(Type)
-#define BOOST_TYPEOF_INTEGRAL_PARAM_GETTYPE(Param)\
- BOOST_PP_SEQ_ELEM(1, Param)
+#define NDNBOOST_TYPEOF_INTEGRAL_PARAM_GETTYPE(Param)\
+ NDNBOOST_PP_SEQ_ELEM(1, Param)
-#define BOOST_TYPEOF_INTEGRAL_PARAM_EXPANDTYPE(Param)\
- BOOST_TYPEOF_INTEGRAL_PARAM_GETTYPE(Param)
+#define NDNBOOST_TYPEOF_INTEGRAL_PARAM_EXPANDTYPE(Param)\
+ NDNBOOST_TYPEOF_INTEGRAL_PARAM_GETTYPE(Param)
// INTEGRAL_PARAM "virtual functions" implementation
-#define BOOST_TYPEOF_INTEGRAL_PARAM_ENCODE(This, n)\
+#define NDNBOOST_TYPEOF_INTEGRAL_PARAM_ENCODE(This, n)\
typedef typename ndnboost::type_of::encode_integral<\
- BOOST_PP_CAT(V, n),\
- BOOST_TYPEOF_INTEGRAL_PARAM_GETTYPE(This),\
- BOOST_PP_CAT(P, n)\
- >::type BOOST_PP_CAT(V, BOOST_PP_INC(n));
+ NDNBOOST_PP_CAT(V, n),\
+ NDNBOOST_TYPEOF_INTEGRAL_PARAM_GETTYPE(This),\
+ NDNBOOST_PP_CAT(P, n)\
+ >::type NDNBOOST_PP_CAT(V, NDNBOOST_PP_INC(n));
-#define BOOST_TYPEOF_INTEGRAL_PARAM_DECODE(This, n)\
- typedef ndnboost::type_of::decode_integral<BOOST_TYPEOF_INTEGRAL_PARAM_GETTYPE(This), BOOST_PP_CAT(iter, n)> BOOST_PP_CAT(d, n);\
- static const BOOST_TYPEOF_INTEGRAL_PARAM_GETTYPE(This) BOOST_PP_CAT(P, n) = BOOST_PP_CAT(d, n)::value;\
- typedef typename BOOST_PP_CAT(d, n)::iter BOOST_PP_CAT(iter, BOOST_PP_INC(n));
+#define NDNBOOST_TYPEOF_INTEGRAL_PARAM_DECODE(This, n)\
+ typedef ndnboost::type_of::decode_integral<NDNBOOST_TYPEOF_INTEGRAL_PARAM_GETTYPE(This), NDNBOOST_PP_CAT(iter, n)> NDNBOOST_PP_CAT(d, n);\
+ static const NDNBOOST_TYPEOF_INTEGRAL_PARAM_GETTYPE(This) NDNBOOST_PP_CAT(P, n) = NDNBOOST_PP_CAT(d, n)::value;\
+ typedef typename NDNBOOST_PP_CAT(d, n)::iter NDNBOOST_PP_CAT(iter, NDNBOOST_PP_INC(n));
-#define BOOST_TYPEOF_INTEGRAL_PARAM_PLACEHOLDER(Param)\
- (BOOST_TYPEOF_INTEGRAL_PARAM_GETTYPE(Param))0
+#define NDNBOOST_TYPEOF_INTEGRAL_PARAM_PLACEHOLDER(Param)\
+ (NDNBOOST_TYPEOF_INTEGRAL_PARAM_GETTYPE(Param))0
-#define BOOST_TYPEOF_INTEGRAL_PARAM_DECLARATION_TYPE(Param)\
- BOOST_TYPEOF_INTEGRAL_PARAM_GETTYPE(Param)
+#define NDNBOOST_TYPEOF_INTEGRAL_PARAM_DECLARATION_TYPE(Param)\
+ NDNBOOST_TYPEOF_INTEGRAL_PARAM_GETTYPE(Param)
-#define BOOST_TYPEOF_INTEGRAL_PARAM_PLACEHOLDER_TYPES(Param, n)\
- BOOST_PP_CAT(T,n)
+#define NDNBOOST_TYPEOF_INTEGRAL_PARAM_PLACEHOLDER_TYPES(Param, n)\
+ NDNBOOST_PP_CAT(T,n)
-#define BOOST_TYPEOF_INTEGRAL_PARAM_ISTEMPLATE 0
+#define NDNBOOST_TYPEOF_INTEGRAL_PARAM_ISTEMPLATE 0
-#endif//BOOST_TYPEOF_INTEGRAL_TEMPLATE_PARAM_HPP_INCLUDED
+#endif//NDNBOOST_TYPEOF_INTEGRAL_TEMPLATE_PARAM_HPP_INCLUDED
diff --git a/include/ndnboost/typeof/message.hpp b/include/ndnboost/typeof/message.hpp
index cabbb82..a47868f 100644
--- a/include/ndnboost/typeof/message.hpp
+++ b/include/ndnboost/typeof/message.hpp
@@ -2,7 +2,7 @@
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-#if defined(_MSC_VER) && defined BOOST_TYPEOF_MESSAGES
-# pragma message(BOOST_TYPEOF_TEXT)
+#if defined(_MSC_VER) && defined NDNBOOST_TYPEOF_MESSAGES
+# pragma message(NDNBOOST_TYPEOF_TEXT)
#endif
-#undef BOOST_TYPEOF_TEXT
+#undef NDNBOOST_TYPEOF_TEXT
diff --git a/include/ndnboost/typeof/modifiers.hpp b/include/ndnboost/typeof/modifiers.hpp
index afd65df..b985b6b 100644
--- a/include/ndnboost/typeof/modifiers.hpp
+++ b/include/ndnboost/typeof/modifiers.hpp
@@ -2,17 +2,17 @@
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#ifndef BOOST_TYPEOF_MODIFIERS_HPP_INCLUDED
-#define BOOST_TYPEOF_MODIFIERS_HPP_INCLUDED
+#ifndef NDNBOOST_TYPEOF_MODIFIERS_HPP_INCLUDED
+#define NDNBOOST_TYPEOF_MODIFIERS_HPP_INCLUDED
#include <ndnboost/typeof/encode_decode.hpp>
#include <ndnboost/preprocessor/facilities/identity.hpp>
-#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
+#include NDNBOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
// modifiers
-#define BOOST_TYPEOF_modifier_support(ID, Fun)\
+#define NDNBOOST_TYPEOF_modifier_support(ID, Fun)\
template<class V, class T> struct encode_type_impl<V, Fun(T)>\
{\
typedef\
@@ -31,61 +31,61 @@
}
-#define BOOST_TYPEOF_const_fun(T) const T
-#define BOOST_TYPEOF_volatile_fun(T) volatile T
-#define BOOST_TYPEOF_volatile_const_fun(T) volatile const T
-#define BOOST_TYPEOF_pointer_fun(T) T*
-#define BOOST_TYPEOF_reference_fun(T) T&
+#define NDNBOOST_TYPEOF_const_fun(T) const T
+#define NDNBOOST_TYPEOF_volatile_fun(T) volatile T
+#define NDNBOOST_TYPEOF_volatile_const_fun(T) volatile const T
+#define NDNBOOST_TYPEOF_pointer_fun(T) T*
+#define NDNBOOST_TYPEOF_reference_fun(T) T&
#if defined(__BORLANDC__) && (__BORLANDC__ < 0x600)
//Borland incorrectly handles T const, T const volatile and T volatile.
//It drops the decoration no matter what, so we need to try to handle T* const etc. without loosing the top modifier.
-#define BOOST_TYPEOF_const_pointer_fun(T) T const *
-#define BOOST_TYPEOF_const_reference_fun(T) T const &
-#define BOOST_TYPEOF_volatile_pointer_fun(T) T volatile*
-#define BOOST_TYPEOF_volatile_reference_fun(T) T volatile&
-#define BOOST_TYPEOF_volatile_const_pointer_fun(T) T volatile const *
-#define BOOST_TYPEOF_volatile_const_reference_fun(T) T volatile const &
+#define NDNBOOST_TYPEOF_const_pointer_fun(T) T const *
+#define NDNBOOST_TYPEOF_const_reference_fun(T) T const &
+#define NDNBOOST_TYPEOF_volatile_pointer_fun(T) T volatile*
+#define NDNBOOST_TYPEOF_volatile_reference_fun(T) T volatile&
+#define NDNBOOST_TYPEOF_volatile_const_pointer_fun(T) T volatile const *
+#define NDNBOOST_TYPEOF_volatile_const_reference_fun(T) T volatile const &
#endif
-BOOST_TYPEOF_BEGIN_ENCODE_NS
+NDNBOOST_TYPEOF_BEGIN_ENCODE_NS
-BOOST_TYPEOF_modifier_support(BOOST_TYPEOF_UNIQUE_ID(), BOOST_TYPEOF_const_fun);
-BOOST_TYPEOF_modifier_support(BOOST_TYPEOF_UNIQUE_ID(), BOOST_TYPEOF_volatile_fun);
-BOOST_TYPEOF_modifier_support(BOOST_TYPEOF_UNIQUE_ID(), BOOST_TYPEOF_volatile_const_fun);
-BOOST_TYPEOF_modifier_support(BOOST_TYPEOF_UNIQUE_ID(), BOOST_TYPEOF_pointer_fun);
-BOOST_TYPEOF_modifier_support(BOOST_TYPEOF_UNIQUE_ID(), BOOST_TYPEOF_reference_fun);
+NDNBOOST_TYPEOF_modifier_support(NDNBOOST_TYPEOF_UNIQUE_ID(), NDNBOOST_TYPEOF_const_fun);
+NDNBOOST_TYPEOF_modifier_support(NDNBOOST_TYPEOF_UNIQUE_ID(), NDNBOOST_TYPEOF_volatile_fun);
+NDNBOOST_TYPEOF_modifier_support(NDNBOOST_TYPEOF_UNIQUE_ID(), NDNBOOST_TYPEOF_volatile_const_fun);
+NDNBOOST_TYPEOF_modifier_support(NDNBOOST_TYPEOF_UNIQUE_ID(), NDNBOOST_TYPEOF_pointer_fun);
+NDNBOOST_TYPEOF_modifier_support(NDNBOOST_TYPEOF_UNIQUE_ID(), NDNBOOST_TYPEOF_reference_fun);
#if defined(__BORLANDC__) && (__BORLANDC__ < 0x600)
-BOOST_TYPEOF_modifier_support(BOOST_TYPEOF_UNIQUE_ID(), BOOST_TYPEOF_const_pointer_fun);
-BOOST_TYPEOF_modifier_support(BOOST_TYPEOF_UNIQUE_ID(), BOOST_TYPEOF_const_reference_fun);
-BOOST_TYPEOF_modifier_support(BOOST_TYPEOF_UNIQUE_ID(), BOOST_TYPEOF_volatile_pointer_fun);
-BOOST_TYPEOF_modifier_support(BOOST_TYPEOF_UNIQUE_ID(), BOOST_TYPEOF_volatile_reference_fun);
-BOOST_TYPEOF_modifier_support(BOOST_TYPEOF_UNIQUE_ID(), BOOST_TYPEOF_volatile_const_pointer_fun);
-BOOST_TYPEOF_modifier_support(BOOST_TYPEOF_UNIQUE_ID(), BOOST_TYPEOF_volatile_const_reference_fun);
+NDNBOOST_TYPEOF_modifier_support(NDNBOOST_TYPEOF_UNIQUE_ID(), NDNBOOST_TYPEOF_const_pointer_fun);
+NDNBOOST_TYPEOF_modifier_support(NDNBOOST_TYPEOF_UNIQUE_ID(), NDNBOOST_TYPEOF_const_reference_fun);
+NDNBOOST_TYPEOF_modifier_support(NDNBOOST_TYPEOF_UNIQUE_ID(), NDNBOOST_TYPEOF_volatile_pointer_fun);
+NDNBOOST_TYPEOF_modifier_support(NDNBOOST_TYPEOF_UNIQUE_ID(), NDNBOOST_TYPEOF_volatile_reference_fun);
+NDNBOOST_TYPEOF_modifier_support(NDNBOOST_TYPEOF_UNIQUE_ID(), NDNBOOST_TYPEOF_volatile_const_pointer_fun);
+NDNBOOST_TYPEOF_modifier_support(NDNBOOST_TYPEOF_UNIQUE_ID(), NDNBOOST_TYPEOF_volatile_const_reference_fun);
#endif
-BOOST_TYPEOF_END_ENCODE_NS
+NDNBOOST_TYPEOF_END_ENCODE_NS
-#undef BOOST_TYPEOF_modifier_support
-#undef BOOST_TYPEOF_const_fun
-#undef BOOST_TYPEOF_volatile_fun
-#undef BOOST_TYPEOF_volatile_const_fun
-#undef BOOST_TYPEOF_pointer_fun
-#undef BOOST_TYPEOF_reference_fun
+#undef NDNBOOST_TYPEOF_modifier_support
+#undef NDNBOOST_TYPEOF_const_fun
+#undef NDNBOOST_TYPEOF_volatile_fun
+#undef NDNBOOST_TYPEOF_volatile_const_fun
+#undef NDNBOOST_TYPEOF_pointer_fun
+#undef NDNBOOST_TYPEOF_reference_fun
#if defined(__BORLANDC__) && (__BORLANDC__ < 0x600)
-#undef BOOST_TYPEOF_const_pointer_fun
-#undef BOOST_TYPEOF_const_reference_fun
-#undef BOOST_TYPEOF_volatile_pointer_fun
-#undef BOOST_TYPEOF_volatile_reference_fun
-#undef BOOST_TYPEOF_volatile_const_pointer_fun
-#undef BOOST_TYPEOF_volatile_const_reference_fun
+#undef NDNBOOST_TYPEOF_const_pointer_fun
+#undef NDNBOOST_TYPEOF_const_reference_fun
+#undef NDNBOOST_TYPEOF_volatile_pointer_fun
+#undef NDNBOOST_TYPEOF_volatile_reference_fun
+#undef NDNBOOST_TYPEOF_volatile_const_pointer_fun
+#undef NDNBOOST_TYPEOF_volatile_const_reference_fun
#endif
// arrays
-#define BOOST_TYPEOF_array_support(ID, Qualifier)\
+#define NDNBOOST_TYPEOF_array_support(ID, Qualifier)\
template<class V, class T, int N>\
struct encode_type_impl<V, Qualifier() T[N]>\
{\
@@ -108,14 +108,14 @@
typedef typename d::iter iter;\
}
-BOOST_TYPEOF_BEGIN_ENCODE_NS
+NDNBOOST_TYPEOF_BEGIN_ENCODE_NS
-BOOST_TYPEOF_array_support(BOOST_TYPEOF_UNIQUE_ID(), BOOST_PP_EMPTY);
-BOOST_TYPEOF_array_support(BOOST_TYPEOF_UNIQUE_ID(), BOOST_PP_IDENTITY(const));
-BOOST_TYPEOF_array_support(BOOST_TYPEOF_UNIQUE_ID(), BOOST_PP_IDENTITY(volatile));
-BOOST_TYPEOF_array_support(BOOST_TYPEOF_UNIQUE_ID(), BOOST_PP_IDENTITY(volatile const));
-BOOST_TYPEOF_END_ENCODE_NS
+NDNBOOST_TYPEOF_array_support(NDNBOOST_TYPEOF_UNIQUE_ID(), NDNBOOST_PP_EMPTY);
+NDNBOOST_TYPEOF_array_support(NDNBOOST_TYPEOF_UNIQUE_ID(), NDNBOOST_PP_IDENTITY(const));
+NDNBOOST_TYPEOF_array_support(NDNBOOST_TYPEOF_UNIQUE_ID(), NDNBOOST_PP_IDENTITY(volatile));
+NDNBOOST_TYPEOF_array_support(NDNBOOST_TYPEOF_UNIQUE_ID(), NDNBOOST_PP_IDENTITY(volatile const));
+NDNBOOST_TYPEOF_END_ENCODE_NS
-#undef BOOST_TYPEOF_array_support
+#undef NDNBOOST_TYPEOF_array_support
-#endif//BOOST_TYPEOF_MODIFIERS_HPP_INCLUDED
+#endif//NDNBOOST_TYPEOF_MODIFIERS_HPP_INCLUDED
diff --git a/include/ndnboost/typeof/msvc/typeof_impl.hpp b/include/ndnboost/typeof/msvc/typeof_impl.hpp
index 2f2dd61..5dea7e1 100644
--- a/include/ndnboost/typeof/msvc/typeof_impl.hpp
+++ b/include/ndnboost/typeof/msvc/typeof_impl.hpp
@@ -6,8 +6,8 @@
// 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_MSVC_TYPEOF_IMPL_HPP_INCLUDED
-# define BOOST_TYPEOF_MSVC_TYPEOF_IMPL_HPP_INCLUDED
+#ifndef NDNBOOST_TYPEOF_MSVC_TYPEOF_IMPL_HPP_INCLUDED
+# define NDNBOOST_TYPEOF_MSVC_TYPEOF_IMPL_HPP_INCLUDED
# include <ndnboost/config.hpp>
# include <ndnboost/detail/workaround.hpp>
@@ -15,7 +15,7 @@
# include <ndnboost/type_traits/is_function.hpp>
# include <ndnboost/utility/enable_if.hpp>
-# if BOOST_WORKAROUND(BOOST_MSVC,>=1310)
+# if NDNBOOST_WORKAROUND(NDNBOOST_MSVC,>=1310)
# include <typeinfo>
# endif
@@ -25,7 +25,7 @@
{
//Compile time constant code
-# if BOOST_WORKAROUND(BOOST_MSVC,>=1300) && defined(_MSC_EXTENSIONS)
+# if NDNBOOST_WORKAROUND(NDNBOOST_MSVC,>=1300) && defined(_MSC_EXTENSIONS)
template<int N> struct the_counter;
template<typename T,int N = 5/*for similarity*/>
@@ -33,35 +33,35 @@
{
__if_exists(the_counter<N + 256>)
{
- BOOST_STATIC_CONSTANT(unsigned,count=(encode_counter<T,N + 257>::count));
+ NDNBOOST_STATIC_CONSTANT(unsigned,count=(encode_counter<T,N + 257>::count));
}
__if_not_exists(the_counter<N + 256>)
{
__if_exists(the_counter<N + 64>)
{
- BOOST_STATIC_CONSTANT(unsigned,count=(encode_counter<T,N + 65>::count));
+ NDNBOOST_STATIC_CONSTANT(unsigned,count=(encode_counter<T,N + 65>::count));
}
__if_not_exists(the_counter<N + 64>)
{
__if_exists(the_counter<N + 16>)
{
- BOOST_STATIC_CONSTANT(unsigned,count=(encode_counter<T,N + 17>::count));
+ NDNBOOST_STATIC_CONSTANT(unsigned,count=(encode_counter<T,N + 17>::count));
}
__if_not_exists(the_counter<N + 16>)
{
__if_exists(the_counter<N + 4>)
{
- BOOST_STATIC_CONSTANT(unsigned,count=(encode_counter<T,N + 5>::count));
+ NDNBOOST_STATIC_CONSTANT(unsigned,count=(encode_counter<T,N + 5>::count));
}
__if_not_exists(the_counter<N + 4>)
{
__if_exists(the_counter<N>)
{
- BOOST_STATIC_CONSTANT(unsigned,count=(encode_counter<T,N + 1>::count));
+ NDNBOOST_STATIC_CONSTANT(unsigned,count=(encode_counter<T,N + 1>::count));
}
__if_not_exists(the_counter<N>)
{
- BOOST_STATIC_CONSTANT(unsigned,count=N);
+ NDNBOOST_STATIC_CONSTANT(unsigned,count=N);
typedef the_counter<N> type;
}
}
@@ -70,8 +70,8 @@
}
};
-# define BOOST_TYPEOF_INDEX(T) (encode_counter<T>::count)
-# define BOOST_TYPEOF_NEXT_INDEX(next)
+# define NDNBOOST_TYPEOF_INDEX(T) (encode_counter<T>::count)
+# define NDNBOOST_TYPEOF_NEXT_INDEX(next)
# else
template<int N> struct encode_counter : encode_counter<N - 1> {};
template<> struct encode_counter<0> {};
@@ -79,13 +79,13 @@
//Need to default to a larger value than 4, as due to MSVC's ETI errors. (sizeof(int)==4)
char (*encode_index(...))[5];
-# define BOOST_TYPEOF_INDEX(T) (sizeof(*ndnboost::type_of::encode_index((ndnboost::type_of::encode_counter<1005>*)0)))
-# define BOOST_TYPEOF_NEXT_INDEX(next) friend char (*encode_index(encode_counter<next>*))[next];
+# define NDNBOOST_TYPEOF_INDEX(T) (sizeof(*ndnboost::type_of::encode_index((ndnboost::type_of::encode_counter<1005>*)0)))
+# define NDNBOOST_TYPEOF_NEXT_INDEX(next) friend char (*encode_index(encode_counter<next>*))[next];
# endif
//Typeof code
-# if BOOST_WORKAROUND(BOOST_MSVC,==1300)
+# if NDNBOOST_WORKAROUND(NDNBOOST_MSVC,==1300)
template<typename ID>
struct msvc_extract_type
{
@@ -104,7 +104,7 @@
typedef T type;
};
};
-#elif BOOST_WORKAROUND(BOOST_MSVC,>=1400)
+#elif NDNBOOST_WORKAROUND(NDNBOOST_MSVC,>=1400)
struct msvc_extract_type_default_param {};
template<typename ID, typename T = msvc_extract_type_default_param>
@@ -155,7 +155,7 @@
# endif
// EAN: preprocess this block out on advice of Peder Holt
// to eliminate errors in type_traits/common_type.hpp
-# if 0 //BOOST_WORKAROUND(BOOST_MSVC,==1310)
+# if 0 //NDNBOOST_WORKAROUND(NDNBOOST_MSVC,==1310)
template<const std::type_info& ref_type_info>
struct msvc_typeid_wrapper {
typedef typename msvc_extract_type<msvc_typeid_wrapper>::id2type id2type;
@@ -187,19 +187,19 @@
msvc_register_type<T,Organizer> typeof_register_type(const T&);
-# define BOOST_TYPEOF(expr) \
+# define NDNBOOST_TYPEOF(expr) \
ndnboost::type_of::msvc_typeid_wrapper<typeid(ndnboost::type_of::encode_start(expr))>::type
-# define BOOST_TYPEOF_TPL(expr) typename BOOST_TYPEOF(expr)
+# define NDNBOOST_TYPEOF_TPL(expr) typename NDNBOOST_TYPEOF(expr)
-# define BOOST_TYPEOF_NESTED_TYPEDEF_TPL(name,expr) \
+# define NDNBOOST_TYPEOF_NESTED_TYPEDEF_TPL(name,expr) \
struct name {\
enum {_typeof_register_value=sizeof(typeid(ndnboost::type_of::typeof_register_type<name>(expr)))};\
typedef typename ndnboost::type_of::msvc_extract_type<name>::id2type id2type;\
typedef typename id2type::type type;\
};
-# define BOOST_TYPEOF_NESTED_TYPEDEF(name,expr) \
+# define NDNBOOST_TYPEOF_NESTED_TYPEDEF(name,expr) \
struct name {\
enum {_typeof_register_value=sizeof(typeid(ndnboost::type_of::typeof_register_type<name>(expr)))};\
typedef ndnboost::type_of::msvc_extract_type<name>::id2type id2type;\
@@ -228,13 +228,13 @@
struct encode_type
{
//Get the next available compile time constants index
- BOOST_STATIC_CONSTANT(unsigned,value=BOOST_TYPEOF_INDEX(T));
+ NDNBOOST_STATIC_CONSTANT(unsigned,value=NDNBOOST_TYPEOF_INDEX(T));
//Instantiate the template
typedef typename msvc_register_type<T,mpl::int_<value> >::id2type type;
//Set the next compile time constants index
- BOOST_STATIC_CONSTANT(unsigned,next=value+1);
+ NDNBOOST_STATIC_CONSTANT(unsigned,next=value+1);
//Increment the compile time constant (only needed when extensions are not active
- BOOST_TYPEOF_NEXT_INDEX(next);
+ NDNBOOST_TYPEOF_NEXT_INDEX(next);
};
template<class T>
@@ -242,7 +242,7 @@
{
typedef char(*type)[encode_type<T>::value];
};
-# if BOOST_WORKAROUND(BOOST_MSVC,>=1310)
+# if NDNBOOST_WORKAROUND(NDNBOOST_MSVC,>=1310)
template<typename T> typename disable_if<
typename is_function<T>::type,
typename sizer<T>::type>::type encode_start(T const&);
@@ -257,21 +257,21 @@
template<typename Organizer, typename T>
msvc_register_type<T,Organizer> typeof_register_type(const T&,Organizer* =0);
-# define BOOST_TYPEOF(expr) \
+# define NDNBOOST_TYPEOF(expr) \
ndnboost::type_of::msvc_typeid_wrapper<sizeof(*ndnboost::type_of::encode_start(expr))>::type
-# define BOOST_TYPEOF_TPL(expr) typename BOOST_TYPEOF(expr)
+# define NDNBOOST_TYPEOF_TPL(expr) typename NDNBOOST_TYPEOF(expr)
-# define BOOST_TYPEOF_NESTED_TYPEDEF_TPL(name,expr) \
+# define NDNBOOST_TYPEOF_NESTED_TYPEDEF_TPL(name,expr) \
struct name {\
- BOOST_STATIC_CONSTANT(int,_typeof_register_value=sizeof(ndnboost::type_of::typeof_register_type<name>(expr)));\
+ NDNBOOST_STATIC_CONSTANT(int,_typeof_register_value=sizeof(ndnboost::type_of::typeof_register_type<name>(expr)));\
typedef typename ndnboost::type_of::msvc_extract_type<name>::id2type id2type;\
typedef typename id2type::type type;\
};
-# define BOOST_TYPEOF_NESTED_TYPEDEF(name,expr) \
+# define NDNBOOST_TYPEOF_NESTED_TYPEDEF(name,expr) \
struct name {\
- BOOST_STATIC_CONSTANT(int,_typeof_register_value=sizeof(ndnboost::type_of::typeof_register_type<name>(expr)));\
+ NDNBOOST_STATIC_CONSTANT(int,_typeof_register_value=sizeof(ndnboost::type_of::typeof_register_type<name>(expr)));\
typedef ndnboost::type_of::msvc_extract_type<name>::id2type id2type;\
typedef id2type::type type;\
};
@@ -280,4 +280,4 @@
}
}
-#endif//BOOST_TYPEOF_MSVC_TYPEOF_IMPL_HPP_INCLUDED
+#endif//NDNBOOST_TYPEOF_MSVC_TYPEOF_IMPL_HPP_INCLUDED
diff --git a/include/ndnboost/typeof/native.hpp b/include/ndnboost/typeof/native.hpp
index 3caf7ba..d88b419 100644
--- a/include/ndnboost/typeof/native.hpp
+++ b/include/ndnboost/typeof/native.hpp
@@ -2,12 +2,12 @@
// 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_NATIVE_HPP_INCLUDED
-#define BOOST_TYPEOF_NATIVE_HPP_INCLUDED
+#ifndef NDNBOOST_TYPEOF_NATIVE_HPP_INCLUDED
+#define NDNBOOST_TYPEOF_NATIVE_HPP_INCLUDED
#ifndef MSVC_TYPEOF_HACK
-#ifdef BOOST_NO_SFINAE
+#ifdef NDNBOOST_NO_SFINAE
namespace ndnboost { namespace type_of {
@@ -22,7 +22,7 @@
#include <ndnboost/utility/enable_if.hpp>
namespace ndnboost { namespace type_of {
-# ifdef BOOST_NO_SFINAE
+# ifdef NDNBOOST_NO_SFINAE
template<class T>
T& ensure_obj(const T&);
# else
@@ -36,25 +36,25 @@
# endif
}}
-#endif//BOOST_NO_SFINAE
+#endif//NDNBOOST_NO_SFINAE
-#define BOOST_TYPEOF(expr) BOOST_TYPEOF_KEYWORD(ndnboost::type_of::ensure_obj(expr))
-#define BOOST_TYPEOF_TPL BOOST_TYPEOF
+#define NDNBOOST_TYPEOF(expr) NDNBOOST_TYPEOF_KEYWORD(ndnboost::type_of::ensure_obj(expr))
+#define NDNBOOST_TYPEOF_TPL NDNBOOST_TYPEOF
-#define BOOST_TYPEOF_NESTED_TYPEDEF_TPL(name,expr) \
+#define NDNBOOST_TYPEOF_NESTED_TYPEDEF_TPL(name,expr) \
struct name {\
- typedef BOOST_TYPEOF_TPL(expr) type;\
+ typedef NDNBOOST_TYPEOF_TPL(expr) type;\
};
-#define BOOST_TYPEOF_NESTED_TYPEDEF(name,expr) \
+#define NDNBOOST_TYPEOF_NESTED_TYPEDEF(name,expr) \
struct name {\
- typedef BOOST_TYPEOF(expr) type;\
+ typedef NDNBOOST_TYPEOF(expr) type;\
};
#endif//MSVC_TYPEOF_HACK
-#define BOOST_TYPEOF_REGISTER_TYPE(x)
-#define BOOST_TYPEOF_REGISTER_TEMPLATE(x, params)
+#define NDNBOOST_TYPEOF_REGISTER_TYPE(x)
+#define NDNBOOST_TYPEOF_REGISTER_TEMPLATE(x, params)
-#endif//BOOST_TYPEOF_NATIVE_HPP_INCLUDED
+#endif//NDNBOOST_TYPEOF_NATIVE_HPP_INCLUDED
diff --git a/include/ndnboost/typeof/pointers_data_members.hpp b/include/ndnboost/typeof/pointers_data_members.hpp
index e376f8e..e1872d9 100644
--- a/include/ndnboost/typeof/pointers_data_members.hpp
+++ b/include/ndnboost/typeof/pointers_data_members.hpp
@@ -2,29 +2,29 @@
// 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_POINTERS_DATA_MEMBERS_HPP_INCLUDED
-#define BOOST_TYPEOF_POINTERS_DATA_MEMBERS_HPP_INCLUDED
+#ifndef NDNBOOST_TYPEOF_POINTERS_DATA_MEMBERS_HPP_INCLUDED
+#define NDNBOOST_TYPEOF_POINTERS_DATA_MEMBERS_HPP_INCLUDED
#include <ndnboost/typeof/encode_decode_params.hpp>
#include <ndnboost/typeof/encode_decode.hpp>
-#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
+#include NDNBOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
-BOOST_TYPEOF_BEGIN_ENCODE_NS
+NDNBOOST_TYPEOF_BEGIN_ENCODE_NS
-enum {PTR_DATA_MEM_ID = BOOST_TYPEOF_UNIQUE_ID()};
+enum {PTR_DATA_MEM_ID = NDNBOOST_TYPEOF_UNIQUE_ID()};
template<class V, class P0, class P1>
struct encode_type_impl<V, P0 P1::*>
{
- typedef BOOST_TYPEOF_ENCODE_PARAMS(2, PTR_DATA_MEM_ID) type;
+ typedef NDNBOOST_TYPEOF_ENCODE_PARAMS(2, PTR_DATA_MEM_ID) type;
};
template<class Iter>
struct decode_type_impl<ndnboost::mpl::size_t<PTR_DATA_MEM_ID>, Iter>
{
typedef Iter iter0;
- BOOST_TYPEOF_DECODE_PARAMS(2)
+ NDNBOOST_TYPEOF_DECODE_PARAMS(2)
template<class T> struct workaround{
typedef p0 T::* type;
@@ -33,6 +33,6 @@
typedef iter2 iter;
};
-BOOST_TYPEOF_END_ENCODE_NS
+NDNBOOST_TYPEOF_END_ENCODE_NS
-#endif//BOOST_TYPEOF_POINTERS_DATA_MEMBERS_HPP_INCLUDED
+#endif//NDNBOOST_TYPEOF_POINTERS_DATA_MEMBERS_HPP_INCLUDED
diff --git a/include/ndnboost/typeof/register_functions.hpp b/include/ndnboost/typeof/register_functions.hpp
index 6d0e107..bb229f9 100644
--- a/include/ndnboost/typeof/register_functions.hpp
+++ b/include/ndnboost/typeof/register_functions.hpp
@@ -2,8 +2,8 @@
// 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_REGISTER_FUNCTIONS_HPP_INCLUDED
-#define BOOST_TYPEOF_REGISTER_FUNCTIONS_HPP_INCLUDED
+#ifndef NDNBOOST_TYPEOF_REGISTER_FUNCTIONS_HPP_INCLUDED
+#define NDNBOOST_TYPEOF_REGISTER_FUNCTIONS_HPP_INCLUDED
#include <ndnboost/preprocessor/repetition/enum.hpp>
#include <ndnboost/preprocessor/repetition/enum_params.hpp>
@@ -15,36 +15,36 @@
#include <ndnboost/preprocessor/arithmetic/add.hpp>
#include <ndnboost/preprocessor/iteration/iterate.hpp>
-#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
+#include NDNBOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
-#ifndef BOOST_TYPEOF_LIMIT_FUNCTION_ARITY
-#define BOOST_TYPEOF_LIMIT_FUNCTION_ARITY 10
+#ifndef NDNBOOST_TYPEOF_LIMIT_FUNCTION_ARITY
+#define NDNBOOST_TYPEOF_LIMIT_FUNCTION_ARITY 10
#endif
enum
{
- FUN_ID = BOOST_TYPEOF_UNIQUE_ID(),
- FUN_PTR_ID = FUN_ID + 1 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
- FUN_REF_ID = FUN_ID + 2 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
- MEM_FUN_ID = FUN_ID + 3 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
- CONST_MEM_FUN_ID = FUN_ID + 4 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
- VOLATILE_MEM_FUN_ID = FUN_ID + 5 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
- VOLATILE_CONST_MEM_FUN_ID = FUN_ID + 6 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
- FUN_VAR_ID = FUN_ID + 7 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
- FUN_VAR_PTR_ID = FUN_ID + 8 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
- FUN_VAR_REF_ID = FUN_ID + 9 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
- MEM_FUN_VAR_ID = FUN_ID + 10 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
- CONST_MEM_FUN_VAR_ID = FUN_ID + 11 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
- VOLATILE_MEM_FUN_VAR_ID = FUN_ID + 12 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
- VOLATILE_CONST_MEM_FUN_VAR_ID = FUN_ID + 13 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY)
+ FUN_ID = NDNBOOST_TYPEOF_UNIQUE_ID(),
+ FUN_PTR_ID = FUN_ID + 1 * NDNBOOST_PP_INC(NDNBOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
+ FUN_REF_ID = FUN_ID + 2 * NDNBOOST_PP_INC(NDNBOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
+ MEM_FUN_ID = FUN_ID + 3 * NDNBOOST_PP_INC(NDNBOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
+ CONST_MEM_FUN_ID = FUN_ID + 4 * NDNBOOST_PP_INC(NDNBOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
+ VOLATILE_MEM_FUN_ID = FUN_ID + 5 * NDNBOOST_PP_INC(NDNBOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
+ VOLATILE_CONST_MEM_FUN_ID = FUN_ID + 6 * NDNBOOST_PP_INC(NDNBOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
+ FUN_VAR_ID = FUN_ID + 7 * NDNBOOST_PP_INC(NDNBOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
+ FUN_VAR_PTR_ID = FUN_ID + 8 * NDNBOOST_PP_INC(NDNBOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
+ FUN_VAR_REF_ID = FUN_ID + 9 * NDNBOOST_PP_INC(NDNBOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
+ MEM_FUN_VAR_ID = FUN_ID + 10 * NDNBOOST_PP_INC(NDNBOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
+ CONST_MEM_FUN_VAR_ID = FUN_ID + 11 * NDNBOOST_PP_INC(NDNBOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
+ VOLATILE_MEM_FUN_VAR_ID = FUN_ID + 12 * NDNBOOST_PP_INC(NDNBOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
+ VOLATILE_CONST_MEM_FUN_VAR_ID = FUN_ID + 13 * NDNBOOST_PP_INC(NDNBOOST_TYPEOF_LIMIT_FUNCTION_ARITY)
};
-BOOST_TYPEOF_BEGIN_ENCODE_NS
+NDNBOOST_TYPEOF_BEGIN_ENCODE_NS
-# define BOOST_PP_ITERATION_LIMITS (0, BOOST_TYPEOF_LIMIT_FUNCTION_ARITY)
-# define BOOST_PP_FILENAME_1 <ndnboost/typeof/register_functions_iterate.hpp>
-# include BOOST_PP_ITERATE()
+# define NDNBOOST_PP_ITERATION_LIMITS (0, NDNBOOST_TYPEOF_LIMIT_FUNCTION_ARITY)
+# define NDNBOOST_PP_FILENAME_1 <ndnboost/typeof/register_functions_iterate.hpp>
+# include NDNBOOST_PP_ITERATE()
-BOOST_TYPEOF_END_ENCODE_NS
+NDNBOOST_TYPEOF_END_ENCODE_NS
-#endif//BOOST_TYPEOF_REGISTER_FUNCTIONS_HPP_INCLUDED
+#endif//NDNBOOST_TYPEOF_REGISTER_FUNCTIONS_HPP_INCLUDED
diff --git a/include/ndnboost/typeof/register_functions_iterate.hpp b/include/ndnboost/typeof/register_functions_iterate.hpp
index 0d3d9df..3f487a9 100644
--- a/include/ndnboost/typeof/register_functions_iterate.hpp
+++ b/include/ndnboost/typeof/register_functions_iterate.hpp
@@ -4,131 +4,131 @@
#include <ndnboost/typeof/encode_decode_params.hpp>
-#define n BOOST_PP_ITERATION()
+#define n NDNBOOST_PP_ITERATION()
// function pointers
-template<class V, class R BOOST_PP_ENUM_TRAILING_PARAMS(n, class P)>
-struct encode_type_impl<V, R(*)(BOOST_PP_ENUM_PARAMS(n, P))>
+template<class V, class R NDNBOOST_PP_ENUM_TRAILING_PARAMS(n, class P)>
+struct encode_type_impl<V, R(*)(NDNBOOST_PP_ENUM_PARAMS(n, P))>
{
- typedef R BOOST_PP_CAT(P, n);
- typedef BOOST_TYPEOF_ENCODE_PARAMS(BOOST_PP_INC(n), FUN_PTR_ID + n) type;
+ typedef R NDNBOOST_PP_CAT(P, n);
+ typedef NDNBOOST_TYPEOF_ENCODE_PARAMS(NDNBOOST_PP_INC(n), FUN_PTR_ID + n) type;
};
-template<class V, class R BOOST_PP_ENUM_TRAILING_PARAMS(n, class P)>
-struct encode_type_impl<V, R(*)(BOOST_PP_ENUM_PARAMS(n, P) ...)>
+template<class V, class R NDNBOOST_PP_ENUM_TRAILING_PARAMS(n, class P)>
+struct encode_type_impl<V, R(*)(NDNBOOST_PP_ENUM_PARAMS(n, P) ...)>
{
- typedef R BOOST_PP_CAT(P, n);
- typedef BOOST_TYPEOF_ENCODE_PARAMS(BOOST_PP_INC(n), FUN_VAR_PTR_ID + n) type;
+ typedef R NDNBOOST_PP_CAT(P, n);
+ typedef NDNBOOST_TYPEOF_ENCODE_PARAMS(NDNBOOST_PP_INC(n), FUN_VAR_PTR_ID + n) type;
};
template<class Iter>
struct decode_type_impl<ndnboost::mpl::size_t<FUN_PTR_ID + n>, Iter>
{
typedef Iter iter0;
- BOOST_TYPEOF_DECODE_PARAMS(BOOST_PP_INC(n))
- typedef BOOST_PP_CAT(p, n)(*type)(BOOST_PP_ENUM_PARAMS(n, p));
- typedef BOOST_PP_CAT(iter, BOOST_PP_INC(n)) iter;
+ NDNBOOST_TYPEOF_DECODE_PARAMS(NDNBOOST_PP_INC(n))
+ typedef NDNBOOST_PP_CAT(p, n)(*type)(NDNBOOST_PP_ENUM_PARAMS(n, p));
+ typedef NDNBOOST_PP_CAT(iter, NDNBOOST_PP_INC(n)) iter;
};
template<class Iter>
struct decode_type_impl<ndnboost::mpl::size_t<FUN_VAR_PTR_ID + n>, Iter>
{
typedef Iter iter0;
- BOOST_TYPEOF_DECODE_PARAMS(BOOST_PP_INC(n))
- typedef BOOST_PP_CAT(p, n)(*type)(BOOST_PP_ENUM_PARAMS(n, p) ...);
- typedef BOOST_PP_CAT(iter, BOOST_PP_INC(n)) iter;
+ NDNBOOST_TYPEOF_DECODE_PARAMS(NDNBOOST_PP_INC(n))
+ typedef NDNBOOST_PP_CAT(p, n)(*type)(NDNBOOST_PP_ENUM_PARAMS(n, p) ...);
+ typedef NDNBOOST_PP_CAT(iter, NDNBOOST_PP_INC(n)) iter;
};
-#ifndef BOOST_TYPEOF_NO_FUNCTION_TYPES
+#ifndef NDNBOOST_TYPEOF_NO_FUNCTION_TYPES
// function references
- template<class V, class R BOOST_PP_ENUM_TRAILING_PARAMS(n, class P)>
- struct encode_type_impl<V, R(&)(BOOST_PP_ENUM_PARAMS(n, P))>
+ template<class V, class R NDNBOOST_PP_ENUM_TRAILING_PARAMS(n, class P)>
+ struct encode_type_impl<V, R(&)(NDNBOOST_PP_ENUM_PARAMS(n, P))>
{
- typedef R BOOST_PP_CAT(P, n);
- typedef BOOST_TYPEOF_ENCODE_PARAMS(BOOST_PP_INC(n), FUN_REF_ID + n) type;
+ typedef R NDNBOOST_PP_CAT(P, n);
+ typedef NDNBOOST_TYPEOF_ENCODE_PARAMS(NDNBOOST_PP_INC(n), FUN_REF_ID + n) type;
};
- template<class V, class R BOOST_PP_ENUM_TRAILING_PARAMS(n, class P)>
- struct encode_type_impl<V, R(&)(BOOST_PP_ENUM_PARAMS(n, P) ...)>
+ template<class V, class R NDNBOOST_PP_ENUM_TRAILING_PARAMS(n, class P)>
+ struct encode_type_impl<V, R(&)(NDNBOOST_PP_ENUM_PARAMS(n, P) ...)>
{
- typedef R BOOST_PP_CAT(P, n);
- typedef BOOST_TYPEOF_ENCODE_PARAMS(BOOST_PP_INC(n), FUN_VAR_REF_ID + n) type;
+ typedef R NDNBOOST_PP_CAT(P, n);
+ typedef NDNBOOST_TYPEOF_ENCODE_PARAMS(NDNBOOST_PP_INC(n), FUN_VAR_REF_ID + n) type;
};
template<class Iter>
struct decode_type_impl<ndnboost::mpl::size_t<FUN_REF_ID + n>, Iter>
{
typedef Iter iter0;
- BOOST_TYPEOF_DECODE_PARAMS(BOOST_PP_INC(n))
- typedef BOOST_PP_CAT(p, n)(&type)(BOOST_PP_ENUM_PARAMS(n, p));
- typedef BOOST_PP_CAT(iter, BOOST_PP_INC(n)) iter;
+ NDNBOOST_TYPEOF_DECODE_PARAMS(NDNBOOST_PP_INC(n))
+ typedef NDNBOOST_PP_CAT(p, n)(&type)(NDNBOOST_PP_ENUM_PARAMS(n, p));
+ typedef NDNBOOST_PP_CAT(iter, NDNBOOST_PP_INC(n)) iter;
};
template<class Iter>
struct decode_type_impl<ndnboost::mpl::size_t<FUN_VAR_REF_ID + n>, Iter>
{
typedef Iter iter0;
- BOOST_TYPEOF_DECODE_PARAMS(BOOST_PP_INC(n))
- typedef BOOST_PP_CAT(p, n)(&type)(BOOST_PP_ENUM_PARAMS(n, p) ...);
- typedef BOOST_PP_CAT(iter, BOOST_PP_INC(n)) iter;
+ NDNBOOST_TYPEOF_DECODE_PARAMS(NDNBOOST_PP_INC(n))
+ typedef NDNBOOST_PP_CAT(p, n)(&type)(NDNBOOST_PP_ENUM_PARAMS(n, p) ...);
+ typedef NDNBOOST_PP_CAT(iter, NDNBOOST_PP_INC(n)) iter;
};
// functions
- template<class V, class R BOOST_PP_ENUM_TRAILING_PARAMS(n, class P)>
- struct encode_type_impl<V, R(BOOST_PP_ENUM_PARAMS(n, P))>
+ template<class V, class R NDNBOOST_PP_ENUM_TRAILING_PARAMS(n, class P)>
+ struct encode_type_impl<V, R(NDNBOOST_PP_ENUM_PARAMS(n, P))>
{
- typedef R BOOST_PP_CAT(P, n);
- typedef BOOST_TYPEOF_ENCODE_PARAMS(BOOST_PP_INC(n), FUN_ID + n) type;
+ typedef R NDNBOOST_PP_CAT(P, n);
+ typedef NDNBOOST_TYPEOF_ENCODE_PARAMS(NDNBOOST_PP_INC(n), FUN_ID + n) type;
};
- template<class V, class R BOOST_PP_ENUM_TRAILING_PARAMS(n, class P)>
- struct encode_type_impl<V, R(BOOST_PP_ENUM_PARAMS(n, P) ...)>
+ template<class V, class R NDNBOOST_PP_ENUM_TRAILING_PARAMS(n, class P)>
+ struct encode_type_impl<V, R(NDNBOOST_PP_ENUM_PARAMS(n, P) ...)>
{
- typedef R BOOST_PP_CAT(P, n);
- typedef BOOST_TYPEOF_ENCODE_PARAMS(BOOST_PP_INC(n), FUN_VAR_ID + n) type;
+ typedef R NDNBOOST_PP_CAT(P, n);
+ typedef NDNBOOST_TYPEOF_ENCODE_PARAMS(NDNBOOST_PP_INC(n), FUN_VAR_ID + n) type;
};
template<class Iter>
struct decode_type_impl<ndnboost::mpl::size_t<FUN_ID + n>, Iter>
{
typedef Iter iter0;
- BOOST_TYPEOF_DECODE_PARAMS(BOOST_PP_INC(n))
- typedef BOOST_PP_CAT(p, n)(type)(BOOST_PP_ENUM_PARAMS(n, p));
- typedef BOOST_PP_CAT(iter, BOOST_PP_INC(n)) iter;
+ NDNBOOST_TYPEOF_DECODE_PARAMS(NDNBOOST_PP_INC(n))
+ typedef NDNBOOST_PP_CAT(p, n)(type)(NDNBOOST_PP_ENUM_PARAMS(n, p));
+ typedef NDNBOOST_PP_CAT(iter, NDNBOOST_PP_INC(n)) iter;
};
template<class Iter>
struct decode_type_impl<ndnboost::mpl::size_t<FUN_VAR_ID + n>, Iter>
{
typedef Iter iter0;
- BOOST_TYPEOF_DECODE_PARAMS(BOOST_PP_INC(n))
- typedef BOOST_PP_CAT(p, n)(type)(BOOST_PP_ENUM_PARAMS(n, p) ...);
- typedef BOOST_PP_CAT(iter, BOOST_PP_INC(n)) iter;
+ NDNBOOST_TYPEOF_DECODE_PARAMS(NDNBOOST_PP_INC(n))
+ typedef NDNBOOST_PP_CAT(p, n)(type)(NDNBOOST_PP_ENUM_PARAMS(n, p) ...);
+ typedef NDNBOOST_PP_CAT(iter, NDNBOOST_PP_INC(n)) iter;
};
-#endif//BOOST_TYPEOF_NO_FUNCTION_TYPES
+#endif//NDNBOOST_TYPEOF_NO_FUNCTION_TYPES
-#ifndef BOOST_TYPEOF_NO_MEMBER_FUNCTION_TYPES
+#ifndef NDNBOOST_TYPEOF_NO_MEMBER_FUNCTION_TYPES
// member functions
-#define BOOST_TYPEOF_qualifier
-#define BOOST_TYPEOF_id MEM_FUN_ID
+#define NDNBOOST_TYPEOF_qualifier
+#define NDNBOOST_TYPEOF_id MEM_FUN_ID
#include <ndnboost/typeof/register_mem_functions.hpp>
-#define BOOST_TYPEOF_qualifier const
-#define BOOST_TYPEOF_id CONST_MEM_FUN_ID
+#define NDNBOOST_TYPEOF_qualifier const
+#define NDNBOOST_TYPEOF_id CONST_MEM_FUN_ID
#include <ndnboost/typeof/register_mem_functions.hpp>
-#define BOOST_TYPEOF_qualifier volatile
-#define BOOST_TYPEOF_id VOLATILE_MEM_FUN_ID
+#define NDNBOOST_TYPEOF_qualifier volatile
+#define NDNBOOST_TYPEOF_id VOLATILE_MEM_FUN_ID
#include <ndnboost/typeof/register_mem_functions.hpp>
-#define BOOST_TYPEOF_qualifier volatile const
-#define BOOST_TYPEOF_id VOLATILE_CONST_MEM_FUN_ID
+#define NDNBOOST_TYPEOF_qualifier volatile const
+#define NDNBOOST_TYPEOF_id VOLATILE_CONST_MEM_FUN_ID
#include <ndnboost/typeof/register_mem_functions.hpp>
#undef n
diff --git a/include/ndnboost/typeof/register_fundamental.hpp b/include/ndnboost/typeof/register_fundamental.hpp
index c1b99d8..2e72ef3 100644
--- a/include/ndnboost/typeof/register_fundamental.hpp
+++ b/include/ndnboost/typeof/register_fundamental.hpp
@@ -3,60 +3,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_REGISTER_FUNDAMENTAL_HPP_INCLUDED
-#define BOOST_TYPEOF_REGISTER_FUNDAMENTAL_HPP_INCLUDED
+#ifndef NDNBOOST_TYPEOF_REGISTER_FUNDAMENTAL_HPP_INCLUDED
+#define NDNBOOST_TYPEOF_REGISTER_FUNDAMENTAL_HPP_INCLUDED
#include <ndnboost/typeof/typeof.hpp>
-#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
+#include NDNBOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
-BOOST_TYPEOF_REGISTER_TYPE(unsigned char)
-BOOST_TYPEOF_REGISTER_TYPE(unsigned short)
-BOOST_TYPEOF_REGISTER_TYPE(unsigned int)
-BOOST_TYPEOF_REGISTER_TYPE(unsigned long)
+NDNBOOST_TYPEOF_REGISTER_TYPE(unsigned char)
+NDNBOOST_TYPEOF_REGISTER_TYPE(unsigned short)
+NDNBOOST_TYPEOF_REGISTER_TYPE(unsigned int)
+NDNBOOST_TYPEOF_REGISTER_TYPE(unsigned long)
-BOOST_TYPEOF_REGISTER_TYPE(signed char)
-BOOST_TYPEOF_REGISTER_TYPE(signed short)
-BOOST_TYPEOF_REGISTER_TYPE(signed int)
-BOOST_TYPEOF_REGISTER_TYPE(signed long)
+NDNBOOST_TYPEOF_REGISTER_TYPE(signed char)
+NDNBOOST_TYPEOF_REGISTER_TYPE(signed short)
+NDNBOOST_TYPEOF_REGISTER_TYPE(signed int)
+NDNBOOST_TYPEOF_REGISTER_TYPE(signed long)
-BOOST_TYPEOF_REGISTER_TYPE(bool)
-BOOST_TYPEOF_REGISTER_TYPE(char)
+NDNBOOST_TYPEOF_REGISTER_TYPE(bool)
+NDNBOOST_TYPEOF_REGISTER_TYPE(char)
-BOOST_TYPEOF_REGISTER_TYPE(float)
-BOOST_TYPEOF_REGISTER_TYPE(double)
-BOOST_TYPEOF_REGISTER_TYPE(long double)
+NDNBOOST_TYPEOF_REGISTER_TYPE(float)
+NDNBOOST_TYPEOF_REGISTER_TYPE(double)
+NDNBOOST_TYPEOF_REGISTER_TYPE(long double)
-#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+#ifndef NDNBOOST_NO_INTRINSIC_WCHAR_T
// If the following line fails to compile and you're using the Intel
// compiler, see http://lists.boost.org/MailArchives/boost-users/msg06567.php,
-// and define BOOST_NO_INTRINSIC_WCHAR_T on the command line.
-BOOST_TYPEOF_REGISTER_TYPE(wchar_t)
+// and define NDNBOOST_NO_INTRINSIC_WCHAR_T on the command line.
+NDNBOOST_TYPEOF_REGISTER_TYPE(wchar_t)
#endif
-#if (defined(BOOST_MSVC) && (BOOST_MSVC == 1200)) \
- || (defined(BOOST_INTEL_CXX_VERSION) && defined(_MSC_VER) && (BOOST_INTEL_CXX_VERSION <= 600)) \
+#if (defined(NDNBOOST_MSVC) && (NDNBOOST_MSVC == 1200)) \
+ || (defined(NDNBOOST_INTEL_CXX_VERSION) && defined(_MSC_VER) && (NDNBOOST_INTEL_CXX_VERSION <= 600)) \
|| (defined(__BORLANDC__) && (__BORLANDC__ == 0x600) && (_MSC_VER == 1200))
-BOOST_TYPEOF_REGISTER_TYPE(unsigned __int8)
-BOOST_TYPEOF_REGISTER_TYPE(__int8)
-BOOST_TYPEOF_REGISTER_TYPE(unsigned __int16)
-BOOST_TYPEOF_REGISTER_TYPE(__int16)
-BOOST_TYPEOF_REGISTER_TYPE(unsigned __int32)
-BOOST_TYPEOF_REGISTER_TYPE(__int32)
+NDNBOOST_TYPEOF_REGISTER_TYPE(unsigned __int8)
+NDNBOOST_TYPEOF_REGISTER_TYPE(__int8)
+NDNBOOST_TYPEOF_REGISTER_TYPE(unsigned __int16)
+NDNBOOST_TYPEOF_REGISTER_TYPE(__int16)
+NDNBOOST_TYPEOF_REGISTER_TYPE(unsigned __int32)
+NDNBOOST_TYPEOF_REGISTER_TYPE(__int32)
#ifdef __BORLANDC__
-BOOST_TYPEOF_REGISTER_TYPE(unsigned __int64)
-BOOST_TYPEOF_REGISTER_TYPE(__int64)
+NDNBOOST_TYPEOF_REGISTER_TYPE(unsigned __int64)
+NDNBOOST_TYPEOF_REGISTER_TYPE(__int64)
#endif
#endif
-# if defined(BOOST_HAS_LONG_LONG)
-BOOST_TYPEOF_REGISTER_TYPE(::ndnboost::ulong_long_type)
-BOOST_TYPEOF_REGISTER_TYPE(::ndnboost::long_long_type)
-#elif defined(BOOST_HAS_MS_INT64)
-BOOST_TYPEOF_REGISTER_TYPE(unsigned __int64)
-BOOST_TYPEOF_REGISTER_TYPE(__int64)
+# if defined(NDNBOOST_HAS_LONG_LONG)
+NDNBOOST_TYPEOF_REGISTER_TYPE(::ndnboost::ulong_long_type)
+NDNBOOST_TYPEOF_REGISTER_TYPE(::ndnboost::long_long_type)
+#elif defined(NDNBOOST_HAS_MS_INT64)
+NDNBOOST_TYPEOF_REGISTER_TYPE(unsigned __int64)
+NDNBOOST_TYPEOF_REGISTER_TYPE(__int64)
#endif
-BOOST_TYPEOF_REGISTER_TYPE(void)
+NDNBOOST_TYPEOF_REGISTER_TYPE(void)
-#endif//BOOST_TYPEOF_REGISTER_FUNDAMENTAL_HPP_INCLUDED
+#endif//NDNBOOST_TYPEOF_REGISTER_FUNDAMENTAL_HPP_INCLUDED
diff --git a/include/ndnboost/typeof/register_mem_functions.hpp b/include/ndnboost/typeof/register_mem_functions.hpp
index efb40a9..35de8c3 100644
--- a/include/ndnboost/typeof/register_mem_functions.hpp
+++ b/include/ndnboost/typeof/register_mem_functions.hpp
@@ -6,27 +6,27 @@
// member functions
-template<class V, class T, class R BOOST_PP_ENUM_TRAILING_PARAMS(n, class P)>
-struct encode_type_impl<V, R(T::*)(BOOST_PP_ENUM_PARAMS(n, P)) BOOST_TYPEOF_qualifier>
+template<class V, class T, class R NDNBOOST_PP_ENUM_TRAILING_PARAMS(n, class P)>
+struct encode_type_impl<V, R(T::*)(NDNBOOST_PP_ENUM_PARAMS(n, P)) NDNBOOST_TYPEOF_qualifier>
{
- typedef R BOOST_PP_CAT(P, n);
- typedef T BOOST_PP_CAT(P, BOOST_PP_INC(n));
- typedef BOOST_TYPEOF_ENCODE_PARAMS(BOOST_PP_ADD(n, 2), BOOST_TYPEOF_id + n) type;
+ typedef R NDNBOOST_PP_CAT(P, n);
+ typedef T NDNBOOST_PP_CAT(P, NDNBOOST_PP_INC(n));
+ typedef NDNBOOST_TYPEOF_ENCODE_PARAMS(NDNBOOST_PP_ADD(n, 2), NDNBOOST_TYPEOF_id + n) type;
};
template<class Iter>
-struct decode_type_impl<ndnboost::mpl::size_t<BOOST_TYPEOF_id + n>, Iter>
+struct decode_type_impl<ndnboost::mpl::size_t<NDNBOOST_TYPEOF_id + n>, Iter>
{
typedef Iter iter0;
- BOOST_TYPEOF_DECODE_PARAMS(BOOST_PP_ADD(n, 2))
+ NDNBOOST_TYPEOF_DECODE_PARAMS(NDNBOOST_PP_ADD(n, 2))
template<class T> struct workaround{
- typedef BOOST_PP_CAT(p, n)(T::*type)(BOOST_PP_ENUM_PARAMS(n, p)) BOOST_TYPEOF_qualifier;
+ typedef NDNBOOST_PP_CAT(p, n)(T::*type)(NDNBOOST_PP_ENUM_PARAMS(n, p)) NDNBOOST_TYPEOF_qualifier;
};
- typedef typename workaround<BOOST_PP_CAT(p, BOOST_PP_INC(n))>::type type;
- typedef BOOST_PP_CAT(iter, BOOST_PP_ADD(n, 2)) iter;
+ typedef typename workaround<NDNBOOST_PP_CAT(p, NDNBOOST_PP_INC(n))>::type type;
+ typedef NDNBOOST_PP_CAT(iter, NDNBOOST_PP_ADD(n, 2)) iter;
};
// undef parameters
-#undef BOOST_TYPEOF_id
-#undef BOOST_TYPEOF_qualifier
+#undef NDNBOOST_TYPEOF_id
+#undef NDNBOOST_TYPEOF_qualifier
diff --git a/include/ndnboost/typeof/template_encoding.hpp b/include/ndnboost/typeof/template_encoding.hpp
index 6c5781b..b2a0fe1 100644
--- a/include/ndnboost/typeof/template_encoding.hpp
+++ b/include/ndnboost/typeof/template_encoding.hpp
@@ -3,8 +3,8 @@
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#ifndef BOOST_TYPEOF_TEMPLATE_ENCODING_HPP_INCLUDED
-#define BOOST_TYPEOF_TEMPLATE_ENCODING_HPP_INCLUDED
+#ifndef NDNBOOST_TYPEOF_TEMPLATE_ENCODING_HPP_INCLUDED
+#define NDNBOOST_TYPEOF_TEMPLATE_ENCODING_HPP_INCLUDED
#include <ndnboost/preprocessor/cat.hpp>
#include <ndnboost/preprocessor/repetition/enum_trailing.hpp>
@@ -24,9 +24,9 @@
#include <ndnboost/typeof/template_template_param.hpp>
#ifdef __BORLANDC__
-#define BOOST_TYPEOF_QUALIFY(P) self_t::P
+#define NDNBOOST_TYPEOF_QUALIFY(P) self_t::P
#else
-#define BOOST_TYPEOF_QUALIFY(P) P
+#define NDNBOOST_TYPEOF_QUALIFY(P) P
#endif
// The template parameter description, entered by the user,
// is converted into a polymorphic "object"
@@ -34,116 +34,116 @@
// encoding/decoding the parameter, etc.
// make sure to cat the sequence first, and only then add the prefix.
-#define BOOST_TYPEOF_MAKE_OBJ(elem) BOOST_PP_CAT(\
- BOOST_TYPEOF_MAKE_OBJ,\
- BOOST_PP_SEQ_CAT((_) BOOST_TYPEOF_TO_SEQ(elem))\
+#define NDNBOOST_TYPEOF_MAKE_OBJ(elem) NDNBOOST_PP_CAT(\
+ NDNBOOST_TYPEOF_MAKE_OBJ,\
+ NDNBOOST_PP_SEQ_CAT((_) NDNBOOST_TYPEOF_TO_SEQ(elem))\
)
-#define BOOST_TYPEOF_TO_SEQ(tokens) BOOST_TYPEOF_ ## tokens ## _BOOST_TYPEOF
+#define NDNBOOST_TYPEOF_TO_SEQ(tokens) NDNBOOST_TYPEOF_ ## tokens ## _NDNBOOST_TYPEOF
-// BOOST_TYPEOF_REGISTER_TEMPLATE
+// NDNBOOST_TYPEOF_REGISTER_TEMPLATE
-#define BOOST_TYPEOF_REGISTER_TEMPLATE_EXPLICIT_ID(Name, Params, Id)\
- BOOST_TYPEOF_REGISTER_TEMPLATE_IMPL(\
+#define NDNBOOST_TYPEOF_REGISTER_TEMPLATE_EXPLICIT_ID(Name, Params, Id)\
+ NDNBOOST_TYPEOF_REGISTER_TEMPLATE_IMPL(\
Name,\
- BOOST_TYPEOF_MAKE_OBJS(BOOST_TYPEOF_TOSEQ(Params)),\
- BOOST_PP_SEQ_SIZE(BOOST_TYPEOF_TOSEQ(Params)),\
+ NDNBOOST_TYPEOF_MAKE_OBJS(NDNBOOST_TYPEOF_TOSEQ(Params)),\
+ NDNBOOST_PP_SEQ_SIZE(NDNBOOST_TYPEOF_TOSEQ(Params)),\
Id)
-#define BOOST_TYPEOF_REGISTER_TEMPLATE(Name, Params)\
- BOOST_TYPEOF_REGISTER_TEMPLATE_EXPLICIT_ID(Name, Params, BOOST_TYPEOF_UNIQUE_ID())
+#define NDNBOOST_TYPEOF_REGISTER_TEMPLATE(Name, Params)\
+ NDNBOOST_TYPEOF_REGISTER_TEMPLATE_EXPLICIT_ID(Name, Params, NDNBOOST_TYPEOF_UNIQUE_ID())
-#define BOOST_TYPEOF_OBJECT_MAKER(s, data, elem)\
- BOOST_TYPEOF_MAKE_OBJ(elem)
+#define NDNBOOST_TYPEOF_OBJECT_MAKER(s, data, elem)\
+ NDNBOOST_TYPEOF_MAKE_OBJ(elem)
-#define BOOST_TYPEOF_MAKE_OBJS(Params)\
- BOOST_PP_SEQ_TRANSFORM(BOOST_TYPEOF_OBJECT_MAKER, ~, Params)
+#define NDNBOOST_TYPEOF_MAKE_OBJS(Params)\
+ NDNBOOST_PP_SEQ_TRANSFORM(NDNBOOST_TYPEOF_OBJECT_MAKER, ~, Params)
// As suggested by Paul Mensonides:
-#define BOOST_TYPEOF_TOSEQ(x)\
- BOOST_PP_IIF(\
- BOOST_PP_IS_UNARY(x),\
- x BOOST_PP_TUPLE_EAT(3), BOOST_PP_REPEAT\
- )(x, BOOST_TYPEOF_TOSEQ_2, ~)
+#define NDNBOOST_TYPEOF_TOSEQ(x)\
+ NDNBOOST_PP_IIF(\
+ NDNBOOST_PP_IS_UNARY(x),\
+ x NDNBOOST_PP_TUPLE_EAT(3), NDNBOOST_PP_REPEAT\
+ )(x, NDNBOOST_TYPEOF_TOSEQ_2, ~)
-#define BOOST_TYPEOF_TOSEQ_2(z, n, _) (class)
+#define NDNBOOST_TYPEOF_TOSEQ_2(z, n, _) (class)
-// BOOST_TYPEOF_VIRTUAL
+// NDNBOOST_TYPEOF_VIRTUAL
-#define BOOST_TYPEOF_CAT_4(a, b, c, d) BOOST_TYPEOF_CAT_4_I(a, b, c, d)
-#define BOOST_TYPEOF_CAT_4_I(a, b, c, d) a ## b ## c ## d
+#define NDNBOOST_TYPEOF_CAT_4(a, b, c, d) NDNBOOST_TYPEOF_CAT_4_I(a, b, c, d)
+#define NDNBOOST_TYPEOF_CAT_4_I(a, b, c, d) a ## b ## c ## d
-#define BOOST_TYPEOF_VIRTUAL(Fun, Obj)\
- BOOST_TYPEOF_CAT_4(BOOST_TYPEOF_, BOOST_PP_SEQ_HEAD(Obj), _, Fun)
+#define NDNBOOST_TYPEOF_VIRTUAL(Fun, Obj)\
+ NDNBOOST_TYPEOF_CAT_4(NDNBOOST_TYPEOF_, NDNBOOST_PP_SEQ_HEAD(Obj), _, Fun)
-// BOOST_TYPEOF_SEQ_ENUM[_TRAILING][_1]
+// NDNBOOST_TYPEOF_SEQ_ENUM[_TRAILING][_1]
// Two versions provided due to reentrancy issue
-#define BOOST_TYPEOF_SEQ_EXPAND_ELEMENT(z,n,seq)\
- BOOST_PP_SEQ_ELEM(0,seq) (z,n,BOOST_PP_SEQ_ELEM(n,BOOST_PP_SEQ_ELEM(1,seq)))
+#define NDNBOOST_TYPEOF_SEQ_EXPAND_ELEMENT(z,n,seq)\
+ NDNBOOST_PP_SEQ_ELEM(0,seq) (z,n,NDNBOOST_PP_SEQ_ELEM(n,NDNBOOST_PP_SEQ_ELEM(1,seq)))
-#define BOOST_TYPEOF_SEQ_ENUM(seq,macro)\
- BOOST_PP_ENUM(BOOST_PP_SEQ_SIZE(seq),BOOST_TYPEOF_SEQ_EXPAND_ELEMENT,(macro)(seq))
+#define NDNBOOST_TYPEOF_SEQ_ENUM(seq,macro)\
+ NDNBOOST_PP_ENUM(NDNBOOST_PP_SEQ_SIZE(seq),NDNBOOST_TYPEOF_SEQ_EXPAND_ELEMENT,(macro)(seq))
-#define BOOST_TYPEOF_SEQ_ENUM_TRAILING(seq,macro)\
- BOOST_PP_ENUM_TRAILING(BOOST_PP_SEQ_SIZE(seq),BOOST_TYPEOF_SEQ_EXPAND_ELEMENT,(macro)(seq))
+#define NDNBOOST_TYPEOF_SEQ_ENUM_TRAILING(seq,macro)\
+ NDNBOOST_PP_ENUM_TRAILING(NDNBOOST_PP_SEQ_SIZE(seq),NDNBOOST_TYPEOF_SEQ_EXPAND_ELEMENT,(macro)(seq))
-#define BOOST_TYPEOF_SEQ_EXPAND_ELEMENT_1(z,n,seq)\
- BOOST_PP_SEQ_ELEM(0,seq) (z,n,BOOST_PP_SEQ_ELEM(n,BOOST_PP_SEQ_ELEM(1,seq)))
+#define NDNBOOST_TYPEOF_SEQ_EXPAND_ELEMENT_1(z,n,seq)\
+ NDNBOOST_PP_SEQ_ELEM(0,seq) (z,n,NDNBOOST_PP_SEQ_ELEM(n,NDNBOOST_PP_SEQ_ELEM(1,seq)))
-#define BOOST_TYPEOF_SEQ_ENUM_1(seq,macro)\
- BOOST_PP_ENUM(BOOST_PP_SEQ_SIZE(seq),BOOST_TYPEOF_SEQ_EXPAND_ELEMENT_1,(macro)(seq))
+#define NDNBOOST_TYPEOF_SEQ_ENUM_1(seq,macro)\
+ NDNBOOST_PP_ENUM(NDNBOOST_PP_SEQ_SIZE(seq),NDNBOOST_TYPEOF_SEQ_EXPAND_ELEMENT_1,(macro)(seq))
-#define BOOST_TYPEOF_SEQ_ENUM_TRAILING_1(seq,macro)\
- BOOST_PP_ENUM_TRAILING(BOOST_PP_SEQ_SIZE(seq),BOOST_TYPEOF_SEQ_EXPAND_ELEMENT_1,(macro)(seq))
+#define NDNBOOST_TYPEOF_SEQ_ENUM_TRAILING_1(seq,macro)\
+ NDNBOOST_PP_ENUM_TRAILING(NDNBOOST_PP_SEQ_SIZE(seq),NDNBOOST_TYPEOF_SEQ_EXPAND_ELEMENT_1,(macro)(seq))
//
-#define BOOST_TYPEOF_PLACEHOLDER(z, n, elem)\
- BOOST_TYPEOF_VIRTUAL(PLACEHOLDER, elem)(elem)
+#define NDNBOOST_TYPEOF_PLACEHOLDER(z, n, elem)\
+ NDNBOOST_TYPEOF_VIRTUAL(PLACEHOLDER, elem)(elem)
-#define BOOST_TYPEOF_PLACEHOLDER_TYPES(z, n, elem)\
- BOOST_TYPEOF_VIRTUAL(PLACEHOLDER_TYPES, elem)(elem, n)
+#define NDNBOOST_TYPEOF_PLACEHOLDER_TYPES(z, n, elem)\
+ NDNBOOST_TYPEOF_VIRTUAL(PLACEHOLDER_TYPES, elem)(elem, n)
-#define BOOST_TYPEOF_REGISTER_TEMPLATE_ENCODE_PARAM(r, data, n, elem)\
- BOOST_TYPEOF_VIRTUAL(ENCODE, elem)(elem, n)
+#define NDNBOOST_TYPEOF_REGISTER_TEMPLATE_ENCODE_PARAM(r, data, n, elem)\
+ NDNBOOST_TYPEOF_VIRTUAL(ENCODE, elem)(elem, n)
-#define BOOST_TYPEOF_REGISTER_TEMPLATE_DECODE_PARAM(r, data, n, elem)\
- BOOST_TYPEOF_VIRTUAL(DECODE, elem)(elem, n)
+#define NDNBOOST_TYPEOF_REGISTER_TEMPLATE_DECODE_PARAM(r, data, n, elem)\
+ NDNBOOST_TYPEOF_VIRTUAL(DECODE, elem)(elem, n)
-#define BOOST_TYPEOF_REGISTER_TEMPLATE_PARAM_PAIR(z, n, elem) \
- BOOST_TYPEOF_VIRTUAL(EXPANDTYPE, elem)(elem) BOOST_PP_CAT(P, n)
+#define NDNBOOST_TYPEOF_REGISTER_TEMPLATE_PARAM_PAIR(z, n, elem) \
+ NDNBOOST_TYPEOF_VIRTUAL(EXPANDTYPE, elem)(elem) NDNBOOST_PP_CAT(P, n)
-#define BOOST_TYPEOF_REGISTER_DEFAULT_TEMPLATE_TYPE(Name,Params,ID)\
- Name< BOOST_PP_ENUM_PARAMS(BOOST_PP_SEQ_SIZE(Params), P) >
+#define NDNBOOST_TYPEOF_REGISTER_DEFAULT_TEMPLATE_TYPE(Name,Params,ID)\
+ Name< NDNBOOST_PP_ENUM_PARAMS(NDNBOOST_PP_SEQ_SIZE(Params), P) >
//Since we are creating an internal decode struct, we need to use different template names, T instead of P.
-#define BOOST_TYPEOF_REGISTER_DECODER_TYPE_PARAM_PAIR(z,n,elem) \
- BOOST_TYPEOF_VIRTUAL(EXPANDTYPE, elem)(elem) BOOST_PP_CAT(T, n)
+#define NDNBOOST_TYPEOF_REGISTER_DECODER_TYPE_PARAM_PAIR(z,n,elem) \
+ NDNBOOST_TYPEOF_VIRTUAL(EXPANDTYPE, elem)(elem) NDNBOOST_PP_CAT(T, n)
//Default template param decoding
-#define BOOST_TYPEOF_TYPEDEF_DECODED_TEMPLATE_TYPE(Name,Params)\
- typedef Name<BOOST_PP_ENUM_PARAMS(BOOST_PP_SEQ_SIZE(Params),BOOST_TYPEOF_QUALIFY(P))> type;
+#define NDNBOOST_TYPEOF_TYPEDEF_DECODED_TEMPLATE_TYPE(Name,Params)\
+ typedef Name<NDNBOOST_PP_ENUM_PARAMS(NDNBOOST_PP_SEQ_SIZE(Params),NDNBOOST_TYPEOF_QUALIFY(P))> type;
//Branch the decoding
-#define BOOST_TYPEOF_TYPEDEF_DECODED_TYPE(Name,Params)\
- BOOST_PP_IF(BOOST_TYPEOF_HAS_TEMPLATES(Params),\
- BOOST_TYPEOF_TYPEDEF_DECODED_TEMPLATE_TEMPLATE_TYPE,\
- BOOST_TYPEOF_TYPEDEF_DECODED_TEMPLATE_TYPE)(Name,Params)
+#define NDNBOOST_TYPEOF_TYPEDEF_DECODED_TYPE(Name,Params)\
+ NDNBOOST_PP_IF(NDNBOOST_TYPEOF_HAS_TEMPLATES(Params),\
+ NDNBOOST_TYPEOF_TYPEDEF_DECODED_TEMPLATE_TEMPLATE_TYPE,\
+ NDNBOOST_TYPEOF_TYPEDEF_DECODED_TEMPLATE_TYPE)(Name,Params)
-#define BOOST_TYPEOF_REGISTER_TEMPLATE_IMPL(Name, Params, Size, ID)\
- BOOST_TYPEOF_BEGIN_ENCODE_NS\
- BOOST_TYPEOF_REGISTER_TEMPLATE_TEMPLATE_IMPL(Name, Params, ID)\
+#define NDNBOOST_TYPEOF_REGISTER_TEMPLATE_IMPL(Name, Params, Size, ID)\
+ NDNBOOST_TYPEOF_BEGIN_ENCODE_NS\
+ NDNBOOST_TYPEOF_REGISTER_TEMPLATE_TEMPLATE_IMPL(Name, Params, ID)\
template<class V\
- BOOST_TYPEOF_SEQ_ENUM_TRAILING(Params, BOOST_TYPEOF_REGISTER_TEMPLATE_PARAM_PAIR)\
+ NDNBOOST_TYPEOF_SEQ_ENUM_TRAILING(Params, NDNBOOST_TYPEOF_REGISTER_TEMPLATE_PARAM_PAIR)\
>\
- struct encode_type_impl<V, Name<BOOST_PP_ENUM_PARAMS(Size, P)> >\
+ struct encode_type_impl<V, Name<NDNBOOST_PP_ENUM_PARAMS(Size, P)> >\
{\
typedef typename ndnboost::type_of::push_back<V, ndnboost::mpl::size_t<ID> >::type V0;\
- BOOST_PP_SEQ_FOR_EACH_I(BOOST_TYPEOF_REGISTER_TEMPLATE_ENCODE_PARAM, ~, Params)\
- typedef BOOST_PP_CAT(V, Size) type;\
+ NDNBOOST_PP_SEQ_FOR_EACH_I(NDNBOOST_TYPEOF_REGISTER_TEMPLATE_ENCODE_PARAM, ~, Params)\
+ typedef NDNBOOST_PP_CAT(V, Size) type;\
};\
template<class Iter>\
struct decode_type_impl<ndnboost::mpl::size_t<ID>, Iter>\
@@ -151,10 +151,10 @@
typedef decode_type_impl<ndnboost::mpl::size_t<ID>, Iter> self_t;\
typedef ndnboost::mpl::size_t<ID> self_id;\
typedef Iter iter0;\
- BOOST_PP_SEQ_FOR_EACH_I(BOOST_TYPEOF_REGISTER_TEMPLATE_DECODE_PARAM, ~, Params)\
- BOOST_TYPEOF_TYPEDEF_DECODED_TYPE(Name, Params)\
- typedef BOOST_PP_CAT(iter, Size) iter;\
+ NDNBOOST_PP_SEQ_FOR_EACH_I(NDNBOOST_TYPEOF_REGISTER_TEMPLATE_DECODE_PARAM, ~, Params)\
+ NDNBOOST_TYPEOF_TYPEDEF_DECODED_TYPE(Name, Params)\
+ typedef NDNBOOST_PP_CAT(iter, Size) iter;\
};\
- BOOST_TYPEOF_END_ENCODE_NS
+ NDNBOOST_TYPEOF_END_ENCODE_NS
-#endif//BOOST_TYPEOF_TEMPLATE_ENCODING_HPP_INCLUDED
+#endif//NDNBOOST_TYPEOF_TEMPLATE_ENCODING_HPP_INCLUDED
diff --git a/include/ndnboost/typeof/template_template_param.hpp b/include/ndnboost/typeof/template_template_param.hpp
index b704616..d0802b7 100644
--- a/include/ndnboost/typeof/template_template_param.hpp
+++ b/include/ndnboost/typeof/template_template_param.hpp
@@ -3,69 +3,69 @@
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#ifndef BOOST_TYPEOF_TEMPLATE_TEMPLATE_PARAM_HPP_INCLUDED
-#define BOOST_TYPEOF_TEMPLATE_TEMPLATE_PARAM_HPP_INCLUDED
+#ifndef NDNBOOST_TYPEOF_TEMPLATE_TEMPLATE_PARAM_HPP_INCLUDED
+#define NDNBOOST_TYPEOF_TEMPLATE_TEMPLATE_PARAM_HPP_INCLUDED
#include <ndnboost/preprocessor/logical/or.hpp>
#include <ndnboost/preprocessor/seq/fold_left.hpp>
#include <ndnboost/preprocessor/seq/enum.hpp>
-#define BOOST_TYPEOF_MAKE_OBJ_template(x) BOOST_TYPEOF_TEMPLATE_PARAM(x)
-#define BOOST_TYPEOF_TEMPLATE(X) template(X) BOOST_TYPEOF_EAT
-#define BOOST_TYPEOF_template(X) (template(X))
+#define NDNBOOST_TYPEOF_MAKE_OBJ_template(x) NDNBOOST_TYPEOF_TEMPLATE_PARAM(x)
+#define NDNBOOST_TYPEOF_TEMPLATE(X) template(X) NDNBOOST_TYPEOF_EAT
+#define NDNBOOST_TYPEOF_template(X) (template(X))
-#define BOOST_TYPEOF_TEMPLATE_PARAM(Params)\
+#define NDNBOOST_TYPEOF_TEMPLATE_PARAM(Params)\
(TEMPLATE_PARAM)\
(Params)
-#define BOOST_TYPEOF_TEMPLATE_PARAM_GETPARAMS(This)\
- BOOST_TYPEOF_TOSEQ(BOOST_PP_SEQ_ELEM(1, This))
+#define NDNBOOST_TYPEOF_TEMPLATE_PARAM_GETPARAMS(This)\
+ NDNBOOST_TYPEOF_TOSEQ(NDNBOOST_PP_SEQ_ELEM(1, This))
//Encode / decode this
-#define BOOST_TYPEOF_TEMPLATE_PARAM_ENCODE(This, n)\
- typedef typename ndnboost::type_of::encode_template<BOOST_PP_CAT(V, n),\
- BOOST_PP_CAT(P, n)<BOOST_TYPEOF_SEQ_ENUM(BOOST_TYPEOF_MAKE_OBJS(BOOST_TYPEOF_TEMPLATE_PARAM_GETPARAMS(This)),BOOST_TYPEOF_PLACEHOLDER) >\
- >::type BOOST_PP_CAT(V, BOOST_PP_INC(n));
+#define NDNBOOST_TYPEOF_TEMPLATE_PARAM_ENCODE(This, n)\
+ typedef typename ndnboost::type_of::encode_template<NDNBOOST_PP_CAT(V, n),\
+ NDNBOOST_PP_CAT(P, n)<NDNBOOST_TYPEOF_SEQ_ENUM(NDNBOOST_TYPEOF_MAKE_OBJS(NDNBOOST_TYPEOF_TEMPLATE_PARAM_GETPARAMS(This)),NDNBOOST_TYPEOF_PLACEHOLDER) >\
+ >::type NDNBOOST_PP_CAT(V, NDNBOOST_PP_INC(n));
-#define BOOST_TYPEOF_TEMPLATE_PARAM_DECODE(This, n)\
- typedef ndnboost::type_of::decode_template< BOOST_PP_CAT(iter, n) > BOOST_PP_CAT(d, n);\
- typedef typename BOOST_PP_CAT(d, n)::type BOOST_PP_CAT(P, n);\
- typedef typename BOOST_PP_CAT(d, n)::iter BOOST_PP_CAT(iter,BOOST_PP_INC(n));
+#define NDNBOOST_TYPEOF_TEMPLATE_PARAM_DECODE(This, n)\
+ typedef ndnboost::type_of::decode_template< NDNBOOST_PP_CAT(iter, n) > NDNBOOST_PP_CAT(d, n);\
+ typedef typename NDNBOOST_PP_CAT(d, n)::type NDNBOOST_PP_CAT(P, n);\
+ typedef typename NDNBOOST_PP_CAT(d, n)::iter NDNBOOST_PP_CAT(iter,NDNBOOST_PP_INC(n));
// template<class, unsigned int, ...> class
-#define BOOST_TYPEOF_TEMPLATE_PARAM_EXPANDTYPE(This) \
- template <BOOST_PP_SEQ_ENUM(BOOST_TYPEOF_TEMPLATE_PARAM_GETPARAMS(This)) > class
+#define NDNBOOST_TYPEOF_TEMPLATE_PARAM_EXPANDTYPE(This) \
+ template <NDNBOOST_PP_SEQ_ENUM(NDNBOOST_TYPEOF_TEMPLATE_PARAM_GETPARAMS(This)) > class
-#define BOOST_TYPEOF_TEMPLATE_PARAM_PLACEHOLDER(Param)\
+#define NDNBOOST_TYPEOF_TEMPLATE_PARAM_PLACEHOLDER(Param)\
Nested_Template_Template_Arguments_Not_Supported
//'template<class,int> class' is reduced to 'class'
-#define BOOST_TYPEOF_TEMPLATE_PARAM_DECLARATION_TYPE(Param) class
+#define NDNBOOST_TYPEOF_TEMPLATE_PARAM_DECLARATION_TYPE(Param) class
// T3<int, (unsigned int)0, ...>
-#define BOOST_TYPEOF_TEMPLATE_PARAM_PLACEHOLDER_TYPES(Param, n)\
- BOOST_PP_CAT(T,n)<BOOST_TYPEOF_SEQ_ENUM_1(BOOST_TYPEOF_MAKE_OBJS(BOOST_TYPEOF_TEMPLATE_PARAM_GETPARAMS(Param)),BOOST_TYPEOF_PLACEHOLDER) >
+#define NDNBOOST_TYPEOF_TEMPLATE_PARAM_PLACEHOLDER_TYPES(Param, n)\
+ NDNBOOST_PP_CAT(T,n)<NDNBOOST_TYPEOF_SEQ_ENUM_1(NDNBOOST_TYPEOF_MAKE_OBJS(NDNBOOST_TYPEOF_TEMPLATE_PARAM_GETPARAMS(Param)),NDNBOOST_TYPEOF_PLACEHOLDER) >
-#define BOOST_TYPEOF_TEMPLATE_PARAM_ISTEMPLATE 1
+#define NDNBOOST_TYPEOF_TEMPLATE_PARAM_ISTEMPLATE 1
////////////////////////////
// move to encode_decode?
-BOOST_TYPEOF_BEGIN_ENCODE_NS
+NDNBOOST_TYPEOF_BEGIN_ENCODE_NS
template<class V, class Type_Not_Registered_With_Typeof_System> struct encode_template_impl;
template<class T, class Iter> struct decode_template_impl;
-BOOST_TYPEOF_END_ENCODE_NS
+NDNBOOST_TYPEOF_END_ENCODE_NS
namespace ndnboost { namespace type_of {
template<class V, class T> struct encode_template
- : BOOST_TYPEOF_ENCODE_NS_QUALIFIER::encode_template_impl<V, T>
+ : NDNBOOST_TYPEOF_ENCODE_NS_QUALIFIER::encode_template_impl<V, T>
{};
template<class Iter> struct decode_template
- : BOOST_TYPEOF_ENCODE_NS_QUALIFIER::decode_template_impl<typename Iter::type, typename Iter::next>
+ : NDNBOOST_TYPEOF_ENCODE_NS_QUALIFIER::decode_template_impl<typename Iter::type, typename Iter::next>
{};
}}
@@ -73,77 +73,77 @@
// move to template_encoding.hpp?
//Template template registration
-#define BOOST_TYPEOF_REGISTER_TYPE_FOR_TEMPLATE_TEMPLATE(Name,Params,ID)\
+#define NDNBOOST_TYPEOF_REGISTER_TYPE_FOR_TEMPLATE_TEMPLATE(Name,Params,ID)\
template<class V\
- BOOST_TYPEOF_SEQ_ENUM_TRAILING(Params,BOOST_TYPEOF_REGISTER_TEMPLATE_PARAM_PAIR)\
+ NDNBOOST_TYPEOF_SEQ_ENUM_TRAILING(Params,NDNBOOST_TYPEOF_REGISTER_TEMPLATE_PARAM_PAIR)\
>\
struct encode_template_impl<V,Name<\
- BOOST_PP_ENUM_PARAMS(\
- BOOST_PP_SEQ_SIZE(Params),\
+ NDNBOOST_PP_ENUM_PARAMS(\
+ NDNBOOST_PP_SEQ_SIZE(Params),\
P)> >\
: ndnboost::type_of::push_back<V, ndnboost::mpl::size_t<ID> >\
{\
};\
template<class Iter> struct decode_template_impl<ndnboost::mpl::size_t<ID>, Iter>\
{\
- BOOST_PP_REPEAT(BOOST_PP_SEQ_SIZE(Params),BOOST_TYPEOF_TYPEDEF_INT_PN,_)\
- typedef Name<BOOST_TYPEOF_SEQ_ENUM(Params,BOOST_TYPEOF_PLACEHOLDER) > type;\
+ NDNBOOST_PP_REPEAT(NDNBOOST_PP_SEQ_SIZE(Params),NDNBOOST_TYPEOF_TYPEDEF_INT_PN,_)\
+ typedef Name<NDNBOOST_TYPEOF_SEQ_ENUM(Params,NDNBOOST_TYPEOF_PLACEHOLDER) > type;\
typedef Iter iter;\
};
-#define BOOST_TYPEOF_TYPEDEF_INT_PN(z,n,Params) typedef int BOOST_PP_CAT(P,n);
+#define NDNBOOST_TYPEOF_TYPEDEF_INT_PN(z,n,Params) typedef int NDNBOOST_PP_CAT(P,n);
#ifdef __BORLANDC__
-#define BOOST_TYPEOF_DECODE_NESTED_TEMPLATE_HELPER_NAME BOOST_PP_CAT(\
- BOOST_PP_CAT(\
- BOOST_PP_CAT(\
+#define NDNBOOST_TYPEOF_DECODE_NESTED_TEMPLATE_HELPER_NAME NDNBOOST_PP_CAT(\
+ NDNBOOST_PP_CAT(\
+ NDNBOOST_PP_CAT(\
decode_nested_template_helper,\
- BOOST_TYPEOF_REGISTRATION_GROUP\
+ NDNBOOST_TYPEOF_REGISTRATION_GROUP\
),0x10000\
),__LINE__\
)
-#define BOOST_TYPEOF_REGISTER_DECODE_NESTED_TEMPLATE_HELPER_IMPL(Name,Params,ID)\
- struct BOOST_TYPEOF_DECODE_NESTED_TEMPLATE_HELPER_NAME {\
- template<BOOST_TYPEOF_SEQ_ENUM(Params,BOOST_TYPEOF_REGISTER_DECLARE_DECODER_TYPE_PARAM_PAIR) >\
+#define NDNBOOST_TYPEOF_REGISTER_DECODE_NESTED_TEMPLATE_HELPER_IMPL(Name,Params,ID)\
+ struct NDNBOOST_TYPEOF_DECODE_NESTED_TEMPLATE_HELPER_NAME {\
+ template<NDNBOOST_TYPEOF_SEQ_ENUM(Params,NDNBOOST_TYPEOF_REGISTER_DECLARE_DECODER_TYPE_PARAM_PAIR) >\
struct decode_params;\
- template<BOOST_TYPEOF_SEQ_ENUM(Params,BOOST_TYPEOF_REGISTER_DECODER_TYPE_PARAM_PAIR) >\
- struct decode_params<BOOST_TYPEOF_SEQ_ENUM(Params,BOOST_TYPEOF_PLACEHOLDER_TYPES) >\
+ template<NDNBOOST_TYPEOF_SEQ_ENUM(Params,NDNBOOST_TYPEOF_REGISTER_DECODER_TYPE_PARAM_PAIR) >\
+ struct decode_params<NDNBOOST_TYPEOF_SEQ_ENUM(Params,NDNBOOST_TYPEOF_PLACEHOLDER_TYPES) >\
{\
- typedef Name<BOOST_PP_ENUM_PARAMS(BOOST_PP_SEQ_SIZE(Params),T)> type;\
+ typedef Name<NDNBOOST_PP_ENUM_PARAMS(NDNBOOST_PP_SEQ_SIZE(Params),T)> type;\
};\
};
//Template template param decoding
-#define BOOST_TYPEOF_TYPEDEF_DECODED_TEMPLATE_TEMPLATE_TYPE(Name,Params)\
- typedef typename BOOST_TYPEOF_DECODE_NESTED_TEMPLATE_HELPER_NAME::decode_params<BOOST_PP_ENUM_PARAMS(BOOST_PP_SEQ_SIZE(Params),P)>::type type;
+#define NDNBOOST_TYPEOF_TYPEDEF_DECODED_TEMPLATE_TEMPLATE_TYPE(Name,Params)\
+ typedef typename NDNBOOST_TYPEOF_DECODE_NESTED_TEMPLATE_HELPER_NAME::decode_params<NDNBOOST_PP_ENUM_PARAMS(NDNBOOST_PP_SEQ_SIZE(Params),P)>::type type;
#else
-#define BOOST_TYPEOF_REGISTER_DECODE_NESTED_TEMPLATE_HELPER_IMPL(Name,Params,ID)
+#define NDNBOOST_TYPEOF_REGISTER_DECODE_NESTED_TEMPLATE_HELPER_IMPL(Name,Params,ID)
//Template template param decoding
-#define BOOST_TYPEOF_TYPEDEF_DECODED_TEMPLATE_TEMPLATE_TYPE(Name,Params)\
- template<BOOST_TYPEOF_SEQ_ENUM(Params,BOOST_TYPEOF_REGISTER_DECLARE_DECODER_TYPE_PARAM_PAIR) >\
+#define NDNBOOST_TYPEOF_TYPEDEF_DECODED_TEMPLATE_TEMPLATE_TYPE(Name,Params)\
+ template<NDNBOOST_TYPEOF_SEQ_ENUM(Params,NDNBOOST_TYPEOF_REGISTER_DECLARE_DECODER_TYPE_PARAM_PAIR) >\
struct decode_params;\
- template<BOOST_TYPEOF_SEQ_ENUM(Params,BOOST_TYPEOF_REGISTER_DECODER_TYPE_PARAM_PAIR) >\
- struct decode_params<BOOST_TYPEOF_SEQ_ENUM(Params,BOOST_TYPEOF_PLACEHOLDER_TYPES) >\
+ template<NDNBOOST_TYPEOF_SEQ_ENUM(Params,NDNBOOST_TYPEOF_REGISTER_DECODER_TYPE_PARAM_PAIR) >\
+ struct decode_params<NDNBOOST_TYPEOF_SEQ_ENUM(Params,NDNBOOST_TYPEOF_PLACEHOLDER_TYPES) >\
{\
- typedef Name<BOOST_PP_ENUM_PARAMS(BOOST_PP_SEQ_SIZE(Params),T)> type;\
+ typedef Name<NDNBOOST_PP_ENUM_PARAMS(NDNBOOST_PP_SEQ_SIZE(Params),T)> type;\
};\
- typedef typename decode_params<BOOST_PP_ENUM_PARAMS(BOOST_PP_SEQ_SIZE(Params),P)>::type type;
+ typedef typename decode_params<NDNBOOST_PP_ENUM_PARAMS(NDNBOOST_PP_SEQ_SIZE(Params),P)>::type type;
#endif
-#define BOOST_TYPEOF_REGISTER_DECLARE_DECODER_TYPE_PARAM_PAIR(z,n,elem) \
- BOOST_TYPEOF_VIRTUAL(DECLARATION_TYPE, elem)(elem) BOOST_PP_CAT(T, n)
+#define NDNBOOST_TYPEOF_REGISTER_DECLARE_DECODER_TYPE_PARAM_PAIR(z,n,elem) \
+ NDNBOOST_TYPEOF_VIRTUAL(DECLARATION_TYPE, elem)(elem) NDNBOOST_PP_CAT(T, n)
-// BOOST_TYPEOF_HAS_TEMPLATES
-#define BOOST_TYPEOF_HAS_TEMPLATES(Params)\
- BOOST_PP_SEQ_FOLD_LEFT(BOOST_TYPEOF_HAS_TEMPLATES_OP, 0, Params)
+// NDNBOOST_TYPEOF_HAS_TEMPLATES
+#define NDNBOOST_TYPEOF_HAS_TEMPLATES(Params)\
+ NDNBOOST_PP_SEQ_FOLD_LEFT(NDNBOOST_TYPEOF_HAS_TEMPLATES_OP, 0, Params)
-#define BOOST_TYPEOF_HAS_TEMPLATES_OP(s, state, elem)\
- BOOST_PP_OR(state, BOOST_TYPEOF_VIRTUAL(ISTEMPLATE, elem))
+#define NDNBOOST_TYPEOF_HAS_TEMPLATES_OP(s, state, elem)\
+ NDNBOOST_PP_OR(state, NDNBOOST_TYPEOF_VIRTUAL(ISTEMPLATE, elem))
//Define template template arguments
-#define BOOST_TYPEOF_REGISTER_TEMPLATE_TEMPLATE_IMPL(Name,Params,ID)\
- BOOST_PP_IF(BOOST_TYPEOF_HAS_TEMPLATES(Params),\
- BOOST_TYPEOF_REGISTER_DECODE_NESTED_TEMPLATE_HELPER_IMPL,\
- BOOST_TYPEOF_REGISTER_TYPE_FOR_TEMPLATE_TEMPLATE)(Name,Params,ID)
+#define NDNBOOST_TYPEOF_REGISTER_TEMPLATE_TEMPLATE_IMPL(Name,Params,ID)\
+ NDNBOOST_PP_IF(NDNBOOST_TYPEOF_HAS_TEMPLATES(Params),\
+ NDNBOOST_TYPEOF_REGISTER_DECODE_NESTED_TEMPLATE_HELPER_IMPL,\
+ NDNBOOST_TYPEOF_REGISTER_TYPE_FOR_TEMPLATE_TEMPLATE)(Name,Params,ID)
-#endif //BOOST_TYPEOF_TEMPLATE_TEMPLATE_PARAM_HPP_INCLUDED
+#endif //NDNBOOST_TYPEOF_TEMPLATE_TEMPLATE_PARAM_HPP_INCLUDED
diff --git a/include/ndnboost/typeof/type_encoding.hpp b/include/ndnboost/typeof/type_encoding.hpp
index 53c4508..ad59bf2 100644
--- a/include/ndnboost/typeof/type_encoding.hpp
+++ b/include/ndnboost/typeof/type_encoding.hpp
@@ -2,10 +2,10 @@
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#ifndef BOOST_TYPEOF_TYPE_ENCODING_HPP_INCLUDED
-#define BOOST_TYPEOF_TYPE_ENCODING_HPP_INCLUDED
+#ifndef NDNBOOST_TYPEOF_TYPE_ENCODING_HPP_INCLUDED
+#define NDNBOOST_TYPEOF_TYPE_ENCODING_HPP_INCLUDED
-#define BOOST_TYPEOF_REGISTER_TYPE_IMPL(T, Id) \
+#define NDNBOOST_TYPEOF_REGISTER_TYPE_IMPL(T, Id) \
\
template<class V> struct encode_type_impl<V, T > \
: ndnboost::type_of::push_back<V, ndnboost::mpl::size_t<Id> > \
@@ -16,12 +16,12 @@
typedef Iter iter; \
};
-#define BOOST_TYPEOF_REGISTER_TYPE_EXPLICIT_ID(Type, Id) \
- BOOST_TYPEOF_BEGIN_ENCODE_NS \
- BOOST_TYPEOF_REGISTER_TYPE_IMPL(Type, Id) \
- BOOST_TYPEOF_END_ENCODE_NS
+#define NDNBOOST_TYPEOF_REGISTER_TYPE_EXPLICIT_ID(Type, Id) \
+ NDNBOOST_TYPEOF_BEGIN_ENCODE_NS \
+ NDNBOOST_TYPEOF_REGISTER_TYPE_IMPL(Type, Id) \
+ NDNBOOST_TYPEOF_END_ENCODE_NS
-#define BOOST_TYPEOF_REGISTER_TYPE(Type) \
- BOOST_TYPEOF_REGISTER_TYPE_EXPLICIT_ID(Type, BOOST_TYPEOF_UNIQUE_ID())
+#define NDNBOOST_TYPEOF_REGISTER_TYPE(Type) \
+ NDNBOOST_TYPEOF_REGISTER_TYPE_EXPLICIT_ID(Type, NDNBOOST_TYPEOF_UNIQUE_ID())
-#endif//BOOST_TYPEOF_TYPE_ENCODING_HPP_INCLUDED
+#endif//NDNBOOST_TYPEOF_TYPE_ENCODING_HPP_INCLUDED
diff --git a/include/ndnboost/typeof/type_template_param.hpp b/include/ndnboost/typeof/type_template_param.hpp
index 283f480..9abc45c 100644
--- a/include/ndnboost/typeof/type_template_param.hpp
+++ b/include/ndnboost/typeof/type_template_param.hpp
@@ -2,36 +2,36 @@
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#ifndef BOOST_TYPEOF_TYPE_TEMPLATE_PARAM_HPP_INCLUDED
-#define BOOST_TYPEOF_TYPE_TEMPLATE_PARAM_HPP_INCLUDED
+#ifndef NDNBOOST_TYPEOF_TYPE_TEMPLATE_PARAM_HPP_INCLUDED
+#define NDNBOOST_TYPEOF_TYPE_TEMPLATE_PARAM_HPP_INCLUDED
-#define BOOST_TYPEOF_class_BOOST_TYPEOF (class)
-#define BOOST_TYPEOF_typename_BOOST_TYPEOF (typename)
+#define NDNBOOST_TYPEOF_class_NDNBOOST_TYPEOF (class)
+#define NDNBOOST_TYPEOF_typename_NDNBOOST_TYPEOF (typename)
-#define BOOST_TYPEOF_MAKE_OBJ_class BOOST_TYPEOF_TYPE_PARAM
-#define BOOST_TYPEOF_MAKE_OBJ_typename BOOST_TYPEOF_TYPE_PARAM
+#define NDNBOOST_TYPEOF_MAKE_OBJ_class NDNBOOST_TYPEOF_TYPE_PARAM
+#define NDNBOOST_TYPEOF_MAKE_OBJ_typename NDNBOOST_TYPEOF_TYPE_PARAM
-#define BOOST_TYPEOF_TYPE_PARAM\
+#define NDNBOOST_TYPEOF_TYPE_PARAM\
(TYPE_PARAM)
-#define BOOST_TYPEOF_TYPE_PARAM_EXPANDTYPE(Param) class
+#define NDNBOOST_TYPEOF_TYPE_PARAM_EXPANDTYPE(Param) class
// TYPE_PARAM "virtual functions" implementation
-#define BOOST_TYPEOF_TYPE_PARAM_ENCODE(This, n)\
+#define NDNBOOST_TYPEOF_TYPE_PARAM_ENCODE(This, n)\
typedef typename ndnboost::type_of::encode_type<\
- BOOST_PP_CAT(V, n),\
- BOOST_PP_CAT(P, n)\
- >::type BOOST_PP_CAT(V, BOOST_PP_INC(n));
+ NDNBOOST_PP_CAT(V, n),\
+ NDNBOOST_PP_CAT(P, n)\
+ >::type NDNBOOST_PP_CAT(V, NDNBOOST_PP_INC(n));
-#define BOOST_TYPEOF_TYPE_PARAM_DECODE(This, n)\
- typedef ndnboost::type_of::decode_type< BOOST_PP_CAT(iter, n) > BOOST_PP_CAT(d, n);\
- typedef typename BOOST_PP_CAT(d, n)::type BOOST_PP_CAT(P, n);\
- typedef typename BOOST_PP_CAT(d, n)::iter BOOST_PP_CAT(iter, BOOST_PP_INC(n));
+#define NDNBOOST_TYPEOF_TYPE_PARAM_DECODE(This, n)\
+ typedef ndnboost::type_of::decode_type< NDNBOOST_PP_CAT(iter, n) > NDNBOOST_PP_CAT(d, n);\
+ typedef typename NDNBOOST_PP_CAT(d, n)::type NDNBOOST_PP_CAT(P, n);\
+ typedef typename NDNBOOST_PP_CAT(d, n)::iter NDNBOOST_PP_CAT(iter, NDNBOOST_PP_INC(n));
-#define BOOST_TYPEOF_TYPE_PARAM_PLACEHOLDER(Param) int
-#define BOOST_TYPEOF_TYPE_PARAM_DECLARATION_TYPE(Param) class
-#define BOOST_TYPEOF_TYPE_PARAM_PLACEHOLDER_TYPES(Param, n) BOOST_PP_CAT(T,n)
-#define BOOST_TYPEOF_TYPE_PARAM_ISTEMPLATE 0
+#define NDNBOOST_TYPEOF_TYPE_PARAM_PLACEHOLDER(Param) int
+#define NDNBOOST_TYPEOF_TYPE_PARAM_DECLARATION_TYPE(Param) class
+#define NDNBOOST_TYPEOF_TYPE_PARAM_PLACEHOLDER_TYPES(Param, n) NDNBOOST_PP_CAT(T,n)
+#define NDNBOOST_TYPEOF_TYPE_PARAM_ISTEMPLATE 0
-#endif//BOOST_TYPEOF_TYPE_TEMPLATE_PARAM_HPP_INCLUDED
+#endif//NDNBOOST_TYPEOF_TYPE_TEMPLATE_PARAM_HPP_INCLUDED
diff --git a/include/ndnboost/typeof/typeof.hpp b/include/ndnboost/typeof/typeof.hpp
index 98505d9..4847baf 100644
--- a/include/ndnboost/typeof/typeof.hpp
+++ b/include/ndnboost/typeof/typeof.hpp
@@ -2,29 +2,29 @@
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#ifndef BOOST_TYPEOF_TYPEOF_HPP_INCLUDED
-#define BOOST_TYPEOF_TYPEOF_HPP_INCLUDED
+#ifndef NDNBOOST_TYPEOF_TYPEOF_HPP_INCLUDED
+#define NDNBOOST_TYPEOF_TYPEOF_HPP_INCLUDED
-#if defined(BOOST_TYPEOF_COMPLIANT)
-# define BOOST_TYPEOF_EMULATION
+#if defined(NDNBOOST_TYPEOF_COMPLIANT)
+# define NDNBOOST_TYPEOF_EMULATION
#endif
-#if defined(BOOST_TYPEOF_EMULATION) && defined(BOOST_TYPEOF_NATIVE)
+#if defined(NDNBOOST_TYPEOF_EMULATION) && defined(NDNBOOST_TYPEOF_NATIVE)
# error both typeof emulation and native mode requested
#endif
#if defined(__COMO__)
# ifdef __GNUG__
-# ifndef BOOST_TYPEOF_EMULATION
-# ifndef BOOST_TYPEOF_NATIVE
-# define BOOST_TYPEOF_NATIVE
+# ifndef NDNBOOST_TYPEOF_EMULATION
+# ifndef NDNBOOST_TYPEOF_NATIVE
+# define NDNBOOST_TYPEOF_NATIVE
# endif
-# define BOOST_TYPEOF_KEYWORD typeof
+# define NDNBOOST_TYPEOF_KEYWORD typeof
# endif
# else
-# ifndef BOOST_TYPEOF_NATIVE
-# ifndef BOOST_TYPEOF_EMULATION
-# define BOOST_TYPEOF_EMULATION
+# ifndef NDNBOOST_TYPEOF_NATIVE
+# ifndef NDNBOOST_TYPEOF_EMULATION
+# define NDNBOOST_TYPEOF_EMULATION
# endif
# else
# error native typeof is not supported
@@ -33,16 +33,16 @@
#elif defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC) || defined(__ECC)
# ifdef __GNUC__
-# ifndef BOOST_TYPEOF_EMULATION
-# ifndef BOOST_TYPEOF_NATIVE
-# define BOOST_TYPEOF_NATIVE
+# ifndef NDNBOOST_TYPEOF_EMULATION
+# ifndef NDNBOOST_TYPEOF_NATIVE
+# define NDNBOOST_TYPEOF_NATIVE
# endif
-# define BOOST_TYPEOF_KEYWORD __typeof__
+# define NDNBOOST_TYPEOF_KEYWORD __typeof__
# endif
# else
-# ifndef BOOST_TYPEOF_NATIVE
-# ifndef BOOST_TYPEOF_EMULATION
-# define BOOST_TYPEOF_EMULATION
+# ifndef NDNBOOST_TYPEOF_NATIVE
+# ifndef NDNBOOST_TYPEOF_EMULATION
+# define NDNBOOST_TYPEOF_EMULATION
# endif
# else
# error native typeof is not supported
@@ -50,60 +50,60 @@
# endif
#elif defined(__GNUC__)
-# ifndef BOOST_TYPEOF_EMULATION
-# ifndef BOOST_TYPEOF_NATIVE
-# define BOOST_TYPEOF_NATIVE
+# ifndef NDNBOOST_TYPEOF_EMULATION
+# ifndef NDNBOOST_TYPEOF_NATIVE
+# define NDNBOOST_TYPEOF_NATIVE
# endif
-# define BOOST_TYPEOF_KEYWORD __typeof__
+# define NDNBOOST_TYPEOF_KEYWORD __typeof__
# endif
#elif defined(__MWERKS__)
# if(__MWERKS__ <= 0x3003) // 8.x
-# ifndef BOOST_TYPEOF_EMULATION
-# ifndef BOOST_TYPEOF_NATIVE
-# define BOOST_TYPEOF_NATIVE
+# ifndef NDNBOOST_TYPEOF_EMULATION
+# ifndef NDNBOOST_TYPEOF_NATIVE
+# define NDNBOOST_TYPEOF_NATIVE
# endif
-# define BOOST_TYPEOF_KEYWORD __typeof__
+# define NDNBOOST_TYPEOF_KEYWORD __typeof__
# else
-# define BOOST_TYPEOF_EMULATION_UNSUPPORTED
+# define NDNBOOST_TYPEOF_EMULATION_UNSUPPORTED
# endif
# else // 9.x
-# ifndef BOOST_TYPEOF_EMULATION
-# ifndef BOOST_TYPEOF_NATIVE
-# define BOOST_TYPEOF_NATIVE
+# ifndef NDNBOOST_TYPEOF_EMULATION
+# ifndef NDNBOOST_TYPEOF_NATIVE
+# define NDNBOOST_TYPEOF_NATIVE
# endif
-# define BOOST_TYPEOF_KEYWORD __typeof__
+# define NDNBOOST_TYPEOF_KEYWORD __typeof__
# endif
# endif
#elif defined __CODEGEARC__
-# ifndef BOOST_TYPEOF_EMULATION
-# ifndef BOOST_TYPEOF_NATIVE
-# define BOOST_TYPEOF_EMULATION_UNSUPPORTED
+# ifndef NDNBOOST_TYPEOF_EMULATION
+# ifndef NDNBOOST_TYPEOF_NATIVE
+# define NDNBOOST_TYPEOF_EMULATION_UNSUPPORTED
# endif
# else
-# define BOOST_TYPEOF_EMULATION_UNSUPPORTED
+# define NDNBOOST_TYPEOF_EMULATION_UNSUPPORTED
# endif
#elif defined __BORLANDC__
-# ifndef BOOST_TYPEOF_EMULATION
-# ifndef BOOST_TYPEOF_NATIVE
-# define BOOST_TYPEOF_EMULATION_UNSUPPORTED
+# ifndef NDNBOOST_TYPEOF_EMULATION
+# ifndef NDNBOOST_TYPEOF_NATIVE
+# define NDNBOOST_TYPEOF_EMULATION_UNSUPPORTED
# endif
# else
-# define BOOST_TYPEOF_EMULATION_UNSUPPORTED
+# define NDNBOOST_TYPEOF_EMULATION_UNSUPPORTED
# endif
#elif defined __DMC__
-# ifndef BOOST_TYPEOF_EMULATION
-# ifndef BOOST_TYPEOF_NATIVE
-# define BOOST_TYPEOF_NATIVE
+# ifndef NDNBOOST_TYPEOF_EMULATION
+# ifndef NDNBOOST_TYPEOF_NATIVE
+# define NDNBOOST_TYPEOF_NATIVE
# endif
# include <ndnboost/typeof/dmc/typeof_impl.hpp>
# define MSVC_TYPEOF_HACK
# endif
#elif defined(_MSC_VER)
# if (_MSC_VER <= 1300) // 6.5, 7.0
-# ifndef BOOST_TYPEOF_EMULATION
-# ifndef BOOST_TYPEOF_NATIVE
-# define BOOST_TYPEOF_NATIVE
+# ifndef NDNBOOST_TYPEOF_EMULATION
+# ifndef NDNBOOST_TYPEOF_NATIVE
+# define NDNBOOST_TYPEOF_NATIVE
# endif
# include <ndnboost/typeof/msvc/typeof_impl.hpp>
# define MSVC_TYPEOF_HACK
@@ -111,33 +111,33 @@
# error typeof emulation is not supported
# endif
# elif (_MSC_VER >= 1310) // 7.1 ->
-# ifndef BOOST_TYPEOF_EMULATION
-# ifndef BOOST_TYPEOF_NATIVE
+# ifndef NDNBOOST_TYPEOF_EMULATION
+# ifndef NDNBOOST_TYPEOF_NATIVE
# ifndef _MSC_EXTENSIONS
-# define BOOST_TYPEOF_EMULATION
+# define NDNBOOST_TYPEOF_EMULATION
# else
-# define BOOST_TYPEOF_NATIVE
+# define NDNBOOST_TYPEOF_NATIVE
# endif
# endif
# endif
-# ifdef BOOST_TYPEOF_NATIVE
+# ifdef NDNBOOST_TYPEOF_NATIVE
# include <ndnboost/typeof/msvc/typeof_impl.hpp>
# define MSVC_TYPEOF_HACK
# endif
# endif
#elif defined(__HP_aCC)
-# ifndef BOOST_TYPEOF_NATIVE
-# ifndef BOOST_TYPEOF_EMULATION
-# define BOOST_TYPEOF_EMULATION
+# ifndef NDNBOOST_TYPEOF_NATIVE
+# ifndef NDNBOOST_TYPEOF_EMULATION
+# define NDNBOOST_TYPEOF_EMULATION
# endif
# else
# error native typeof is not supported
# endif
#elif defined(__DECCXX)
-# ifndef BOOST_TYPEOF_NATIVE
-# ifndef BOOST_TYPEOF_EMULATION
-# define BOOST_TYPEOF_EMULATION
+# ifndef NDNBOOST_TYPEOF_NATIVE
+# ifndef NDNBOOST_TYPEOF_EMULATION
+# define NDNBOOST_TYPEOF_EMULATION
# endif
# else
# error native typeof is not supported
@@ -145,55 +145,55 @@
#elif defined(__BORLANDC__)
# if (__BORLANDC__ < 0x590)
-# define BOOST_TYPEOF_NO_FUNCTION_TYPES
-# define BOOST_TYPEOF_NO_MEMBER_FUNCTION_TYPES
+# define NDNBOOST_TYPEOF_NO_FUNCTION_TYPES
+# define NDNBOOST_TYPEOF_NO_MEMBER_FUNCTION_TYPES
# endif
-# ifndef BOOST_TYPEOF_NATIVE
-# ifndef BOOST_TYPEOF_EMULATION
-# define BOOST_TYPEOF_EMULATION
+# ifndef NDNBOOST_TYPEOF_NATIVE
+# ifndef NDNBOOST_TYPEOF_EMULATION
+# define NDNBOOST_TYPEOF_EMULATION
# endif
# else
# error native typeof is not supported
# endif
#elif defined(__SUNPRO_CC)
# if (__SUNPRO_CC < 0x590 )
-# ifdef BOOST_TYPEOF_NATIVE
+# ifdef NDNBOOST_TYPEOF_NATIVE
# error native typeof is not supported
# endif
-# ifndef BOOST_TYPEOF_EMULATION
-# define BOOST_TYPEOF_EMULATION
+# ifndef NDNBOOST_TYPEOF_EMULATION
+# define NDNBOOST_TYPEOF_EMULATION
# endif
# else
-# ifndef BOOST_TYPEOF_EMULATION
-# ifndef BOOST_TYPEOF_NATIVE
-# define BOOST_TYPEOF_NATIVE
+# ifndef NDNBOOST_TYPEOF_EMULATION
+# ifndef NDNBOOST_TYPEOF_NATIVE
+# define NDNBOOST_TYPEOF_NATIVE
# endif
-# define BOOST_TYPEOF_KEYWORD __typeof__
+# define NDNBOOST_TYPEOF_KEYWORD __typeof__
# endif
# endif
#else //unknown compiler
-# ifndef BOOST_TYPEOF_NATIVE
-# ifndef BOOST_TYPEOF_EMULATION
-# define BOOST_TYPEOF_EMULATION
+# ifndef NDNBOOST_TYPEOF_NATIVE
+# ifndef NDNBOOST_TYPEOF_EMULATION
+# define NDNBOOST_TYPEOF_EMULATION
# endif
# else
-# ifndef BOOST_TYPEOF_KEYWORD
-# define BOOST_TYPEOF_KEYWORD typeof
+# ifndef NDNBOOST_TYPEOF_KEYWORD
+# define NDNBOOST_TYPEOF_KEYWORD typeof
# endif
# endif
#endif
-#define BOOST_TYPEOF_UNIQUE_ID()\
- BOOST_TYPEOF_REGISTRATION_GROUP * 0x10000 + __LINE__
+#define NDNBOOST_TYPEOF_UNIQUE_ID()\
+ NDNBOOST_TYPEOF_REGISTRATION_GROUP * 0x10000 + __LINE__
-#define BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()\
+#define NDNBOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()\
<ndnboost/typeof/incr_registration_group.hpp>
-#ifdef BOOST_TYPEOF_EMULATION_UNSUPPORTED
+#ifdef NDNBOOST_TYPEOF_EMULATION_UNSUPPORTED
# include <ndnboost/typeof/unsupported.hpp>
-#elif defined BOOST_TYPEOF_EMULATION
-# define BOOST_TYPEOF_TEXT "using typeof emulation"
+#elif defined NDNBOOST_TYPEOF_EMULATION
+# define NDNBOOST_TYPEOF_TEXT "using typeof emulation"
# include <ndnboost/typeof/message.hpp>
# include <ndnboost/typeof/typeof_impl.hpp>
# include <ndnboost/typeof/type_encoding.hpp>
@@ -203,8 +203,8 @@
# include <ndnboost/typeof/register_functions.hpp>
# include <ndnboost/typeof/register_fundamental.hpp>
-#elif defined(BOOST_TYPEOF_NATIVE)
-# define BOOST_TYPEOF_TEXT "using native typeof"
+#elif defined(NDNBOOST_TYPEOF_NATIVE)
+# define NDNBOOST_TYPEOF_TEXT "using native typeof"
# include <ndnboost/typeof/message.hpp>
# include <ndnboost/typeof/native.hpp>
#else
@@ -212,7 +212,7 @@
#endif
// auto
-#define BOOST_AUTO(Var, Expr) BOOST_TYPEOF(Expr) Var = Expr
-#define BOOST_AUTO_TPL(Var, Expr) BOOST_TYPEOF_TPL(Expr) Var = Expr
+#define NDNBOOST_AUTO(Var, Expr) NDNBOOST_TYPEOF(Expr) Var = Expr
+#define NDNBOOST_AUTO_TPL(Var, Expr) NDNBOOST_TYPEOF_TPL(Expr) Var = Expr
-#endif//BOOST_TYPEOF_TYPEOF_HPP_INCLUDED
+#endif//NDNBOOST_TYPEOF_TYPEOF_HPP_INCLUDED
diff --git a/include/ndnboost/typeof/typeof_impl.hpp b/include/ndnboost/typeof/typeof_impl.hpp
index 880afed..95ec28c 100644
--- a/include/ndnboost/typeof/typeof_impl.hpp
+++ b/include/ndnboost/typeof/typeof_impl.hpp
@@ -3,8 +3,8 @@
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#ifndef BOOST_TYPEOF_TYPEOF_IMPL_HPP_INCLUDED
-#define BOOST_TYPEOF_TYPEOF_IMPL_HPP_INCLUDED
+#ifndef NDNBOOST_TYPEOF_TYPEOF_IMPL_HPP_INCLUDED
+#define NDNBOOST_TYPEOF_TYPEOF_IMPL_HPP_INCLUDED
#include <ndnboost/mpl/size_t.hpp>
#include <ndnboost/preprocessor/repetition/enum.hpp>
@@ -13,9 +13,9 @@
#include <ndnboost/type_traits/is_function.hpp>
#include <ndnboost/utility/enable_if.hpp>
-#define BOOST_TYPEOF_VECTOR(n) BOOST_PP_CAT(ndnboost::type_of::vector, n)
+#define NDNBOOST_TYPEOF_VECTOR(n) NDNBOOST_PP_CAT(ndnboost::type_of::vector, n)
-#define BOOST_TYPEOF_sizer_item(z, n, _)\
+#define NDNBOOST_TYPEOF_sizer_item(z, n, _)\
char item ## n[V::item ## n ::value];
namespace ndnboost { namespace type_of {
@@ -26,15 +26,15 @@
// char item1[V::item1::value];
// ...
- BOOST_PP_REPEAT(BOOST_TYPEOF_LIMIT_SIZE, BOOST_TYPEOF_sizer_item, ~)
+ NDNBOOST_PP_REPEAT(NDNBOOST_TYPEOF_LIMIT_SIZE, NDNBOOST_TYPEOF_sizer_item, ~)
};
}}
-#undef BOOST_TYPEOF_sizer_item
+#undef NDNBOOST_TYPEOF_sizer_item
//
namespace ndnboost { namespace type_of {
-# ifdef BOOST_NO_SFINAE
+# ifdef NDNBOOST_NO_SFINAE
template<class V, class T>
sizer<typename encode_type<V, T>::type> encode(const T&);
# else
@@ -59,18 +59,18 @@
};
}}
-#define BOOST_TYPEOF_TYPEITEM(z, n, expr)\
- ndnboost::mpl::size_t<sizeof(ndnboost::type_of::encode<BOOST_TYPEOF_VECTOR(0)<> >(expr).item ## n)>
+#define NDNBOOST_TYPEOF_TYPEITEM(z, n, expr)\
+ ndnboost::mpl::size_t<sizeof(ndnboost::type_of::encode<NDNBOOST_TYPEOF_VECTOR(0)<> >(expr).item ## n)>
-#define BOOST_TYPEOF_ENCODED_VECTOR(Expr) \
- BOOST_TYPEOF_VECTOR(BOOST_TYPEOF_LIMIT_SIZE)< \
- BOOST_PP_ENUM(BOOST_TYPEOF_LIMIT_SIZE, BOOST_TYPEOF_TYPEITEM, Expr) \
+#define NDNBOOST_TYPEOF_ENCODED_VECTOR(Expr) \
+ NDNBOOST_TYPEOF_VECTOR(NDNBOOST_TYPEOF_LIMIT_SIZE)< \
+ NDNBOOST_PP_ENUM(NDNBOOST_TYPEOF_LIMIT_SIZE, NDNBOOST_TYPEOF_TYPEITEM, Expr) \
>
-#define BOOST_TYPEOF(Expr)\
- ndnboost::type_of::decode_begin<BOOST_TYPEOF_ENCODED_VECTOR(Expr) >::type
+#define NDNBOOST_TYPEOF(Expr)\
+ ndnboost::type_of::decode_begin<NDNBOOST_TYPEOF_ENCODED_VECTOR(Expr) >::type
-#define BOOST_TYPEOF_TPL typename BOOST_TYPEOF
+#define NDNBOOST_TYPEOF_TPL typename NDNBOOST_TYPEOF
//offset_vector is used to delay the insertion of data into the vector in order to allow
//encoding to be done in many steps
@@ -90,19 +90,19 @@
};
}}
-#define BOOST_TYPEOF_NESTED_TYPEITEM(z, n, expr)\
- BOOST_STATIC_CONSTANT(int,BOOST_PP_CAT(value,n) = sizeof(ndnboost::type_of::encode<_typeof_start_vector>(expr).item ## n));\
- typedef ndnboost::mpl::size_t<BOOST_PP_CAT(self_t::value,n)> BOOST_PP_CAT(item,n);
+#define NDNBOOST_TYPEOF_NESTED_TYPEITEM(z, n, expr)\
+ NDNBOOST_STATIC_CONSTANT(int,NDNBOOST_PP_CAT(value,n) = sizeof(ndnboost::type_of::encode<_typeof_start_vector>(expr).item ## n));\
+ typedef ndnboost::mpl::size_t<NDNBOOST_PP_CAT(self_t::value,n)> NDNBOOST_PP_CAT(item,n);
#ifdef __DMC__
-#define BOOST_TYPEOF_NESTED_TYPEITEM_2(z,n,expr)\
- typedef typename _typeof_encode_fraction<iteration>::BOOST_PP_CAT(item,n) BOOST_PP_CAT(item,n);
+#define NDNBOOST_TYPEOF_NESTED_TYPEITEM_2(z,n,expr)\
+ typedef typename _typeof_encode_fraction<iteration>::NDNBOOST_PP_CAT(item,n) NDNBOOST_PP_CAT(item,n);
-#define BOOST_TYPEOF_FRACTIONTYPE()\
- BOOST_PP_REPEAT(BOOST_TYPEOF_LIMIT_SIZE,BOOST_TYPEOF_NESTED_TYPEITEM_2,_)\
+#define NDNBOOST_TYPEOF_FRACTIONTYPE()\
+ NDNBOOST_PP_REPEAT(NDNBOOST_TYPEOF_LIMIT_SIZE,NDNBOOST_TYPEOF_NESTED_TYPEITEM_2,_)\
typedef _typeof_fraction_iter<Pos> fraction_type;
#else
-#define BOOST_TYPEOF_FRACTIONTYPE()\
+#define NDNBOOST_TYPEOF_FRACTIONTYPE()\
typedef _typeof_encode_fraction<self_t::iteration> fraction_type;
#endif
@@ -119,13 +119,13 @@
typedef typename v_iter<fraction_type,mpl::int_<self_t::where> >::type type;
};
}}
-#define BOOST_TYPEOF_NESTED_TYPEDEF_IMPL(expr) \
+#define NDNBOOST_TYPEOF_NESTED_TYPEDEF_IMPL(expr) \
template<int _Typeof_Iteration>\
struct _typeof_encode_fraction {\
typedef _typeof_encode_fraction<_Typeof_Iteration> self_t;\
- BOOST_STATIC_CONSTANT(int,_typeof_encode_offset = (_Typeof_Iteration*BOOST_TYPEOF_LIMIT_SIZE));\
- typedef ndnboost::type_of::offset_vector<BOOST_TYPEOF_VECTOR(0)<>,ndnboost::mpl::size_t<self_t::_typeof_encode_offset> > _typeof_start_vector;\
- BOOST_PP_REPEAT(BOOST_TYPEOF_LIMIT_SIZE,BOOST_TYPEOF_NESTED_TYPEITEM,expr)\
+ NDNBOOST_STATIC_CONSTANT(int,_typeof_encode_offset = (_Typeof_Iteration*NDNBOOST_TYPEOF_LIMIT_SIZE));\
+ typedef ndnboost::type_of::offset_vector<NDNBOOST_TYPEOF_VECTOR(0)<>,ndnboost::mpl::size_t<self_t::_typeof_encode_offset> > _typeof_start_vector;\
+ NDNBOOST_PP_REPEAT(NDNBOOST_TYPEOF_LIMIT_SIZE,NDNBOOST_TYPEOF_NESTED_TYPEITEM,expr)\
template<int Next>\
struct _apply_next {\
typedef _typeof_encode_fraction<Next> type;\
@@ -138,49 +138,49 @@
typedef typename self_t::type type;\
};
#else
-#define BOOST_TYPEOF_NESTED_TYPEDEF_IMPL(expr) \
+#define NDNBOOST_TYPEOF_NESTED_TYPEDEF_IMPL(expr) \
template<int _Typeof_Iteration>\
struct _typeof_encode_fraction {\
typedef _typeof_encode_fraction<_Typeof_Iteration> self_t;\
- BOOST_STATIC_CONSTANT(int,_typeof_encode_offset = (_Typeof_Iteration*BOOST_TYPEOF_LIMIT_SIZE));\
- typedef ndnboost::type_of::offset_vector<BOOST_TYPEOF_VECTOR(0)<>,ndnboost::mpl::size_t<self_t::_typeof_encode_offset> > _typeof_start_vector;\
- BOOST_PP_REPEAT(BOOST_TYPEOF_LIMIT_SIZE,BOOST_TYPEOF_NESTED_TYPEITEM,expr)\
+ NDNBOOST_STATIC_CONSTANT(int,_typeof_encode_offset = (_Typeof_Iteration*NDNBOOST_TYPEOF_LIMIT_SIZE));\
+ typedef ndnboost::type_of::offset_vector<NDNBOOST_TYPEOF_VECTOR(0)<>,ndnboost::mpl::size_t<self_t::_typeof_encode_offset> > _typeof_start_vector;\
+ NDNBOOST_PP_REPEAT(NDNBOOST_TYPEOF_LIMIT_SIZE,NDNBOOST_TYPEOF_NESTED_TYPEITEM,expr)\
};\
template<typename Pos>\
struct _typeof_fraction_iter {\
typedef _typeof_fraction_iter<Pos> self_t;\
- BOOST_STATIC_CONSTANT(int,pos=(Pos::value));\
- BOOST_STATIC_CONSTANT(int,iteration=(pos/BOOST_TYPEOF_LIMIT_SIZE));\
- BOOST_STATIC_CONSTANT(int,where=pos%BOOST_TYPEOF_LIMIT_SIZE);\
- BOOST_TYPEOF_FRACTIONTYPE()\
+ NDNBOOST_STATIC_CONSTANT(int,pos=(Pos::value));\
+ NDNBOOST_STATIC_CONSTANT(int,iteration=(pos/NDNBOOST_TYPEOF_LIMIT_SIZE));\
+ NDNBOOST_STATIC_CONSTANT(int,where=pos%NDNBOOST_TYPEOF_LIMIT_SIZE);\
+ NDNBOOST_TYPEOF_FRACTIONTYPE()\
typedef typename ndnboost::type_of::v_iter<fraction_type,ndnboost::mpl::int_<self_t::where> >::type type;\
typedef _typeof_fraction_iter<typename Pos::next> next;\
};
#endif
#ifdef __MWERKS__
-# define BOOST_TYPEOF_NESTED_TYPEDEF(name,expr) \
+# define NDNBOOST_TYPEOF_NESTED_TYPEDEF(name,expr) \
template<typename T>\
-struct BOOST_PP_CAT(_typeof_template_,name) {\
- BOOST_TYPEOF_NESTED_TYPEDEF_IMPL(expr)\
+struct NDNBOOST_PP_CAT(_typeof_template_,name) {\
+ NDNBOOST_TYPEOF_NESTED_TYPEDEF_IMPL(expr)\
typedef typename ndnboost::type_of::decode_type<_typeof_fraction_iter<ndnboost::mpl::size_t<0> > >::type type;\
};\
-typedef BOOST_PP_CAT(_typeof_template_,name)<int> name;
+typedef NDNBOOST_PP_CAT(_typeof_template_,name)<int> name;
-# define BOOST_TYPEOF_NESTED_TYPEDEF_TPL(name,expr) BOOST_TYPEOF_NESTED_TYPEDEF(name,expr)
+# define NDNBOOST_TYPEOF_NESTED_TYPEDEF_TPL(name,expr) NDNBOOST_TYPEOF_NESTED_TYPEDEF(name,expr)
#else
-# define BOOST_TYPEOF_NESTED_TYPEDEF_TPL(name,expr) \
+# define NDNBOOST_TYPEOF_NESTED_TYPEDEF_TPL(name,expr) \
struct name {\
- BOOST_TYPEOF_NESTED_TYPEDEF_IMPL(expr)\
+ NDNBOOST_TYPEOF_NESTED_TYPEDEF_IMPL(expr)\
typedef typename ndnboost::type_of::decode_type<_typeof_fraction_iter<ndnboost::mpl::size_t<0> > >::type type;\
};
-# define BOOST_TYPEOF_NESTED_TYPEDEF(name,expr) \
+# define NDNBOOST_TYPEOF_NESTED_TYPEDEF(name,expr) \
struct name {\
- BOOST_TYPEOF_NESTED_TYPEDEF_IMPL(expr)\
+ NDNBOOST_TYPEOF_NESTED_TYPEDEF_IMPL(expr)\
typedef ndnboost::type_of::decode_type<_typeof_fraction_iter<ndnboost::mpl::size_t<0> > >::type type;\
};
#endif
-#endif//BOOST_TYPEOF_COMPLIANT_TYPEOF_IMPL_HPP_INCLUDED
+#endif//NDNBOOST_TYPEOF_COMPLIANT_TYPEOF_IMPL_HPP_INCLUDED
diff --git a/include/ndnboost/typeof/unsupported.hpp b/include/ndnboost/typeof/unsupported.hpp
index d3aae47..11b2a82 100644
--- a/include/ndnboost/typeof/unsupported.hpp
+++ b/include/ndnboost/typeof/unsupported.hpp
@@ -2,28 +2,28 @@
// 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_UNSUPPORTED_HPP_INCLUDED
-#define BOOST_TYPEOF_UNSUPPORTED_HPP_INCLUDED
+#ifndef NDNBOOST_TYPEOF_UNSUPPORTED_HPP_INCLUDED
+#define NDNBOOST_TYPEOF_UNSUPPORTED_HPP_INCLUDED
namespace ndnboost { namespace type_of {
struct typeof_emulation_is_unsupported_on_this_compiler {};
}}
-#define BOOST_TYPEOF(expr) ndnboost::type_of::typeof_emulation_is_unsupported_on_this_compiler
-#define BOOST_TYPEOF_TPL BOOST_TYPEOF
+#define NDNBOOST_TYPEOF(expr) ndnboost::type_of::typeof_emulation_is_unsupported_on_this_compiler
+#define NDNBOOST_TYPEOF_TPL NDNBOOST_TYPEOF
-#define BOOST_TYPEOF_NESTED_TYPEDEF_TPL(name,expr) \
+#define NDNBOOST_TYPEOF_NESTED_TYPEDEF_TPL(name,expr) \
struct name {\
- typedef BOOST_TYPEOF_TPL(expr) type;\
+ typedef NDNBOOST_TYPEOF_TPL(expr) type;\
};
-#define BOOST_TYPEOF_NESTED_TYPEDEF(name,expr) \
+#define NDNBOOST_TYPEOF_NESTED_TYPEDEF(name,expr) \
struct name {\
- typedef BOOST_TYPEOF(expr) type;\
+ typedef NDNBOOST_TYPEOF(expr) type;\
};
-#define BOOST_TYPEOF_REGISTER_TYPE(x)
-#define BOOST_TYPEOF_REGISTER_TEMPLATE(x, params)
+#define NDNBOOST_TYPEOF_REGISTER_TYPE(x)
+#define NDNBOOST_TYPEOF_REGISTER_TEMPLATE(x, params)
#endif
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
diff --git a/include/ndnboost/typeof/vector100.hpp b/include/ndnboost/typeof/vector100.hpp
index 9887744..2216cd9 100644
--- a/include/ndnboost/typeof/vector100.hpp
+++ b/include/ndnboost/typeof/vector100.hpp
@@ -9,7 +9,7 @@
namespace ndnboost { namespace type_of {
- template<class V, class Increase_BOOST_TYPEOF_LIMIT_SIZE> struct v_iter;
+ template<class V, class Increase_NDNBOOST_TYPEOF_LIMIT_SIZE> struct v_iter;
template<class V> struct v_iter<V, mpl::int_<0> > { typedef typename V::item0 type; typedef v_iter<V, mpl::int_<0 + 1> > next; };
template<class V> struct v_iter<V, mpl::int_<1> > { typedef typename V::item1 type; typedef v_iter<V, mpl::int_<1 + 1> > next; };
template<class V> struct v_iter<V, mpl::int_<2> > { typedef typename V::item2 type; typedef v_iter<V, mpl::int_<2 + 1> > next; };
diff --git a/include/ndnboost/typeof/vector150.hpp b/include/ndnboost/typeof/vector150.hpp
index dc9a754..882e846 100644
--- a/include/ndnboost/typeof/vector150.hpp
+++ b/include/ndnboost/typeof/vector150.hpp
@@ -9,7 +9,7 @@
namespace ndnboost { namespace type_of {
- template<class V, class Increase_BOOST_TYPEOF_LIMIT_SIZE> struct v_iter;
+ template<class V, class Increase_NDNBOOST_TYPEOF_LIMIT_SIZE> struct v_iter;
template<class V> struct v_iter<V, mpl::int_<0> > { typedef typename V::item0 type; typedef v_iter<V, mpl::int_<0 + 1> > next; };
template<class V> struct v_iter<V, mpl::int_<1> > { typedef typename V::item1 type; typedef v_iter<V, mpl::int_<1 + 1> > next; };
template<class V> struct v_iter<V, mpl::int_<2> > { typedef typename V::item2 type; typedef v_iter<V, mpl::int_<2 + 1> > next; };
diff --git a/include/ndnboost/typeof/vector200.hpp b/include/ndnboost/typeof/vector200.hpp
index 8285902..40a8d0c 100644
--- a/include/ndnboost/typeof/vector200.hpp
+++ b/include/ndnboost/typeof/vector200.hpp
@@ -9,7 +9,7 @@
namespace ndnboost { namespace type_of {
- template<class V, class Increase_BOOST_TYPEOF_LIMIT_SIZE> struct v_iter;
+ template<class V, class Increase_NDNBOOST_TYPEOF_LIMIT_SIZE> struct v_iter;
template<class V> struct v_iter<V, mpl::int_<0> > { typedef typename V::item0 type; typedef v_iter<V, mpl::int_<0 + 1> > next; };
template<class V> struct v_iter<V, mpl::int_<1> > { typedef typename V::item1 type; typedef v_iter<V, mpl::int_<1 + 1> > next; };
template<class V> struct v_iter<V, mpl::int_<2> > { typedef typename V::item2 type; typedef v_iter<V, mpl::int_<2 + 1> > next; };
diff --git a/include/ndnboost/typeof/vector50.hpp b/include/ndnboost/typeof/vector50.hpp
index 8c368e2..a041ce7 100644
--- a/include/ndnboost/typeof/vector50.hpp
+++ b/include/ndnboost/typeof/vector50.hpp
@@ -9,7 +9,7 @@
namespace ndnboost { namespace type_of {
- template<class V, class Increase_BOOST_TYPEOF_LIMIT_SIZE> struct v_iter;
+ template<class V, class Increase_NDNBOOST_TYPEOF_LIMIT_SIZE> struct v_iter;
template<class V> struct v_iter<V, mpl::int_<0> > { typedef typename V::item0 type; typedef v_iter<V, mpl::int_<0 + 1> > next; };
template<class V> struct v_iter<V, mpl::int_<1> > { typedef typename V::item1 type; typedef v_iter<V, mpl::int_<1 + 1> > next; };
template<class V> struct v_iter<V, mpl::int_<2> > { typedef typename V::item2 type; typedef v_iter<V, mpl::int_<2 + 1> > next; };