ndnboost: Also rename BOOST_ to NDNBOOST_
diff --git a/include/ndnboost/lexical_cast.hpp b/include/ndnboost/lexical_cast.hpp
index aed41ce..828a1f1 100644
--- a/include/ndnboost/lexical_cast.hpp
+++ b/include/ndnboost/lexical_cast.hpp
@@ -1,5 +1,5 @@
-#ifndef BOOST_LEXICAL_CAST_INCLUDED
-#define BOOST_LEXICAL_CAST_INCLUDED
+#ifndef NDNBOOST_LEXICAL_CAST_INCLUDED
+#define NDNBOOST_LEXICAL_CAST_INCLUDED
// MS compatible compilers support #pragma once
@@ -22,8 +22,8 @@
// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2013
#include <ndnboost/config.hpp>
-#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
-#define BOOST_LCAST_NO_WCHAR_T
+#if defined(NDNBOOST_NO_STRINGSTREAM) || defined(NDNBOOST_NO_STD_WSTRING)
+#define NDNBOOST_LCAST_NO_WCHAR_T
#endif
#include <climits>
@@ -43,57 +43,57 @@
#include <ndnboost/detail/workaround.hpp>
-#ifndef BOOST_NO_STD_LOCALE
+#ifndef NDNBOOST_NO_STD_LOCALE
# include <locale>
#else
-# ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
+# ifndef NDNBOOST_LEXICAL_CAST_ASSUME_C_LOCALE
// Getting error at this point means, that your STL library is old/lame/misconfigured.
- // If nothing can be done with STL library, define BOOST_LEXICAL_CAST_ASSUME_C_LOCALE,
+ // If nothing can be done with STL library, define NDNBOOST_LEXICAL_CAST_ASSUME_C_LOCALE,
// but beware: lexical_cast will understand only 'C' locale delimeters and thousands
// separators.
-# error "Unable to use <locale> header. Define BOOST_LEXICAL_CAST_ASSUME_C_LOCALE to force "
+# error "Unable to use <locale> header. Define NDNBOOST_LEXICAL_CAST_ASSUME_C_LOCALE to force "
# error "ndnboost::lexical_cast to use only 'C' locale during conversions."
# endif
#endif
-#ifdef BOOST_NO_STRINGSTREAM
+#ifdef NDNBOOST_NO_STRINGSTREAM
#include <strstream>
#else
#include <sstream>
#endif
-#ifdef BOOST_NO_TYPEID
-#define BOOST_LCAST_THROW_BAD_CAST(S, T) throw_exception(bad_lexical_cast())
+#ifdef NDNBOOST_NO_TYPEID
+#define NDNBOOST_LCAST_THROW_BAD_CAST(S, T) throw_exception(bad_lexical_cast())
#else
-#define BOOST_LCAST_THROW_BAD_CAST(Source, Target) \
+#define NDNBOOST_LCAST_THROW_BAD_CAST(Source, Target) \
throw_exception(bad_lexical_cast(typeid(Source), typeid(Target)))
#endif
-#if (defined(BOOST_LCAST_HAS_INT128) && !defined(__GNUC__)) || GCC_VERSION > 40700
-#define BOOST_LCAST_HAS_INT128
+#if (defined(NDNBOOST_LCAST_HAS_INT128) && !defined(__GNUC__)) || GCC_VERSION > 40700
+#define NDNBOOST_LCAST_HAS_INT128
#endif
namespace ndnboost
{
// exception used to indicate runtime lexical_cast failure
- class BOOST_SYMBOL_VISIBLE bad_lexical_cast :
+ class NDNBOOST_SYMBOL_VISIBLE bad_lexical_cast :
// workaround MSVC bug with std::bad_cast when _HAS_EXCEPTIONS == 0
-#if defined(BOOST_MSVC) && defined(_HAS_EXCEPTIONS) && !_HAS_EXCEPTIONS
+#if defined(NDNBOOST_MSVC) && defined(_HAS_EXCEPTIONS) && !_HAS_EXCEPTIONS
public std::exception
#else
public std::bad_cast
#endif
-#if defined(__BORLANDC__) && BOOST_WORKAROUND( __BORLANDC__, < 0x560 )
+#if defined(__BORLANDC__) && NDNBOOST_WORKAROUND( __BORLANDC__, < 0x560 )
// under bcc32 5.5.1 bad_cast doesn't derive from exception
, public std::exception
#endif
{
public:
- bad_lexical_cast() BOOST_NOEXCEPT :
-#ifndef BOOST_NO_TYPEID
+ bad_lexical_cast() NDNBOOST_NOEXCEPT :
+#ifndef NDNBOOST_NO_TYPEID
source(&typeid(void)), target(&typeid(void))
#else
source(0), target(0) // this breaks getters
@@ -103,7 +103,7 @@
bad_lexical_cast(
const std::type_info &source_type_arg,
- const std::type_info &target_type_arg) BOOST_NOEXCEPT :
+ const std::type_info &target_type_arg) NDNBOOST_NOEXCEPT :
source(&source_type_arg), target(&target_type_arg)
{
}
@@ -117,7 +117,7 @@
return *target;
}
-#ifndef BOOST_NO_CXX11_NOEXCEPT
+#ifndef NDNBOOST_NO_CXX11_NOEXCEPT
virtual const char *what() const noexcept
#else
virtual const char *what() const throw()
@@ -127,8 +127,8 @@
"source type value could not be interpreted as target";
}
-#ifndef BOOST_NO_CXX11_NOEXCEPT
- virtual ~bad_lexical_cast() BOOST_NOEXCEPT
+#ifndef NDNBOOST_NO_CXX11_NOEXCEPT
+ virtual ~bad_lexical_cast() NDNBOOST_NOEXCEPT
#else
virtual ~bad_lexical_cast() throw()
#endif
@@ -143,7 +143,7 @@
template <typename TargetChar, typename SourceChar>
struct widest_char
{
- typedef BOOST_DEDUCED_TYPENAME ndnboost::mpl::if_c<
+ typedef NDNBOOST_DEDUCED_TYPENAME ndnboost::mpl::if_c<
(sizeof(TargetChar) > sizeof(SourceChar))
, TargetChar
, SourceChar >::type type;
@@ -151,12 +151,12 @@
}
} // namespace ndnboost
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(__SUNPRO_CC) && !defined(__PGIC__)
+#if !defined(NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(__SUNPRO_CC) && !defined(__PGIC__)
#include <cmath>
#include <istream>
-#ifndef BOOST_NO_CXX11_HDR_ARRAY
+#ifndef NDNBOOST_NO_CXX11_HDR_ARRAY
#include <array>
#endif
@@ -174,7 +174,7 @@
#include <ndnboost/range/iterator_range_core.hpp>
#include <ndnboost/container/container_fwd.hpp>
#include <ndnboost/integer.hpp>
-#ifndef BOOST_NO_CWCHAR
+#ifndef NDNBOOST_NO_CWCHAR
# include <cwchar>
#endif
@@ -188,20 +188,20 @@
{
typedef ndnboost::type_traits::ice_or<
ndnboost::is_same< T, char >::value,
- #ifndef BOOST_LCAST_NO_WCHAR_T
+ #ifndef NDNBOOST_LCAST_NO_WCHAR_T
ndnboost::is_same< T, wchar_t >::value,
#endif
- #ifndef BOOST_NO_CXX11_CHAR16_T
+ #ifndef NDNBOOST_NO_CXX11_CHAR16_T
ndnboost::is_same< T, char16_t >::value,
#endif
- #ifndef BOOST_NO_CXX11_CHAR32_T
+ #ifndef NDNBOOST_NO_CXX11_CHAR32_T
ndnboost::is_same< T, char32_t >::value,
#endif
ndnboost::is_same< T, unsigned char >::value,
ndnboost::is_same< T, signed char >::value
> result_type;
- BOOST_STATIC_CONSTANT(bool, value = (result_type::value) );
+ NDNBOOST_STATIC_CONSTANT(bool, value = (result_type::value) );
};
}
@@ -300,7 +300,7 @@
ndnboost::detail::deduce_character_type_later< ndnboost::array< const Char, N > >
> {};
-#ifndef BOOST_NO_CXX11_HDR_ARRAY
+#ifndef NDNBOOST_NO_CXX11_HDR_ARRAY
template < typename Char, std::size_t N >
struct stream_char_common< std::array<Char, N > >: public ndnboost::mpl::if_c<
ndnboost::detail::is_char_or_wchar< Char >::value,
@@ -316,12 +316,12 @@
> {};
#endif
-#ifdef BOOST_LCAST_HAS_INT128
+#ifdef NDNBOOST_LCAST_HAS_INT128
template <> struct stream_char_common< ndnboost::int128_type >: public ndnboost::mpl::identity< char > {};
template <> struct stream_char_common< ndnboost::uint128_type >: public ndnboost::mpl::identity< char > {};
#endif
-#if !defined(BOOST_LCAST_NO_WCHAR_T) && defined(BOOST_NO_INTRINSIC_WCHAR_T)
+#if !defined(NDNBOOST_LCAST_NO_WCHAR_T) && defined(NDNBOOST_NO_INTRINSIC_WCHAR_T)
template <>
struct stream_char_common< wchar_t >
{
@@ -340,7 +340,7 @@
template < class Char >
struct deduce_source_char_impl
{
- typedef BOOST_DEDUCED_TYPENAME ndnboost::detail::normalize_single_byte_char< Char >::type type;
+ typedef NDNBOOST_DEDUCED_TYPENAME ndnboost::detail::normalize_single_byte_char< Char >::type type;
};
template < class T >
@@ -348,16 +348,16 @@
{
typedef ndnboost::has_left_shift< std::basic_ostream< char >, T > result_t;
-#if defined(BOOST_LCAST_NO_WCHAR_T)
- BOOST_STATIC_ASSERT_MSG((result_t::value),
+#if defined(NDNBOOST_LCAST_NO_WCHAR_T)
+ NDNBOOST_STATIC_ASSERT_MSG((result_t::value),
"Source type is not std::ostream`able and std::wostream`s are not supported by your STL implementation");
typedef char type;
#else
- typedef BOOST_DEDUCED_TYPENAME ndnboost::mpl::if_c<
+ typedef NDNBOOST_DEDUCED_TYPENAME ndnboost::mpl::if_c<
result_t::value, char, wchar_t
>::type type;
- BOOST_STATIC_ASSERT_MSG((result_t::value || ndnboost::has_left_shift< std::basic_ostream< type >, T >::value),
+ NDNBOOST_STATIC_ASSERT_MSG((result_t::value || ndnboost::has_left_shift< std::basic_ostream< type >, T >::value),
"Source type is neither std::ostream`able nor std::wostream`able");
#endif
};
@@ -373,7 +373,7 @@
template < class Char >
struct deduce_target_char_impl
{
- typedef BOOST_DEDUCED_TYPENAME normalize_single_byte_char< Char >::type type;
+ typedef NDNBOOST_DEDUCED_TYPENAME normalize_single_byte_char< Char >::type type;
};
template < class T >
@@ -381,16 +381,16 @@
{
typedef ndnboost::has_right_shift<std::basic_istream<char>, T > result_t;
-#if defined(BOOST_LCAST_NO_WCHAR_T)
- BOOST_STATIC_ASSERT_MSG((result_t::value),
+#if defined(NDNBOOST_LCAST_NO_WCHAR_T)
+ NDNBOOST_STATIC_ASSERT_MSG((result_t::value),
"Target type is not std::istream`able and std::wistream`s are not supported by your STL implementation");
typedef char type;
#else
- typedef BOOST_DEDUCED_TYPENAME ndnboost::mpl::if_c<
+ typedef NDNBOOST_DEDUCED_TYPENAME ndnboost::mpl::if_c<
result_t::value, char, wchar_t
>::type type;
- BOOST_STATIC_ASSERT_MSG((result_t::value || ndnboost::has_right_shift<std::basic_istream<wchar_t>, T >::value),
+ NDNBOOST_STATIC_ASSERT_MSG((result_t::value || ndnboost::has_right_shift<std::basic_istream<wchar_t>, T >::value),
"Target type is neither std::istream`able nor std::wistream`able");
#endif
};
@@ -416,8 +416,8 @@
template < class T >
struct deduce_target_char
{
- typedef BOOST_DEDUCED_TYPENAME stream_char_common< T >::type stage1_type;
- typedef BOOST_DEDUCED_TYPENAME deduce_target_char_impl< stage1_type >::type stage2_type;
+ typedef NDNBOOST_DEDUCED_TYPENAME stream_char_common< T >::type stage1_type;
+ typedef NDNBOOST_DEDUCED_TYPENAME deduce_target_char_impl< stage1_type >::type stage2_type;
typedef stage2_type type;
};
@@ -425,8 +425,8 @@
template < class T >
struct deduce_source_char
{
- typedef BOOST_DEDUCED_TYPENAME stream_char_common< T >::type stage1_type;
- typedef BOOST_DEDUCED_TYPENAME deduce_source_char_impl< stage1_type >::type stage2_type;
+ typedef NDNBOOST_DEDUCED_TYPENAME stream_char_common< T >::type stage1_type;
+ typedef NDNBOOST_DEDUCED_TYPENAME deduce_source_char_impl< stage1_type >::type stage2_type;
typedef stage2_type type;
};
@@ -540,7 +540,7 @@
{
typedef ndnboost::type_traits::ice_and<
ndnboost::is_float<Float>::value,
-#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_SWPRINTF) && !defined(__MINGW32__)
+#if !defined(NDNBOOST_LCAST_NO_WCHAR_T) && !defined(NDNBOOST_NO_SWPRINTF) && !defined(__MINGW32__)
ndnboost::type_traits::ice_or<
ndnboost::type_traits::ice_eq<sizeof(Char), sizeof(char) >::value,
ndnboost::is_same<Char, wchar_t>::value
@@ -550,7 +550,7 @@
#endif
> result_type;
- BOOST_STATIC_CONSTANT(bool, value = (result_type::value) );
+ NDNBOOST_STATIC_CONSTANT(bool, value = (result_type::value) );
};
}
@@ -561,7 +561,7 @@
>
struct lcast_src_length
{
- BOOST_STATIC_CONSTANT(std::size_t, value = 1);
+ NDNBOOST_STATIC_CONSTANT(std::size_t, value = 1);
// To check coverage, build the test with
// bjam --v2 profile optimization=off
static void check_coverage() {}
@@ -583,44 +583,44 @@
template<class Source>
struct lcast_src_length_integral
{
-#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
- BOOST_STATIC_CONSTANT(std::size_t, value =
+#ifndef NDNBOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+ NDNBOOST_STATIC_CONSTANT(std::size_t, value =
std::numeric_limits<Source>::is_signed +
std::numeric_limits<Source>::is_specialized + /* == 1 */
std::numeric_limits<Source>::digits10 * 2
);
#else
- BOOST_STATIC_CONSTANT(std::size_t, value = 156);
- BOOST_STATIC_ASSERT(sizeof(Source) * CHAR_BIT <= 256);
+ NDNBOOST_STATIC_CONSTANT(std::size_t, value = 156);
+ NDNBOOST_STATIC_ASSERT(sizeof(Source) * CHAR_BIT <= 256);
#endif
};
-#define BOOST_LCAST_DEF(T) \
+#define NDNBOOST_LCAST_DEF(T) \
template<> struct lcast_src_length<T> \
: lcast_src_length_integral<T> \
{ static void check_coverage() {} };
- BOOST_LCAST_DEF(short)
- BOOST_LCAST_DEF(unsigned short)
- BOOST_LCAST_DEF(int)
- BOOST_LCAST_DEF(unsigned int)
- BOOST_LCAST_DEF(long)
- BOOST_LCAST_DEF(unsigned long)
-#if defined(BOOST_HAS_LONG_LONG)
- BOOST_LCAST_DEF(ndnboost::ulong_long_type)
- BOOST_LCAST_DEF(ndnboost::long_long_type )
-#elif defined(BOOST_HAS_MS_INT64)
- BOOST_LCAST_DEF(unsigned __int64)
- BOOST_LCAST_DEF( __int64)
+ NDNBOOST_LCAST_DEF(short)
+ NDNBOOST_LCAST_DEF(unsigned short)
+ NDNBOOST_LCAST_DEF(int)
+ NDNBOOST_LCAST_DEF(unsigned int)
+ NDNBOOST_LCAST_DEF(long)
+ NDNBOOST_LCAST_DEF(unsigned long)
+#if defined(NDNBOOST_HAS_LONG_LONG)
+ NDNBOOST_LCAST_DEF(ndnboost::ulong_long_type)
+ NDNBOOST_LCAST_DEF(ndnboost::long_long_type )
+#elif defined(NDNBOOST_HAS_MS_INT64)
+ NDNBOOST_LCAST_DEF(unsigned __int64)
+ NDNBOOST_LCAST_DEF( __int64)
#endif
-#ifdef BOOST_LCAST_HAS_INT128
- BOOST_LCAST_DEF(ndnboost::int128_type)
- BOOST_LCAST_DEF(ndnboost::uint128_type)
+#ifdef NDNBOOST_LCAST_HAS_INT128
+ NDNBOOST_LCAST_DEF(ndnboost::int128_type)
+ NDNBOOST_LCAST_DEF(ndnboost::uint128_type)
#endif
-#undef BOOST_LCAST_DEF
+#undef NDNBOOST_LCAST_DEF
-#ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
+#ifndef NDNBOOST_LCAST_NO_COMPILE_TIME_PRECISION
// Helper for floating point types.
// -1.23456789e-123456
// ^ sign
@@ -634,11 +634,11 @@
template<class Source>
struct lcast_src_length_floating
{
- BOOST_STATIC_ASSERT(
+ NDNBOOST_STATIC_ASSERT(
std::numeric_limits<Source>::max_exponent10 <= 999999L &&
std::numeric_limits<Source>::min_exponent10 >= -999999L
);
- BOOST_STATIC_CONSTANT(std::size_t, value =
+ NDNBOOST_STATIC_CONSTANT(std::size_t, value =
5 + lcast_precision<Source>::value + 6
);
};
@@ -664,36 +664,36 @@
static void check_coverage() {}
};
-#endif // #ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
+#endif // #ifndef NDNBOOST_LCAST_NO_COMPILE_TIME_PRECISION
}
namespace detail // lexical_cast_stream_traits<Source, Target>
{
template <class Source, class Target>
struct lexical_cast_stream_traits {
- typedef BOOST_DEDUCED_TYPENAME ndnboost::detail::array_to_pointer_decay<Source>::type src;
- typedef BOOST_DEDUCED_TYPENAME ndnboost::remove_cv<src>::type no_cv_src;
+ typedef NDNBOOST_DEDUCED_TYPENAME ndnboost::detail::array_to_pointer_decay<Source>::type src;
+ typedef NDNBOOST_DEDUCED_TYPENAME ndnboost::remove_cv<src>::type no_cv_src;
typedef ndnboost::detail::deduce_source_char<no_cv_src> deduce_src_char_metafunc;
- typedef BOOST_DEDUCED_TYPENAME deduce_src_char_metafunc::type src_char_t;
- typedef BOOST_DEDUCED_TYPENAME ndnboost::detail::deduce_target_char<Target>::type target_char_t;
+ typedef NDNBOOST_DEDUCED_TYPENAME deduce_src_char_metafunc::type src_char_t;
+ typedef NDNBOOST_DEDUCED_TYPENAME ndnboost::detail::deduce_target_char<Target>::type target_char_t;
- typedef BOOST_DEDUCED_TYPENAME ndnboost::detail::widest_char<
+ typedef NDNBOOST_DEDUCED_TYPENAME ndnboost::detail::widest_char<
target_char_t, src_char_t
>::type char_type;
-#if !defined(BOOST_NO_CXX11_CHAR16_T) && defined(BOOST_NO_CXX11_UNICODE_LITERALS)
- BOOST_STATIC_ASSERT_MSG(( !ndnboost::is_same<char16_t, src_char_t>::value
+#if !defined(NDNBOOST_NO_CXX11_CHAR16_T) && defined(NDNBOOST_NO_CXX11_UNICODE_LITERALS)
+ NDNBOOST_STATIC_ASSERT_MSG(( !ndnboost::is_same<char16_t, src_char_t>::value
&& !ndnboost::is_same<char16_t, target_char_t>::value),
"Your compiler does not have full support for char16_t" );
#endif
-#if !defined(BOOST_NO_CXX11_CHAR32_T) && defined(BOOST_NO_CXX11_UNICODE_LITERALS)
- BOOST_STATIC_ASSERT_MSG(( !ndnboost::is_same<char32_t, src_char_t>::value
+#if !defined(NDNBOOST_NO_CXX11_CHAR32_T) && defined(NDNBOOST_NO_CXX11_UNICODE_LITERALS)
+ NDNBOOST_STATIC_ASSERT_MSG(( !ndnboost::is_same<char32_t, src_char_t>::value
&& !ndnboost::is_same<char32_t, target_char_t>::value),
"Your compiler does not have full support for char32_t" );
#endif
- typedef BOOST_DEDUCED_TYPENAME ndnboost::detail::deduce_char_traits<
+ typedef NDNBOOST_DEDUCED_TYPENAME ndnboost::detail::deduce_char_traits<
char_type, Target, no_cv_src
>::type traits;
@@ -709,13 +709,13 @@
ndnboost::is_integral<no_cv_src>::value,
ndnboost::detail::is_this_float_conversion_optimized<no_cv_src, char_type >::value,
ndnboost::detail::is_char_or_wchar<
- BOOST_DEDUCED_TYPENAME deduce_src_char_metafunc::stage1_type // if we did not get character type at stage1
+ NDNBOOST_DEDUCED_TYPENAME deduce_src_char_metafunc::stage1_type // if we did not get character type at stage1
>::value // then we have no optimization for that type
>::value > is_source_input_not_optimized_t;
// If we have an optimized conversion for
// Source, we do not need to construct stringbuf.
- BOOST_STATIC_CONSTANT(bool, requires_stringbuf =
+ NDNBOOST_STATIC_CONSTANT(bool, requires_stringbuf =
(ndnboost::type_traits::ice_or<
is_string_widening_required_t::value, is_source_input_not_optimized_t::value
>::value)
@@ -732,50 +732,50 @@
template<>
struct lcast_char_constants<char>
{
- BOOST_STATIC_CONSTANT(char, zero = '0');
- BOOST_STATIC_CONSTANT(char, minus = '-');
- BOOST_STATIC_CONSTANT(char, plus = '+');
- BOOST_STATIC_CONSTANT(char, lowercase_e = 'e');
- BOOST_STATIC_CONSTANT(char, capital_e = 'E');
- BOOST_STATIC_CONSTANT(char, c_decimal_separator = '.');
+ NDNBOOST_STATIC_CONSTANT(char, zero = '0');
+ NDNBOOST_STATIC_CONSTANT(char, minus = '-');
+ NDNBOOST_STATIC_CONSTANT(char, plus = '+');
+ NDNBOOST_STATIC_CONSTANT(char, lowercase_e = 'e');
+ NDNBOOST_STATIC_CONSTANT(char, capital_e = 'E');
+ NDNBOOST_STATIC_CONSTANT(char, c_decimal_separator = '.');
};
-#ifndef BOOST_LCAST_NO_WCHAR_T
+#ifndef NDNBOOST_LCAST_NO_WCHAR_T
template<>
struct lcast_char_constants<wchar_t>
{
- BOOST_STATIC_CONSTANT(wchar_t, zero = L'0');
- BOOST_STATIC_CONSTANT(wchar_t, minus = L'-');
- BOOST_STATIC_CONSTANT(wchar_t, plus = L'+');
- BOOST_STATIC_CONSTANT(wchar_t, lowercase_e = L'e');
- BOOST_STATIC_CONSTANT(wchar_t, capital_e = L'E');
- BOOST_STATIC_CONSTANT(wchar_t, c_decimal_separator = L'.');
+ NDNBOOST_STATIC_CONSTANT(wchar_t, zero = L'0');
+ NDNBOOST_STATIC_CONSTANT(wchar_t, minus = L'-');
+ NDNBOOST_STATIC_CONSTANT(wchar_t, plus = L'+');
+ NDNBOOST_STATIC_CONSTANT(wchar_t, lowercase_e = L'e');
+ NDNBOOST_STATIC_CONSTANT(wchar_t, capital_e = L'E');
+ NDNBOOST_STATIC_CONSTANT(wchar_t, c_decimal_separator = L'.');
};
#endif
-#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
+#if !defined(NDNBOOST_NO_CXX11_CHAR16_T) && !defined(NDNBOOST_NO_CXX11_UNICODE_LITERALS)
template<>
struct lcast_char_constants<char16_t>
{
- BOOST_STATIC_CONSTANT(char16_t, zero = u'0');
- BOOST_STATIC_CONSTANT(char16_t, minus = u'-');
- BOOST_STATIC_CONSTANT(char16_t, plus = u'+');
- BOOST_STATIC_CONSTANT(char16_t, lowercase_e = u'e');
- BOOST_STATIC_CONSTANT(char16_t, capital_e = u'E');
- BOOST_STATIC_CONSTANT(char16_t, c_decimal_separator = u'.');
+ NDNBOOST_STATIC_CONSTANT(char16_t, zero = u'0');
+ NDNBOOST_STATIC_CONSTANT(char16_t, minus = u'-');
+ NDNBOOST_STATIC_CONSTANT(char16_t, plus = u'+');
+ NDNBOOST_STATIC_CONSTANT(char16_t, lowercase_e = u'e');
+ NDNBOOST_STATIC_CONSTANT(char16_t, capital_e = u'E');
+ NDNBOOST_STATIC_CONSTANT(char16_t, c_decimal_separator = u'.');
};
#endif
-#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
+#if !defined(NDNBOOST_NO_CXX11_CHAR32_T) && !defined(NDNBOOST_NO_CXX11_UNICODE_LITERALS)
template<>
struct lcast_char_constants<char32_t>
{
- BOOST_STATIC_CONSTANT(char32_t, zero = U'0');
- BOOST_STATIC_CONSTANT(char32_t, minus = U'-');
- BOOST_STATIC_CONSTANT(char32_t, plus = U'+');
- BOOST_STATIC_CONSTANT(char32_t, lowercase_e = U'e');
- BOOST_STATIC_CONSTANT(char32_t, capital_e = U'E');
- BOOST_STATIC_CONSTANT(char32_t, c_decimal_separator = U'.');
+ NDNBOOST_STATIC_CONSTANT(char32_t, zero = U'0');
+ NDNBOOST_STATIC_CONSTANT(char32_t, minus = U'-');
+ NDNBOOST_STATIC_CONSTANT(char32_t, plus = U'+');
+ NDNBOOST_STATIC_CONSTANT(char32_t, lowercase_e = U'e');
+ NDNBOOST_STATIC_CONSTANT(char32_t, capital_e = U'E');
+ NDNBOOST_STATIC_CONSTANT(char32_t, c_decimal_separator = U'.');
};
#endif
}
@@ -784,9 +784,9 @@
{
template<class T>
inline
- BOOST_DEDUCED_TYPENAME make_unsigned<T>::type lcast_to_unsigned(T value) BOOST_NOEXCEPT
+ NDNBOOST_DEDUCED_TYPENAME make_unsigned<T>::type lcast_to_unsigned(T value) NDNBOOST_NOEXCEPT
{
- typedef BOOST_DEDUCED_TYPENAME ndnboost::make_unsigned<T>::type result_type;
+ typedef NDNBOOST_DEDUCED_TYPENAME ndnboost::make_unsigned<T>::type result_type;
return static_cast<result_type>(
value < 0 ? 0u - static_cast<result_type>(value) : value
);
@@ -798,33 +798,33 @@
template<class Traits, class T, class CharT>
CharT* lcast_put_unsigned(const T n_param, CharT* finish)
{
-#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
- BOOST_STATIC_ASSERT(!std::numeric_limits<T>::is_signed);
+#ifndef NDNBOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+ NDNBOOST_STATIC_ASSERT(!std::numeric_limits<T>::is_signed);
#endif
typedef typename Traits::int_type int_type;
CharT const czero = lcast_char_constants<CharT>::zero;
int_type const zero = Traits::to_int_type(czero);
- BOOST_DEDUCED_TYPENAME ndnboost::mpl::if_c<
+ NDNBOOST_DEDUCED_TYPENAME ndnboost::mpl::if_c<
(sizeof(int_type) > sizeof(T))
, int_type
, T
>::type n = n_param;
-#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
+#ifndef NDNBOOST_LEXICAL_CAST_ASSUME_C_LOCALE
std::locale loc;
if (loc != std::locale::classic()) {
typedef std::numpunct<CharT> numpunct;
- numpunct const& np = BOOST_USE_FACET(numpunct, loc);
+ numpunct const& np = NDNBOOST_USE_FACET(numpunct, loc);
std::string const grouping = np.grouping();
std::string::size_type const grouping_size = grouping.size();
if ( grouping_size && grouping[0] > 0 )
{
-#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+#ifndef NDNBOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
// Check that ulimited group is unreachable:
- BOOST_STATIC_ASSERT(std::numeric_limits<T>::digits10 < CHAR_MAX);
+ NDNBOOST_STATIC_ASSERT(std::numeric_limits<T>::digits10 < CHAR_MAX);
#endif
CharT thousands_sep = np.thousands_sep();
std::string::size_type group = 0; // current group number
@@ -877,8 +877,8 @@
template<class Traits, class T, class CharT>
inline bool lcast_ret_unsigned(T& value, const CharT* const begin, const CharT* end)
{
-#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
- BOOST_STATIC_ASSERT(!std::numeric_limits<T>::is_signed);
+#ifndef NDNBOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+ NDNBOOST_STATIC_ASSERT(!std::numeric_limits<T>::is_signed);
#endif
CharT const czero = lcast_char_constants<CharT>::zero;
--end;
@@ -891,11 +891,11 @@
T multiplier = 1;
bool multiplier_overflowed = false;
-#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
+#ifndef NDNBOOST_LEXICAL_CAST_ASSUME_C_LOCALE
std::locale loc;
if (loc != std::locale::classic()) {
typedef std::numpunct<CharT> numpunct;
- numpunct const& np = BOOST_USE_FACET(numpunct, loc);
+ numpunct const& np = NDNBOOST_USE_FACET(numpunct, loc);
std::string const& grouping = np.grouping();
std::string::size_type const grouping_size = grouping.size();
@@ -986,7 +986,7 @@
namespace detail
{
template <class CharT>
- bool lc_iequal(const CharT* val, const CharT* lcase, const CharT* ucase, unsigned int len) BOOST_NOEXCEPT {
+ bool lc_iequal(const CharT* val, const CharT* lcase, const CharT* ucase, unsigned int len) NDNBOOST_NOEXCEPT {
for( unsigned int i=0; i < len; ++i ) {
if ( val[i] != lcase[i] && val[i] != ucase[i] ) return false;
}
@@ -999,7 +999,7 @@
inline bool parse_inf_nan_impl(const CharT* begin, const CharT* end, T& value
, const CharT* lc_NAN, const CharT* lc_nan
, const CharT* lc_INFINITY, const CharT* lc_infinity
- , const CharT opening_brace, const CharT closing_brace) BOOST_NOEXCEPT
+ , const CharT opening_brace, const CharT closing_brace) NDNBOOST_NOEXCEPT
{
using namespace std;
if (begin == end) return false;
@@ -1055,7 +1055,7 @@
template <class CharT, class T>
bool put_inf_nan_impl(CharT* begin, CharT*& end, const T& value
, const CharT* lc_nan
- , const CharT* lc_infinity) BOOST_NOEXCEPT
+ , const CharT* lc_infinity) NDNBOOST_NOEXCEPT
{
using namespace std;
const CharT minus = lcast_char_constants<CharT>::minus;
@@ -1087,9 +1087,9 @@
}
-#ifndef BOOST_LCAST_NO_WCHAR_T
+#ifndef NDNBOOST_LCAST_NO_WCHAR_T
template <class T>
- bool parse_inf_nan(const wchar_t* begin, const wchar_t* end, T& value) BOOST_NOEXCEPT
+ bool parse_inf_nan(const wchar_t* begin, const wchar_t* end, T& value) NDNBOOST_NOEXCEPT
{
return parse_inf_nan_impl(begin, end, value
, L"NAN", L"nan"
@@ -1098,15 +1098,15 @@
}
template <class T>
- bool put_inf_nan(wchar_t* begin, wchar_t*& end, const T& value) BOOST_NOEXCEPT
+ bool put_inf_nan(wchar_t* begin, wchar_t*& end, const T& value) NDNBOOST_NOEXCEPT
{
return put_inf_nan_impl(begin, end, value, L"nan", L"infinity");
}
#endif
-#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
+#if !defined(NDNBOOST_NO_CXX11_CHAR16_T) && !defined(NDNBOOST_NO_CXX11_UNICODE_LITERALS)
template <class T>
- bool parse_inf_nan(const char16_t* begin, const char16_t* end, T& value) BOOST_NOEXCEPT
+ bool parse_inf_nan(const char16_t* begin, const char16_t* end, T& value) NDNBOOST_NOEXCEPT
{
return parse_inf_nan_impl(begin, end, value
, u"NAN", u"nan"
@@ -1115,14 +1115,14 @@
}
template <class T>
- bool put_inf_nan(char16_t* begin, char16_t*& end, const T& value) BOOST_NOEXCEPT
+ bool put_inf_nan(char16_t* begin, char16_t*& end, const T& value) NDNBOOST_NOEXCEPT
{
return put_inf_nan_impl(begin, end, value, u"nan", u"infinity");
}
#endif
-#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
+#if !defined(NDNBOOST_NO_CXX11_CHAR32_T) && !defined(NDNBOOST_NO_CXX11_UNICODE_LITERALS)
template <class T>
- bool parse_inf_nan(const char32_t* begin, const char32_t* end, T& value) BOOST_NOEXCEPT
+ bool parse_inf_nan(const char32_t* begin, const char32_t* end, T& value) NDNBOOST_NOEXCEPT
{
return parse_inf_nan_impl(begin, end, value
, U"NAN", U"nan"
@@ -1131,14 +1131,14 @@
}
template <class T>
- bool put_inf_nan(char32_t* begin, char32_t*& end, const T& value) BOOST_NOEXCEPT
+ bool put_inf_nan(char32_t* begin, char32_t*& end, const T& value) NDNBOOST_NOEXCEPT
{
return put_inf_nan_impl(begin, end, value, U"nan", U"infinity");
}
#endif
template <class CharT, class T>
- bool parse_inf_nan(const CharT* begin, const CharT* end, T& value) BOOST_NOEXCEPT
+ bool parse_inf_nan(const CharT* begin, const CharT* end, T& value) NDNBOOST_NOEXCEPT
{
return parse_inf_nan_impl(begin, end, value
, "NAN", "nan"
@@ -1147,7 +1147,7 @@
}
template <class CharT, class T>
- bool put_inf_nan(CharT* begin, CharT*& end, const T& value) BOOST_NOEXCEPT
+ bool put_inf_nan(CharT* begin, CharT*& end, const T& value) NDNBOOST_NOEXCEPT
{
return put_inf_nan_impl(begin, end, value, "nan", "infinity");
}
@@ -1178,11 +1178,11 @@
template <>
struct mantissa_holder_type<double>
{
-#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+#ifndef NDNBOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
typedef long double wide_result_t;
-#if defined(BOOST_HAS_LONG_LONG)
+#if defined(NDNBOOST_HAS_LONG_LONG)
typedef ndnboost::ulong_long_type type;
-#elif defined(BOOST_HAS_MS_INT64)
+#elif defined(NDNBOOST_HAS_MS_INT64)
typedef unsigned __int64 type;
#endif
#endif
@@ -1192,10 +1192,10 @@
inline bool lcast_ret_float(T& value, const CharT* begin, const CharT* end)
{
-#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
+#ifndef NDNBOOST_LEXICAL_CAST_ASSUME_C_LOCALE
std::locale loc;
typedef std::numpunct<CharT> numpunct;
- numpunct const& np = BOOST_USE_FACET(numpunct, loc);
+ numpunct const& np = NDNBOOST_USE_FACET(numpunct, loc);
std::string const grouping(
(loc == std::locale::classic())
? std::string()
@@ -1221,8 +1221,8 @@
if (parse_inf_nan(begin, end, value)) return true;
typedef typename Traits::int_type int_type;
- typedef BOOST_DEDUCED_TYPENAME mantissa_holder_type<T>::type mantissa_type;
- typedef BOOST_DEDUCED_TYPENAME mantissa_holder_type<T>::wide_result_t wide_result_t;
+ typedef NDNBOOST_DEDUCED_TYPENAME mantissa_holder_type<T>::type mantissa_type;
+ typedef NDNBOOST_DEDUCED_TYPENAME mantissa_holder_type<T>::wide_result_t wide_result_t;
int_type const zero = Traits::to_int_type(czero);
if (begin == end) return false;
@@ -1291,7 +1291,7 @@
found_number_before_exp = true;
++ length_since_last_delim;
} else if (Traits::eq(*begin, decimal_point) || Traits::eq(*begin, lowercase_e) || Traits::eq(*begin, capital_e)) {
-#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
+#ifndef NDNBOOST_LEXICAL_CAST_ASSUME_C_LOCALE
/* If ( we need to check grouping
* and ( grouping missmatches
* or grouping position is incorrect
@@ -1318,7 +1318,7 @@
break;
}
}
-#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
+#ifndef NDNBOOST_LEXICAL_CAST_ASSUME_C_LOCALE
else if (grouping_size && Traits::eq(*begin, thousands_sep)){
if(found_grouping)
{
@@ -1436,7 +1436,7 @@
public:
parser_buf() : base_type() { setbuf(0, 0); }
const charT* getnext() { return this->gptr(); }
-#ifndef BOOST_NO_USING_TEMPLATE
+#ifndef NDNBOOST_NO_USING_TEMPLATE
using base_type::pptr;
using base_type::pbase;
#else
@@ -1493,12 +1493,12 @@
}
default: ;
}
-#ifdef BOOST_MSVC
+#ifdef NDNBOOST_MSVC
#pragma warning(push)
#pragma warning(disable:4244)
#endif
return static_cast<pos_type>(this->gptr() - this->eback());
-#ifdef BOOST_MSVC
+#ifdef NDNBOOST_MSVC
#pragma warning(pop)
#endif
}
@@ -1523,16 +1523,16 @@
class lexical_stream_limited_src
{
-#if defined(BOOST_NO_STRINGSTREAM)
+#if defined(NDNBOOST_NO_STRINGSTREAM)
typedef std::ostrstream out_stream_t;
-#elif defined(BOOST_NO_STD_LOCALE)
+#elif defined(NDNBOOST_NO_STD_LOCALE)
typedef std::ostringstream out_stream_t;
typedef parser_buf<std::streambuf, char> buffer_t;
#else
typedef std::basic_ostringstream<CharT, Traits> out_stream_t;
typedef parser_buf<std::basic_streambuf<CharT, Traits>, CharT> buffer_t;
#endif
- typedef BOOST_DEDUCED_TYPENAME ndnboost::mpl::if_c<
+ typedef NDNBOOST_DEDUCED_TYPENAME ndnboost::mpl::if_c<
RequiresStringbuffer,
out_stream_t,
do_not_construct_out_stream_t
@@ -1544,7 +1544,7 @@
deduced_out_stream_t out_stream;
public:
- lexical_stream_limited_src(CharT* sta, CharT* fin) BOOST_NOEXCEPT
+ lexical_stream_limited_src(CharT* sta, CharT* fin) NDNBOOST_NOEXCEPT
: start(sta)
, finish(fin)
{}
@@ -1555,23 +1555,23 @@
void operator=(lexical_stream_limited_src const&);
/************************************ HELPER FUNCTIONS FOR OPERATORS << ( ... ) ********************************/
- bool shl_char(CharT ch) BOOST_NOEXCEPT
+ bool shl_char(CharT ch) NDNBOOST_NOEXCEPT
{
Traits::assign(*start, ch);
finish = start + 1;
return true;
}
-#ifndef BOOST_LCAST_NO_WCHAR_T
+#ifndef NDNBOOST_LCAST_NO_WCHAR_T
template <class T>
bool shl_char(T ch)
{
- BOOST_STATIC_ASSERT_MSG(( sizeof(T) <= sizeof(CharT)) ,
+ NDNBOOST_STATIC_ASSERT_MSG(( sizeof(T) <= sizeof(CharT)) ,
"ndnboost::lexical_cast does not support narrowing of char types."
"Use ndnboost::locale instead" );
-#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
+#ifndef NDNBOOST_LEXICAL_CAST_ASSUME_C_LOCALE
std::locale loc;
- CharT const w = BOOST_USE_FACET(std::ctype<CharT>, loc).widen(ch);
+ CharT const w = NDNBOOST_USE_FACET(std::ctype<CharT>, loc).widen(ch);
#else
CharT const w = static_cast<CharT>(ch);
#endif
@@ -1581,7 +1581,7 @@
}
#endif
- bool shl_char_array(CharT const* str) BOOST_NOEXCEPT
+ bool shl_char_array(CharT const* str) NDNBOOST_NOEXCEPT
{
start = const_cast<CharT*>(str);
finish = start + Traits::length(str);
@@ -1591,13 +1591,13 @@
template <class T>
bool shl_char_array(T const* str)
{
- BOOST_STATIC_ASSERT_MSG(( sizeof(T) <= sizeof(CharT)),
+ NDNBOOST_STATIC_ASSERT_MSG(( sizeof(T) <= sizeof(CharT)),
"ndnboost::lexical_cast does not support narrowing of char types."
"Use ndnboost::locale instead" );
return shl_input_streamable(str);
}
- bool shl_char_array_limited(CharT const* str, std::size_t max_size) BOOST_NOEXCEPT
+ bool shl_char_array_limited(CharT const* str, std::size_t max_size) NDNBOOST_NOEXCEPT
{
start = const_cast<CharT*>(str);
finish = std::find(start, start + max_size, Traits::to_char_type(0));
@@ -1607,10 +1607,10 @@
template<typename InputStreamable>
bool shl_input_streamable(InputStreamable& input)
{
-#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_LOCALE)
+#if defined(NDNBOOST_NO_STRINGSTREAM) || defined(NDNBOOST_NO_STD_LOCALE)
// If you have compilation error at this point, than your STL library
// does not support such conversions. Try updating it.
- BOOST_STATIC_ASSERT((ndnboost::is_same<char, CharT>::value));
+ NDNBOOST_STATIC_ASSERT((ndnboost::is_same<char, CharT>::value));
#endif
bool const result = !(out_stream << input).fail();
const buffer_t* const p = static_cast<buffer_t*>(
@@ -1685,7 +1685,7 @@
#endif
-#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_SWPRINTF) && !defined(__MINGW32__)
+#if !defined(NDNBOOST_LCAST_NO_WCHAR_T) && !defined(NDNBOOST_NO_SWPRINTF) && !defined(__MINGW32__)
static bool shl_real_type(float val, wchar_t* begin, wchar_t*& end)
{ using namespace std;
if (put_inf_nan(begin, end, val)) return true;
@@ -1717,7 +1717,7 @@
/************************************ OPERATORS << ( ... ) ********************************/
public:
template<class Alloc>
- bool operator<<(std::basic_string<CharT,Traits,Alloc> const& str) BOOST_NOEXCEPT
+ bool operator<<(std::basic_string<CharT,Traits,Alloc> const& str) NDNBOOST_NOEXCEPT
{
start = const_cast<CharT*>(str.data());
finish = start + str.length();
@@ -1725,14 +1725,14 @@
}
template<class Alloc>
- bool operator<<(ndnboost::container::basic_string<CharT,Traits,Alloc> const& str) BOOST_NOEXCEPT
+ bool operator<<(ndnboost::container::basic_string<CharT,Traits,Alloc> const& str) NDNBOOST_NOEXCEPT
{
start = const_cast<CharT*>(str.data());
finish = start + str.length();
return true;
}
- bool operator<<(bool value) BOOST_NOEXCEPT
+ bool operator<<(bool value) NDNBOOST_NOEXCEPT
{
CharT const czero = lcast_char_constants<CharT>::zero;
Traits::assign(*start, Traits::to_char_type(czero + value));
@@ -1740,21 +1740,21 @@
return true;
}
- bool operator<<(const iterator_range<CharT*>& rng) BOOST_NOEXCEPT
+ bool operator<<(const iterator_range<CharT*>& rng) NDNBOOST_NOEXCEPT
{
start = rng.begin();
finish = rng.end();
return true;
}
- bool operator<<(const iterator_range<const CharT*>& rng) BOOST_NOEXCEPT
+ bool operator<<(const iterator_range<const CharT*>& rng) NDNBOOST_NOEXCEPT
{
start = const_cast<CharT*>(rng.begin());
finish = const_cast<CharT*>(rng.end());
return true;
}
- bool operator<<(const iterator_range<const signed char*>& rng) BOOST_NOEXCEPT
+ bool operator<<(const iterator_range<const signed char*>& rng) NDNBOOST_NOEXCEPT
{
return (*this) << iterator_range<char*>(
const_cast<char*>(reinterpret_cast<const char*>(rng.begin())),
@@ -1762,7 +1762,7 @@
);
}
- bool operator<<(const iterator_range<const unsigned char*>& rng) BOOST_NOEXCEPT
+ bool operator<<(const iterator_range<const unsigned char*>& rng) NDNBOOST_NOEXCEPT
{
return (*this) << iterator_range<char*>(
const_cast<char*>(reinterpret_cast<const char*>(rng.begin())),
@@ -1770,7 +1770,7 @@
);
}
- bool operator<<(const iterator_range<signed char*>& rng) BOOST_NOEXCEPT
+ bool operator<<(const iterator_range<signed char*>& rng) NDNBOOST_NOEXCEPT
{
return (*this) << iterator_range<char*>(
reinterpret_cast<char*>(rng.begin()),
@@ -1778,7 +1778,7 @@
);
}
- bool operator<<(const iterator_range<unsigned char*>& rng) BOOST_NOEXCEPT
+ bool operator<<(const iterator_range<unsigned char*>& rng) NDNBOOST_NOEXCEPT
{
return (*this) << iterator_range<char*>(
reinterpret_cast<char*>(rng.begin()),
@@ -1789,19 +1789,19 @@
bool operator<<(char ch) { return shl_char(ch); }
bool operator<<(unsigned char ch) { return ((*this) << static_cast<char>(ch)); }
bool operator<<(signed char ch) { return ((*this) << static_cast<char>(ch)); }
-#if !defined(BOOST_LCAST_NO_WCHAR_T)
+#if !defined(NDNBOOST_LCAST_NO_WCHAR_T)
bool operator<<(wchar_t const* str) { return shl_char_array(str); }
bool operator<<(wchar_t * str) { return shl_char_array(str); }
-#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+#ifndef NDNBOOST_NO_INTRINSIC_WCHAR_T
bool operator<<(wchar_t ch) { return shl_char(ch); }
#endif
#endif
-#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
+#if !defined(NDNBOOST_NO_CXX11_CHAR16_T) && !defined(NDNBOOST_NO_CXX11_UNICODE_LITERALS)
bool operator<<(char16_t ch) { return shl_char(ch); }
bool operator<<(char16_t * str) { return shl_char_array(str); }
bool operator<<(char16_t const * str) { return shl_char_array(str); }
#endif
-#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
+#if !defined(NDNBOOST_NO_CXX11_CHAR32_T) && !defined(NDNBOOST_NO_CXX11_UNICODE_LITERALS)
bool operator<<(char32_t ch) { return shl_char(ch); }
bool operator<<(char32_t * str) { return shl_char_array(str); }
bool operator<<(char32_t const * str) { return shl_char_array(str); }
@@ -1819,15 +1819,15 @@
bool operator<<(unsigned int n) { start = lcast_put_unsigned<Traits>(n, finish); return true; }
bool operator<<(unsigned long n) { start = lcast_put_unsigned<Traits>(n, finish); return true; }
-#if defined(BOOST_HAS_LONG_LONG)
+#if defined(NDNBOOST_HAS_LONG_LONG)
bool operator<<(ndnboost::ulong_long_type n) { start = lcast_put_unsigned<Traits>(n, finish); return true; }
bool operator<<(ndnboost::long_long_type n) { return shl_signed(n); }
-#elif defined(BOOST_HAS_MS_INT64)
+#elif defined(NDNBOOST_HAS_MS_INT64)
bool operator<<(unsigned __int64 n) { start = lcast_put_unsigned<Traits>(n, finish); return true; }
bool operator<<( __int64 n) { return shl_signed(n); }
#endif
-#ifdef BOOST_LCAST_HAS_INT128
+#ifdef NDNBOOST_LCAST_HAS_INT128
bool operator<<(const ndnboost::uint128_type& n) { start = lcast_put_unsigned<Traits>(n, finish); return true; }
bool operator<<(const ndnboost::int128_type& n) { return shl_signed(n); }
#endif
@@ -1843,58 +1843,58 @@
}
template <std::size_t N>
- bool operator<<(ndnboost::array<CharT, N> const& input) BOOST_NOEXCEPT
+ bool operator<<(ndnboost::array<CharT, N> const& input) NDNBOOST_NOEXCEPT
{ return shl_char_array_limited(input.begin(), N); }
template <std::size_t N>
- bool operator<<(ndnboost::array<unsigned char, N> const& input) BOOST_NOEXCEPT
+ bool operator<<(ndnboost::array<unsigned char, N> const& input) NDNBOOST_NOEXCEPT
{ return ((*this) << reinterpret_cast<ndnboost::array<char, N> const& >(input)); }
template <std::size_t N>
- bool operator<<(ndnboost::array<signed char, N> const& input) BOOST_NOEXCEPT
+ bool operator<<(ndnboost::array<signed char, N> const& input) NDNBOOST_NOEXCEPT
{ return ((*this) << reinterpret_cast<ndnboost::array<char, N> const& >(input)); }
template <std::size_t N>
- bool operator<<(ndnboost::array<const CharT, N> const& input) BOOST_NOEXCEPT
+ bool operator<<(ndnboost::array<const CharT, N> const& input) NDNBOOST_NOEXCEPT
{ return shl_char_array_limited(input.begin(), N); }
template <std::size_t N>
- bool operator<<(ndnboost::array<const unsigned char, N> const& input) BOOST_NOEXCEPT
+ bool operator<<(ndnboost::array<const unsigned char, N> const& input) NDNBOOST_NOEXCEPT
{ return ((*this) << reinterpret_cast<ndnboost::array<const char, N> const& >(input)); }
template <std::size_t N>
- bool operator<<(ndnboost::array<const signed char, N> const& input) BOOST_NOEXCEPT
+ bool operator<<(ndnboost::array<const signed char, N> const& input) NDNBOOST_NOEXCEPT
{ return ((*this) << reinterpret_cast<ndnboost::array<const char, N> const& >(input)); }
-#ifndef BOOST_NO_CXX11_HDR_ARRAY
+#ifndef NDNBOOST_NO_CXX11_HDR_ARRAY
template <std::size_t N>
- bool operator<<(std::array<CharT, N> const& input) BOOST_NOEXCEPT
+ bool operator<<(std::array<CharT, N> const& input) NDNBOOST_NOEXCEPT
{
if (input.size()) return shl_char_array_limited(&input[0], N);
else return true;
}
template <std::size_t N>
- bool operator<<(std::array<unsigned char, N> const& input) BOOST_NOEXCEPT
+ bool operator<<(std::array<unsigned char, N> const& input) NDNBOOST_NOEXCEPT
{ return ((*this) << reinterpret_cast<ndnboost::array<char, N> const& >(input)); }
template <std::size_t N>
- bool operator<<(std::array<signed char, N> const& input) BOOST_NOEXCEPT
+ bool operator<<(std::array<signed char, N> const& input) NDNBOOST_NOEXCEPT
{ return ((*this) << reinterpret_cast<ndnboost::array<char, N> const& >(input)); }
template <std::size_t N>
- bool operator<<(std::array<const CharT, N> const& input) BOOST_NOEXCEPT
+ bool operator<<(std::array<const CharT, N> const& input) NDNBOOST_NOEXCEPT
{
if (input.size()) return shl_char_array_limited(&input[0], N);
else return true;
}
template <std::size_t N>
- bool operator<<(std::array<const unsigned char, N> const& input) BOOST_NOEXCEPT
+ bool operator<<(std::array<const unsigned char, N> const& input) NDNBOOST_NOEXCEPT
{ return ((*this) << reinterpret_cast<ndnboost::array<const char, N> const& >(input)); }
template <std::size_t N>
- bool operator<<(std::array<const signed char, N> const& input) BOOST_NOEXCEPT
+ bool operator<<(std::array<const signed char, N> const& input) NDNBOOST_NOEXCEPT
{ return ((*this) << reinterpret_cast<ndnboost::array<const char, N> const& >(input)); }
#endif
@@ -1937,7 +1937,7 @@
if (start == finish) return false;
CharT const minus = lcast_char_constants<CharT>::minus;
CharT const plus = lcast_char_constants<CharT>::plus;
- typedef BOOST_DEDUCED_TYPENAME make_unsigned<Type>::type utype;
+ typedef NDNBOOST_DEDUCED_TYPENAME make_unsigned<Type>::type utype;
utype out_tmp =0;
bool has_minus = false;
@@ -1967,39 +1967,39 @@
template<typename InputStreamable>
bool shr_using_base_class(InputStreamable& output)
{
- BOOST_STATIC_ASSERT_MSG(
+ NDNBOOST_STATIC_ASSERT_MSG(
(!ndnboost::is_pointer<InputStreamable>::value),
"ndnboost::lexical_cast can not convert to pointers"
);
-#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_LOCALE)
- BOOST_STATIC_ASSERT_MSG((ndnboost::is_same<char, CharT>::value),
+#if defined(NDNBOOST_NO_STRINGSTREAM) || defined(NDNBOOST_NO_STD_LOCALE)
+ NDNBOOST_STATIC_ASSERT_MSG((ndnboost::is_same<char, CharT>::value),
"ndnboost::lexical_cast can not convert, because your STL library does not "
"support such conversions. Try updating it."
);
#endif
-#if defined(BOOST_NO_STRINGSTREAM)
+#if defined(NDNBOOST_NO_STRINGSTREAM)
std::istrstream stream(start, finish - start);
#else
buffer_t buf;
buf.setbuf(start, finish - start);
-#if defined(BOOST_NO_STD_LOCALE)
+#if defined(NDNBOOST_NO_STD_LOCALE)
std::istream stream(&buf);
#else
std::basic_istream<CharT, Traits> stream(&buf);
-#endif // BOOST_NO_STD_LOCALE
-#endif // BOOST_NO_STRINGSTREAM
+#endif // NDNBOOST_NO_STD_LOCALE
+#endif // NDNBOOST_NO_STRINGSTREAM
stream.unsetf(std::ios::skipws);
lcast_set_precision(stream, static_cast<InputStreamable*>(0));
return stream >> output &&
stream.get() ==
-#if defined(__GNUC__) && (__GNUC__<3) && defined(BOOST_NO_STD_WSTRING)
+#if defined(__GNUC__) && (__GNUC__<3) && defined(NDNBOOST_NO_STD_WSTRING)
// GCC 2.9x lacks std::char_traits<>::eof().
- // We use BOOST_NO_STD_WSTRING to filter out STLport and libstdc++-v3
+ // We use NDNBOOST_NO_STD_WSTRING to filter out STLport and libstdc++-v3
// configurations, which do provide std::char_traits<>::eof().
EOF;
@@ -2011,7 +2011,7 @@
template<class T>
inline bool shr_xchar(T& output)
{
- BOOST_STATIC_ASSERT_MSG(( sizeof(CharT) == sizeof(T) ),
+ NDNBOOST_STATIC_ASSERT_MSG(( sizeof(CharT) == sizeof(T) ),
"ndnboost::lexical_cast does not support narrowing of character types."
"Use ndnboost::locale instead" );
bool const ok = (finish - start == 1);
@@ -2031,15 +2031,15 @@
bool operator>>(short& output) { return shr_signed(output); }
bool operator>>(int& output) { return shr_signed(output); }
bool operator>>(long int& output) { return shr_signed(output); }
-#if defined(BOOST_HAS_LONG_LONG)
+#if defined(NDNBOOST_HAS_LONG_LONG)
bool operator>>(ndnboost::ulong_long_type& output) { return shr_unsigned(output); }
bool operator>>(ndnboost::long_long_type& output) { return shr_signed(output); }
-#elif defined(BOOST_HAS_MS_INT64)
+#elif defined(NDNBOOST_HAS_MS_INT64)
bool operator>>(unsigned __int64& output) { return shr_unsigned(output); }
bool operator>>(__int64& output) { return shr_signed(output); }
#endif
-#ifdef BOOST_LCAST_HAS_INT128
+#ifdef NDNBOOST_LCAST_HAS_INT128
bool operator>>(ndnboost::uint128_type& output) { return shr_unsigned(output); }
bool operator>>(ndnboost::int128_type& output) { return shr_signed(output); }
#endif
@@ -2047,13 +2047,13 @@
bool operator>>(char& output) { return shr_xchar(output); }
bool operator>>(unsigned char& output) { return shr_xchar(output); }
bool operator>>(signed char& output) { return shr_xchar(output); }
-#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+#if !defined(NDNBOOST_LCAST_NO_WCHAR_T) && !defined(NDNBOOST_NO_INTRINSIC_WCHAR_T)
bool operator>>(wchar_t& output) { return shr_xchar(output); }
#endif
-#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
+#if !defined(NDNBOOST_NO_CXX11_CHAR16_T) && !defined(NDNBOOST_NO_CXX11_UNICODE_LITERALS)
bool operator>>(char16_t& output) { return shr_xchar(output); }
#endif
-#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
+#if !defined(NDNBOOST_NO_CXX11_CHAR32_T) && !defined(NDNBOOST_NO_CXX11_UNICODE_LITERALS)
bool operator>>(char32_t& output) { return shr_xchar(output); }
#endif
template<class Alloc>
@@ -2065,7 +2065,7 @@
private:
template <std::size_t N, class ArrayT>
- bool shr_std_array(ArrayT& output) BOOST_NOEXCEPT
+ bool shr_std_array(ArrayT& output) NDNBOOST_NOEXCEPT
{
using namespace std;
const std::size_t size = finish - start;
@@ -2081,7 +2081,7 @@
public:
template <std::size_t N>
- bool operator>>(ndnboost::array<CharT, N>& output) BOOST_NOEXCEPT
+ bool operator>>(ndnboost::array<CharT, N>& output) NDNBOOST_NOEXCEPT
{
return shr_std_array<N>(output);
}
@@ -2098,9 +2098,9 @@
return ((*this) >> reinterpret_cast<ndnboost::array<char, N>& >(output));
}
-#ifndef BOOST_NO_CXX11_HDR_ARRAY
+#ifndef NDNBOOST_NO_CXX11_HDR_ARRAY
template <std::size_t N>
- bool operator>>(std::array<CharT, N>& output) BOOST_NOEXCEPT
+ bool operator>>(std::array<CharT, N>& output) NDNBOOST_NOEXCEPT
{
return shr_std_array<N>(output);
}
@@ -2124,7 +2124,7 @@
* case "1" || "+1": output = true; return true;
* default: return false;
*/
- bool operator>>(bool& output) BOOST_NOEXCEPT
+ bool operator>>(bool& output) NDNBOOST_NOEXCEPT
{
CharT const zero = lcast_char_constants<CharT>::zero;
CharT const plus = lcast_char_constants<CharT>::plus;
@@ -2199,7 +2199,7 @@
* double, because it will give a big precision loss.
* */
ndnboost::mpl::if_c<
-#if (defined(BOOST_HAS_LONG_LONG) || defined(BOOST_HAS_MS_INT64)) && !defined(BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS)
+#if (defined(NDNBOOST_HAS_LONG_LONG) || defined(NDNBOOST_HAS_MS_INT64)) && !defined(NDNBOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS)
ndnboost::type_traits::ice_eq< sizeof(double), sizeof(long double) >::value,
#else
1,
@@ -2229,25 +2229,25 @@
template<typename T>
struct is_stdstring
{
- BOOST_STATIC_CONSTANT(bool, value = false );
+ NDNBOOST_STATIC_CONSTANT(bool, value = false );
};
template<typename CharT, typename Traits, typename Alloc>
struct is_stdstring< std::basic_string<CharT, Traits, Alloc> >
{
- BOOST_STATIC_CONSTANT(bool, value = true );
+ NDNBOOST_STATIC_CONSTANT(bool, value = true );
};
template<typename CharT, typename Traits, typename Alloc>
struct is_stdstring< ndnboost::container::basic_string<CharT, Traits, Alloc> >
{
- BOOST_STATIC_CONSTANT(bool, value = true );
+ NDNBOOST_STATIC_CONSTANT(bool, value = true );
};
template<typename Target, typename Source>
struct is_arithmetic_and_not_xchars
{
- BOOST_STATIC_CONSTANT(bool, value =
+ NDNBOOST_STATIC_CONSTANT(bool, value =
(
ndnboost::type_traits::ice_and<
ndnboost::is_arithmetic<Source>::value,
@@ -2271,7 +2271,7 @@
template<typename Target, typename Source>
struct is_xchar_to_xchar
{
- BOOST_STATIC_CONSTANT(bool, value =
+ NDNBOOST_STATIC_CONSTANT(bool, value =
(
ndnboost::type_traits::ice_or<
ndnboost::type_traits::ice_and<
@@ -2292,31 +2292,31 @@
template<typename Target, typename Source>
struct is_char_array_to_stdstring
{
- BOOST_STATIC_CONSTANT(bool, value = false );
+ NDNBOOST_STATIC_CONSTANT(bool, value = false );
};
template<typename CharT, typename Traits, typename Alloc>
struct is_char_array_to_stdstring< std::basic_string<CharT, Traits, Alloc>, CharT* >
{
- BOOST_STATIC_CONSTANT(bool, value = true );
+ NDNBOOST_STATIC_CONSTANT(bool, value = true );
};
template<typename CharT, typename Traits, typename Alloc>
struct is_char_array_to_stdstring< std::basic_string<CharT, Traits, Alloc>, const CharT* >
{
- BOOST_STATIC_CONSTANT(bool, value = true );
+ NDNBOOST_STATIC_CONSTANT(bool, value = true );
};
template<typename CharT, typename Traits, typename Alloc>
struct is_char_array_to_stdstring< ndnboost::container::basic_string<CharT, Traits, Alloc>, CharT* >
{
- BOOST_STATIC_CONSTANT(bool, value = true );
+ NDNBOOST_STATIC_CONSTANT(bool, value = true );
};
template<typename CharT, typename Traits, typename Alloc>
struct is_char_array_to_stdstring< ndnboost::container::basic_string<CharT, Traits, Alloc>, const CharT* >
{
- BOOST_STATIC_CONSTANT(bool, value = true );
+ NDNBOOST_STATIC_CONSTANT(bool, value = true );
};
#if (defined _MSC_VER)
@@ -2333,22 +2333,22 @@
typedef lexical_cast_stream_traits<Source, Target> stream_trait;
typedef detail::lexical_stream_limited_src<
- BOOST_DEDUCED_TYPENAME stream_trait::char_type,
- BOOST_DEDUCED_TYPENAME stream_trait::traits,
+ NDNBOOST_DEDUCED_TYPENAME stream_trait::char_type,
+ NDNBOOST_DEDUCED_TYPENAME stream_trait::traits,
stream_trait::requires_stringbuf
> interpreter_type;
// Target type must be default constructible
Target result;
- BOOST_DEDUCED_TYPENAME stream_trait::char_type buf[stream_trait::len_t::value + 1];
+ NDNBOOST_DEDUCED_TYPENAME stream_trait::char_type buf[stream_trait::len_t::value + 1];
stream_trait::len_t::check_coverage();
interpreter_type interpreter(buf, buf + stream_trait::len_t::value + 1);
// Disabling ADL, by directly specifying operators.
if(!(interpreter.operator <<(arg) && interpreter.operator >>(result)))
- BOOST_LCAST_THROW_BAD_CAST(Source, Target);
+ NDNBOOST_LCAST_THROW_BAD_CAST(Source, Target);
return result;
}
@@ -2360,7 +2360,7 @@
template <typename Source>
struct lexical_cast_copy
{
- static inline const Source& lexical_cast_impl(const Source &arg) BOOST_NOEXCEPT
+ static inline const Source& lexical_cast_impl(const Source &arg) NDNBOOST_NOEXCEPT
{
return arg;
}
@@ -2372,7 +2372,7 @@
typedef ndnboost::numeric::Trunc<Source> Rounder;
typedef Source source_type ;
- typedef BOOST_DEDUCED_TYPENAME mpl::if_<
+ typedef NDNBOOST_DEDUCED_TYPENAME mpl::if_<
ndnboost::is_arithmetic<Source>, Source, Source const&
>::type argument_type ;
@@ -2384,7 +2384,7 @@
const source_type eps = std::numeric_limits<source_type>::epsilon();
if ((orig_div_round > 1 ? orig_div_round - 1 : 1 - orig_div_round) > eps)
- BOOST_LCAST_THROW_BAD_CAST(Source, Target);
+ NDNBOOST_LCAST_THROW_BAD_CAST(Source, Target);
}
return s ;
@@ -2399,7 +2399,7 @@
void operator() ( ndnboost::numeric::range_check_result r )
{
if (r != ndnboost::numeric::cInRange)
- BOOST_LCAST_THROW_BAD_CAST(Source, Target);
+ NDNBOOST_LCAST_THROW_BAD_CAST(Source, Target);
}
} ;
@@ -2423,7 +2423,7 @@
{
static inline Target lexical_cast_impl(const Source &arg)
{
- typedef BOOST_DEDUCED_TYPENAME ndnboost::mpl::eval_if_c<
+ typedef NDNBOOST_DEDUCED_TYPENAME ndnboost::mpl::eval_if_c<
ndnboost::is_float<Source>::value,
ndnboost::mpl::identity<Source>,
ndnboost::make_unsigned<Source>
@@ -2466,7 +2466,7 @@
{
static inline Target lexical_cast_impl(const Source &arg)
{
- typedef BOOST_DEDUCED_TYPENAME ndnboost::mpl::if_c<
+ typedef NDNBOOST_DEDUCED_TYPENAME ndnboost::mpl::if_c<
ndnboost::type_traits::ice_and<
ndnboost::type_traits::ice_or<
ndnboost::is_signed<Source>::value,
@@ -2492,9 +2492,9 @@
template <typename Target, typename Source>
inline Target lexical_cast(const Source &arg)
{
- typedef BOOST_DEDUCED_TYPENAME ndnboost::detail::array_to_pointer_decay<Source>::type src;
+ typedef NDNBOOST_DEDUCED_TYPENAME ndnboost::detail::array_to_pointer_decay<Source>::type src;
- typedef BOOST_DEDUCED_TYPENAME ndnboost::type_traits::ice_or<
+ typedef NDNBOOST_DEDUCED_TYPENAME ndnboost::type_traits::ice_or<
ndnboost::detail::is_xchar_to_xchar<Target, src >::value,
ndnboost::detail::is_char_array_to_stdstring<Target, src >::value,
ndnboost::type_traits::ice_and<
@@ -2503,13 +2503,13 @@
>::value
> shall_we_copy_t;
- typedef BOOST_DEDUCED_TYPENAME
+ typedef NDNBOOST_DEDUCED_TYPENAME
ndnboost::detail::is_arithmetic_and_not_xchars<Target, src > shall_we_copy_with_dynamic_check_t;
- typedef BOOST_DEDUCED_TYPENAME ndnboost::mpl::if_c<
+ typedef NDNBOOST_DEDUCED_TYPENAME ndnboost::mpl::if_c<
shall_we_copy_t::value,
ndnboost::detail::lexical_cast_copy<src >,
- BOOST_DEDUCED_TYPENAME ndnboost::mpl::if_c<
+ NDNBOOST_DEDUCED_TYPENAME ndnboost::mpl::if_c<
shall_we_copy_with_dynamic_check_t::value,
ndnboost::detail::lexical_cast_dynamic_num<Target, src >,
ndnboost::detail::lexical_cast_do_cast<Target, src >
@@ -2544,7 +2544,7 @@
);
}
-#ifndef BOOST_LCAST_NO_WCHAR_T
+#ifndef NDNBOOST_LCAST_NO_WCHAR_T
template <typename Target>
inline Target lexical_cast(const wchar_t* chars, std::size_t count)
{
@@ -2553,7 +2553,7 @@
);
}
#endif
-#ifndef BOOST_NO_CHAR16_T
+#ifndef NDNBOOST_NO_CHAR16_T
template <typename Target>
inline Target lexical_cast(const char16_t* chars, std::size_t count)
{
@@ -2562,7 +2562,7 @@
);
}
#endif
-#ifndef BOOST_NO_CHAR32_T
+#ifndef NDNBOOST_NO_CHAR32_T
template <typename Target>
inline Target lexical_cast(const char32_t* chars, std::size_t count)
{
@@ -2574,7 +2574,7 @@
} // namespace ndnboost
-#else // #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#else // #ifndef NDNBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
namespace ndnboost {
namespace detail
@@ -2587,8 +2587,8 @@
typedef char type;
};
-#ifndef BOOST_LCAST_NO_WCHAR_T
-#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+#ifndef NDNBOOST_LCAST_NO_WCHAR_T
+#ifndef NDNBOOST_NO_INTRINSIC_WCHAR_T
template<>
struct stream_char<wchar_t>
{
@@ -2634,7 +2634,7 @@
}
~lexical_stream()
{
- #if defined(BOOST_NO_STRINGSTREAM)
+ #if defined(NDNBOOST_NO_STRINGSTREAM)
stream.freeze(false);
#endif
}
@@ -2648,9 +2648,9 @@
return !is_pointer<InputStreamable>::value &&
stream >> output &&
stream.get() ==
-#if defined(__GNUC__) && (__GNUC__<3) && defined(BOOST_NO_STD_WSTRING)
+#if defined(__GNUC__) && (__GNUC__<3) && defined(NDNBOOST_NO_STD_WSTRING)
// GCC 2.9x lacks std::char_traits<>::eof().
-// We use BOOST_NO_STD_WSTRING to filter out STLport and libstdc++-v3
+// We use NDNBOOST_NO_STD_WSTRING to filter out STLport and libstdc++-v3
// configurations, which do provide std::char_traits<>::eof().
EOF;
@@ -2661,13 +2661,13 @@
bool operator>>(std::string &output)
{
- #if defined(BOOST_NO_STRINGSTREAM)
+ #if defined(NDNBOOST_NO_STRINGSTREAM)
stream << '\0';
#endif
stream.str().swap(output);
return true;
}
- #ifndef BOOST_LCAST_NO_WCHAR_T
+ #ifndef NDNBOOST_LCAST_NO_WCHAR_T
bool operator>>(std::wstring &output)
{
stream.str().swap(output);
@@ -2676,9 +2676,9 @@
#endif
private:
- #if defined(BOOST_NO_STRINGSTREAM)
+ #if defined(NDNBOOST_NO_STRINGSTREAM)
std::strstream stream;
- #elif defined(BOOST_NO_STD_LOCALE)
+ #elif defined(NDNBOOST_NO_STD_LOCALE)
std::stringstream stream;
#else
std::basic_stringstream<char_type,traits_type> stream;
@@ -2692,8 +2692,8 @@
Target lexical_cast(Source arg)
{
typedef typename detail::widest_char<
- BOOST_DEDUCED_TYPENAME detail::stream_char<Target>::type
- , BOOST_DEDUCED_TYPENAME detail::stream_char<Source>::type
+ NDNBOOST_DEDUCED_TYPENAME detail::stream_char<Target>::type
+ , NDNBOOST_DEDUCED_TYPENAME detail::stream_char<Source>::type
>::type char_type;
typedef std::char_traits<char_type> traits;
@@ -2701,7 +2701,7 @@
Target result;
if(!(interpreter << arg && interpreter >> result))
- BOOST_LCAST_THROW_BAD_CAST(Source, Target);
+ NDNBOOST_LCAST_THROW_BAD_CAST(Source, Target);
return result;
}
@@ -2717,9 +2717,9 @@
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
-#undef BOOST_LCAST_THROW_BAD_CAST
-#undef BOOST_LCAST_NO_WCHAR_T
-#undef BOOST_LCAST_HAS_INT128
+#undef NDNBOOST_LCAST_THROW_BAD_CAST
+#undef NDNBOOST_LCAST_NO_WCHAR_T
+#undef NDNBOOST_LCAST_HAS_INT128
-#endif // BOOST_LEXICAL_CAST_INCLUDED
+#endif // NDNBOOST_LEXICAL_CAST_INCLUDED