blob: 40d19031acbe1096451b6e7f9a05d324bbcb014b [file] [log] [blame]
Jeff Thompsonef2d5a42013-08-22 19:09:24 -07001#ifndef BOOST_LEXICAL_CAST_INCLUDED
2#define BOOST_LEXICAL_CAST_INCLUDED
3
4// MS compatible compilers support #pragma once
5
6#if defined(_MSC_VER) && (_MSC_VER >= 1020)
7# pragma once
8#endif
9
10// Boost lexical_cast.hpp header -------------------------------------------//
11//
12// See http://www.boost.org/libs/conversion for documentation.
13// See end of this header for rights and permissions.
14//
15// what: lexical_cast custom keyword cast
16// who: contributed by Kevlin Henney,
17// enhanced with contributions from Terje Slettebo,
18// with additional fixes and suggestions from Gennaro Prota,
19// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
20// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
21// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
22// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2013
23
24#include <ndnboost/config.hpp>
25#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
26#define BOOST_LCAST_NO_WCHAR_T
27#endif
28
29#include <climits>
30#include <cstddef>
31#include <string>
32#include <cstring>
33#include <cstdio>
34#include <typeinfo>
35#include <exception>
36#include <ndnboost/limits.hpp>
37#include <ndnboost/mpl/if.hpp>
38#include <ndnboost/throw_exception.hpp>
39#include <ndnboost/type_traits/ice.hpp>
40#include <ndnboost/type_traits/is_pointer.hpp>
41#include <ndnboost/static_assert.hpp>
42#include <ndnboost/detail/lcast_precision.hpp>
43#include <ndnboost/detail/workaround.hpp>
44
45
46#ifndef BOOST_NO_STD_LOCALE
47# include <locale>
48#else
49# ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
50 // Getting error at this point means, that your STL library is old/lame/misconfigured.
51 // If nothing can be done with STL library, define BOOST_LEXICAL_CAST_ASSUME_C_LOCALE,
52 // but beware: lexical_cast will understand only 'C' locale delimeters and thousands
53 // separators.
54# error "Unable to use <locale> header. Define BOOST_LEXICAL_CAST_ASSUME_C_LOCALE to force "
55# error "ndnboost::lexical_cast to use only 'C' locale during conversions."
56# endif
57#endif
58
59#ifdef BOOST_NO_STRINGSTREAM
60#include <strstream>
61#else
62#include <sstream>
63#endif
64
65#ifdef BOOST_NO_TYPEID
66#define BOOST_LCAST_THROW_BAD_CAST(S, T) throw_exception(bad_lexical_cast())
67#else
68#define BOOST_LCAST_THROW_BAD_CAST(Source, Target) \
69 throw_exception(bad_lexical_cast(typeid(Source), typeid(Target)))
70#endif
71
72#if (defined(BOOST_LCAST_HAS_INT128) && !defined(__GNUC__)) || GCC_VERSION > 40700
73#define BOOST_LCAST_HAS_INT128
74#endif
75
76
77namespace ndnboost
78{
79 // exception used to indicate runtime lexical_cast failure
80 class BOOST_SYMBOL_VISIBLE bad_lexical_cast :
81 // workaround MSVC bug with std::bad_cast when _HAS_EXCEPTIONS == 0
82#if defined(BOOST_MSVC) && defined(_HAS_EXCEPTIONS) && !_HAS_EXCEPTIONS
83 public std::exception
84#else
85 public std::bad_cast
86#endif
87
88#if defined(__BORLANDC__) && BOOST_WORKAROUND( __BORLANDC__, < 0x560 )
89 // under bcc32 5.5.1 bad_cast doesn't derive from exception
90 , public std::exception
91#endif
92
93 {
94 public:
95 bad_lexical_cast() BOOST_NOEXCEPT :
96#ifndef BOOST_NO_TYPEID
97 source(&typeid(void)), target(&typeid(void))
98#else
99 source(0), target(0) // this breaks getters
100#endif
101 {
102 }
103
104 bad_lexical_cast(
105 const std::type_info &source_type_arg,
106 const std::type_info &target_type_arg) BOOST_NOEXCEPT :
107 source(&source_type_arg), target(&target_type_arg)
108 {
109 }
110
111 const std::type_info &source_type() const
112 {
113 return *source;
114 }
115 const std::type_info &target_type() const
116 {
117 return *target;
118 }
119
120#ifndef BOOST_NO_CXX11_NOEXCEPT
121 virtual const char *what() const noexcept
122#else
123 virtual const char *what() const throw()
124#endif
125 {
126 return "bad lexical cast: "
127 "source type value could not be interpreted as target";
128 }
129
130#ifndef BOOST_NO_CXX11_NOEXCEPT
131 virtual ~bad_lexical_cast() BOOST_NOEXCEPT
132#else
133 virtual ~bad_lexical_cast() throw()
134#endif
135 {}
136 private:
137 const std::type_info *source;
138 const std::type_info *target;
139 };
140
141 namespace detail // widest_char
142 {
143 template <typename TargetChar, typename SourceChar>
144 struct widest_char
145 {
146 typedef BOOST_DEDUCED_TYPENAME ndnboost::mpl::if_c<
147 (sizeof(TargetChar) > sizeof(SourceChar))
148 , TargetChar
149 , SourceChar >::type type;
150 };
151 }
152} // namespace ndnboost
153
154#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(__SUNPRO_CC) && !defined(__PGIC__)
155
156#include <cmath>
157#include <istream>
158
159#ifndef BOOST_NO_CXX11_HDR_ARRAY
160#include <array>
161#endif
162
163#include <ndnboost/array.hpp>
164#include <ndnboost/numeric/conversion/cast.hpp>
165#include <ndnboost/type_traits/make_unsigned.hpp>
166#include <ndnboost/type_traits/is_signed.hpp>
167#include <ndnboost/type_traits/is_integral.hpp>
168#include <ndnboost/type_traits/is_arithmetic.hpp>
169#include <ndnboost/type_traits/remove_pointer.hpp>
170#include <ndnboost/type_traits/has_left_shift.hpp>
171#include <ndnboost/type_traits/has_right_shift.hpp>
172#include <ndnboost/math/special_functions/sign.hpp>
173#include <ndnboost/math/special_functions/fpclassify.hpp>
174#include <ndnboost/range/iterator_range_core.hpp>
175#include <ndnboost/container/container_fwd.hpp>
176#include <ndnboost/integer.hpp>
177#ifndef BOOST_NO_CWCHAR
178# include <cwchar>
179#endif
180
181namespace ndnboost {
182
183 namespace detail // is_char_or_wchar<...>
184 {
185 // returns true, if T is one of the character types
186 template < typename T >
187 struct is_char_or_wchar
188 {
189 typedef ndnboost::type_traits::ice_or<
190 ndnboost::is_same< T, char >::value,
191 #ifndef BOOST_LCAST_NO_WCHAR_T
192 ndnboost::is_same< T, wchar_t >::value,
193 #endif
194 #ifndef BOOST_NO_CXX11_CHAR16_T
195 ndnboost::is_same< T, char16_t >::value,
196 #endif
197 #ifndef BOOST_NO_CXX11_CHAR32_T
198 ndnboost::is_same< T, char32_t >::value,
199 #endif
200 ndnboost::is_same< T, unsigned char >::value,
201 ndnboost::is_same< T, signed char >::value
202 > result_type;
203
204 BOOST_STATIC_CONSTANT(bool, value = (result_type::value) );
205 };
206 }
207
208 namespace detail // normalize_single_byte_char<Char>
209 {
210 // Converts signed/unsigned char to char
211 template < class Char >
212 struct normalize_single_byte_char
213 {
214 typedef Char type;
215 };
216
217 template <>
218 struct normalize_single_byte_char< signed char >
219 {
220 typedef char type;
221 };
222
223 template <>
224 struct normalize_single_byte_char< unsigned char >
225 {
226 typedef char type;
227 };
228 }
229
230 namespace detail // deduce_character_type_later<T>
231 {
232 // Helper type, meaning that stram character for T must be deduced
233 // at Stage 2 (See deduce_source_char<T> and deduce_target_char<T>)
234 template < class T > struct deduce_character_type_later {};
235 }
236
237 namespace detail // stream_char_common<T>
238 {
239 // Selectors to choose stream character type (common for Source and Target)
240 // Returns one of char, wchar_t, char16_t, char32_t or deduce_character_type_later<T> types
241 // Executed on Stage 1 (See deduce_source_char<T> and deduce_target_char<T>)
242 template < typename Type >
243 struct stream_char_common: public ndnboost::mpl::if_c<
244 ndnboost::detail::is_char_or_wchar< Type >::value,
245 Type,
246 ndnboost::detail::deduce_character_type_later< Type >
247 > {};
248
249 template < typename Char >
250 struct stream_char_common< Char* >: public ndnboost::mpl::if_c<
251 ndnboost::detail::is_char_or_wchar< Char >::value,
252 Char,
253 ndnboost::detail::deduce_character_type_later< Char* >
254 > {};
255
256 template < typename Char >
257 struct stream_char_common< const Char* >: public ndnboost::mpl::if_c<
258 ndnboost::detail::is_char_or_wchar< Char >::value,
259 Char,
260 ndnboost::detail::deduce_character_type_later< const Char* >
261 > {};
262
263 template < typename Char >
264 struct stream_char_common< ndnboost::iterator_range< Char* > >: public ndnboost::mpl::if_c<
265 ndnboost::detail::is_char_or_wchar< Char >::value,
266 Char,
267 ndnboost::detail::deduce_character_type_later< ndnboost::iterator_range< Char* > >
268 > {};
269
270 template < typename Char >
271 struct stream_char_common< ndnboost::iterator_range< const Char* > >: public ndnboost::mpl::if_c<
272 ndnboost::detail::is_char_or_wchar< Char >::value,
273 Char,
274 ndnboost::detail::deduce_character_type_later< ndnboost::iterator_range< const Char* > >
275 > {};
276
277 template < class Char, class Traits, class Alloc >
278 struct stream_char_common< std::basic_string< Char, Traits, Alloc > >
279 {
280 typedef Char type;
281 };
282
283 template < class Char, class Traits, class Alloc >
284 struct stream_char_common< ndnboost::container::basic_string< Char, Traits, Alloc > >
285 {
286 typedef Char type;
287 };
288
289 template < typename Char, std::size_t N >
290 struct stream_char_common< ndnboost::array< Char, N > >: public ndnboost::mpl::if_c<
291 ndnboost::detail::is_char_or_wchar< Char >::value,
292 Char,
293 ndnboost::detail::deduce_character_type_later< ndnboost::array< Char, N > >
294 > {};
295
296 template < typename Char, std::size_t N >
297 struct stream_char_common< ndnboost::array< const Char, N > >: public ndnboost::mpl::if_c<
298 ndnboost::detail::is_char_or_wchar< Char >::value,
299 Char,
300 ndnboost::detail::deduce_character_type_later< ndnboost::array< const Char, N > >
301 > {};
302
303#ifndef BOOST_NO_CXX11_HDR_ARRAY
304 template < typename Char, std::size_t N >
305 struct stream_char_common< std::array<Char, N > >: public ndnboost::mpl::if_c<
306 ndnboost::detail::is_char_or_wchar< Char >::value,
307 Char,
308 ndnboost::detail::deduce_character_type_later< std::array< Char, N > >
309 > {};
310
311 template < typename Char, std::size_t N >
312 struct stream_char_common< std::array< const Char, N > >: public ndnboost::mpl::if_c<
313 ndnboost::detail::is_char_or_wchar< Char >::value,
314 Char,
315 ndnboost::detail::deduce_character_type_later< std::array< const Char, N > >
316 > {};
317#endif
318
319#ifdef BOOST_LCAST_HAS_INT128
320 template <> struct stream_char_common< ndnboost::int128_type >: public ndnboost::mpl::identity< char > {};
321 template <> struct stream_char_common< ndnboost::uint128_type >: public ndnboost::mpl::identity< char > {};
322#endif
323
324#if !defined(BOOST_LCAST_NO_WCHAR_T) && defined(BOOST_NO_INTRINSIC_WCHAR_T)
325 template <>
326 struct stream_char_common< wchar_t >
327 {
328 typedef char type;
329 };
330#endif
331 }
332
333 namespace detail // deduce_source_char_impl<T>
334 {
335 // If type T is `deduce_character_type_later` type, then tries to deduce
336 // character type using ndnboost::has_left_shift<T> metafunction.
337 // Otherwise supplied type T is a character type, that must be normalized
338 // using normalize_single_byte_char<Char>.
339 // Executed at Stage 2 (See deduce_source_char<T> and deduce_target_char<T>)
340 template < class Char >
341 struct deduce_source_char_impl
342 {
343 typedef BOOST_DEDUCED_TYPENAME ndnboost::detail::normalize_single_byte_char< Char >::type type;
344 };
345
346 template < class T >
347 struct deduce_source_char_impl< deduce_character_type_later< T > >
348 {
349 typedef ndnboost::has_left_shift< std::basic_ostream< char >, T > result_t;
350
351#if defined(BOOST_LCAST_NO_WCHAR_T)
352 BOOST_STATIC_ASSERT_MSG((result_t::value),
353 "Source type is not std::ostream`able and std::wostream`s are not supported by your STL implementation");
354 typedef char type;
355#else
356 typedef BOOST_DEDUCED_TYPENAME ndnboost::mpl::if_c<
357 result_t::value, char, wchar_t
358 >::type type;
359
360 BOOST_STATIC_ASSERT_MSG((result_t::value || ndnboost::has_left_shift< std::basic_ostream< type >, T >::value),
361 "Source type is neither std::ostream`able nor std::wostream`able");
362#endif
363 };
364 }
365
366 namespace detail // deduce_target_char_impl<T>
367 {
368 // If type T is `deduce_character_type_later` type, then tries to deduce
369 // character type using ndnboost::has_right_shift<T> metafunction.
370 // Otherwise supplied type T is a character type, that must be normalized
371 // using normalize_single_byte_char<Char>.
372 // Executed at Stage 2 (See deduce_source_char<T> and deduce_target_char<T>)
373 template < class Char >
374 struct deduce_target_char_impl
375 {
376 typedef BOOST_DEDUCED_TYPENAME normalize_single_byte_char< Char >::type type;
377 };
378
379 template < class T >
380 struct deduce_target_char_impl< deduce_character_type_later<T> >
381 {
382 typedef ndnboost::has_right_shift<std::basic_istream<char>, T > result_t;
383
384#if defined(BOOST_LCAST_NO_WCHAR_T)
385 BOOST_STATIC_ASSERT_MSG((result_t::value),
386 "Target type is not std::istream`able and std::wistream`s are not supported by your STL implementation");
387 typedef char type;
388#else
389 typedef BOOST_DEDUCED_TYPENAME ndnboost::mpl::if_c<
390 result_t::value, char, wchar_t
391 >::type type;
392
393 BOOST_STATIC_ASSERT_MSG((result_t::value || ndnboost::has_right_shift<std::basic_istream<wchar_t>, T >::value),
394 "Target type is neither std::istream`able nor std::wistream`able");
395#endif
396 };
397 }
398
399 namespace detail // deduce_target_char<T> and deduce_source_char<T>
400 {
401 // We deduce stream character types in two stages.
402 //
403 // Stage 1 is common for Target and Source. At Stage 1 we get
404 // non normalized character type (may contain unsigned/signed char)
405 // or deduce_character_type_later<T> where T is the original type.
406 // Stage 1 is executed by stream_char_common<T>
407 //
408 // At Stage 2 we normalize character types or try to deduce character
409 // type using metafunctions.
410 // Stage 2 is executed by deduce_target_char_impl<T> and
411 // deduce_source_char_impl<T>
412 //
413 // deduce_target_char<T> and deduce_source_char<T> functions combine
414 // both stages
415
416 template < class T >
417 struct deduce_target_char
418 {
419 typedef BOOST_DEDUCED_TYPENAME stream_char_common< T >::type stage1_type;
420 typedef BOOST_DEDUCED_TYPENAME deduce_target_char_impl< stage1_type >::type stage2_type;
421
422 typedef stage2_type type;
423 };
424
425 template < class T >
426 struct deduce_source_char
427 {
428 typedef BOOST_DEDUCED_TYPENAME stream_char_common< T >::type stage1_type;
429 typedef BOOST_DEDUCED_TYPENAME deduce_source_char_impl< stage1_type >::type stage2_type;
430
431 typedef stage2_type type;
432 };
433 }
434
435 namespace detail // deduce_char_traits template
436 {
437 // We are attempting to get char_traits<> from Source or Tagret
438 // template parameter. Otherwise we'll be using std::char_traits<Char>
439 template < class Char, class Target, class Source >
440 struct deduce_char_traits
441 {
442 typedef std::char_traits< Char > type;
443 };
444
445 template < class Char, class Traits, class Alloc, class Source >
446 struct deduce_char_traits< Char
447 , std::basic_string< Char, Traits, Alloc >
448 , Source
449 >
450 {
451 typedef Traits type;
452 };
453
454 template < class Char, class Target, class Traits, class Alloc >
455 struct deduce_char_traits< Char
456 , Target
457 , std::basic_string< Char, Traits, Alloc >
458 >
459 {
460 typedef Traits type;
461 };
462
463 template < class Char, class Traits, class Alloc, class Source >
464 struct deduce_char_traits< Char
465 , ndnboost::container::basic_string< Char, Traits, Alloc >
466 , Source
467 >
468 {
469 typedef Traits type;
470 };
471
472 template < class Char, class Target, class Traits, class Alloc >
473 struct deduce_char_traits< Char
474 , Target
475 , ndnboost::container::basic_string< Char, Traits, Alloc >
476 >
477 {
478 typedef Traits type;
479 };
480
481 template < class Char, class Traits, class Alloc1, class Alloc2 >
482 struct deduce_char_traits< Char
483 , std::basic_string< Char, Traits, Alloc1 >
484 , std::basic_string< Char, Traits, Alloc2 >
485 >
486 {
487 typedef Traits type;
488 };
489
490 template<class Char, class Traits, class Alloc1, class Alloc2>
491 struct deduce_char_traits< Char
492 , ndnboost::container::basic_string< Char, Traits, Alloc1 >
493 , ndnboost::container::basic_string< Char, Traits, Alloc2 >
494 >
495 {
496 typedef Traits type;
497 };
498
499 template < class Char, class Traits, class Alloc1, class Alloc2 >
500 struct deduce_char_traits< Char
501 , ndnboost::container::basic_string< Char, Traits, Alloc1 >
502 , std::basic_string< Char, Traits, Alloc2 >
503 >
504 {
505 typedef Traits type;
506 };
507
508 template < class Char, class Traits, class Alloc1, class Alloc2 >
509 struct deduce_char_traits< Char
510 , std::basic_string< Char, Traits, Alloc1 >
511 , ndnboost::container::basic_string< Char, Traits, Alloc2 >
512 >
513 {
514 typedef Traits type;
515 };
516 }
517
518 namespace detail // array_to_pointer_decay<T>
519 {
520 template<class T>
521 struct array_to_pointer_decay
522 {
523 typedef T type;
524 };
525
526 template<class T, std::size_t N>
527 struct array_to_pointer_decay<T[N]>
528 {
529 typedef const T * type;
530 };
531 }
532
533 namespace detail // is_this_float_conversion_optimized<Float, Char>
534 {
535 // this metafunction evaluates to true, if we have optimized comnversion
536 // from Float type to Char array.
537 // Must be in sync with lexical_stream_limited_src<Char, ...>::shl_real_type(...)
538 template <typename Float, typename Char>
539 struct is_this_float_conversion_optimized
540 {
541 typedef ndnboost::type_traits::ice_and<
542 ndnboost::is_float<Float>::value,
543#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_SWPRINTF) && !defined(__MINGW32__)
544 ndnboost::type_traits::ice_or<
545 ndnboost::type_traits::ice_eq<sizeof(Char), sizeof(char) >::value,
546 ndnboost::is_same<Char, wchar_t>::value
547 >::value
548#else
549 ndnboost::type_traits::ice_eq<sizeof(Char), sizeof(char) >::value
550#endif
551 > result_type;
552
553 BOOST_STATIC_CONSTANT(bool, value = (result_type::value) );
554 };
555 }
556
557 namespace detail // lcast_src_length
558 {
559 // Return max. length of string representation of Source;
560 template< class Source // Source type of lexical_cast.
561 >
562 struct lcast_src_length
563 {
564 BOOST_STATIC_CONSTANT(std::size_t, value = 1);
565 // To check coverage, build the test with
566 // bjam --v2 profile optimization=off
567 static void check_coverage() {}
568 };
569
570 // Helper for integral types.
571 // Notes on length calculation:
572 // Max length for 32bit int with grouping "\1" and thousands_sep ',':
573 // "-2,1,4,7,4,8,3,6,4,7"
574 // ^ - is_signed
575 // ^ - 1 digit not counted by digits10
576 // ^^^^^^^^^^^^^^^^^^ - digits10 * 2
577 //
578 // Constant is_specialized is used instead of constant 1
579 // to prevent buffer overflow in a rare case when
580 // <ndnboost/limits.hpp> doesn't add missing specialization for
581 // numeric_limits<T> for some integral type T.
582 // When is_specialized is false, the whole expression is 0.
583 template<class Source>
584 struct lcast_src_length_integral
585 {
586#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
587 BOOST_STATIC_CONSTANT(std::size_t, value =
588 std::numeric_limits<Source>::is_signed +
589 std::numeric_limits<Source>::is_specialized + /* == 1 */
590 std::numeric_limits<Source>::digits10 * 2
591 );
592#else
593 BOOST_STATIC_CONSTANT(std::size_t, value = 156);
594 BOOST_STATIC_ASSERT(sizeof(Source) * CHAR_BIT <= 256);
595#endif
596 };
597
598#define BOOST_LCAST_DEF(T) \
599 template<> struct lcast_src_length<T> \
600 : lcast_src_length_integral<T> \
601 { static void check_coverage() {} };
602
603 BOOST_LCAST_DEF(short)
604 BOOST_LCAST_DEF(unsigned short)
605 BOOST_LCAST_DEF(int)
606 BOOST_LCAST_DEF(unsigned int)
607 BOOST_LCAST_DEF(long)
608 BOOST_LCAST_DEF(unsigned long)
609#if defined(BOOST_HAS_LONG_LONG)
610 BOOST_LCAST_DEF(ndnboost::ulong_long_type)
611 BOOST_LCAST_DEF(ndnboost::long_long_type )
612#elif defined(BOOST_HAS_MS_INT64)
613 BOOST_LCAST_DEF(unsigned __int64)
614 BOOST_LCAST_DEF( __int64)
615#endif
616#ifdef BOOST_LCAST_HAS_INT128
617 BOOST_LCAST_DEF(ndnboost::int128_type)
618 BOOST_LCAST_DEF(ndnboost::uint128_type)
619#endif
620
621#undef BOOST_LCAST_DEF
622
623#ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
624 // Helper for floating point types.
625 // -1.23456789e-123456
626 // ^ sign
627 // ^ leading digit
628 // ^ decimal point
629 // ^^^^^^^^ lcast_precision<Source>::value
630 // ^ "e"
631 // ^ exponent sign
632 // ^^^^^^ exponent (assumed 6 or less digits)
633 // sign + leading digit + decimal point + "e" + exponent sign == 5
634 template<class Source>
635 struct lcast_src_length_floating
636 {
637 BOOST_STATIC_ASSERT(
638 std::numeric_limits<Source>::max_exponent10 <= 999999L &&
639 std::numeric_limits<Source>::min_exponent10 >= -999999L
640 );
641 BOOST_STATIC_CONSTANT(std::size_t, value =
642 5 + lcast_precision<Source>::value + 6
643 );
644 };
645
646 template<>
647 struct lcast_src_length<float>
648 : lcast_src_length_floating<float>
649 {
650 static void check_coverage() {}
651 };
652
653 template<>
654 struct lcast_src_length<double>
655 : lcast_src_length_floating<double>
656 {
657 static void check_coverage() {}
658 };
659
660 template<>
661 struct lcast_src_length<long double>
662 : lcast_src_length_floating<long double>
663 {
664 static void check_coverage() {}
665 };
666
667#endif // #ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
668 }
669
670 namespace detail // lexical_cast_stream_traits<Source, Target>
671 {
672 template <class Source, class Target>
673 struct lexical_cast_stream_traits {
674 typedef BOOST_DEDUCED_TYPENAME ndnboost::detail::array_to_pointer_decay<Source>::type src;
675 typedef BOOST_DEDUCED_TYPENAME ndnboost::remove_cv<src>::type no_cv_src;
676
677 typedef ndnboost::detail::deduce_source_char<no_cv_src> deduce_src_char_metafunc;
678 typedef BOOST_DEDUCED_TYPENAME deduce_src_char_metafunc::type src_char_t;
679 typedef BOOST_DEDUCED_TYPENAME ndnboost::detail::deduce_target_char<Target>::type target_char_t;
680
681 typedef BOOST_DEDUCED_TYPENAME ndnboost::detail::widest_char<
682 target_char_t, src_char_t
683 >::type char_type;
684
685#if !defined(BOOST_NO_CXX11_CHAR16_T) && defined(BOOST_NO_CXX11_UNICODE_LITERALS)
686 BOOST_STATIC_ASSERT_MSG(( !ndnboost::is_same<char16_t, src_char_t>::value
687 && !ndnboost::is_same<char16_t, target_char_t>::value),
688 "Your compiler does not have full support for char16_t" );
689#endif
690#if !defined(BOOST_NO_CXX11_CHAR32_T) && defined(BOOST_NO_CXX11_UNICODE_LITERALS)
691 BOOST_STATIC_ASSERT_MSG(( !ndnboost::is_same<char32_t, src_char_t>::value
692 && !ndnboost::is_same<char32_t, target_char_t>::value),
693 "Your compiler does not have full support for char32_t" );
694#endif
695
696 typedef BOOST_DEDUCED_TYPENAME ndnboost::detail::deduce_char_traits<
697 char_type, Target, no_cv_src
698 >::type traits;
699
700 typedef ndnboost::type_traits::ice_and<
701 ndnboost::is_same<char, src_char_t>::value, // source is not a wide character based type
702 ndnboost::type_traits::ice_ne<sizeof(char), sizeof(target_char_t) >::value, // target type is based on wide character
703 ndnboost::type_traits::ice_not<
704 ndnboost::detail::is_char_or_wchar<no_cv_src>::value // single character widening is optimized
705 >::value // and does not requires stringbuffer
706 > is_string_widening_required_t;
707
708 typedef ndnboost::type_traits::ice_not< ndnboost::type_traits::ice_or<
709 ndnboost::is_integral<no_cv_src>::value,
710 ndnboost::detail::is_this_float_conversion_optimized<no_cv_src, char_type >::value,
711 ndnboost::detail::is_char_or_wchar<
712 BOOST_DEDUCED_TYPENAME deduce_src_char_metafunc::stage1_type // if we did not get character type at stage1
713 >::value // then we have no optimization for that type
714 >::value > is_source_input_not_optimized_t;
715
716 // If we have an optimized conversion for
717 // Source, we do not need to construct stringbuf.
718 BOOST_STATIC_CONSTANT(bool, requires_stringbuf =
719 (ndnboost::type_traits::ice_or<
720 is_string_widening_required_t::value, is_source_input_not_optimized_t::value
721 >::value)
722 );
723
724 typedef ndnboost::detail::lcast_src_length<no_cv_src> len_t;
725 };
726 }
727
728 namespace detail // '0', '+' and '-' constants
729 {
730 template < typename Char > struct lcast_char_constants;
731
732 template<>
733 struct lcast_char_constants<char>
734 {
735 BOOST_STATIC_CONSTANT(char, zero = '0');
736 BOOST_STATIC_CONSTANT(char, minus = '-');
737 BOOST_STATIC_CONSTANT(char, plus = '+');
738 BOOST_STATIC_CONSTANT(char, lowercase_e = 'e');
739 BOOST_STATIC_CONSTANT(char, capital_e = 'E');
740 BOOST_STATIC_CONSTANT(char, c_decimal_separator = '.');
741 };
742
743#ifndef BOOST_LCAST_NO_WCHAR_T
744 template<>
745 struct lcast_char_constants<wchar_t>
746 {
747 BOOST_STATIC_CONSTANT(wchar_t, zero = L'0');
748 BOOST_STATIC_CONSTANT(wchar_t, minus = L'-');
749 BOOST_STATIC_CONSTANT(wchar_t, plus = L'+');
750 BOOST_STATIC_CONSTANT(wchar_t, lowercase_e = L'e');
751 BOOST_STATIC_CONSTANT(wchar_t, capital_e = L'E');
752 BOOST_STATIC_CONSTANT(wchar_t, c_decimal_separator = L'.');
753 };
754#endif
755
756#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
757 template<>
758 struct lcast_char_constants<char16_t>
759 {
760 BOOST_STATIC_CONSTANT(char16_t, zero = u'0');
761 BOOST_STATIC_CONSTANT(char16_t, minus = u'-');
762 BOOST_STATIC_CONSTANT(char16_t, plus = u'+');
763 BOOST_STATIC_CONSTANT(char16_t, lowercase_e = u'e');
764 BOOST_STATIC_CONSTANT(char16_t, capital_e = u'E');
765 BOOST_STATIC_CONSTANT(char16_t, c_decimal_separator = u'.');
766 };
767#endif
768
769#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
770 template<>
771 struct lcast_char_constants<char32_t>
772 {
773 BOOST_STATIC_CONSTANT(char32_t, zero = U'0');
774 BOOST_STATIC_CONSTANT(char32_t, minus = U'-');
775 BOOST_STATIC_CONSTANT(char32_t, plus = U'+');
776 BOOST_STATIC_CONSTANT(char32_t, lowercase_e = U'e');
777 BOOST_STATIC_CONSTANT(char32_t, capital_e = U'E');
778 BOOST_STATIC_CONSTANT(char32_t, c_decimal_separator = U'.');
779 };
780#endif
781 }
782
783 namespace detail // lcast_to_unsigned
784 {
785 template<class T>
786 inline
787 BOOST_DEDUCED_TYPENAME make_unsigned<T>::type lcast_to_unsigned(T value) BOOST_NOEXCEPT
788 {
789 typedef BOOST_DEDUCED_TYPENAME ndnboost::make_unsigned<T>::type result_type;
790 return static_cast<result_type>(
791 value < 0 ? 0u - static_cast<result_type>(value) : value
792 );
793 }
794 }
795
796 namespace detail // lcast_put_unsigned
797 {
798 template<class Traits, class T, class CharT>
799 CharT* lcast_put_unsigned(const T n_param, CharT* finish)
800 {
801#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
802 BOOST_STATIC_ASSERT(!std::numeric_limits<T>::is_signed);
803#endif
804
805 typedef typename Traits::int_type int_type;
806 CharT const czero = lcast_char_constants<CharT>::zero;
807 int_type const zero = Traits::to_int_type(czero);
808 BOOST_DEDUCED_TYPENAME ndnboost::mpl::if_c<
809 (sizeof(int_type) > sizeof(T))
810 , int_type
811 , T
812 >::type n = n_param;
813
814#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
815 std::locale loc;
816 if (loc != std::locale::classic()) {
817 typedef std::numpunct<CharT> numpunct;
818 numpunct const& np = BOOST_USE_FACET(numpunct, loc);
819 std::string const grouping = np.grouping();
820 std::string::size_type const grouping_size = grouping.size();
821
822 if ( grouping_size && grouping[0] > 0 )
823 {
824
825#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
826 // Check that ulimited group is unreachable:
827 BOOST_STATIC_ASSERT(std::numeric_limits<T>::digits10 < CHAR_MAX);
828#endif
829 CharT thousands_sep = np.thousands_sep();
830 std::string::size_type group = 0; // current group number
831 char last_grp_size = grouping[0];
832 char left = last_grp_size;
833
834 do
835 {
836 if(left == 0)
837 {
838 ++group;
839 if(group < grouping_size)
840 {
841 char const grp_size = grouping[group];
842 last_grp_size = grp_size <= 0 ? static_cast<char>(CHAR_MAX) : grp_size;
843 }
844
845 left = last_grp_size;
846 --finish;
847 Traits::assign(*finish, thousands_sep);
848 }
849
850 --left;
851
852 --finish;
853 int_type const digit = static_cast<int_type>(n % 10U);
854 Traits::assign(*finish, Traits::to_char_type(zero + digit));
855 n /= 10;
856 } while(n);
857 return finish;
858 }
859 }
860#endif
861 {
862 do
863 {
864 --finish;
865 int_type const digit = static_cast<int_type>(n % 10U);
866 Traits::assign(*finish, Traits::to_char_type(zero + digit));
867 n /= 10;
868 } while(n);
869 }
870
871 return finish;
872 }
873 }
874
875 namespace detail // lcast_ret_unsigned
876 {
877 template<class Traits, class T, class CharT>
878 inline bool lcast_ret_unsigned(T& value, const CharT* const begin, const CharT* end)
879 {
880#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
881 BOOST_STATIC_ASSERT(!std::numeric_limits<T>::is_signed);
882#endif
883 CharT const czero = lcast_char_constants<CharT>::zero;
884 --end;
885 value = 0;
886
887 if (begin > end || *end < czero || *end >= czero + 10)
888 return false;
889 value = static_cast<T>(*end - czero);
890 --end;
891 T multiplier = 1;
892 bool multiplier_overflowed = false;
893
894#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
895 std::locale loc;
896 if (loc != std::locale::classic()) {
897 typedef std::numpunct<CharT> numpunct;
898 numpunct const& np = BOOST_USE_FACET(numpunct, loc);
899 std::string const& grouping = np.grouping();
900 std::string::size_type const grouping_size = grouping.size();
901
902 /* According to Programming languages - C++
903 * we MUST check for correct grouping
904 */
905 if (grouping_size && grouping[0] > 0)
906 {
907 unsigned char current_grouping = 0;
908 CharT const thousands_sep = np.thousands_sep();
909 char remained = static_cast<char>(grouping[current_grouping] - 1);
910 bool shall_we_return = true;
911
912 for(;end>=begin; --end)
913 {
914 if (remained) {
915 T const multiplier_10 = static_cast<T>(multiplier * 10);
916 if (multiplier_10 / 10 != multiplier) multiplier_overflowed = true;
917
918 T const dig_value = static_cast<T>(*end - czero);
919 T const new_sub_value = static_cast<T>(multiplier_10 * dig_value);
920
921 if (*end < czero || *end >= czero + 10
922 /* detecting overflow */
923 || (dig_value && new_sub_value / dig_value != multiplier_10)
924 || static_cast<T>((std::numeric_limits<T>::max)()-new_sub_value) < value
925 || (multiplier_overflowed && dig_value)
926 )
927 return false;
928
929 value = static_cast<T>(value + new_sub_value);
930 multiplier = static_cast<T>(multiplier * 10);
931 --remained;
932 } else {
933 if ( !Traits::eq(*end, thousands_sep) ) //|| begin == end ) return false;
934 {
935 /*
936 * According to Programming languages - C++
937 * Digit grouping is checked. That is, the positions of discarded
938 * separators is examined for consistency with
939 * use_facet<numpunct<charT> >(loc ).grouping()
940 *
941 * BUT what if there is no separators at all and grouping()
942 * is not empty? Well, we have no extraced separators, so we
943 * won`t check them for consistency. This will allow us to
944 * work with "C" locale from other locales
945 */
946 shall_we_return = false;
947 break;
948 } else {
949 if ( begin == end ) return false;
950 if (current_grouping < grouping_size-1 ) ++current_grouping;
951 remained = grouping[current_grouping];
952 }
953 }
954 }
955
956 if (shall_we_return) return true;
957 }
958 }
959#endif
960 {
961 while ( begin <= end )
962 {
963 T const multiplier_10 = static_cast<T>(multiplier * 10);
964 if (multiplier_10 / 10 != multiplier) multiplier_overflowed = true;
965
966 T const dig_value = static_cast<T>(*end - czero);
967 T const new_sub_value = static_cast<T>(multiplier_10 * dig_value);
968
969 if (*end < czero || *end >= czero + 10
970 /* detecting overflow */
971 || (dig_value && new_sub_value / dig_value != multiplier_10)
972 || static_cast<T>((std::numeric_limits<T>::max)()-new_sub_value) < value
973 || (multiplier_overflowed && dig_value)
974 )
975 return false;
976
977 value = static_cast<T>(value + new_sub_value);
978 multiplier = static_cast<T>(multiplier * 10);
979 --end;
980 }
981 }
982 return true;
983 }
984 }
985
986 namespace detail
987 {
988 template <class CharT>
989 bool lc_iequal(const CharT* val, const CharT* lcase, const CharT* ucase, unsigned int len) BOOST_NOEXCEPT {
990 for( unsigned int i=0; i < len; ++i ) {
991 if ( val[i] != lcase[i] && val[i] != ucase[i] ) return false;
992 }
993
994 return true;
995 }
996
997 /* Returns true and sets the correct value if found NaN or Inf. */
998 template <class CharT, class T>
999 inline bool parse_inf_nan_impl(const CharT* begin, const CharT* end, T& value
1000 , const CharT* lc_NAN, const CharT* lc_nan
1001 , const CharT* lc_INFINITY, const CharT* lc_infinity
1002 , const CharT opening_brace, const CharT closing_brace) BOOST_NOEXCEPT
1003 {
1004 using namespace std;
1005 if (begin == end) return false;
1006 const CharT minus = lcast_char_constants<CharT>::minus;
1007 const CharT plus = lcast_char_constants<CharT>::plus;
1008 const int inifinity_size = 8;
1009
1010 bool has_minus = false;
1011 /* Parsing +/- */
1012 if( *begin == minus)
1013 {
1014 ++ begin;
1015 has_minus = true;
1016 }
1017 else if( *begin == plus ) ++begin;
1018
1019 if( end-begin < 3 ) return false;
1020 if( lc_iequal(begin, lc_nan, lc_NAN, 3) )
1021 {
1022 begin += 3;
1023 if (end != begin) /* It is 'nan(...)' or some bad input*/
1024 {
1025 if(end-begin<2) return false; // bad input
1026 -- end;
1027 if( *begin != opening_brace || *end != closing_brace) return false; // bad input
1028 }
1029
1030 if( !has_minus ) value = std::numeric_limits<T>::quiet_NaN();
1031 else value = (ndnboost::math::changesign) (std::numeric_limits<T>::quiet_NaN());
1032 return true;
1033 } else
1034 if (( /* 'INF' or 'inf' */
1035 end-begin==3
1036 &&
1037 lc_iequal(begin, lc_infinity, lc_INFINITY, 3)
1038 )
1039 ||
1040 ( /* 'INFINITY' or 'infinity' */
1041 end-begin==inifinity_size
1042 &&
1043 lc_iequal(begin, lc_infinity, lc_INFINITY, inifinity_size)
1044 )
1045 )
1046 {
1047 if( !has_minus ) value = std::numeric_limits<T>::infinity();
1048 else value = (ndnboost::math::changesign) (std::numeric_limits<T>::infinity());
1049 return true;
1050 }
1051
1052 return false;
1053 }
1054
1055 template <class CharT, class T>
1056 bool put_inf_nan_impl(CharT* begin, CharT*& end, const T& value
1057 , const CharT* lc_nan
1058 , const CharT* lc_infinity) BOOST_NOEXCEPT
1059 {
1060 using namespace std;
1061 const CharT minus = lcast_char_constants<CharT>::minus;
1062 if ( (ndnboost::math::isnan)(value) )
1063 {
1064 if ( (ndnboost::math::signbit)(value) )
1065 {
1066 *begin = minus;
1067 ++ begin;
1068 }
1069
1070 memcpy(begin, lc_nan, 3 * sizeof(CharT));
1071 end = begin + 3;
1072 return true;
1073 } else if ( (ndnboost::math::isinf)(value) )
1074 {
1075 if ( (ndnboost::math::signbit)(value) )
1076 {
1077 *begin = minus;
1078 ++ begin;
1079 }
1080
1081 memcpy(begin, lc_infinity, 3 * sizeof(CharT));
1082 end = begin + 3;
1083 return true;
1084 }
1085
1086 return false;
1087 }
1088
1089
1090#ifndef BOOST_LCAST_NO_WCHAR_T
1091 template <class T>
1092 bool parse_inf_nan(const wchar_t* begin, const wchar_t* end, T& value) BOOST_NOEXCEPT
1093 {
1094 return parse_inf_nan_impl(begin, end, value
1095 , L"NAN", L"nan"
1096 , L"INFINITY", L"infinity"
1097 , L'(', L')');
1098 }
1099
1100 template <class T>
1101 bool put_inf_nan(wchar_t* begin, wchar_t*& end, const T& value) BOOST_NOEXCEPT
1102 {
1103 return put_inf_nan_impl(begin, end, value, L"nan", L"infinity");
1104 }
1105
1106#endif
1107#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
1108 template <class T>
1109 bool parse_inf_nan(const char16_t* begin, const char16_t* end, T& value) BOOST_NOEXCEPT
1110 {
1111 return parse_inf_nan_impl(begin, end, value
1112 , u"NAN", u"nan"
1113 , u"INFINITY", u"infinity"
1114 , u'(', u')');
1115 }
1116
1117 template <class T>
1118 bool put_inf_nan(char16_t* begin, char16_t*& end, const T& value) BOOST_NOEXCEPT
1119 {
1120 return put_inf_nan_impl(begin, end, value, u"nan", u"infinity");
1121 }
1122#endif
1123#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
1124 template <class T>
1125 bool parse_inf_nan(const char32_t* begin, const char32_t* end, T& value) BOOST_NOEXCEPT
1126 {
1127 return parse_inf_nan_impl(begin, end, value
1128 , U"NAN", U"nan"
1129 , U"INFINITY", U"infinity"
1130 , U'(', U')');
1131 }
1132
1133 template <class T>
1134 bool put_inf_nan(char32_t* begin, char32_t*& end, const T& value) BOOST_NOEXCEPT
1135 {
1136 return put_inf_nan_impl(begin, end, value, U"nan", U"infinity");
1137 }
1138#endif
1139
1140 template <class CharT, class T>
1141 bool parse_inf_nan(const CharT* begin, const CharT* end, T& value) BOOST_NOEXCEPT
1142 {
1143 return parse_inf_nan_impl(begin, end, value
1144 , "NAN", "nan"
1145 , "INFINITY", "infinity"
1146 , '(', ')');
1147 }
1148
1149 template <class CharT, class T>
1150 bool put_inf_nan(CharT* begin, CharT*& end, const T& value) BOOST_NOEXCEPT
1151 {
1152 return put_inf_nan_impl(begin, end, value, "nan", "infinity");
1153 }
1154 }
1155
1156
1157 namespace detail // lcast_ret_float
1158 {
1159
1160// Silence buggy MS warnings like C4244: '+=' : conversion from 'int' to 'unsigned short', possible loss of data
1161#if defined(_MSC_VER) && (_MSC_VER == 1400)
1162# pragma warning(push)
1163# pragma warning(disable:4244)
1164#endif
1165 template <class T>
1166 struct mantissa_holder_type
1167 {
1168 /* Can not be used with this type */
1169 };
1170
1171 template <>
1172 struct mantissa_holder_type<float>
1173 {
1174 typedef unsigned int type;
1175 typedef double wide_result_t;
1176 };
1177
1178 template <>
1179 struct mantissa_holder_type<double>
1180 {
1181#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
1182 typedef long double wide_result_t;
1183#if defined(BOOST_HAS_LONG_LONG)
1184 typedef ndnboost::ulong_long_type type;
1185#elif defined(BOOST_HAS_MS_INT64)
1186 typedef unsigned __int64 type;
1187#endif
1188#endif
1189 };
1190
1191 template<class Traits, class T, class CharT>
1192 inline bool lcast_ret_float(T& value, const CharT* begin, const CharT* end)
1193 {
1194
1195#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
1196 std::locale loc;
1197 typedef std::numpunct<CharT> numpunct;
1198 numpunct const& np = BOOST_USE_FACET(numpunct, loc);
1199 std::string const grouping(
1200 (loc == std::locale::classic())
1201 ? std::string()
1202 : np.grouping()
1203 );
1204 std::string::size_type const grouping_size = grouping.size();
1205 CharT const thousands_sep = static_cast<CharT>(grouping_size ? np.thousands_sep() : 0);
1206 CharT const decimal_point = np.decimal_point();
1207 bool found_grouping = false;
1208 std::string::size_type last_grouping_pos = grouping_size - 1;
1209#else
1210 CharT const decimal_point = lcast_char_constants<CharT>::c_decimal_separator;
1211#endif
1212
1213 CharT const czero = lcast_char_constants<CharT>::zero;
1214 CharT const minus = lcast_char_constants<CharT>::minus;
1215 CharT const plus = lcast_char_constants<CharT>::plus;
1216 CharT const capital_e = lcast_char_constants<CharT>::capital_e;
1217 CharT const lowercase_e = lcast_char_constants<CharT>::lowercase_e;
1218
1219 value = static_cast<T>(0);
1220
1221 if (parse_inf_nan(begin, end, value)) return true;
1222
1223 typedef typename Traits::int_type int_type;
1224 typedef BOOST_DEDUCED_TYPENAME mantissa_holder_type<T>::type mantissa_type;
1225 typedef BOOST_DEDUCED_TYPENAME mantissa_holder_type<T>::wide_result_t wide_result_t;
1226 int_type const zero = Traits::to_int_type(czero);
1227 if (begin == end) return false;
1228
1229 /* Getting the plus/minus sign */
1230 bool has_minus = false;
1231 if (Traits::eq(*begin, minus) ) {
1232 ++ begin;
1233 has_minus = true;
1234 if (begin == end) return false;
1235 } else if (Traits::eq(*begin, plus) ) {
1236 ++begin;
1237 if (begin == end) return false;
1238 }
1239
1240 bool found_decimal = false;
1241 bool found_number_before_exp = false;
1242 int pow_of_10 = 0;
1243 mantissa_type mantissa=0;
1244 bool is_mantissa_full = false;
1245
1246 char length_since_last_delim = 0;
1247
1248 while ( begin != end )
1249 {
1250 if (found_decimal) {
1251 /* We allow no thousand_separators after decimal point */
1252
1253 mantissa_type tmp_mantissa = mantissa * 10u;
1254 if (Traits::eq(*begin, lowercase_e) || Traits::eq(*begin, capital_e)) break;
1255 if ( *begin < czero || *begin >= czero + 10 ) return false;
1256 if ( is_mantissa_full
1257 || tmp_mantissa / 10u != mantissa
1258 || (std::numeric_limits<mantissa_type>::max)()-(*begin - zero) < tmp_mantissa
1259 ) {
1260 is_mantissa_full = true;
1261 ++ begin;
1262 continue;
1263 }
1264
1265 -- pow_of_10;
1266 mantissa = tmp_mantissa;
1267 mantissa += *begin - zero;
1268
1269 found_number_before_exp = true;
1270 } else {
1271
1272 if (*begin >= czero && *begin < czero + 10) {
1273
1274 /* Checking for mantissa overflow. If overflow will
1275 * occur, them we only increase multiplyer
1276 */
1277 mantissa_type tmp_mantissa = mantissa * 10u;
1278 if( !is_mantissa_full
1279 && tmp_mantissa / 10u == mantissa
1280 && (std::numeric_limits<mantissa_type>::max)()-(*begin - zero) >= tmp_mantissa
1281 )
1282 {
1283 mantissa = tmp_mantissa;
1284 mantissa += *begin - zero;
1285 } else
1286 {
1287 is_mantissa_full = true;
1288 ++ pow_of_10;
1289 }
1290
1291 found_number_before_exp = true;
1292 ++ length_since_last_delim;
1293 } else if (Traits::eq(*begin, decimal_point) || Traits::eq(*begin, lowercase_e) || Traits::eq(*begin, capital_e)) {
1294#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
1295 /* If ( we need to check grouping
1296 * and ( grouping missmatches
1297 * or grouping position is incorrect
1298 * or we are using the grouping position 0 twice
1299 * )
1300 * ) then return error
1301 */
1302 if( grouping_size && found_grouping
1303 && (
1304 length_since_last_delim != grouping[0]
1305 || last_grouping_pos>1
1306 || (last_grouping_pos==0 && grouping_size>1)
1307 )
1308 ) return false;
1309#endif
1310
1311 if(Traits::eq(*begin, decimal_point)) {
1312 ++ begin;
1313 found_decimal = true;
1314 if (!found_number_before_exp && begin==end) return false;
1315 continue;
1316 }else {
1317 if (!found_number_before_exp) return false;
1318 break;
1319 }
1320 }
1321#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
1322 else if (grouping_size && Traits::eq(*begin, thousands_sep)){
1323 if(found_grouping)
1324 {
1325 /* It is not he first time, when we find thousands separator,
1326 * so we need to chek, is the distance between two groupings
1327 * equal to grouping[last_grouping_pos] */
1328
1329 if (length_since_last_delim != grouping[last_grouping_pos] )
1330 {
1331 if (!last_grouping_pos) return false;
1332 else
1333 {
1334 -- last_grouping_pos;
1335 if (length_since_last_delim != grouping[last_grouping_pos]) return false;
1336 }
1337 } else
1338 /* We are calling the grouping[0] twice, when grouping size is more than 1 */
1339 if (grouping_size>1u && last_grouping_pos+1<grouping_size) return false;
1340
1341 } else {
1342 /* Delimiter at the begining ',000' */
1343 if (!length_since_last_delim) return false;
1344
1345 found_grouping = true;
1346 if (length_since_last_delim > grouping[last_grouping_pos] ) return false;
1347 }
1348
1349 length_since_last_delim = 0;
1350 ++ begin;
1351
1352 /* Delimiter at the end '100,' */
1353 if (begin == end) return false;
1354 continue;
1355 }
1356#endif
1357 else return false;
1358 }
1359
1360 ++begin;
1361 }
1362
1363 // Exponent found
1364 if ( begin != end && (Traits::eq(*begin, lowercase_e) || Traits::eq(*begin, capital_e)) ) {
1365 ++ begin;
1366 if ( begin == end ) return false;
1367
1368 bool exp_has_minus = false;
1369 if(Traits::eq(*begin, minus)) {
1370 exp_has_minus = true;
1371 ++ begin;
1372 if ( begin == end ) return false;
1373 } else if (Traits::eq(*begin, plus)) {
1374 ++ begin;
1375 if ( begin == end ) return false;
1376 }
1377
1378 int exp_pow_of_10 = 0;
1379 while ( begin != end )
1380 {
1381 if ( *begin < czero
1382 || *begin >= czero + 10
1383 || exp_pow_of_10 * 10 < exp_pow_of_10) /* Overflows are checked lower more precisely*/
1384 return false;
1385
1386 exp_pow_of_10 *= 10;
1387 exp_pow_of_10 += *begin - zero;
1388 ++ begin;
1389 };
1390
1391 if ( exp_pow_of_10 ) {
1392 /* Overflows are checked lower */
1393 if ( exp_has_minus ) {
1394 pow_of_10 -= exp_pow_of_10;
1395 } else {
1396 pow_of_10 += exp_pow_of_10;
1397 }
1398 }
1399 }
1400
1401 /* We need a more accurate algorithm... We can not use current algorithm
1402 * with long doubles (and with doubles if sizeof(double)==sizeof(long double)).
1403 */
1404 const wide_result_t result = std::pow(static_cast<wide_result_t>(10.0), pow_of_10) * mantissa;
1405 value = static_cast<T>( has_minus ? (ndnboost::math::changesign)(result) : result);
1406
1407 if ( (ndnboost::math::isinf)(value) || (ndnboost::math::isnan)(value) ) return false;
1408
1409 return true;
1410 }
1411// Unsilence buggy MS warnings like C4244: '+=' : conversion from 'int' to 'unsigned short', possible loss of data
1412#if defined(_MSC_VER) && (_MSC_VER == 1400)
1413# pragma warning(pop)
1414#endif
1415 }
1416
1417 namespace detail // parser_buf
1418 {
1419 //
1420 // class parser_buf:
1421 // acts as a stream buffer which wraps around a pair of pointers
1422 //
1423 // This class is copied (and slightly changed) from
1424 // boost/regex/v4/cpp_regex_traits.hpp
1425 // Thanks John Maddock for it! (previous version had some
1426 // problems with libc++ and some other STL implementations)
1427 template <class BufferType, class charT>
1428 class parser_buf : public BufferType {
1429 typedef BufferType base_type;
1430 typedef typename base_type::int_type int_type;
1431 typedef typename base_type::char_type char_type;
1432 typedef typename base_type::pos_type pos_type;
1433 typedef ::std::streamsize streamsize;
1434 typedef typename base_type::off_type off_type;
1435
1436 public:
1437 parser_buf() : base_type() { setbuf(0, 0); }
1438 const charT* getnext() { return this->gptr(); }
1439#ifndef BOOST_NO_USING_TEMPLATE
1440 using base_type::pptr;
1441 using base_type::pbase;
1442#else
1443 charT* pptr() const { return base_type::pptr(); }
1444 charT* pbase() const { return base_type::pbase(); }
1445#endif
1446 base_type* setbuf(char_type* s, streamsize n) {
1447 this->setg(s, s, s + n);
1448 return this;
1449 }
1450
1451 pos_type seekpos(pos_type sp, ::std::ios_base::openmode which) {
1452 if(which & ::std::ios_base::out)
1453 return pos_type(off_type(-1));
1454 off_type size = static_cast<off_type>(this->egptr() - this->eback());
1455 charT* g = this->eback();
1456 if(off_type(sp) <= size)
1457 {
1458 this->setg(g, g + off_type(sp), g + size);
1459 }
1460 return pos_type(off_type(-1));
1461 }
1462
1463 pos_type seekoff(off_type off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which) {
1464 typedef typename ndnboost::int_t<sizeof(way) * CHAR_BIT>::least cast_type;
1465
1466 if(which & ::std::ios_base::out)
1467 return pos_type(off_type(-1));
1468 std::ptrdiff_t size = this->egptr() - this->eback();
1469 std::ptrdiff_t pos = this->gptr() - this->eback();
1470 charT* g = this->eback();
1471 switch(static_cast<cast_type>(way))
1472 {
1473 case ::std::ios_base::beg:
1474 if((off < 0) || (off > size))
1475 return pos_type(off_type(-1));
1476 else
1477 this->setg(g, g + off, g + size);
1478 break;
1479 case ::std::ios_base::end:
1480 if((off < 0) || (off > size))
1481 return pos_type(off_type(-1));
1482 else
1483 this->setg(g, g + size - off, g + size);
1484 break;
1485 case ::std::ios_base::cur:
1486 {
1487 std::ptrdiff_t newpos = static_cast<std::ptrdiff_t>(pos + off);
1488 if((newpos < 0) || (newpos > size))
1489 return pos_type(off_type(-1));
1490 else
1491 this->setg(g, g + newpos, g + size);
1492 break;
1493 }
1494 default: ;
1495 }
1496#ifdef BOOST_MSVC
1497#pragma warning(push)
1498#pragma warning(disable:4244)
1499#endif
1500 return static_cast<pos_type>(this->gptr() - this->eback());
1501#ifdef BOOST_MSVC
1502#pragma warning(pop)
1503#endif
1504 }
1505 private:
1506 parser_buf& operator=(const parser_buf&);
1507 parser_buf(const parser_buf&);
1508 };
1509 }
1510
1511 namespace detail
1512 {
1513 struct do_not_construct_out_stream_t{};
1514 }
1515
1516 namespace detail // optimized stream wrapper
1517 {
1518 // String representation of Source has an upper limit.
1519 template< class CharT // a result of widest_char transformation
1520 , class Traits // usually char_traits<CharT>
1521 , bool RequiresStringbuffer
1522 >
1523 class lexical_stream_limited_src
1524 {
1525
1526#if defined(BOOST_NO_STRINGSTREAM)
1527 typedef std::ostrstream out_stream_t;
1528#elif defined(BOOST_NO_STD_LOCALE)
1529 typedef std::ostringstream out_stream_t;
1530 typedef parser_buf<std::streambuf, char> buffer_t;
1531#else
1532 typedef std::basic_ostringstream<CharT, Traits> out_stream_t;
1533 typedef parser_buf<std::basic_streambuf<CharT, Traits>, CharT> buffer_t;
1534#endif
1535 typedef BOOST_DEDUCED_TYPENAME ndnboost::mpl::if_c<
1536 RequiresStringbuffer,
1537 out_stream_t,
1538 do_not_construct_out_stream_t
1539 >::type deduced_out_stream_t;
1540
1541 // A string representation of Source is written to [start, finish).
1542 CharT* start;
1543 CharT* finish;
1544 deduced_out_stream_t out_stream;
1545
1546 public:
1547 lexical_stream_limited_src(CharT* sta, CharT* fin) BOOST_NOEXCEPT
1548 : start(sta)
1549 , finish(fin)
1550 {}
1551
1552 private:
1553 // Undefined:
1554 lexical_stream_limited_src(lexical_stream_limited_src const&);
1555 void operator=(lexical_stream_limited_src const&);
1556
1557/************************************ HELPER FUNCTIONS FOR OPERATORS << ( ... ) ********************************/
1558 bool shl_char(CharT ch) BOOST_NOEXCEPT
1559 {
1560 Traits::assign(*start, ch);
1561 finish = start + 1;
1562 return true;
1563 }
1564
1565#ifndef BOOST_LCAST_NO_WCHAR_T
1566 template <class T>
1567 bool shl_char(T ch)
1568 {
1569 BOOST_STATIC_ASSERT_MSG(( sizeof(T) <= sizeof(CharT)) ,
1570 "ndnboost::lexical_cast does not support narrowing of char types."
1571 "Use ndnboost::locale instead" );
1572#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
1573 std::locale loc;
1574 CharT const w = BOOST_USE_FACET(std::ctype<CharT>, loc).widen(ch);
1575#else
1576 CharT const w = static_cast<CharT>(ch);
1577#endif
1578 Traits::assign(*start, w);
1579 finish = start + 1;
1580 return true;
1581 }
1582#endif
1583
1584 bool shl_char_array(CharT const* str) BOOST_NOEXCEPT
1585 {
1586 start = const_cast<CharT*>(str);
1587 finish = start + Traits::length(str);
1588 return true;
1589 }
1590
1591 template <class T>
1592 bool shl_char_array(T const* str)
1593 {
1594 BOOST_STATIC_ASSERT_MSG(( sizeof(T) <= sizeof(CharT)),
1595 "ndnboost::lexical_cast does not support narrowing of char types."
1596 "Use ndnboost::locale instead" );
1597 return shl_input_streamable(str);
1598 }
1599
1600 bool shl_char_array_limited(CharT const* str, std::size_t max_size) BOOST_NOEXCEPT
1601 {
1602 start = const_cast<CharT*>(str);
1603 finish = std::find(start, start + max_size, Traits::to_char_type(0));
1604 return true;
1605 }
1606
1607 template<typename InputStreamable>
1608 bool shl_input_streamable(InputStreamable& input)
1609 {
1610#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_LOCALE)
1611 // If you have compilation error at this point, than your STL library
1612 // does not support such conversions. Try updating it.
1613 BOOST_STATIC_ASSERT((ndnboost::is_same<char, CharT>::value));
1614#endif
1615 bool const result = !(out_stream << input).fail();
1616 const buffer_t* const p = static_cast<buffer_t*>(
1617 static_cast<std::basic_streambuf<CharT, Traits>*>(out_stream.rdbuf())
1618 );
1619 start = p->pbase();
1620 finish = p->pptr();
1621 return result;
1622 }
1623
1624 template <class T>
1625 inline bool shl_signed(T n)
1626 {
1627 start = lcast_put_unsigned<Traits>(lcast_to_unsigned(n), finish);
1628 if(n < 0)
1629 {
1630 --start;
1631 CharT const minus = lcast_char_constants<CharT>::minus;
1632 Traits::assign(*start, minus);
1633 }
1634 return true;
1635 }
1636
1637 template <class T, class SomeCharT>
1638 bool shl_real_type(const T& val, SomeCharT* begin, SomeCharT*& end)
1639 {
1640 if (put_inf_nan(begin, end, val)) return true;
1641 lcast_set_precision(out_stream, &val);
1642 return shl_input_streamable(val);
1643 }
1644
1645 static bool shl_real_type(float val, char* begin, char*& end)
1646 { using namespace std;
1647 if (put_inf_nan(begin, end, val)) return true;
1648 const double val_as_double = val;
1649 end = begin +
1650#if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
1651 sprintf_s(begin, end-begin,
1652#else
1653 sprintf(begin,
1654#endif
1655 "%.*g", static_cast<int>(ndnboost::detail::lcast_get_precision<float>()), val_as_double);
1656 return end > begin;
1657 }
1658
1659 static bool shl_real_type(double val, char* begin, char*& end)
1660 { using namespace std;
1661 if (put_inf_nan(begin, end, val)) return true;
1662 end = begin +
1663#if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
1664 sprintf_s(begin, end-begin,
1665#else
1666 sprintf(begin,
1667#endif
1668 "%.*g", static_cast<int>(ndnboost::detail::lcast_get_precision<double>()), val);
1669 return end > begin;
1670 }
1671
1672#ifndef __MINGW32__
1673 static bool shl_real_type(long double val, char* begin, char*& end)
1674 { using namespace std;
1675 if (put_inf_nan(begin, end, val)) return true;
1676 end = begin +
1677#if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
1678 sprintf_s(begin, end-begin,
1679#else
1680 sprintf(begin,
1681#endif
1682 "%.*Lg", static_cast<int>(ndnboost::detail::lcast_get_precision<long double>()), val );
1683 return end > begin;
1684 }
1685#endif
1686
1687
1688#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_SWPRINTF) && !defined(__MINGW32__)
1689 static bool shl_real_type(float val, wchar_t* begin, wchar_t*& end)
1690 { using namespace std;
1691 if (put_inf_nan(begin, end, val)) return true;
1692 const double val_as_double = val;
1693 end = begin + swprintf(begin, end-begin,
1694 L"%.*g",
1695 static_cast<int>(ndnboost::detail::lcast_get_precision<float >()),
1696 val_as_double );
1697 return end > begin;
1698 }
1699
1700 static bool shl_real_type(double val, wchar_t* begin, wchar_t*& end)
1701 { using namespace std;
1702 if (put_inf_nan(begin, end, val)) return true;
1703 end = begin + swprintf(begin, end-begin,
1704 L"%.*g", static_cast<int>(ndnboost::detail::lcast_get_precision<double >()), val );
1705 return end > begin;
1706 }
1707
1708 static bool shl_real_type(long double val, wchar_t* begin, wchar_t*& end)
1709 { using namespace std;
1710 if (put_inf_nan(begin, end, val)) return true;
1711 end = begin + swprintf(begin, end-begin,
1712 L"%.*Lg", static_cast<int>(ndnboost::detail::lcast_get_precision<long double >()), val );
1713 return end > begin;
1714 }
1715#endif
1716
1717/************************************ OPERATORS << ( ... ) ********************************/
1718 public:
1719 template<class Alloc>
1720 bool operator<<(std::basic_string<CharT,Traits,Alloc> const& str) BOOST_NOEXCEPT
1721 {
1722 start = const_cast<CharT*>(str.data());
1723 finish = start + str.length();
1724 return true;
1725 }
1726
1727 template<class Alloc>
1728 bool operator<<(ndnboost::container::basic_string<CharT,Traits,Alloc> const& str) BOOST_NOEXCEPT
1729 {
1730 start = const_cast<CharT*>(str.data());
1731 finish = start + str.length();
1732 return true;
1733 }
1734
1735 bool operator<<(bool value) BOOST_NOEXCEPT
1736 {
1737 CharT const czero = lcast_char_constants<CharT>::zero;
1738 Traits::assign(*start, Traits::to_char_type(czero + value));
1739 finish = start + 1;
1740 return true;
1741 }
1742
1743 bool operator<<(const iterator_range<CharT*>& rng) BOOST_NOEXCEPT
1744 {
1745 start = rng.begin();
1746 finish = rng.end();
1747 return true;
1748 }
1749
1750 bool operator<<(const iterator_range<const CharT*>& rng) BOOST_NOEXCEPT
1751 {
1752 start = const_cast<CharT*>(rng.begin());
1753 finish = const_cast<CharT*>(rng.end());
1754 return true;
1755 }
1756
1757 bool operator<<(const iterator_range<const signed char*>& rng) BOOST_NOEXCEPT
1758 {
1759 return (*this) << iterator_range<char*>(
1760 const_cast<char*>(reinterpret_cast<const char*>(rng.begin())),
1761 const_cast<char*>(reinterpret_cast<const char*>(rng.end()))
1762 );
1763 }
1764
1765 bool operator<<(const iterator_range<const unsigned char*>& rng) BOOST_NOEXCEPT
1766 {
1767 return (*this) << iterator_range<char*>(
1768 const_cast<char*>(reinterpret_cast<const char*>(rng.begin())),
1769 const_cast<char*>(reinterpret_cast<const char*>(rng.end()))
1770 );
1771 }
1772
1773 bool operator<<(const iterator_range<signed char*>& rng) BOOST_NOEXCEPT
1774 {
1775 return (*this) << iterator_range<char*>(
1776 reinterpret_cast<char*>(rng.begin()),
1777 reinterpret_cast<char*>(rng.end())
1778 );
1779 }
1780
1781 bool operator<<(const iterator_range<unsigned char*>& rng) BOOST_NOEXCEPT
1782 {
1783 return (*this) << iterator_range<char*>(
1784 reinterpret_cast<char*>(rng.begin()),
1785 reinterpret_cast<char*>(rng.end())
1786 );
1787 }
1788
1789 bool operator<<(char ch) { return shl_char(ch); }
1790 bool operator<<(unsigned char ch) { return ((*this) << static_cast<char>(ch)); }
1791 bool operator<<(signed char ch) { return ((*this) << static_cast<char>(ch)); }
1792#if !defined(BOOST_LCAST_NO_WCHAR_T)
1793 bool operator<<(wchar_t const* str) { return shl_char_array(str); }
1794 bool operator<<(wchar_t * str) { return shl_char_array(str); }
1795#ifndef BOOST_NO_INTRINSIC_WCHAR_T
1796 bool operator<<(wchar_t ch) { return shl_char(ch); }
1797#endif
1798#endif
1799#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
1800 bool operator<<(char16_t ch) { return shl_char(ch); }
1801 bool operator<<(char16_t * str) { return shl_char_array(str); }
1802 bool operator<<(char16_t const * str) { return shl_char_array(str); }
1803#endif
1804#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
1805 bool operator<<(char32_t ch) { return shl_char(ch); }
1806 bool operator<<(char32_t * str) { return shl_char_array(str); }
1807 bool operator<<(char32_t const * str) { return shl_char_array(str); }
1808#endif
1809 bool operator<<(unsigned char const* ch) { return ((*this) << reinterpret_cast<char const*>(ch)); }
1810 bool operator<<(unsigned char * ch) { return ((*this) << reinterpret_cast<char *>(ch)); }
1811 bool operator<<(signed char const* ch) { return ((*this) << reinterpret_cast<char const*>(ch)); }
1812 bool operator<<(signed char * ch) { return ((*this) << reinterpret_cast<char *>(ch)); }
1813 bool operator<<(char const* str) { return shl_char_array(str); }
1814 bool operator<<(char* str) { return shl_char_array(str); }
1815 bool operator<<(short n) { return shl_signed(n); }
1816 bool operator<<(int n) { return shl_signed(n); }
1817 bool operator<<(long n) { return shl_signed(n); }
1818 bool operator<<(unsigned short n) { start = lcast_put_unsigned<Traits>(n, finish); return true; }
1819 bool operator<<(unsigned int n) { start = lcast_put_unsigned<Traits>(n, finish); return true; }
1820 bool operator<<(unsigned long n) { start = lcast_put_unsigned<Traits>(n, finish); return true; }
1821
1822#if defined(BOOST_HAS_LONG_LONG)
1823 bool operator<<(ndnboost::ulong_long_type n) { start = lcast_put_unsigned<Traits>(n, finish); return true; }
1824 bool operator<<(ndnboost::long_long_type n) { return shl_signed(n); }
1825#elif defined(BOOST_HAS_MS_INT64)
1826 bool operator<<(unsigned __int64 n) { start = lcast_put_unsigned<Traits>(n, finish); return true; }
1827 bool operator<<( __int64 n) { return shl_signed(n); }
1828#endif
1829
1830#ifdef BOOST_LCAST_HAS_INT128
1831 bool operator<<(const ndnboost::uint128_type& n) { start = lcast_put_unsigned<Traits>(n, finish); return true; }
1832 bool operator<<(const ndnboost::int128_type& n) { return shl_signed(n); }
1833#endif
1834
1835 bool operator<<(float val) { return shl_real_type(val, start, finish); }
1836 bool operator<<(double val) { return shl_real_type(val, start, finish); }
1837 bool operator<<(long double val) {
1838#ifndef __MINGW32__
1839 return shl_real_type(val, start, finish);
1840#else
1841 return shl_real_type(static_cast<double>(val), start, finish);
1842#endif
1843 }
1844
1845 template <std::size_t N>
1846 bool operator<<(ndnboost::array<CharT, N> const& input) BOOST_NOEXCEPT
1847 { return shl_char_array_limited(input.begin(), N); }
1848
1849 template <std::size_t N>
1850 bool operator<<(ndnboost::array<unsigned char, N> const& input) BOOST_NOEXCEPT
1851 { return ((*this) << reinterpret_cast<ndnboost::array<char, N> const& >(input)); }
1852
1853 template <std::size_t N>
1854 bool operator<<(ndnboost::array<signed char, N> const& input) BOOST_NOEXCEPT
1855 { return ((*this) << reinterpret_cast<ndnboost::array<char, N> const& >(input)); }
1856
1857 template <std::size_t N>
1858 bool operator<<(ndnboost::array<const CharT, N> const& input) BOOST_NOEXCEPT
1859 { return shl_char_array_limited(input.begin(), N); }
1860
1861 template <std::size_t N>
1862 bool operator<<(ndnboost::array<const unsigned char, N> const& input) BOOST_NOEXCEPT
1863 { return ((*this) << reinterpret_cast<ndnboost::array<const char, N> const& >(input)); }
1864
1865 template <std::size_t N>
1866 bool operator<<(ndnboost::array<const signed char, N> const& input) BOOST_NOEXCEPT
1867 { return ((*this) << reinterpret_cast<ndnboost::array<const char, N> const& >(input)); }
1868
1869#ifndef BOOST_NO_CXX11_HDR_ARRAY
1870 template <std::size_t N>
1871 bool operator<<(std::array<CharT, N> const& input) BOOST_NOEXCEPT
1872 {
1873 if (input.size()) return shl_char_array_limited(&input[0], N);
1874 else return true;
1875 }
1876
1877 template <std::size_t N>
1878 bool operator<<(std::array<unsigned char, N> const& input) BOOST_NOEXCEPT
1879 { return ((*this) << reinterpret_cast<ndnboost::array<char, N> const& >(input)); }
1880
1881 template <std::size_t N>
1882 bool operator<<(std::array<signed char, N> const& input) BOOST_NOEXCEPT
1883 { return ((*this) << reinterpret_cast<ndnboost::array<char, N> const& >(input)); }
1884
1885 template <std::size_t N>
1886 bool operator<<(std::array<const CharT, N> const& input) BOOST_NOEXCEPT
1887 {
1888 if (input.size()) return shl_char_array_limited(&input[0], N);
1889 else return true;
1890 }
1891
1892 template <std::size_t N>
1893 bool operator<<(std::array<const unsigned char, N> const& input) BOOST_NOEXCEPT
1894 { return ((*this) << reinterpret_cast<ndnboost::array<const char, N> const& >(input)); }
1895
1896 template <std::size_t N>
1897 bool operator<<(std::array<const signed char, N> const& input) BOOST_NOEXCEPT
1898 { return ((*this) << reinterpret_cast<ndnboost::array<const char, N> const& >(input)); }
1899#endif
1900
1901 template <class InStreamable>
1902 bool operator<<(const InStreamable& input) { return shl_input_streamable(input); }
1903
1904/************************************ HELPER FUNCTIONS FOR OPERATORS >> ( ... ) ********************************/
1905 private:
1906
1907 template <typename Type>
1908 bool shr_unsigned(Type& output)
1909 {
1910 if (start == finish) return false;
1911 CharT const minus = lcast_char_constants<CharT>::minus;
1912 CharT const plus = lcast_char_constants<CharT>::plus;
1913 bool has_minus = false;
1914
1915 /* We won`t use `start' any more, so no need in decrementing it after */
1916 if ( Traits::eq(minus,*start) )
1917 {
1918 ++start;
1919 has_minus = true;
1920 } else if ( Traits::eq( plus, *start ) )
1921 {
1922 ++start;
1923 }
1924
1925 bool const succeed = lcast_ret_unsigned<Traits>(output, start, finish);
1926
1927 if (has_minus) {
1928 output = static_cast<Type>(0u - output);
1929 }
1930
1931 return succeed;
1932 }
1933
1934 template <typename Type>
1935 bool shr_signed(Type& output)
1936 {
1937 if (start == finish) return false;
1938 CharT const minus = lcast_char_constants<CharT>::minus;
1939 CharT const plus = lcast_char_constants<CharT>::plus;
1940 typedef BOOST_DEDUCED_TYPENAME make_unsigned<Type>::type utype;
1941 utype out_tmp =0;
1942 bool has_minus = false;
1943
1944 /* We won`t use `start' any more, so no need in decrementing it after */
1945 if ( Traits::eq(minus,*start) )
1946 {
1947 ++start;
1948 has_minus = true;
1949 } else if ( Traits::eq(plus, *start) )
1950 {
1951 ++start;
1952 }
1953
1954 bool succeed = lcast_ret_unsigned<Traits>(out_tmp, start, finish);
1955 if (has_minus) {
1956 utype const comp_val = (static_cast<utype>(1) << std::numeric_limits<Type>::digits);
1957 succeed = succeed && out_tmp<=comp_val;
1958 output = static_cast<Type>(0u - out_tmp);
1959 } else {
1960 utype const comp_val = static_cast<utype>((std::numeric_limits<Type>::max)());
1961 succeed = succeed && out_tmp<=comp_val;
1962 output = out_tmp;
1963 }
1964 return succeed;
1965 }
1966
1967 template<typename InputStreamable>
1968 bool shr_using_base_class(InputStreamable& output)
1969 {
1970 BOOST_STATIC_ASSERT_MSG(
1971 (!ndnboost::is_pointer<InputStreamable>::value),
1972 "ndnboost::lexical_cast can not convert to pointers"
1973 );
1974
1975#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_LOCALE)
1976 BOOST_STATIC_ASSERT_MSG((ndnboost::is_same<char, CharT>::value),
1977 "ndnboost::lexical_cast can not convert, because your STL library does not "
1978 "support such conversions. Try updating it."
1979 );
1980#endif
1981
1982#if defined(BOOST_NO_STRINGSTREAM)
1983 std::istrstream stream(start, finish - start);
1984#else
1985
1986 buffer_t buf;
1987 buf.setbuf(start, finish - start);
1988#if defined(BOOST_NO_STD_LOCALE)
1989 std::istream stream(&buf);
1990#else
1991 std::basic_istream<CharT, Traits> stream(&buf);
1992#endif // BOOST_NO_STD_LOCALE
1993#endif // BOOST_NO_STRINGSTREAM
1994
1995 stream.unsetf(std::ios::skipws);
1996 lcast_set_precision(stream, static_cast<InputStreamable*>(0));
1997
1998 return stream >> output &&
1999 stream.get() ==
2000#if defined(__GNUC__) && (__GNUC__<3) && defined(BOOST_NO_STD_WSTRING)
2001 // GCC 2.9x lacks std::char_traits<>::eof().
2002 // We use BOOST_NO_STD_WSTRING to filter out STLport and libstdc++-v3
2003 // configurations, which do provide std::char_traits<>::eof().
2004
2005 EOF;
2006#else
2007 Traits::eof();
2008#endif
2009 }
2010
2011 template<class T>
2012 inline bool shr_xchar(T& output)
2013 {
2014 BOOST_STATIC_ASSERT_MSG(( sizeof(CharT) == sizeof(T) ),
2015 "ndnboost::lexical_cast does not support narrowing of character types."
2016 "Use ndnboost::locale instead" );
2017 bool const ok = (finish - start == 1);
2018 if (ok) {
2019 CharT out;
2020 Traits::assign(out, *start);
2021 output = static_cast<T>(out);
2022 }
2023 return ok;
2024 }
2025
2026/************************************ OPERATORS >> ( ... ) ********************************/
2027 public:
2028 bool operator>>(unsigned short& output) { return shr_unsigned(output); }
2029 bool operator>>(unsigned int& output) { return shr_unsigned(output); }
2030 bool operator>>(unsigned long int& output) { return shr_unsigned(output); }
2031 bool operator>>(short& output) { return shr_signed(output); }
2032 bool operator>>(int& output) { return shr_signed(output); }
2033 bool operator>>(long int& output) { return shr_signed(output); }
2034#if defined(BOOST_HAS_LONG_LONG)
2035 bool operator>>(ndnboost::ulong_long_type& output) { return shr_unsigned(output); }
2036 bool operator>>(ndnboost::long_long_type& output) { return shr_signed(output); }
2037#elif defined(BOOST_HAS_MS_INT64)
2038 bool operator>>(unsigned __int64& output) { return shr_unsigned(output); }
2039 bool operator>>(__int64& output) { return shr_signed(output); }
2040#endif
2041
2042#ifdef BOOST_LCAST_HAS_INT128
2043 bool operator>>(ndnboost::uint128_type& output) { return shr_unsigned(output); }
2044 bool operator>>(ndnboost::int128_type& output) { return shr_signed(output); }
2045#endif
2046
2047 bool operator>>(char& output) { return shr_xchar(output); }
2048 bool operator>>(unsigned char& output) { return shr_xchar(output); }
2049 bool operator>>(signed char& output) { return shr_xchar(output); }
2050#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
2051 bool operator>>(wchar_t& output) { return shr_xchar(output); }
2052#endif
2053#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
2054 bool operator>>(char16_t& output) { return shr_xchar(output); }
2055#endif
2056#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
2057 bool operator>>(char32_t& output) { return shr_xchar(output); }
2058#endif
2059 template<class Alloc>
2060 bool operator>>(std::basic_string<CharT,Traits,Alloc>& str) { str.assign(start, finish); return true; }
2061
2062 template<class Alloc>
2063 bool operator>>(ndnboost::container::basic_string<CharT,Traits,Alloc>& str) { str.assign(start, finish); return true; }
2064
2065
2066 private:
2067 template <std::size_t N, class ArrayT>
2068 bool shr_std_array(ArrayT& output) BOOST_NOEXCEPT
2069 {
2070 using namespace std;
2071 const std::size_t size = finish - start;
2072 if (size > N - 1) { // `-1` because we need to store \0 at the end
2073 return false;
2074 }
2075
2076 memcpy(&output[0], start, size * sizeof(CharT));
2077 output[size] = Traits::to_char_type(0);
2078 return true;
2079 }
2080
2081 public:
2082
2083 template <std::size_t N>
2084 bool operator>>(ndnboost::array<CharT, N>& output) BOOST_NOEXCEPT
2085 {
2086 return shr_std_array<N>(output);
2087 }
2088
2089 template <std::size_t N>
2090 bool operator>>(ndnboost::array<unsigned char, N>& output)
2091 {
2092 return ((*this) >> reinterpret_cast<ndnboost::array<char, N>& >(output));
2093 }
2094
2095 template <std::size_t N>
2096 bool operator>>(ndnboost::array<signed char, N>& output)
2097 {
2098 return ((*this) >> reinterpret_cast<ndnboost::array<char, N>& >(output));
2099 }
2100
2101#ifndef BOOST_NO_CXX11_HDR_ARRAY
2102 template <std::size_t N>
2103 bool operator>>(std::array<CharT, N>& output) BOOST_NOEXCEPT
2104 {
2105 return shr_std_array<N>(output);
2106 }
2107
2108 template <std::size_t N>
2109 bool operator>>(std::array<unsigned char, N>& output)
2110 {
2111 return ((*this) >> reinterpret_cast<std::array<char, N>& >(output));
2112 }
2113
2114 template <std::size_t N>
2115 bool operator>>(std::array<signed char, N>& output)
2116 {
2117 return ((*this) >> reinterpret_cast<std::array<char, N>& >(output));
2118 }
2119#endif
2120
2121
2122 /*
2123 * case "-0" || "0" || "+0" : output = false; return true;
2124 * case "1" || "+1": output = true; return true;
2125 * default: return false;
2126 */
2127 bool operator>>(bool& output) BOOST_NOEXCEPT
2128 {
2129 CharT const zero = lcast_char_constants<CharT>::zero;
2130 CharT const plus = lcast_char_constants<CharT>::plus;
2131 CharT const minus = lcast_char_constants<CharT>::minus;
2132
2133 switch(finish-start)
2134 {
2135 case 1:
2136 output = Traits::eq(start[0], zero+1);
2137 return output || Traits::eq(start[0], zero );
2138 case 2:
2139 if ( Traits::eq( plus, *start) )
2140 {
2141 ++start;
2142 output = Traits::eq(start[0], zero +1);
2143 return output || Traits::eq(start[0], zero );
2144 } else
2145 {
2146 output = false;
2147 return Traits::eq( minus, *start)
2148 && Traits::eq( zero, start[1]);
2149 }
2150 default:
2151 output = false; // Suppress warning about uninitalized variable
2152 return false;
2153 }
2154 }
2155
2156 bool operator>>(float& output) { return lcast_ret_float<Traits>(output,start,finish); }
2157
2158 private:
2159 // Not optimised converter
2160 template <class T>
2161 bool float_types_converter_internal(T& output, int /*tag*/) {
2162 if (parse_inf_nan(start, finish, output)) return true;
2163 bool return_value = shr_using_base_class(output);
2164
2165 /* Some compilers and libraries successfully
2166 * parse 'inf', 'INFINITY', '1.0E', '1.0E-'...
2167 * We are trying to provide a unified behaviour,
2168 * so we just forbid such conversions (as some
2169 * of the most popular compilers/libraries do)
2170 * */
2171 CharT const minus = lcast_char_constants<CharT>::minus;
2172 CharT const plus = lcast_char_constants<CharT>::plus;
2173 CharT const capital_e = lcast_char_constants<CharT>::capital_e;
2174 CharT const lowercase_e = lcast_char_constants<CharT>::lowercase_e;
2175 if ( return_value &&
2176 (
2177 Traits::eq(*(finish-1), lowercase_e) // 1.0e
2178 || Traits::eq(*(finish-1), capital_e) // 1.0E
2179 || Traits::eq(*(finish-1), minus) // 1.0e- or 1.0E-
2180 || Traits::eq(*(finish-1), plus) // 1.0e+ or 1.0E+
2181 )
2182 ) return false;
2183
2184 return return_value;
2185 }
2186
2187 // Optimised converter
2188 bool float_types_converter_internal(double& output,char /*tag*/) {
2189 return lcast_ret_float<Traits>(output,start,finish);
2190 }
2191 public:
2192
2193 bool operator>>(double& output)
2194 {
2195 /*
2196 * Some compilers implement long double as double. In that case these types have
2197 * same size, same precision, same max and min values... And it means,
2198 * that current implementation of lcast_ret_float cannot be used for type
2199 * double, because it will give a big precision loss.
2200 * */
2201 ndnboost::mpl::if_c<
2202#if (defined(BOOST_HAS_LONG_LONG) || defined(BOOST_HAS_MS_INT64)) && !defined(BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS)
2203 ndnboost::type_traits::ice_eq< sizeof(double), sizeof(long double) >::value,
2204#else
2205 1,
2206#endif
2207 int,
2208 char
2209 >::type tag = 0;
2210
2211 return float_types_converter_internal(output, tag);
2212 }
2213
2214 bool operator>>(long double& output)
2215 {
2216 int tag = 0;
2217 return float_types_converter_internal(output, tag);
2218 }
2219
2220 // Generic istream-based algorithm.
2221 // lcast_streambuf_for_target<InputStreamable>::value is true.
2222 template<typename InputStreamable>
2223 bool operator>>(InputStreamable& output) { return shr_using_base_class(output); }
2224 };
2225 }
2226
2227 namespace detail
2228 {
2229 template<typename T>
2230 struct is_stdstring
2231 {
2232 BOOST_STATIC_CONSTANT(bool, value = false );
2233 };
2234
2235 template<typename CharT, typename Traits, typename Alloc>
2236 struct is_stdstring< std::basic_string<CharT, Traits, Alloc> >
2237 {
2238 BOOST_STATIC_CONSTANT(bool, value = true );
2239 };
2240
2241 template<typename CharT, typename Traits, typename Alloc>
2242 struct is_stdstring< ndnboost::container::basic_string<CharT, Traits, Alloc> >
2243 {
2244 BOOST_STATIC_CONSTANT(bool, value = true );
2245 };
2246
2247 template<typename Target, typename Source>
2248 struct is_arithmetic_and_not_xchars
2249 {
2250 BOOST_STATIC_CONSTANT(bool, value =
2251 (
2252 ndnboost::type_traits::ice_and<
2253 ndnboost::is_arithmetic<Source>::value,
2254 ndnboost::is_arithmetic<Target>::value,
2255 ndnboost::type_traits::ice_not<
2256 detail::is_char_or_wchar<Target>::value
2257 >::value,
2258 ndnboost::type_traits::ice_not<
2259 detail::is_char_or_wchar<Source>::value
2260 >::value
2261 >::value
2262 )
2263 );
2264 };
2265
2266 /*
2267 * is_xchar_to_xchar<Target, Source>::value is true, when
2268 * Target and Souce are the same char types, or when
2269 * Target and Souce are char types of the same size.
2270 */
2271 template<typename Target, typename Source>
2272 struct is_xchar_to_xchar
2273 {
2274 BOOST_STATIC_CONSTANT(bool, value =
2275 (
2276 ndnboost::type_traits::ice_or<
2277 ndnboost::type_traits::ice_and<
2278 is_same<Source,Target>::value,
2279 is_char_or_wchar<Target>::value
2280 >::value,
2281 ndnboost::type_traits::ice_and<
2282 ndnboost::type_traits::ice_eq< sizeof(char),sizeof(Target)>::value,
2283 ndnboost::type_traits::ice_eq< sizeof(char),sizeof(Source)>::value,
2284 is_char_or_wchar<Target>::value,
2285 is_char_or_wchar<Source>::value
2286 >::value
2287 >::value
2288 )
2289 );
2290 };
2291
2292 template<typename Target, typename Source>
2293 struct is_char_array_to_stdstring
2294 {
2295 BOOST_STATIC_CONSTANT(bool, value = false );
2296 };
2297
2298 template<typename CharT, typename Traits, typename Alloc>
2299 struct is_char_array_to_stdstring< std::basic_string<CharT, Traits, Alloc>, CharT* >
2300 {
2301 BOOST_STATIC_CONSTANT(bool, value = true );
2302 };
2303
2304 template<typename CharT, typename Traits, typename Alloc>
2305 struct is_char_array_to_stdstring< std::basic_string<CharT, Traits, Alloc>, const CharT* >
2306 {
2307 BOOST_STATIC_CONSTANT(bool, value = true );
2308 };
2309
2310 template<typename CharT, typename Traits, typename Alloc>
2311 struct is_char_array_to_stdstring< ndnboost::container::basic_string<CharT, Traits, Alloc>, CharT* >
2312 {
2313 BOOST_STATIC_CONSTANT(bool, value = true );
2314 };
2315
2316 template<typename CharT, typename Traits, typename Alloc>
2317 struct is_char_array_to_stdstring< ndnboost::container::basic_string<CharT, Traits, Alloc>, const CharT* >
2318 {
2319 BOOST_STATIC_CONSTANT(bool, value = true );
2320 };
2321
2322#if (defined _MSC_VER)
2323# pragma warning( push )
2324# pragma warning( disable : 4701 ) // possible use of ... before initialization
2325# pragma warning( disable : 4702 ) // unreachable code
2326# pragma warning( disable : 4267 ) // conversion from 'size_t' to 'unsigned int'
2327#endif
2328 template<typename Target, typename Source>
2329 struct lexical_cast_do_cast
2330 {
2331 static inline Target lexical_cast_impl(const Source& arg)
2332 {
2333 typedef lexical_cast_stream_traits<Source, Target> stream_trait;
2334
2335 typedef detail::lexical_stream_limited_src<
2336 BOOST_DEDUCED_TYPENAME stream_trait::char_type,
2337 BOOST_DEDUCED_TYPENAME stream_trait::traits,
2338 stream_trait::requires_stringbuf
2339 > interpreter_type;
2340
2341 // Target type must be default constructible
2342 Target result;
2343
2344 BOOST_DEDUCED_TYPENAME stream_trait::char_type buf[stream_trait::len_t::value + 1];
2345 stream_trait::len_t::check_coverage();
2346
2347 interpreter_type interpreter(buf, buf + stream_trait::len_t::value + 1);
2348
2349 // Disabling ADL, by directly specifying operators.
2350 if(!(interpreter.operator <<(arg) && interpreter.operator >>(result)))
2351 BOOST_LCAST_THROW_BAD_CAST(Source, Target);
2352
2353 return result;
2354 }
2355 };
2356#if (defined _MSC_VER)
2357# pragma warning( pop )
2358#endif
2359
2360 template <typename Source>
2361 struct lexical_cast_copy
2362 {
2363 static inline const Source& lexical_cast_impl(const Source &arg) BOOST_NOEXCEPT
2364 {
2365 return arg;
2366 }
2367 };
2368
2369 template <class Source, class Target >
2370 struct detect_precision_loss
2371 {
2372 typedef ndnboost::numeric::Trunc<Source> Rounder;
2373 typedef Source source_type ;
2374
2375 typedef BOOST_DEDUCED_TYPENAME mpl::if_<
2376 ndnboost::is_arithmetic<Source>, Source, Source const&
2377 >::type argument_type ;
2378
2379 static source_type nearbyint ( argument_type s )
2380 {
2381 const source_type near_int = Rounder::nearbyint(s);
2382 if (near_int) {
2383 const source_type orig_div_round = s / near_int;
2384 const source_type eps = std::numeric_limits<source_type>::epsilon();
2385
2386 if ((orig_div_round > 1 ? orig_div_round - 1 : 1 - orig_div_round) > eps)
2387 BOOST_LCAST_THROW_BAD_CAST(Source, Target);
2388 }
2389
2390 return s ;
2391 }
2392
2393 typedef typename Rounder::round_style round_style;
2394 } ;
2395
2396 template <class Source, class Target >
2397 struct nothrow_overflow_handler
2398 {
2399 void operator() ( ndnboost::numeric::range_check_result r )
2400 {
2401 if (r != ndnboost::numeric::cInRange)
2402 BOOST_LCAST_THROW_BAD_CAST(Source, Target);
2403 }
2404 } ;
2405
2406 template <typename Target, typename Source>
2407 struct lexical_cast_dynamic_num_not_ignoring_minus
2408 {
2409 static inline Target lexical_cast_impl(const Source &arg)
2410 {
2411 return ndnboost::numeric::converter<
2412 Target,
2413 Source,
2414 ndnboost::numeric::conversion_traits<Target,Source>,
2415 nothrow_overflow_handler<Source, Target>,
2416 detect_precision_loss<Source, Target>
2417 >::convert(arg);
2418 }
2419 };
2420
2421 template <typename Target, typename Source>
2422 struct lexical_cast_dynamic_num_ignoring_minus
2423 {
2424 static inline Target lexical_cast_impl(const Source &arg)
2425 {
2426 typedef BOOST_DEDUCED_TYPENAME ndnboost::mpl::eval_if_c<
2427 ndnboost::is_float<Source>::value,
2428 ndnboost::mpl::identity<Source>,
2429 ndnboost::make_unsigned<Source>
2430 >::type usource_t;
2431
2432 typedef ndnboost::numeric::converter<
2433 Target,
2434 usource_t,
2435 ndnboost::numeric::conversion_traits<Target,usource_t>,
2436 nothrow_overflow_handler<usource_t, Target>,
2437 detect_precision_loss<usource_t, Target>
2438 > converter_t;
2439
2440 return (
2441 arg < 0 ? static_cast<Target>(0u - converter_t::convert(0u - arg)) : converter_t::convert(arg)
2442 );
2443 }
2444 };
2445
2446 /*
2447 * lexical_cast_dynamic_num follows the rules:
2448 * 1) If Source can be converted to Target without precision loss and
2449 * without overflows, then assign Source to Target and return
2450 *
2451 * 2) If Source is less than 0 and Target is an unsigned integer,
2452 * then negate Source, check the requirements of rule 1) and if
2453 * successful, assign static_casted Source to Target and return
2454 *
2455 * 3) Otherwise throw a bad_lexical_cast exception
2456 *
2457 *
2458 * Rule 2) required because ndnboost::lexical_cast has the behavior of
2459 * stringstream, which uses the rules of scanf for conversions. And
2460 * in the C99 standard for unsigned input value minus sign is
2461 * optional, so if a negative number is read, no errors will arise
2462 * and the result will be the two's complement.
2463 */
2464 template <typename Target, typename Source>
2465 struct lexical_cast_dynamic_num
2466 {
2467 static inline Target lexical_cast_impl(const Source &arg)
2468 {
2469 typedef BOOST_DEDUCED_TYPENAME ndnboost::mpl::if_c<
2470 ndnboost::type_traits::ice_and<
2471 ndnboost::type_traits::ice_or<
2472 ndnboost::is_signed<Source>::value,
2473 ndnboost::is_float<Source>::value
2474 >::value,
2475 ndnboost::type_traits::ice_not<
2476 ndnboost::is_same<Source, bool>::value
2477 >::value,
2478 ndnboost::type_traits::ice_not<
2479 ndnboost::is_same<Target, bool>::value
2480 >::value,
2481 ndnboost::is_unsigned<Target>::value
2482 >::value,
2483 lexical_cast_dynamic_num_ignoring_minus<Target, Source>,
2484 lexical_cast_dynamic_num_not_ignoring_minus<Target, Source>
2485 >::type caster_type;
2486
2487 return caster_type::lexical_cast_impl(arg);
2488 }
2489 };
2490 }
2491
2492 template <typename Target, typename Source>
2493 inline Target lexical_cast(const Source &arg)
2494 {
2495 typedef BOOST_DEDUCED_TYPENAME ndnboost::detail::array_to_pointer_decay<Source>::type src;
2496
2497 typedef BOOST_DEDUCED_TYPENAME ndnboost::type_traits::ice_or<
2498 ndnboost::detail::is_xchar_to_xchar<Target, src >::value,
2499 ndnboost::detail::is_char_array_to_stdstring<Target, src >::value,
2500 ndnboost::type_traits::ice_and<
2501 ndnboost::is_same<Target, src >::value,
2502 ndnboost::detail::is_stdstring<Target >::value
2503 >::value
2504 > shall_we_copy_t;
2505
2506 typedef BOOST_DEDUCED_TYPENAME
2507 ndnboost::detail::is_arithmetic_and_not_xchars<Target, src > shall_we_copy_with_dynamic_check_t;
2508
2509 typedef BOOST_DEDUCED_TYPENAME ndnboost::mpl::if_c<
2510 shall_we_copy_t::value,
2511 ndnboost::detail::lexical_cast_copy<src >,
2512 BOOST_DEDUCED_TYPENAME ndnboost::mpl::if_c<
2513 shall_we_copy_with_dynamic_check_t::value,
2514 ndnboost::detail::lexical_cast_dynamic_num<Target, src >,
2515 ndnboost::detail::lexical_cast_do_cast<Target, src >
2516 >::type
2517 >::type caster_type;
2518
2519 return caster_type::lexical_cast_impl(arg);
2520 }
2521
2522 template <typename Target>
2523 inline Target lexical_cast(const char* chars, std::size_t count)
2524 {
2525 return ::ndnboost::lexical_cast<Target>(
2526 ::ndnboost::iterator_range<const char*>(chars, chars + count)
2527 );
2528 }
2529
2530
2531 template <typename Target>
2532 inline Target lexical_cast(const unsigned char* chars, std::size_t count)
2533 {
2534 return ::ndnboost::lexical_cast<Target>(
2535 ::ndnboost::iterator_range<const unsigned char*>(chars, chars + count)
2536 );
2537 }
2538
2539 template <typename Target>
2540 inline Target lexical_cast(const signed char* chars, std::size_t count)
2541 {
2542 return ::ndnboost::lexical_cast<Target>(
2543 ::ndnboost::iterator_range<const signed char*>(chars, chars + count)
2544 );
2545 }
2546
2547#ifndef BOOST_LCAST_NO_WCHAR_T
2548 template <typename Target>
2549 inline Target lexical_cast(const wchar_t* chars, std::size_t count)
2550 {
2551 return ::ndnboost::lexical_cast<Target>(
2552 ::ndnboost::iterator_range<const wchar_t*>(chars, chars + count)
2553 );
2554 }
2555#endif
2556#ifndef BOOST_NO_CHAR16_T
2557 template <typename Target>
2558 inline Target lexical_cast(const char16_t* chars, std::size_t count)
2559 {
2560 return ::ndnboost::lexical_cast<Target>(
2561 ::ndnboost::iterator_range<const char16_t*>(chars, chars + count)
2562 );
2563 }
2564#endif
2565#ifndef BOOST_NO_CHAR32_T
2566 template <typename Target>
2567 inline Target lexical_cast(const char32_t* chars, std::size_t count)
2568 {
2569 return ::ndnboost::lexical_cast<Target>(
2570 ::ndnboost::iterator_range<const char32_t*>(chars, chars + count)
2571 );
2572 }
2573#endif
2574
2575} // namespace ndnboost
2576
2577#else // #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
2578
2579namespace ndnboost {
2580 namespace detail
2581 {
2582
2583 // selectors for choosing stream character type
2584 template<typename Type>
2585 struct stream_char
2586 {
2587 typedef char type;
2588 };
2589
2590#ifndef BOOST_LCAST_NO_WCHAR_T
2591#ifndef BOOST_NO_INTRINSIC_WCHAR_T
2592 template<>
2593 struct stream_char<wchar_t>
2594 {
2595 typedef wchar_t type;
2596 };
2597#endif
2598
2599 template<>
2600 struct stream_char<wchar_t *>
2601 {
2602 typedef wchar_t type;
2603 };
2604
2605 template<>
2606 struct stream_char<const wchar_t *>
2607 {
2608 typedef wchar_t type;
2609 };
2610
2611 template<>
2612 struct stream_char<std::wstring>
2613 {
2614 typedef wchar_t type;
2615 };
2616#endif
2617
2618 // stream wrapper for handling lexical conversions
2619 template<typename Target, typename Source, typename Traits>
2620 class lexical_stream
2621 {
2622 private:
2623 typedef typename widest_char<
2624 typename stream_char<Target>::type,
2625 typename stream_char<Source>::type>::type char_type;
2626
2627 typedef Traits traits_type;
2628
2629 public:
2630 lexical_stream(char_type* = 0, char_type* = 0)
2631 {
2632 stream.unsetf(std::ios::skipws);
2633 lcast_set_precision(stream, static_cast<Source*>(0), static_cast<Target*>(0) );
2634 }
2635 ~lexical_stream()
2636 {
2637 #if defined(BOOST_NO_STRINGSTREAM)
2638 stream.freeze(false);
2639 #endif
2640 }
2641 bool operator<<(const Source &input)
2642 {
2643 return !(stream << input).fail();
2644 }
2645 template<typename InputStreamable>
2646 bool operator>>(InputStreamable &output)
2647 {
2648 return !is_pointer<InputStreamable>::value &&
2649 stream >> output &&
2650 stream.get() ==
2651#if defined(__GNUC__) && (__GNUC__<3) && defined(BOOST_NO_STD_WSTRING)
2652// GCC 2.9x lacks std::char_traits<>::eof().
2653// We use BOOST_NO_STD_WSTRING to filter out STLport and libstdc++-v3
2654// configurations, which do provide std::char_traits<>::eof().
2655
2656 EOF;
2657#else
2658 traits_type::eof();
2659#endif
2660 }
2661
2662 bool operator>>(std::string &output)
2663 {
2664 #if defined(BOOST_NO_STRINGSTREAM)
2665 stream << '\0';
2666 #endif
2667 stream.str().swap(output);
2668 return true;
2669 }
2670 #ifndef BOOST_LCAST_NO_WCHAR_T
2671 bool operator>>(std::wstring &output)
2672 {
2673 stream.str().swap(output);
2674 return true;
2675 }
2676 #endif
2677
2678 private:
2679 #if defined(BOOST_NO_STRINGSTREAM)
2680 std::strstream stream;
2681 #elif defined(BOOST_NO_STD_LOCALE)
2682 std::stringstream stream;
2683 #else
2684 std::basic_stringstream<char_type,traits_type> stream;
2685 #endif
2686 };
2687 }
2688
2689 // call-by-value fallback version (deprecated)
2690
2691 template<typename Target, typename Source>
2692 Target lexical_cast(Source arg)
2693 {
2694 typedef typename detail::widest_char<
2695 BOOST_DEDUCED_TYPENAME detail::stream_char<Target>::type
2696 , BOOST_DEDUCED_TYPENAME detail::stream_char<Source>::type
2697 >::type char_type;
2698
2699 typedef std::char_traits<char_type> traits;
2700 detail::lexical_stream<Target, Source, traits> interpreter;
2701 Target result;
2702
2703 if(!(interpreter << arg && interpreter >> result))
2704 BOOST_LCAST_THROW_BAD_CAST(Source, Target);
2705 return result;
2706 }
2707
2708} // namespace ndnboost
2709
2710#endif
2711
2712// Copyright Kevlin Henney, 2000-2005.
2713// Copyright Alexander Nasonov, 2006-2010.
2714// Copyright Antony Polukhin, 2011-2013.
2715//
2716// Distributed under the Boost Software License, Version 1.0. (See
2717// accompanying file LICENSE_1_0.txt or copy at
2718// http://www.boost.org/LICENSE_1_0.txt)
2719
2720#undef BOOST_LCAST_THROW_BAD_CAST
2721#undef BOOST_LCAST_NO_WCHAR_T
2722#undef BOOST_LCAST_HAS_INT128
2723
2724#endif // BOOST_LEXICAL_CAST_INCLUDED
2725