00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00124 #ifndef LITE_XFORMAT_HPP
00125 #define LITE_XFORMAT_HPP
00126
00127 #ifdef _MSC_VER
00128 #pragma warning (push)
00129 #pragma warning (disable:4996)
00130 #endif
00131
00132 #ifndef __LINE__ // true when Doxygen is processing the file
00133 #define DOCUMENTATION_ONLY
00134 #endif
00135
00136 #define LITE_XFORMAT_VERSION 1007
00137
00138 #include <locale>
00139 #include <iostream>
00140 #include <sstream>
00141 #include <stdexcept>
00142 #include <typeinfo>
00143
00144 #ifndef LITE_ASSERT
00145 #define LITE_ASSERT(x)
00146 #define LITE_ASSERT_LOCAL 1
00147 #endif // LITE_ASSERT
00148
00149 namespace lite
00150 {
00151
00152 class format_error;
00153 class argument_index_error;
00154 class input_mismatch_error;
00155 class conversion_error;
00156
00157 template<
00158 typename _char_type =char,
00159 typename _traits_type =std::char_traits<_char_type>,
00160 typename _alloc_type =std::allocator<_char_type> >
00161 class basic_conversion;
00162
00164 typedef basic_conversion<char> conversion;
00165
00167 typedef basic_conversion<wchar_t> wconversion;
00168
00169
00170
00171
00172
00270 #ifdef DOCUMENTATION_ONLY
00271
00282 template<
00283 typename _char_type,
00284 typename _traits_type,
00285 typename _argument1_type,
00286 ...,
00287 typename _argumentN_type>
00288 std::basic_ostream<_char_type, _traits_type>&
00289 xprintf(std::basic_ostream<_char_type, _traits_type>& os,
00290 const _char_type* format,
00291 const _argument1_type& arg1,
00292 ...,
00293 const _argumentN_type& argN);
00294 #endif // DOCUMENTATION_ONLY
00295
00296 template<
00297 typename _char_type,
00298 typename _traits_type>
00299 std::basic_ostream<_char_type, _traits_type>&
00300 xprintf(std::basic_ostream<_char_type, _traits_type>& os,
00301 const _char_type* format);
00302
00303 template<
00304 typename _char_type,
00305 typename _traits_type,
00306 typename _argument1_type>
00307 std::basic_ostream<_char_type, _traits_type>&
00308 xprintf(std::basic_ostream<_char_type, _traits_type>& os,
00309 const _char_type* format,
00310 const _argument1_type& arg1);
00311
00312 template<
00313 typename _char_type,
00314 typename _traits_type,
00315 typename _argument1_type,
00316 typename _argument2_type>
00317 std::basic_ostream<_char_type, _traits_type>&
00318 xprintf(std::basic_ostream<_char_type, _traits_type>& os,
00319 const _char_type* format,
00320 const _argument1_type& arg1,
00321 const _argument2_type& arg2);
00322
00323 template<
00324 typename _char_type,
00325 typename _traits_type,
00326 typename _argument1_type,
00327 typename _argument2_type,
00328 typename _argument3_type>
00329 std::basic_ostream<_char_type, _traits_type>&
00330 xprintf(std::basic_ostream<_char_type, _traits_type>& os,
00331 const _char_type* format,
00332 const _argument1_type& arg1,
00333 const _argument2_type& arg2,
00334 const _argument3_type& arg3);
00335
00336 template<
00337 typename _char_type,
00338 typename _traits_type,
00339 typename _argument1_type,
00340 typename _argument2_type,
00341 typename _argument3_type,
00342 typename _argument4_type>
00343 std::basic_ostream<_char_type, _traits_type>&
00344 xprintf(std::basic_ostream<_char_type, _traits_type>& os,
00345 const _char_type* format,
00346 const _argument1_type& arg1,
00347 const _argument2_type& arg2,
00348 const _argument3_type& arg3,
00349 const _argument4_type& arg4);
00350
00351 template<
00352 typename _char_type,
00353 typename _traits_type,
00354 typename _argument1_type,
00355 typename _argument2_type,
00356 typename _argument3_type,
00357 typename _argument4_type,
00358 typename _argument5_type>
00359 std::basic_ostream<_char_type, _traits_type>&
00360 xprintf(std::basic_ostream<_char_type, _traits_type>& os,
00361 const _char_type* format,
00362 const _argument1_type& arg1,
00363 const _argument2_type& arg2,
00364 const _argument3_type& arg3,
00365 const _argument4_type& arg4,
00366 const _argument5_type& arg5);
00367
00368 template<
00369 typename _char_type,
00370 typename _traits_type,
00371 typename _argument1_type,
00372 typename _argument2_type,
00373 typename _argument3_type,
00374 typename _argument4_type,
00375 typename _argument5_type,
00376 typename _argument6_type>
00377 std::basic_ostream<_char_type, _traits_type>&
00378 xprintf(std::basic_ostream<_char_type, _traits_type>& os,
00379 const _char_type* format,
00380 const _argument1_type& arg1,
00381 const _argument2_type& arg2,
00382 const _argument3_type& arg3,
00383 const _argument4_type& arg4,
00384 const _argument5_type& arg5,
00385 const _argument6_type& arg6);
00386
00387 template<
00388 typename _char_type,
00389 typename _traits_type,
00390 typename _argument1_type,
00391 typename _argument2_type,
00392 typename _argument3_type,
00393 typename _argument4_type,
00394 typename _argument5_type,
00395 typename _argument6_type,
00396 typename _argument7_type>
00397 std::basic_ostream<_char_type, _traits_type>&
00398 xprintf(std::basic_ostream<_char_type, _traits_type>& os,
00399 const _char_type* format,
00400 const _argument1_type& arg1,
00401 const _argument2_type& arg2,
00402 const _argument3_type& arg3,
00403 const _argument4_type& arg4,
00404 const _argument5_type& arg5,
00405 const _argument6_type& arg6,
00406 const _argument7_type& arg7);
00407
00408 template<
00409 typename _char_type,
00410 typename _traits_type,
00411 typename _argument1_type,
00412 typename _argument2_type,
00413 typename _argument3_type,
00414 typename _argument4_type,
00415 typename _argument5_type,
00416 typename _argument6_type,
00417 typename _argument7_type,
00418 typename _argument8_type>
00419 std::basic_ostream<_char_type, _traits_type>&
00420 xprintf(std::basic_ostream<_char_type, _traits_type>& os,
00421 const _char_type* format,
00422 const _argument1_type& arg1,
00423 const _argument2_type& arg2,
00424 const _argument3_type& arg3,
00425 const _argument4_type& arg4,
00426 const _argument5_type& arg5,
00427 const _argument6_type& arg6,
00428 const _argument7_type& arg7,
00429 const _argument8_type& arg8);
00430
00431 template<
00432 typename _char_type,
00433 typename _traits_type,
00434 typename _argument1_type,
00435 typename _argument2_type,
00436 typename _argument3_type,
00437 typename _argument4_type,
00438 typename _argument5_type,
00439 typename _argument6_type,
00440 typename _argument7_type,
00441 typename _argument8_type,
00442 typename _argument9_type>
00443 std::basic_ostream<_char_type, _traits_type>&
00444 xprintf(std::basic_ostream<_char_type, _traits_type>& os,
00445 const _char_type* format,
00446 const _argument1_type& arg1,
00447 const _argument2_type& arg2,
00448 const _argument3_type& arg3,
00449 const _argument4_type& arg4,
00450 const _argument5_type& arg5,
00451 const _argument6_type& arg6,
00452 const _argument7_type& arg7,
00453 const _argument8_type& arg8,
00454 const _argument9_type& arg9);
00455
00456 template<
00457 typename _char_type,
00458 typename _traits_type,
00459 typename _argument1_type,
00460 typename _argument2_type,
00461 typename _argument3_type,
00462 typename _argument4_type,
00463 typename _argument5_type,
00464 typename _argument6_type,
00465 typename _argument7_type,
00466 typename _argument8_type,
00467 typename _argument9_type,
00468 typename _argument10_type>
00469 std::basic_ostream<_char_type, _traits_type>&
00470 xprintf(std::basic_ostream<_char_type, _traits_type>& os,
00471 const _char_type* format,
00472 const _argument1_type& arg1,
00473 const _argument2_type& arg2,
00474 const _argument3_type& arg3,
00475 const _argument4_type& arg4,
00476 const _argument5_type& arg5,
00477 const _argument6_type& arg6,
00478 const _argument7_type& arg7,
00479 const _argument8_type& arg8,
00480 const _argument9_type& arg9,
00481 const _argument10_type& arg10);
00482
00483
00484
00485 #ifdef DOCUMENTATION_ONLY
00486
00497 template<
00498 typename _char_type,
00499 typename _traits_type,
00500 typename _argument1_type,
00501 ...,
00502 typename _argumentN_type>
00503 std::basic_string<_char_type>
00504 xprintf(const _char_type* format,
00505 const _argument1_type& arg1,
00506 ...,
00507 const _argumentN_type& argN);
00508 #endif // DOCUMENTATION_ONLY
00509
00510 template<
00511 typename _char_type>
00512 std::basic_string<_char_type>
00513 xprintf(const _char_type* format);
00514
00515 template<
00516 typename _char_type,
00517 typename _argument1_type>
00518 std::basic_string<_char_type>
00519 xprintf(const _char_type* format,
00520 const _argument1_type& arg1);
00521
00522 template<
00523 typename _char_type,
00524 typename _argument1_type,
00525 typename _argument2_type>
00526 std::basic_string<_char_type>
00527 xprintf(const _char_type* format,
00528 const _argument1_type& arg1,
00529 const _argument2_type& arg2);
00530
00531 template<
00532 typename _char_type,
00533 typename _argument1_type,
00534 typename _argument2_type,
00535 typename _argument3_type>
00536 std::basic_string<_char_type>
00537 xprintf(const _char_type* format,
00538 const _argument1_type& arg1,
00539 const _argument2_type& arg2,
00540 const _argument3_type& arg3);
00541
00542 template<
00543 typename _char_type,
00544 typename _argument1_type,
00545 typename _argument2_type,
00546 typename _argument3_type,
00547 typename _argument4_type>
00548 std::basic_string<_char_type>
00549 xprintf(const _char_type* format,
00550 const _argument1_type& arg1,
00551 const _argument2_type& arg2,
00552 const _argument3_type& arg3,
00553 const _argument4_type& arg4);
00554
00555 template<
00556 typename _char_type,
00557 typename _argument1_type,
00558 typename _argument2_type,
00559 typename _argument3_type,
00560 typename _argument4_type,
00561 typename _argument5_type>
00562 std::basic_string<_char_type>
00563 xprintf(const _char_type* format,
00564 const _argument1_type& arg1,
00565 const _argument2_type& arg2,
00566 const _argument3_type& arg3,
00567 const _argument4_type& arg4,
00568 const _argument5_type& arg5);
00569
00570 template<
00571 typename _char_type,
00572 typename _argument1_type,
00573 typename _argument2_type,
00574 typename _argument3_type,
00575 typename _argument4_type,
00576 typename _argument5_type,
00577 typename _argument6_type>
00578 std::basic_string<_char_type>
00579 xprintf(const _char_type* format,
00580 const _argument1_type& arg1,
00581 const _argument2_type& arg2,
00582 const _argument3_type& arg3,
00583 const _argument4_type& arg4,
00584 const _argument5_type& arg5,
00585 const _argument6_type& arg6);
00586
00587 template<
00588 typename _char_type,
00589 typename _argument1_type,
00590 typename _argument2_type,
00591 typename _argument3_type,
00592 typename _argument4_type,
00593 typename _argument5_type,
00594 typename _argument6_type,
00595 typename _argument7_type>
00596 std::basic_string<_char_type>
00597 xprintf(const _char_type* format,
00598 const _argument1_type& arg1,
00599 const _argument2_type& arg2,
00600 const _argument3_type& arg3,
00601 const _argument4_type& arg4,
00602 const _argument5_type& arg5,
00603 const _argument6_type& arg6,
00604 const _argument7_type& arg7);
00605
00606 template<
00607 typename _char_type,
00608 typename _argument1_type,
00609 typename _argument2_type,
00610 typename _argument3_type,
00611 typename _argument4_type,
00612 typename _argument5_type,
00613 typename _argument6_type,
00614 typename _argument7_type,
00615 typename _argument8_type>
00616 std::basic_string<_char_type>
00617 xprintf(const _char_type* format,
00618 const _argument1_type& arg1,
00619 const _argument2_type& arg2,
00620 const _argument3_type& arg3,
00621 const _argument4_type& arg4,
00622 const _argument5_type& arg5,
00623 const _argument6_type& arg6,
00624 const _argument7_type& arg7,
00625 const _argument8_type& arg8);
00626
00627 template<
00628 typename _char_type,
00629 typename _argument1_type,
00630 typename _argument2_type,
00631 typename _argument3_type,
00632 typename _argument4_type,
00633 typename _argument5_type,
00634 typename _argument6_type,
00635 typename _argument7_type,
00636 typename _argument8_type,
00637 typename _argument9_type>
00638 std::basic_string<_char_type>
00639 xprintf(const _char_type* format,
00640 const _argument1_type& arg1,
00641 const _argument2_type& arg2,
00642 const _argument3_type& arg3,
00643 const _argument4_type& arg4,
00644 const _argument5_type& arg5,
00645 const _argument6_type& arg6,
00646 const _argument7_type& arg7,
00647 const _argument8_type& arg8,
00648 const _argument9_type& arg9);
00649
00650 template<
00651 typename _char_type,
00652 typename _argument1_type,
00653 typename _argument2_type,
00654 typename _argument3_type,
00655 typename _argument4_type,
00656 typename _argument5_type,
00657 typename _argument6_type,
00658 typename _argument7_type,
00659 typename _argument8_type,
00660 typename _argument9_type,
00661 typename _argument10_type>
00662 std::basic_string<_char_type>
00663 xprintf(const _char_type* format,
00664 const _argument1_type& arg1,
00665 const _argument2_type& arg2,
00666 const _argument3_type& arg3,
00667 const _argument4_type& arg4,
00668 const _argument5_type& arg5,
00669 const _argument6_type& arg6,
00670 const _argument7_type& arg7,
00671 const _argument8_type& arg8,
00672 const _argument9_type& arg9,
00673 const _argument10_type& arg10);
00674
00675
00676
00690 template<typename _char_type, typename _traits_type, typename _argument_iter_type>
00691 std::basic_ostream<_char_type, _traits_type>&
00692 xprintf_range(std::basic_ostream<_char_type, _traits_type>& os,
00693 const _char_type* format_begin,
00694 const _char_type* format_end,
00695 _argument_iter_type first,
00696 _argument_iter_type last);
00697
00710 template<typename _char_type, typename _traits_type, typename _argument_iter_type>
00711 std::basic_ostream<_char_type, _traits_type>&
00712 xprintf_range(std::basic_ostream<_char_type, _traits_type>& os,
00713 const _char_type* format,
00714 _argument_iter_type first,
00715 _argument_iter_type last);
00716
00725 template<typename _char_type, typename _traits_type, typename _argument_type>
00726 inline std::basic_ostream<_char_type, _traits_type>&
00727 xprintf_one(std::basic_ostream<_char_type, _traits_type>& os,
00728 const _char_type* fmt_begin,
00729 const _char_type* fmt_end,
00730 const _argument_type& argument);
00731
00732
00733
00734
00735
00768 #ifdef DOCUMENTATION_ONLY
00769
00782 template<
00783 typename _char_type,
00784 typename _traits_type,
00785 typename _argument1_type,
00786 ...,
00787 typename _argumentN_type>
00788 std::basic_istream<_char_type, _traits_type>&
00789 xscanf(std::basic_istream<_char_type, _traits_type>& is,
00790 const _char_type* format,
00791 _argument1_type& arg1,
00792 ...,
00793 _argumentN_type& argN);
00794 #endif // DOCUMENTATION_ONLY
00795
00796 template<
00797 typename _char_type,
00798 typename _traits_type>
00799 std::basic_istream<_char_type, _traits_type>&
00800 xscanf(std::basic_istream<_char_type, _traits_type>& is,
00801 const _char_type* format);
00802
00803 template<
00804 typename _char_type,
00805 typename _traits_type,
00806 typename _argument1_type>
00807 std::basic_istream<_char_type, _traits_type>&
00808 xscanf(std::basic_istream<_char_type, _traits_type>& is,
00809 const _char_type* format,
00810 _argument1_type& arg1);
00811
00812 template<
00813 typename _char_type,
00814 typename _traits_type,
00815 typename _argument1_type,
00816 typename _argument2_type>
00817 std::basic_istream<_char_type, _traits_type>&
00818 xscanf(std::basic_istream<_char_type, _traits_type>& is,
00819 const _char_type* format,
00820 _argument1_type& arg1,
00821 _argument2_type& arg2);
00822
00823 template<
00824 typename _char_type,
00825 typename _traits_type,
00826 typename _argument1_type,
00827 typename _argument2_type,
00828 typename _argument3_type>
00829 std::basic_istream<_char_type, _traits_type>&
00830 xscanf(std::basic_istream<_char_type, _traits_type>& is,
00831 const _char_type* format,
00832 _argument1_type& arg1,
00833 _argument2_type& arg2,
00834 _argument3_type& arg3);
00835
00836 template<
00837 typename _char_type,
00838 typename _traits_type,
00839 typename _argument1_type,
00840 typename _argument2_type,
00841 typename _argument3_type,
00842 typename _argument4_type>
00843 std::basic_istream<_char_type, _traits_type>&
00844 xscanf(std::basic_istream<_char_type, _traits_type>& is,
00845 const _char_type* format,
00846 _argument1_type& arg1,
00847 _argument2_type& arg2,
00848 _argument3_type& arg3,
00849 _argument4_type& arg4);
00850
00851 template<
00852 typename _char_type,
00853 typename _traits_type,
00854 typename _argument1_type,
00855 typename _argument2_type,
00856 typename _argument3_type,
00857 typename _argument4_type,
00858 typename _argument5_type>
00859 std::basic_istream<_char_type, _traits_type>&
00860 xscanf(std::basic_istream<_char_type, _traits_type>& is,
00861 const _char_type* format,
00862 _argument1_type& arg1,
00863 _argument2_type& arg2,
00864 _argument3_type& arg3,
00865 _argument4_type& arg4,
00866 _argument5_type& arg5);
00867
00868 template<
00869 typename _char_type,
00870 typename _traits_type,
00871 typename _argument1_type,
00872 typename _argument2_type,
00873 typename _argument3_type,
00874 typename _argument4_type,
00875 typename _argument5_type,
00876 typename _argument6_type>
00877 std::basic_istream<_char_type, _traits_type>&
00878 xscanf(std::basic_istream<_char_type, _traits_type>& is,
00879 const _char_type* format,
00880 _argument1_type& arg1,
00881 _argument2_type& arg2,
00882 _argument3_type& arg3,
00883 _argument4_type& arg4,
00884 _argument5_type& arg5,
00885 _argument6_type& arg6);
00886
00887 template<
00888 typename _char_type,
00889 typename _traits_type,
00890 typename _argument1_type,
00891 typename _argument2_type,
00892 typename _argument3_type,
00893 typename _argument4_type,
00894 typename _argument5_type,
00895 typename _argument6_type,
00896 typename _argument7_type>
00897 std::basic_istream<_char_type, _traits_type>&
00898 xscanf(std::basic_istream<_char_type, _traits_type>& is,
00899 const _char_type* format,
00900 _argument1_type& arg1,
00901 _argument2_type& arg2,
00902 _argument3_type& arg3,
00903 _argument4_type& arg4,
00904 _argument5_type& arg5,
00905 _argument6_type& arg6,
00906 _argument7_type& arg7);
00907
00908 template<
00909 typename _char_type,
00910 typename _traits_type,
00911 typename _argument1_type,
00912 typename _argument2_type,
00913 typename _argument3_type,
00914 typename _argument4_type,
00915 typename _argument5_type,
00916 typename _argument6_type,
00917 typename _argument7_type,
00918 typename _argument8_type>
00919 std::basic_istream<_char_type, _traits_type>&
00920 xscanf(std::basic_istream<_char_type, _traits_type>& is,
00921 const _char_type* format,
00922 _argument1_type& arg1,
00923 _argument2_type& arg2,
00924 _argument3_type& arg3,
00925 _argument4_type& arg4,
00926 _argument5_type& arg5,
00927 _argument6_type& arg6,
00928 _argument7_type& arg7,
00929 _argument8_type& arg8);
00930
00931 template<
00932 typename _char_type,
00933 typename _traits_type,
00934 typename _argument1_type,
00935 typename _argument2_type,
00936 typename _argument3_type,
00937 typename _argument4_type,
00938 typename _argument5_type,
00939 typename _argument6_type,
00940 typename _argument7_type,
00941 typename _argument8_type,
00942 typename _argument9_type>
00943 std::basic_istream<_char_type, _traits_type>&
00944 xscanf(std::basic_istream<_char_type, _traits_type>& is,
00945 const _char_type* format,
00946 _argument1_type& arg1,
00947 _argument2_type& arg2,
00948 _argument3_type& arg3,
00949 _argument4_type& arg4,
00950 _argument5_type& arg5,
00951 _argument6_type& arg6,
00952 _argument7_type& arg7,
00953 _argument8_type& arg8,
00954 _argument9_type& arg9);
00955
00956 template<
00957 typename _char_type,
00958 typename _traits_type,
00959 typename _argument1_type,
00960 typename _argument2_type,
00961 typename _argument3_type,
00962 typename _argument4_type,
00963 typename _argument5_type,
00964 typename _argument6_type,
00965 typename _argument7_type,
00966 typename _argument8_type,
00967 typename _argument9_type,
00968 typename _argument10_type>
00969 std::basic_istream<_char_type, _traits_type>&
00970 xscanf(std::basic_istream<_char_type, _traits_type>& is,
00971 const _char_type* format,
00972 _argument1_type& arg1,
00973 _argument2_type& arg2,
00974 _argument3_type& arg3,
00975 _argument4_type& arg4,
00976 _argument5_type& arg5,
00977 _argument6_type& arg6,
00978 _argument7_type& arg7,
00979 _argument8_type& arg8,
00980 _argument9_type& arg9,
00981 _argument10_type& arg10);
00982
00983
00984
00985 #ifdef DOCUMENTATION_ONLY
00986
01004 template<
01005 typename _char_type,
01006 typename _traits_type,
01007 typename _alloc_type,
01008 typename _argument1_type,
01009 ...,
01010 typename _argumentN_type>
01011 std::ios_base::iostate
01012 xscanf(const std::basic_string<_char_type, _traits_type, _alloc_type>& str,
01013 const _char_type* format,
01014 _argument1_type& arg1,
01015 ...,
01016 _argumentN_type& argN);
01017 #endif // DOCUMENTATION_ONLY
01018
01019
01020 template<
01021 typename _char_type,
01022 typename _traits_type,
01023 typename _alloc_type>
01024 std::ios_base::iostate
01025 xscanf(const std::basic_string<_char_type, _traits_type, _alloc_type>& str,
01026 const _char_type* format);
01027
01028 template<
01029 typename _char_type,
01030 typename _traits_type,
01031 typename _alloc_type,
01032 typename _argument1_type>
01033 std::ios_base::iostate
01034 xscanf(const std::basic_string<_char_type, _traits_type, _alloc_type>& str,
01035 const _char_type* format,
01036 _argument1_type& arg1);
01037
01038 template<
01039 typename _char_type,
01040 typename _traits_type,
01041 typename _alloc_type,
01042 typename _argument1_type,
01043 typename _argument2_type>
01044 std::ios_base::iostate
01045 xscanf(const std::basic_string<_char_type, _traits_type, _alloc_type>& str,
01046 const _char_type* format,
01047 _argument1_type& arg1,
01048 _argument2_type& arg2);
01049
01050 template<
01051 typename _char_type,
01052 typename _traits_type,
01053 typename _alloc_type,
01054 typename _argument1_type,
01055 typename _argument2_type,
01056 typename _argument3_type>
01057 std::ios_base::iostate
01058 xscanf(const std::basic_string<_char_type, _traits_type, _alloc_type>& str,
01059 const _char_type* format,
01060 _argument1_type& arg1,
01061 _argument2_type& arg2,
01062 _argument3_type& arg3);
01063
01064 template<
01065 typename _char_type,
01066 typename _traits_type,
01067 typename _alloc_type,
01068 typename _argument1_type,
01069 typename _argument2_type,
01070 typename _argument3_type,
01071 typename _argument4_type>
01072 std::ios_base::iostate
01073 xscanf(const std::basic_string<_char_type, _traits_type, _alloc_type>& str,
01074 const _char_type* format,
01075 _argument1_type& arg1,
01076 _argument2_type& arg2,
01077 _argument3_type& arg3,
01078 _argument4_type& arg4);
01079
01080 template<
01081 typename _char_type,
01082 typename _traits_type,
01083 typename _alloc_type,
01084 typename _argument1_type,
01085 typename _argument2_type,
01086 typename _argument3_type,
01087 typename _argument4_type,
01088 typename _argument5_type>
01089 std::ios_base::iostate
01090 xscanf(const std::basic_string<_char_type, _traits_type, _alloc_type>& str,
01091 const _char_type* format,
01092 _argument1_type& arg1,
01093 _argument2_type& arg2,
01094 _argument3_type& arg3,
01095 _argument4_type& arg4,
01096 _argument5_type& arg5);
01097
01098 template<
01099 typename _char_type,
01100 typename _traits_type,
01101 typename _alloc_type,
01102 typename _argument1_type,
01103 typename _argument2_type,
01104 typename _argument3_type,
01105 typename _argument4_type,
01106 typename _argument5_type,
01107 typename _argument6_type>
01108 std::ios_base::iostate
01109 xscanf(const std::basic_string<_char_type, _traits_type, _alloc_type>& str,
01110 const _char_type* format,
01111 _argument1_type& arg1,
01112 _argument2_type& arg2,
01113 _argument3_type& arg3,
01114 _argument4_type& arg4,
01115 _argument5_type& arg5,
01116 _argument6_type& arg6);
01117
01118 template<
01119 typename _char_type,
01120 typename _traits_type,
01121 typename _alloc_type,
01122 typename _argument1_type,
01123 typename _argument2_type,
01124 typename _argument3_type,
01125 typename _argument4_type,
01126 typename _argument5_type,
01127 typename _argument6_type,
01128 typename _argument7_type>
01129 std::ios_base::iostate
01130 xscanf(const std::basic_string<_char_type, _traits_type, _alloc_type>& str,
01131 const _char_type* format,
01132 _argument1_type& arg1,
01133 _argument2_type& arg2,
01134 _argument3_type& arg3,
01135 _argument4_type& arg4,
01136 _argument5_type& arg5,
01137 _argument6_type& arg6,
01138 _argument7_type& arg7);
01139
01140 template<
01141 typename _char_type,
01142 typename _traits_type,
01143 typename _alloc_type,
01144 typename _argument1_type,
01145 typename _argument2_type,
01146 typename _argument3_type,
01147 typename _argument4_type,
01148 typename _argument5_type,
01149 typename _argument6_type,
01150 typename _argument7_type,
01151 typename _argument8_type>
01152 std::ios_base::iostate
01153 xscanf(const std::basic_string<_char_type, _traits_type, _alloc_type>& str,
01154 const _char_type* format,
01155 _argument1_type& arg1,
01156 _argument2_type& arg2,
01157 _argument3_type& arg3,
01158 _argument4_type& arg4,
01159 _argument5_type& arg5,
01160 _argument6_type& arg6,
01161 _argument7_type& arg7,
01162 _argument8_type& arg8);
01163
01164 template<
01165 typename _char_type,
01166 typename _traits_type,
01167 typename _alloc_type,
01168 typename _argument1_type,
01169 typename _argument2_type,
01170 typename _argument3_type,
01171 typename _argument4_type,
01172 typename _argument5_type,
01173 typename _argument6_type,
01174 typename _argument7_type,
01175 typename _argument8_type,
01176 typename _argument9_type>
01177 std::ios_base::iostate
01178 xscanf(const std::basic_string<_char_type, _traits_type, _alloc_type>& str,
01179 const _char_type* format,
01180 _argument1_type& arg1,
01181 _argument2_type& arg2,
01182 _argument3_type& arg3,
01183 _argument4_type& arg4,
01184 _argument5_type& arg5,
01185 _argument6_type& arg6,
01186 _argument7_type& arg7,
01187 _argument8_type& arg8,
01188 _argument9_type& arg9);
01189
01190 template<
01191 typename _char_type,
01192 typename _traits_type,
01193 typename _alloc_type,
01194 typename _argument1_type,
01195 typename _argument2_type,
01196 typename _argument3_type,
01197 typename _argument4_type,
01198 typename _argument5_type,
01199 typename _argument6_type,
01200 typename _argument7_type,
01201 typename _argument8_type,
01202 typename _argument9_type,
01203 typename _argument10_type>
01204 std::ios_base::iostate
01205 xscanf(const std::basic_string<_char_type, _traits_type, _alloc_type>& str,
01206 const _char_type* format,
01207 _argument1_type& arg1,
01208 _argument2_type& arg2,
01209 _argument3_type& arg3,
01210 _argument4_type& arg4,
01211 _argument5_type& arg5,
01212 _argument6_type& arg6,
01213 _argument7_type& arg7,
01214 _argument8_type& arg8,
01215 _argument9_type& arg9,
01216 _argument10_type& arg10);
01217
01218
01235 template<typename _char_type, typename _traits_type, typename _argument_iter_type>
01236 std::basic_istream<_char_type, _traits_type>&
01237 xscanf_range(std::basic_istream<_char_type, _traits_type>& is,
01238 const _char_type* format_begin,
01239 const _char_type* format_end,
01240 _argument_iter_type first,
01241 _argument_iter_type last);
01242
01258 template<typename _char_type, typename _traits_type, typename _argument_iter_type>
01259 std::basic_istream<_char_type, _traits_type>&
01260 xscanf_range(std::basic_istream<_char_type, _traits_type>& is,
01261 const _char_type* format,
01262 _argument_iter_type first,
01263 _argument_iter_type last);
01264
01273 template<typename _char_type, typename _traits_type, typename _argument_type>
01274 inline std::basic_istream<_char_type, _traits_type>&
01275 xscanf_one(std::basic_istream<_char_type, _traits_type>& is,
01276 const _char_type* fmt_begin,
01277 const _char_type* fmt_end,
01278 _argument_type& argument);
01279
01280
01281
01282
01283
01284 namespace detail
01285 {
01286
01287 struct format_char_info;
01288
01289 template<typename _char_type, typename _traits_type>
01290 class xprintf_argument_wrapper_base;
01291
01292 template<typename _char_type, typename _traits_type, typename _argument_type>
01293 class xprintf_argument_wrapper;
01294
01295 template<typename _char_type, typename _traits_type>
01296 class xscanf_argument_wrapper_base;
01297
01298 template<typename _char_type, typename _traits_type, typename _argument_type>
01299 class xscanf_argument_wrapper;
01300
01301 template<typename _char_type, typename _traits_type>
01302 class xformat_cache;
01303
01304 template<typename _char_type>
01305 inline char do_narrow(const _char_type& ch, const std::ctype<_char_type>& conv)
01306 { return conv.narrow(ch, '\0'); }
01307
01308 inline char do_narrow(const char ch, const std::ctype<char>&)
01309 { return ch; }
01310
01311 template<typename _char_type>
01312 inline const _char_type*
01313 read_number(const _char_type* format_begin,
01314 const _char_type* format_end,
01315 int& num,
01316 const std::ctype<_char_type>& conv);
01317
01318 }
01319
01320
01321
01322
01323
01328 class format_error
01329 : public std::invalid_argument
01330 {
01331 public:
01332 format_error(const std::string& msg ="")
01333 : std::invalid_argument(msg)
01334 {}
01335
01336 ~format_error() throw() {}
01337 };
01338
01339
01340
01341
01342
01347 class argument_index_error
01348 : public std::out_of_range
01349 {
01350 public:
01351 argument_index_error(const std::string& msg ="")
01352 : std::out_of_range(msg)
01353 {}
01354
01355 ~argument_index_error() throw() {}
01356 };
01357
01358
01359
01360
01361
01366 class input_mismatch_error
01367 : public std::runtime_error
01368 {
01369 public:
01370 input_mismatch_error(const std::string& msg ="")
01371 : std::runtime_error(msg)
01372 {}
01373
01374 ~input_mismatch_error() throw() {}
01375 };
01376
01377
01378
01379
01380
01385 class conversion_error
01386 : public std::bad_cast
01387 {
01388 public:
01389 conversion_error(const char* msg)
01390 : m_msg(msg)
01391 {}
01392
01393 const char* what() const throw()
01394 { return m_msg.c_str(); }
01395
01396 ~conversion_error() throw() {}
01397
01398 private:
01399 std::string m_msg;
01400 };
01401
01402
01403
01404
01405
01410 template<
01411 typename _char_type,
01412 typename _traits_type,
01413 typename _alloc_type>
01414 class basic_conversion
01415 {
01416 public:
01417 typedef _char_type char_type;
01418 typedef _traits_type traits_type;
01419 typedef _alloc_type allocator_type;
01420 typedef std::basic_string<_char_type, _traits_type, _alloc_type> string_type;
01421 typedef std::basic_stringstream<_char_type, _traits_type, _alloc_type> stream_type;
01422
01424 stream_type stream;
01425
01426 basic_conversion()
01427 : m_cache(stream)
01428 {
01429 cache_type::get(stream, &m_cache);
01430 }
01431
01436 template<typename _value_type>
01437 bool to_str(const _value_type& value, string_type& str, bool raise=true)
01438 {
01439 stream.str("");
01440 stream.clear();
01441 stream << value;
01442 if (stream.good()) {
01443 str = stream.str();
01444 return true;
01445 }
01446 else
01447 if (raise)
01448 throw conversion_error("basic_conversion to string failed!");
01449 else
01450 return false;
01451 }
01452
01454 template<typename _value_type>
01455 string_type to_str(const _value_type& value)
01456 {
01457 stream.str("");
01458 stream.clear();
01459 stream << value;
01460 if (stream.good() && stream >> std::ws)
01461 return stream.str();
01462 else
01463 throw conversion_error("basic_conversion to string failed!");
01464 }
01465
01470 template<typename _value_type>
01471 bool from_str(const string_type& str, _value_type& value, bool raise=true)
01472 {
01473 stream.str(str);
01474 stream.clear();
01475 stream >> value;
01476 if (stream.rdstate() == std::ios_base::eofbit)
01477 return true;
01478 else {
01479 if (stream.good()) {
01480 const std::ctype<_char_type>& conv = *m_cache.conv;
01481
01482 typename traits_type::int_type meta = stream.rdbuf()->sgetc();
01483
01484 for (; ; meta = stream.rdbuf()->snextc())
01485 if (traits_type::eq_int_type(traits_type::eof(), meta)) {
01486 stream.setstate(std::ios_base::eofbit);
01487 break;
01488 }
01489 else if (!conv.is(std::ctype_base::space, traits_type::to_char_type(meta)))
01490 break;
01491 if (stream.rdstate() == std::ios_base::eofbit)
01492 return true;
01493 }
01494 if (raise)
01495 throw conversion_error("basic_conversion from string failed!");
01496 else
01497 return false;
01498 }
01499 }
01500
01502 template<typename _value_type>
01503 _value_type from_str(const string_type& str)
01504 {
01505 _value_type value;
01506
01507 from_str(str, value, true);
01508 return value;
01509 }
01510
01511 private:
01512 typedef detail::xformat_cache<_char_type, _traits_type> cache_type;
01513 cache_type m_cache;
01514 };
01515
01516
01517
01518
01519
01520 template<typename _char_type, typename _traits_type>
01521 class detail::xformat_cache
01522 {
01523 public:
01524 typedef _char_type char_type;
01525 typedef _traits_type traits_type;
01526
01527 enum cache_type {c_null=0, c_static, c_dynamic};
01528
01529 std::locale loc;
01530 const std::ctype<_char_type>* conv;
01531 char_type ch_perc, ch_dollar, ch_lb, ch_rb;
01532
01533 static xformat_cache* get(std::ios_base& stream, xformat_cache* ext_cache=0)
01534 {
01535 static int x_index = std::ios_base::xalloc();
01536
01537 void*& pw = stream.pword(x_index);
01538
01539 if (pw)
01540 return static_cast<xformat_cache*>(pw);
01541
01542 long& iw = stream.iword(x_index);
01543
01544 if (iw == c_null)
01545 stream.register_callback(&xformat_cache::ios_event_handler, x_index);
01546
01547 xformat_cache* cache =0;
01548
01549 if (ext_cache) {
01550 cache = ext_cache;
01551 iw = c_static;
01552 }
01553 else {
01554 cache = new xformat_cache(stream);
01555 iw = c_dynamic;
01556 }
01557
01558 pw = static_cast<void*>(cache);
01559 return cache;
01560 }
01561
01562 xformat_cache()
01563 {
01564 conv = 0;
01565 ch_perc = ch_dollar = ch_lb = ch_rb = char_type();
01566 }
01567
01568 explicit xformat_cache(const std::ios_base& stream)
01569 {
01570 conv = 0;
01571 update(stream);
01572 }
01573
01574 protected:
01575 void update(const std::ios_base& stream)
01576 {
01577 loc = stream.getloc();
01578 conv = &std::use_facet<std::ctype<_char_type> > (loc);
01579 ch_perc = conv->widen('%');
01580 ch_dollar = conv->widen('$');
01581 ch_lb = conv->widen('{');
01582 ch_rb = conv->widen('}');
01583 }
01584
01585 private:
01586 static void ios_event_handler(std::ios_base::event ev, std::ios_base& stream, int x_index)
01587 {
01588 void*& pw = stream.pword(x_index);
01589
01590 switch (ev)
01591 {
01592 case std::ios_base::copyfmt_event:
01593 case std::ios_base::imbue_event:
01594 if (pw)
01595 static_cast<xformat_cache*>(pw)->update(stream);
01596 break;
01597 case std::ios_base::erase_event:
01598 if (pw && stream.iword(x_index) == c_dynamic) {
01599 delete static_cast<xformat_cache*>(pw);
01600 pw = 0;
01601 }
01602 break;
01603 default:;
01604 }
01605 }
01606 };
01607
01608
01609
01610
01611
01612 struct detail::format_char_info
01613 {
01614 public:
01615 enum char_fmt_type {c_invalid =0, c_flags, c_prefix, c_type, c_special_type};
01616
01617 std::ios_base::fmtflags cflags;
01618 std::ios_base::fmtflags sflags;
01619 char_fmt_type type;
01620
01621 static const format_char_info* get_defaults()
01622 {
01623 static format_char_info records[255];
01624 static bool init = false;
01625
01626 if (!init) {
01627 records[int('-')].cflags = std::ios_base::adjustfield;
01628 records[int('-')].sflags = std::ios_base::left;
01629 records[int('-')].type = c_flags;
01630 records[int('+')].sflags = std::ios_base::showpos;
01631 records[int('+')].type = c_flags;
01632 records[int(' ')].cflags = std::ios_base::adjustfield;
01633 records[int(' ')].sflags = std::ios_base::internal;
01634 records[int(' ')].type = c_flags;
01635 records[int('#')].sflags = std::ios_base::showpoint
01636 | std::ios_base::showbase | std::ios_base::boolalpha;
01637 records[int('#')].type = c_flags;
01638 records[int('0')].type = c_flags;
01639 records[int('c')].type = c_type;
01640 records[int('C')].type = c_type;
01641 records[int('d')].cflags = std::ios_base::basefield;
01642 records[int('d')].sflags = std::ios_base::dec;
01643 records[int('d')].type = c_type;
01644 records[int('i')].cflags = std::ios_base::basefield;
01645 records[int('i')].sflags = std::ios_base::dec;
01646 records[int('i')].type = c_type;
01647 records[int('o')].cflags = std::ios_base::basefield;
01648 records[int('o')].sflags = std::ios_base::oct;
01649 records[int('o')].type = c_type;
01650 records[int('u')].cflags = std::ios_base::basefield;
01651 records[int('u')].sflags = std::ios_base::dec;
01652 records[int('u')].type = c_type;
01653 records[int('x')].cflags = std::ios_base::basefield | std::ios_base::uppercase;
01654 records[int('x')].sflags = std::ios_base::hex;
01655 records[int('x')].type = c_type;
01656 records[int('X')].cflags = std::ios_base::basefield;
01657 records[int('X')].sflags = std::ios_base::hex | std::ios_base::uppercase;
01658 records[int('X')].type = c_type;
01659 records[int('e')].cflags = std::ios_base::floatfield | std::ios_base::uppercase;
01660 records[int('e')].sflags = std::ios_base::scientific;
01661 records[int('e')].type = c_type;
01662 records[int('E')].cflags = std::ios_base::floatfield;
01663 records[int('E')].sflags = std::ios_base::scientific | std::ios_base::uppercase;
01664 records[int('E')].type = c_type;
01665 records[int('f')].cflags = std::ios_base::floatfield;
01666 records[int('f')].sflags = std::ios_base::fixed;
01667 records[int('f')].type = c_type;
01668 records[int('g')].cflags = std::ios_base::floatfield | std::ios_base::uppercase;
01669 records[int('g')].type = c_type;
01670 records[int('G')].cflags = std::ios_base::floatfield;
01671 records[int('G')].sflags = std::ios_base::uppercase;
01672 records[int('G')].type = c_type;
01673 records[int('a')].cflags = std::ios_base::floatfield | std::ios_base::uppercase;
01674 records[int('a')].sflags = std::ios_base::scientific;
01675 records[int('a')].type = c_type;
01676 records[int('A')].cflags = std::ios_base::floatfield;
01677 records[int('A')].sflags = std::ios_base::scientific | std::ios_base::uppercase;
01678 records[int('A')].type = c_type;
01679 records[int('n')].type = c_special_type;
01680 records[int('p')].type = c_type;
01681 records[int('s')].type = c_type;
01682 records[int('S')].type = c_type;
01683 records[int('l')].type = c_prefix;
01684 records[int('L')].type = c_prefix;
01685 records[int('i')].type = c_prefix;
01686 records[int('I')].type = c_prefix;
01687 records[int('h')].type = c_prefix;
01688 records[int('H')].type = c_prefix;
01689
01690 init = true;
01691 }
01692 return records;
01693 }
01694 };
01695
01696
01697
01698
01699
01700 template<typename _char_type, typename _traits_type>
01701 class detail::xprintf_argument_wrapper_base
01702 {
01703 public:
01704 typedef _char_type char_type;
01705 typedef _traits_type traits_type;
01706 typedef std::basic_ostream<_char_type, _traits_type> ostream_type;
01707
01708 virtual ostream_type&
01709 do_print(ostream_type& os, const char_type* fmt_begin, const char_type* fmt_end) const =0;
01710
01711 protected:
01712 virtual ~xprintf_argument_wrapper_base() {}
01713 };
01714
01715
01716
01717
01718
01719 template<typename _char_type, typename _traits_type, typename _argument_type>
01720 class detail::xprintf_argument_wrapper
01721 : public xprintf_argument_wrapper_base<_char_type, _traits_type>
01722 {
01723 public:
01724 typedef _char_type char_type;
01725 typedef _traits_type traits_type;
01726 typedef _argument_type argument_type;
01727 typedef std::basic_ostream<_char_type, _traits_type> ostream_type;
01728
01729 xprintf_argument_wrapper(const _argument_type& arg) : argument(arg) {}
01730
01731 ostream_type& do_print(ostream_type& os, const char_type* fmt_begin, const char_type* fmt_end) const
01732 {
01733 return xprintf_one(os, fmt_begin, fmt_end, argument);
01734 }
01735
01736 const argument_type& argument;
01737
01738 private:
01739 xprintf_argument_wrapper& operator=(const xprintf_argument_wrapper&);
01740 };
01741
01742
01743
01744
01745
01746 template<typename _char_type, typename _traits_type>
01747 class detail::xscanf_argument_wrapper_base
01748 {
01749 public:
01750 typedef _char_type char_type;
01751 typedef _traits_type traits_type;
01752 typedef std::basic_istream<_char_type, _traits_type> istream_type;
01753
01754 virtual istream_type&
01755 do_scan(istream_type& is, const char_type* fmt_begin, const char_type* fmt_end) const =0;
01756
01757 protected:
01758 virtual ~xscanf_argument_wrapper_base() {}
01759 };
01760
01761
01762
01763
01764
01765 template<typename _char_type, typename _traits_type, typename _argument_type>
01766 class detail::xscanf_argument_wrapper
01767 : public xscanf_argument_wrapper_base<_char_type, _traits_type>
01768 {
01769 public:
01770 typedef _char_type char_type;
01771 typedef _traits_type traits_type;
01772 typedef _argument_type argument_type;
01773 typedef std::basic_istream<_char_type, _traits_type> istream_type;
01774
01775 xscanf_argument_wrapper(_argument_type& arg) : argument(arg) {}
01776
01777 istream_type& do_scan(istream_type& is, const char_type* fmt_begin, const char_type* fmt_end) const
01778 {
01779 return xscanf_one(is, fmt_begin, fmt_end, argument);
01780 }
01781
01782 argument_type& argument;
01783
01784 private:
01785 xscanf_argument_wrapper& operator=(const xscanf_argument_wrapper&);
01786 };
01787
01788
01789
01790
01791
01792 template<typename _char_type>
01793 inline const _char_type*
01794 detail::read_number(const _char_type* format_begin,
01795 const _char_type* format_end,
01796 int& num,
01797 const std::ctype<_char_type>& conv)
01798 {
01799 num = 0;
01800
01801 for (const _char_type* cur=format_begin; cur<format_end; ++cur) {
01802 char ch = detail::do_narrow(*cur, conv);
01803
01804
01805 if (ch >= '0' && ch <= '9')
01806 num = num*10+(ch-'0');
01807 else
01808 return cur;
01809 }
01810
01811 return format_end;
01812 }
01813
01814
01815
01816
01817
01818 template<typename _char_type, typename _traits_type>
01819 std::basic_ostream<_char_type, _traits_type>&
01820 xprintf_one(std::basic_ostream<_char_type, _traits_type>& os,
01821 const _char_type* format_begin,
01822 const _char_type* format_end,
01823 const detail::xprintf_argument_wrapper_base<_char_type, _traits_type>* argument_wrapper)
01824 {
01825 return argument_wrapper->do_print(os, format_begin, format_end);
01826 }
01827
01828
01829 template<typename _char_type, typename _traits_type, typename _argument_type>
01830 std::basic_ostream<_char_type, _traits_type>&
01831 xprintf_one(std::basic_ostream<_char_type, _traits_type>& os,
01832 const _char_type*,
01833 const _char_type*,
01834 const _argument_type& argument)
01835 {
01836 return os << argument;
01837 }
01838
01839
01840
01841
01842
01843 template<typename _char_type, typename _traits_type>
01844 std::basic_ostream<_char_type, _traits_type>&
01845 xprintf(std::basic_ostream<_char_type, _traits_type>& os, const _char_type* format)
01846 {
01847 const detail::xprintf_argument_wrapper_base<_char_type, _traits_type>* args = 0;
01848
01849 return xprintf_range(os, format, format+_traits_type::length(format), &args, &args);
01850 }
01851
01852 template<
01853 typename _char_type,
01854 typename _traits_type,
01855 typename _argument1_type>
01856 std::basic_ostream<_char_type, _traits_type>&
01857 xprintf(std::basic_ostream<_char_type, _traits_type>& os,
01858 const _char_type* format,
01859 const _argument1_type& arg1)
01860 {
01861 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument1_type> wrp1(arg1);
01862
01863 const detail::xprintf_argument_wrapper_base<_char_type, _traits_type>* args[] =
01864 {&wrp1};
01865
01866 return xprintf_range(os, format, format+_traits_type::length(format), args, args+1);
01867 }
01868
01869 template<
01870 typename _char_type,
01871 typename _traits_type,
01872 typename _argument1_type,
01873 typename _argument2_type>
01874 std::basic_ostream<_char_type, _traits_type>&
01875 xprintf(std::basic_ostream<_char_type, _traits_type>& os,
01876 const _char_type* format,
01877 const _argument1_type& arg1,
01878 const _argument2_type& arg2)
01879 {
01880 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument1_type> wrp1(arg1);
01881 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument2_type> wrp2(arg2);
01882
01883 const detail::xprintf_argument_wrapper_base<_char_type, _traits_type>* args[] =
01884 {&wrp1, &wrp2};
01885
01886 return xprintf_range(os, format, format+_traits_type::length(format), args, args+2);
01887 }
01888
01889 template<
01890 typename _char_type,
01891 typename _traits_type,
01892 typename _argument1_type,
01893 typename _argument2_type,
01894 typename _argument3_type>
01895 std::basic_ostream<_char_type, _traits_type>&
01896 xprintf(std::basic_ostream<_char_type, _traits_type>& os,
01897 const _char_type* format,
01898 const _argument1_type& arg1,
01899 const _argument2_type& arg2,
01900 const _argument3_type& arg3)
01901 {
01902 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument1_type> wrp1(arg1);
01903 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument2_type> wrp2(arg2);
01904 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument3_type> wrp3(arg3);
01905
01906 const detail::xprintf_argument_wrapper_base<_char_type, _traits_type>* args[] =
01907 {&wrp1, &wrp2, &wrp3};
01908
01909 return xprintf_range(os, format, format+_traits_type::length(format), args, args+3);
01910 }
01911
01912 template<
01913 typename _char_type,
01914 typename _traits_type,
01915 typename _argument1_type,
01916 typename _argument2_type,
01917 typename _argument3_type,
01918 typename _argument4_type>
01919 std::basic_ostream<_char_type, _traits_type>&
01920 xprintf(std::basic_ostream<_char_type, _traits_type>& os,
01921 const _char_type* format,
01922 const _argument1_type& arg1,
01923 const _argument2_type& arg2,
01924 const _argument3_type& arg3,
01925 const _argument4_type& arg4)
01926 {
01927 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument1_type> wrp1(arg1);
01928 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument2_type> wrp2(arg2);
01929 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument3_type> wrp3(arg3);
01930 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument4_type> wrp4(arg4);
01931
01932 const detail::xprintf_argument_wrapper_base<_char_type, _traits_type>* args[] =
01933 {&wrp1, &wrp2, &wrp3, &wrp4};
01934
01935 return xprintf_range(os, format, format+_traits_type::length(format), args, args+4);
01936 }
01937
01938 template<
01939 typename _char_type,
01940 typename _traits_type,
01941 typename _argument1_type,
01942 typename _argument2_type,
01943 typename _argument3_type,
01944 typename _argument4_type,
01945 typename _argument5_type>
01946 std::basic_ostream<_char_type, _traits_type>&
01947 xprintf(std::basic_ostream<_char_type, _traits_type>& os,
01948 const _char_type* format,
01949 const _argument1_type& arg1,
01950 const _argument2_type& arg2,
01951 const _argument3_type& arg3,
01952 const _argument4_type& arg4,
01953 const _argument5_type& arg5)
01954 {
01955 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument1_type> wrp1(arg1);
01956 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument2_type> wrp2(arg2);
01957 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument3_type> wrp3(arg3);
01958 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument4_type> wrp4(arg4);
01959 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument5_type> wrp5(arg5);
01960
01961 const detail::xprintf_argument_wrapper_base<_char_type, _traits_type>* args[] =
01962 {&wrp1, &wrp2, &wrp3, &wrp4, &wrp5};
01963
01964 return xprintf_range(os, format, format+_traits_type::length(format), args, args+5);
01965 }
01966
01967 template<
01968 typename _char_type,
01969 typename _traits_type,
01970 typename _argument1_type,
01971 typename _argument2_type,
01972 typename _argument3_type,
01973 typename _argument4_type,
01974 typename _argument5_type,
01975 typename _argument6_type>
01976 std::basic_ostream<_char_type, _traits_type>&
01977 xprintf(std::basic_ostream<_char_type, _traits_type>& os,
01978 const _char_type* format,
01979 const _argument1_type& arg1,
01980 const _argument2_type& arg2,
01981 const _argument3_type& arg3,
01982 const _argument4_type& arg4,
01983 const _argument5_type& arg5,
01984 const _argument6_type& arg6)
01985 {
01986 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument1_type> wrp1(arg1);
01987 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument2_type> wrp2(arg2);
01988 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument3_type> wrp3(arg3);
01989 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument4_type> wrp4(arg4);
01990 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument5_type> wrp5(arg5);
01991 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument6_type> wrp6(arg6);
01992
01993 const detail::xprintf_argument_wrapper_base<_char_type, _traits_type>* args[] =
01994 {&wrp1, &wrp2, &wrp3, &wrp4, &wrp5, &wrp6};
01995
01996 return xprintf_range(os, format, format+_traits_type::length(format), args, args+6);
01997 }
01998
01999 template<
02000 typename _char_type,
02001 typename _traits_type,
02002 typename _argument1_type,
02003 typename _argument2_type,
02004 typename _argument3_type,
02005 typename _argument4_type,
02006 typename _argument5_type,
02007 typename _argument6_type,
02008 typename _argument7_type>
02009 std::basic_ostream<_char_type, _traits_type>&
02010 xprintf(std::basic_ostream<_char_type, _traits_type>& os,
02011 const _char_type* format,
02012 const _argument1_type& arg1,
02013 const _argument2_type& arg2,
02014 const _argument3_type& arg3,
02015 const _argument4_type& arg4,
02016 const _argument5_type& arg5,
02017 const _argument6_type& arg6,
02018 const _argument7_type& arg7)
02019 {
02020 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument1_type> wrp1(arg1);
02021 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument2_type> wrp2(arg2);
02022 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument3_type> wrp3(arg3);
02023 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument4_type> wrp4(arg4);
02024 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument5_type> wrp5(arg5);
02025 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument6_type> wrp6(arg6);
02026 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument7_type> wrp7(arg7);
02027
02028 const detail::xprintf_argument_wrapper_base<_char_type, _traits_type>* args[] =
02029 {&wrp1, &wrp2, &wrp3, &wrp4, &wrp5, &wrp6, &wrp7};
02030
02031 return xprintf_range(os, format, format+_traits_type::length(format), args, args+7);
02032 }
02033
02034 template<
02035 typename _char_type,
02036 typename _traits_type,
02037 typename _argument1_type,
02038 typename _argument2_type,
02039 typename _argument3_type,
02040 typename _argument4_type,
02041 typename _argument5_type,
02042 typename _argument6_type,
02043 typename _argument7_type,
02044 typename _argument8_type>
02045 std::basic_ostream<_char_type, _traits_type>&
02046 xprintf(std::basic_ostream<_char_type, _traits_type>& os,
02047 const _char_type* format,
02048 const _argument1_type& arg1,
02049 const _argument2_type& arg2,
02050 const _argument3_type& arg3,
02051 const _argument4_type& arg4,
02052 const _argument5_type& arg5,
02053 const _argument6_type& arg6,
02054 const _argument7_type& arg7,
02055 const _argument8_type& arg8)
02056 {
02057 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument1_type> wrp1(arg1);
02058 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument2_type> wrp2(arg2);
02059 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument3_type> wrp3(arg3);
02060 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument4_type> wrp4(arg4);
02061 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument5_type> wrp5(arg5);
02062 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument6_type> wrp6(arg6);
02063 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument7_type> wrp7(arg7);
02064 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument8_type> wrp8(arg8);
02065
02066 const detail::xprintf_argument_wrapper_base<_char_type, _traits_type>* args[] =
02067 {&wrp1, &wrp2, &wrp3, &wrp4, &wrp5, &wrp6, &wrp7, &wrp8};
02068
02069 return xprintf_range(os, format, format+_traits_type::length(format), args, args+8);
02070 }
02071
02072 template<
02073 typename _char_type,
02074 typename _traits_type,
02075 typename _argument1_type,
02076 typename _argument2_type,
02077 typename _argument3_type,
02078 typename _argument4_type,
02079 typename _argument5_type,
02080 typename _argument6_type,
02081 typename _argument7_type,
02082 typename _argument8_type,
02083 typename _argument9_type>
02084 std::basic_ostream<_char_type, _traits_type>&
02085 xprintf(std::basic_ostream<_char_type, _traits_type>& os,
02086 const _char_type* format,
02087 const _argument1_type& arg1,
02088 const _argument2_type& arg2,
02089 const _argument3_type& arg3,
02090 const _argument4_type& arg4,
02091 const _argument5_type& arg5,
02092 const _argument6_type& arg6,
02093 const _argument7_type& arg7,
02094 const _argument8_type& arg8,
02095 const _argument9_type& arg9)
02096 {
02097 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument1_type> wrp1(arg1);
02098 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument2_type> wrp2(arg2);
02099 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument3_type> wrp3(arg3);
02100 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument4_type> wrp4(arg4);
02101 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument5_type> wrp5(arg5);
02102 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument6_type> wrp6(arg6);
02103 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument7_type> wrp7(arg7);
02104 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument8_type> wrp8(arg8);
02105 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument9_type> wrp9(arg9);
02106
02107 const detail::xprintf_argument_wrapper_base<_char_type, _traits_type>* args[] =
02108 {&wrp1, &wrp2, &wrp3, &wrp4, &wrp5, &wrp6, &wrp7, &wrp8, &wrp9};
02109
02110 return xprintf_range(os, format, format+_traits_type::length(format), args, args+9);
02111 }
02112
02113 template<
02114 typename _char_type,
02115 typename _traits_type,
02116 typename _argument1_type,
02117 typename _argument2_type,
02118 typename _argument3_type,
02119 typename _argument4_type,
02120 typename _argument5_type,
02121 typename _argument6_type,
02122 typename _argument7_type,
02123 typename _argument8_type,
02124 typename _argument9_type,
02125 typename _argument10_type>
02126 std::basic_ostream<_char_type, _traits_type>&
02127 xprintf(std::basic_ostream<_char_type, _traits_type>& os,
02128 const _char_type* format,
02129 const _argument1_type& arg1,
02130 const _argument2_type& arg2,
02131 const _argument3_type& arg3,
02132 const _argument4_type& arg4,
02133 const _argument5_type& arg5,
02134 const _argument6_type& arg6,
02135 const _argument7_type& arg7,
02136 const _argument8_type& arg8,
02137 const _argument9_type& arg9,
02138 const _argument10_type& arg10)
02139 {
02140 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument1_type> wrp1(arg1);
02141 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument2_type> wrp2(arg2);
02142 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument3_type> wrp3(arg3);
02143 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument4_type> wrp4(arg4);
02144 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument5_type> wrp5(arg5);
02145 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument6_type> wrp6(arg6);
02146 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument7_type> wrp7(arg7);
02147 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument8_type> wrp8(arg8);
02148 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument9_type> wrp9(arg9);
02149 detail::xprintf_argument_wrapper<_char_type, _traits_type, _argument10_type> wrp10(arg10);
02150
02151 const detail::xprintf_argument_wrapper_base<_char_type, _traits_type>* args[] =
02152 {&wrp1, &wrp2, &wrp3, &wrp4, &wrp5, &wrp6, &wrp7, &wrp8, &wrp9, &wrp10};
02153
02154 return xprintf_range(os, format, format+_traits_type::length(format), args, args+10);
02155 }
02156
02157
02158
02159
02160
02161
02162 template<typename _char_type>
02163 std::basic_string<_char_type>
02164 xprintf(const _char_type* format)
02165 {
02166 typedef std::char_traits<_char_type> traits_type;
02167 const detail::xprintf_argument_wrapper_base<_char_type, traits_type>* args = 0;
02168
02169 std::basic_ostringstream<_char_type, traits_type> oss;
02170
02171 xprintf_range(oss, format, format+traits_type::length(format), &args, &args);
02172 return oss.str();
02173 }
02174
02175 template<
02176 typename _char_type,
02177 typename _argument1_type>
02178 std::basic_string<_char_type>
02179 xprintf(const _char_type* format,
02180 const _argument1_type& arg1)
02181 {
02182 typedef std::char_traits<_char_type> traits_type;
02183 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument1_type> wrp1(arg1);
02184
02185 const detail::xprintf_argument_wrapper_base<_char_type, traits_type>* args[] =
02186 {&wrp1};
02187
02188 std::basic_ostringstream<_char_type, traits_type> oss;
02189
02190 xprintf_range(oss, format, format+traits_type::length(format), args, args+1);
02191 return oss.str();
02192 }
02193
02194 template<
02195 typename _char_type,
02196 typename _argument1_type,
02197 typename _argument2_type>
02198 std::basic_string<_char_type>
02199 xprintf(const _char_type* format,
02200 const _argument1_type& arg1,
02201 const _argument2_type& arg2)
02202 {
02203 typedef std::char_traits<_char_type> traits_type;
02204 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument1_type> wrp1(arg1);
02205 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument2_type> wrp2(arg2);
02206
02207 const detail::xprintf_argument_wrapper_base<_char_type, traits_type>* args[] =
02208 {&wrp1, &wrp2};
02209
02210 std::basic_ostringstream<_char_type, traits_type> oss;
02211
02212 xprintf_range(oss, format, format+traits_type::length(format), args, args+2);
02213 return oss.str();
02214 }
02215
02216 template<
02217 typename _char_type,
02218 typename _argument1_type,
02219 typename _argument2_type,
02220 typename _argument3_type>
02221 std::basic_string<_char_type>
02222 xprintf(const _char_type* format,
02223 const _argument1_type& arg1,
02224 const _argument2_type& arg2,
02225 const _argument3_type& arg3)
02226 {
02227 typedef std::char_traits<_char_type> traits_type;
02228 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument1_type> wrp1(arg1);
02229 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument2_type> wrp2(arg2);
02230 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument3_type> wrp3(arg3);
02231
02232 const detail::xprintf_argument_wrapper_base<_char_type, traits_type>* args[] =
02233 {&wrp1, &wrp2, &wrp3};
02234
02235 std::basic_ostringstream<_char_type, traits_type> oss;
02236
02237 xprintf_range(oss, format, format+traits_type::length(format), args, args+3);
02238 return oss.str();
02239 }
02240
02241 template<
02242 typename _char_type,
02243 typename _argument1_type,
02244 typename _argument2_type,
02245 typename _argument3_type,
02246 typename _argument4_type>
02247 std::basic_string<_char_type>
02248 xprintf(const _char_type* format,
02249 const _argument1_type& arg1,
02250 const _argument2_type& arg2,
02251 const _argument3_type& arg3,
02252 const _argument4_type& arg4)
02253 {
02254 typedef std::char_traits<_char_type> traits_type;
02255 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument1_type> wrp1(arg1);
02256 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument2_type> wrp2(arg2);
02257 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument3_type> wrp3(arg3);
02258 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument4_type> wrp4(arg4);
02259
02260 const detail::xprintf_argument_wrapper_base<_char_type, traits_type>* args[] =
02261 {&wrp1, &wrp2, &wrp3, &wrp4};
02262
02263 std::basic_ostringstream<_char_type, traits_type> oss;
02264
02265 xprintf_range(oss, format, format+traits_type::length(format), args, args+4);
02266 return oss.str();
02267 }
02268
02269 template<
02270 typename _char_type,
02271 typename _argument1_type,
02272 typename _argument2_type,
02273 typename _argument3_type,
02274 typename _argument4_type,
02275 typename _argument5_type>
02276 std::basic_string<_char_type>
02277 xprintf(const _char_type* format,
02278 const _argument1_type& arg1,
02279 const _argument2_type& arg2,
02280 const _argument3_type& arg3,
02281 const _argument4_type& arg4,
02282 const _argument5_type& arg5)
02283 {
02284 typedef std::char_traits<_char_type> traits_type;
02285 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument1_type> wrp1(arg1);
02286 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument2_type> wrp2(arg2);
02287 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument3_type> wrp3(arg3);
02288 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument4_type> wrp4(arg4);
02289 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument5_type> wrp5(arg5);
02290
02291 const detail::xprintf_argument_wrapper_base<_char_type, traits_type>* args[] =
02292 {&wrp1, &wrp2, &wrp3, &wrp4, &wrp5};
02293
02294 std::basic_ostringstream<_char_type, traits_type> oss;
02295
02296 xprintf_range(oss, format, format+traits_type::length(format), args, args+5);
02297 return oss.str();
02298 }
02299
02300 template<
02301 typename _char_type,
02302 typename _argument1_type,
02303 typename _argument2_type,
02304 typename _argument3_type,
02305 typename _argument4_type,
02306 typename _argument5_type,
02307 typename _argument6_type>
02308 std::basic_string<_char_type>
02309 xprintf(const _char_type* format,
02310 const _argument1_type& arg1,
02311 const _argument2_type& arg2,
02312 const _argument3_type& arg3,
02313 const _argument4_type& arg4,
02314 const _argument5_type& arg5,
02315 const _argument6_type& arg6)
02316 {
02317 typedef std::char_traits<_char_type> traits_type;
02318 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument1_type> wrp1(arg1);
02319 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument2_type> wrp2(arg2);
02320 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument3_type> wrp3(arg3);
02321 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument4_type> wrp4(arg4);
02322 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument5_type> wrp5(arg5);
02323 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument6_type> wrp6(arg6);
02324
02325 const detail::xprintf_argument_wrapper_base<_char_type, traits_type>* args[] =
02326 {&wrp1, &wrp2, &wrp3, &wrp4, &wrp5, &wrp6};
02327
02328 std::basic_ostringstream<_char_type, traits_type> oss;
02329
02330 xprintf_range(oss, format, format+traits_type::length(format), args, args+6);
02331 return oss.str();
02332 }
02333
02334 template<
02335 typename _char_type,
02336 typename _argument1_type,
02337 typename _argument2_type,
02338 typename _argument3_type,
02339 typename _argument4_type,
02340 typename _argument5_type,
02341 typename _argument6_type,
02342 typename _argument7_type>
02343 std::basic_string<_char_type>
02344 xprintf(const _char_type* format,
02345 const _argument1_type& arg1,
02346 const _argument2_type& arg2,
02347 const _argument3_type& arg3,
02348 const _argument4_type& arg4,
02349 const _argument5_type& arg5,
02350 const _argument6_type& arg6,
02351 const _argument7_type& arg7)
02352 {
02353 typedef std::char_traits<_char_type> traits_type;
02354 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument1_type> wrp1(arg1);
02355 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument2_type> wrp2(arg2);
02356 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument3_type> wrp3(arg3);
02357 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument4_type> wrp4(arg4);
02358 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument5_type> wrp5(arg5);
02359 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument6_type> wrp6(arg6);
02360 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument7_type> wrp7(arg7);
02361
02362 const detail::xprintf_argument_wrapper_base<_char_type, traits_type>* args[] =
02363 {&wrp1, &wrp2, &wrp3, &wrp4, &wrp5, &wrp6, &wrp7};
02364
02365 std::basic_ostringstream<_char_type, traits_type> oss;
02366
02367 xprintf_range(oss, format, format+traits_type::length(format), args, args+7);
02368 return oss.str();
02369 }
02370
02371 template<
02372 typename _char_type,
02373 typename _argument1_type,
02374 typename _argument2_type,
02375 typename _argument3_type,
02376 typename _argument4_type,
02377 typename _argument5_type,
02378 typename _argument6_type,
02379 typename _argument7_type,
02380 typename _argument8_type>
02381 std::basic_string<_char_type>
02382 xprintf(const _char_type* format,
02383 const _argument1_type& arg1,
02384 const _argument2_type& arg2,
02385 const _argument3_type& arg3,
02386 const _argument4_type& arg4,
02387 const _argument5_type& arg5,
02388 const _argument6_type& arg6,
02389 const _argument7_type& arg7,
02390 const _argument8_type& arg8)
02391 {
02392 typedef std::char_traits<_char_type> traits_type;
02393 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument1_type> wrp1(arg1);
02394 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument2_type> wrp2(arg2);
02395 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument3_type> wrp3(arg3);
02396 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument4_type> wrp4(arg4);
02397 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument5_type> wrp5(arg5);
02398 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument6_type> wrp6(arg6);
02399 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument7_type> wrp7(arg7);
02400 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument8_type> wrp8(arg8);
02401
02402 const detail::xprintf_argument_wrapper_base<_char_type, traits_type>* args[] =
02403 {&wrp1, &wrp2, &wrp3, &wrp4, &wrp5, &wrp6, &wrp7, &wrp8};
02404
02405 std::basic_ostringstream<_char_type, traits_type> oss;
02406
02407 xprintf_range(oss, format, format+traits_type::length(format), args, args+8);
02408 return oss.str();
02409 }
02410
02411 template<
02412 typename _char_type,
02413 typename _argument1_type,
02414 typename _argument2_type,
02415 typename _argument3_type,
02416 typename _argument4_type,
02417 typename _argument5_type,
02418 typename _argument6_type,
02419 typename _argument7_type,
02420 typename _argument8_type,
02421 typename _argument9_type>
02422 std::basic_string<_char_type>
02423 xprintf(const _char_type* format,
02424 const _argument1_type& arg1,
02425 const _argument2_type& arg2,
02426 const _argument3_type& arg3,
02427 const _argument4_type& arg4,
02428 const _argument5_type& arg5,
02429 const _argument6_type& arg6,
02430 const _argument7_type& arg7,
02431 const _argument8_type& arg8,
02432 const _argument9_type& arg9)
02433 {
02434 typedef std::char_traits<_char_type> traits_type;
02435 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument1_type> wrp1(arg1);
02436 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument2_type> wrp2(arg2);
02437 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument3_type> wrp3(arg3);
02438 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument4_type> wrp4(arg4);
02439 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument5_type> wrp5(arg5);
02440 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument6_type> wrp6(arg6);
02441 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument7_type> wrp7(arg7);
02442 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument8_type> wrp8(arg8);
02443 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument9_type> wrp9(arg9);
02444
02445 const detail::xprintf_argument_wrapper_base<_char_type, traits_type>* args[] =
02446 {&wrp1, &wrp2, &wrp3, &wrp4, &wrp5, &wrp6, &wrp7, &wrp8, &wrp9};
02447
02448 std::basic_ostringstream<_char_type, traits_type> oss;
02449
02450 xprintf_range(oss, format, format+traits_type::length(format), args, args+9);
02451 return oss.str();
02452 }
02453
02454 template<
02455 typename _char_type,
02456 typename _argument1_type,
02457 typename _argument2_type,
02458 typename _argument3_type,
02459 typename _argument4_type,
02460 typename _argument5_type,
02461 typename _argument6_type,
02462 typename _argument7_type,
02463 typename _argument8_type,
02464 typename _argument9_type,
02465 typename _argument10_type>
02466 std::basic_string<_char_type>
02467 xprintf(const _char_type* format,
02468 const _argument1_type& arg1,
02469 const _argument2_type& arg2,
02470 const _argument3_type& arg3,
02471 const _argument4_type& arg4,
02472 const _argument5_type& arg5,
02473 const _argument6_type& arg6,
02474 const _argument7_type& arg7,
02475 const _argument8_type& arg8,
02476 const _argument9_type& arg9,
02477 const _argument10_type& arg10)
02478 {
02479 typedef std::char_traits<_char_type> traits_type;
02480 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument1_type> wrp1(arg1);
02481 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument2_type> wrp2(arg2);
02482 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument3_type> wrp3(arg3);
02483 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument4_type> wrp4(arg4);
02484 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument5_type> wrp5(arg5);
02485 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument6_type> wrp6(arg6);
02486 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument7_type> wrp7(arg7);
02487 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument8_type> wrp8(arg8);
02488 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument9_type> wrp9(arg9);
02489 detail::xprintf_argument_wrapper<_char_type, traits_type, _argument10_type> wrp10(arg10);
02490
02491 const detail::xprintf_argument_wrapper_base<_char_type, traits_type>* args[] =
02492 {&wrp1, &wrp2, &wrp3, &wrp4, &wrp5, &wrp6, &wrp7, &wrp8, &wrp9, &wrp10};
02493
02494 std::basic_ostringstream<_char_type, traits_type> oss;
02495
02496 xprintf_range(oss, format, format+traits_type::length(format), args, args+10);
02497 return oss.str();
02498 }
02499
02500
02501
02502
02503
02504
02505 template<typename _char_type, typename _traits_type, typename _argument_iter_type>
02506 std::basic_ostream<_char_type, _traits_type>&
02507 xprintf_range(std::basic_ostream<_char_type, _traits_type>& os,
02508 const _char_type* format,
02509 _argument_iter_type arg_begin,
02510 _argument_iter_type arg_end)
02511 {
02512 return xprintf_range(os, format, format+_traits_type::length(format), arg_begin, arg_end);
02513 }
02514
02515
02516 template<typename _char_type, typename _traits_type, typename _argument_iter_type>
02517 std::basic_ostream<_char_type, _traits_type>&
02518 xprintf_range(std::basic_ostream<_char_type, _traits_type>& os,
02519 const _char_type* format_begin,
02520 const _char_type* format_end,
02521 _argument_iter_type arg_begin,
02522 _argument_iter_type arg_end)
02523 {
02524 typedef std::basic_ostream<_char_type, _traits_type> ostream_type;
02525 typedef std::basic_streambuf<_char_type, _traits_type> streambuf_type;
02526 typedef detail::xformat_cache<_char_type, _traits_type> cache_type;
02527
02528 static const detail::format_char_info* ft_info = detail::format_char_info::get_defaults();
02529
02530 cache_type* cache = cache_type::get(os);
02531 const std::ctype<_char_type>& conv = *cache->conv;
02532 const _char_type ch_perc = cache->ch_perc;
02533 const _char_type ch_dollar = cache->ch_dollar;
02534 const _char_type ch_lb = cache->ch_lb;
02535 const _char_type ch_rb = cache->ch_rb;
02536
02537 const typename ostream_type::sentry sentry(os);
02538
02539 if (!sentry)
02540 return os;
02541
02542 std::ios_base::iostate state = std::ios_base::goodbit;
02543 std::ios_base::fmtflags saved_flags = os.flags();
02544 std::streamsize saved_precision = os.precision();
02545 int cur_arg_index = 0;
02546 const _char_type* cur=format_begin;
02547 bool in_argument = false;
02548
02549 try {
02550 while (cur<format_end) {
02551 streambuf_type* sb = os.rdbuf();
02552 int new_arg_index = -1;
02553
02554 if (!os || !sb) {
02555 os.flags(saved_flags);
02556 os.precision(saved_precision);
02557 return os;
02558 }
02559
02560 const _char_type* perc_pos = _traits_type::find(cur, format_end-cur, ch_perc);
02561
02562
02563 if (!perc_pos) {
02564 std::streamsize count = format_end-cur;
02565
02566 if (sb->sputn(cur, count) != count) {
02567 state |= std::ios_base::badbit;
02568 break;
02569 }
02570 break;
02571 }
02572
02573 std::ios_base::fmtflags cur_flags = saved_flags;
02574 std::streamsize cur_precision = saved_precision;
02575 std::streamsize cur_width = 0;
02576 bool has_width = false;
02577
02578 int num;
02579
02580
02581 if (perc_pos > cur) {
02582 std::streamsize count = perc_pos-cur;
02583
02584 if (sb->sputn(cur, count) != count) {
02585 state |= std::ios_base::badbit;
02586 break;
02587 }
02588 }
02589
02590 cur = perc_pos+1;
02591
02592
02593 if (cur >= format_end) {
02594 state |= std::ios_base::failbit;
02595 if (os.exceptions() & std::ios_base::failbit)
02596 throw format_error("xprintf: incomplete field at the end of format string!");
02597 break;
02598 }
02599
02600
02601 if (*cur == ch_perc) {
02602 ++cur;
02603
02604 if (_traits_type::eq_int_type(_traits_type::eof(), sb->sputc(ch_perc))) {
02605 state |= std::ios_base::badbit;
02606 break;
02607 }
02608 continue;
02609 }
02610
02611
02612 cur_arg_index++;
02613
02614
02615 cur = detail::read_number(cur, format_end, num, conv);
02616
02617
02618 if (cur >= format_end) {
02619 state |= std::ios_base::failbit;
02620 if (os.exceptions() & std::ios_base::failbit)
02621 throw format_error("xprintf: incomplete field at the end of format string!");
02622 break;
02623 }
02624
02625
02626 if (cur > perc_pos+1) {
02627
02628 if (*cur == ch_dollar) {
02629
02630 if (num-1 >= arg_end-arg_begin || num == 0) {
02631 state |= std::ios_base::failbit;
02632 if (os.exceptions() & std::ios_base::failbit)
02633 throw argument_index_error("xprintf: argument index out of range");
02634 break;
02635 }
02636
02637
02638 ++cur;
02639
02640
02641 if (cur >= format_end) {
02642 state |= std::ios_base::failbit;
02643 if (os.exceptions() & std::ios_base::failbit)
02644 throw format_error("xprintf: incomplete field at the end of format string!");
02645 break;
02646 }
02647
02648 new_arg_index = num;
02649 }
02650
02651 else {
02652 cur_width = num;
02653 has_width = true;
02654 }
02655 }
02656
02657
02658 if (!has_width && *cur == ch_lb) {
02659 ++cur;
02660
02661 const _char_type* subfmt_begin = cur;
02662 int balance = 1;
02663
02664 for (; cur<format_end; ++cur) {
02665 if (*cur == ch_rb)
02666 balance--;
02667 else if (*cur == ch_lb)
02668 balance++;
02669
02670 if (balance <= 0)
02671 break;
02672 }
02673
02674
02675 if (cur >= format_end) {
02676 state |= std::ios_base::failbit;
02677 if (os.exceptions() & std::ios_base::failbit)
02678 throw format_error("xprintf: field subformat not closed with a '}'");
02679 break;
02680 }
02681
02682 const _char_type* subfmt_end = cur;
02683
02684 ++cur;
02685
02686 if (new_arg_index != -1)
02687 cur_arg_index = new_arg_index;
02688
02689 if (cur_arg_index-1 >= arg_end-arg_begin) {
02690 state |= std::ios_base::failbit;
02691 if (os.exceptions() & std::ios_base::failbit)
02692 throw argument_index_error("xprintf: argument index out of range");
02693 break;
02694 }
02695
02696 os.flags(cur_flags);
02697 os.precision(cur_precision);
02698 os.width(cur_width);
02699 in_argument = true;
02700 xprintf_one(os, subfmt_begin, subfmt_end, arg_begin[cur_arg_index-1]);
02701 in_argument = false;
02702 if (!os.good())
02703 break;
02704 }
02705 else {
02706 char cur_ch =0;
02707
02708
02709 cur_flags &= ~(std::ios_base::adjustfield | std::ios_base::showpos | std::ios_base::showpoint
02710 | std::ios_base::showbase | std::ios_base::boolalpha);
02711 cur_flags |= std::ios_base::right;
02712
02713
02714 if (!has_width)
02715 {
02716
02717 for (; cur<format_end; ++cur) {
02718 cur_ch = detail::do_narrow(*cur, conv);
02719
02720 const detail::format_char_info& info = ft_info[(int)cur_ch];
02721
02722 if (info.type != detail::format_char_info::c_flags)
02723 break;
02724
02725 cur_flags &= ~info.cflags;
02726 cur_flags |= info.sflags;
02727 }
02728
02729
02730 if (cur >= format_end) {
02731 state |= std::ios_base::failbit;
02732 if (os.exceptions() & std::ios_base::failbit)
02733 throw format_error("xprintf: incomplete field at the end of format string!");
02734 break;
02735 }
02736
02737
02738 if (cur_ch >= '0' && cur_ch <= '9') {
02739 cur = detail::read_number(cur, format_end, num, conv);
02740 cur_width = num;
02741 has_width = true;
02742
02743
02744 if (cur >= format_end) {
02745 state |= std::ios_base::failbit;
02746 if (os.exceptions() & std::ios_base::failbit)
02747 throw format_error("xprintf: incomplete field at the end of format string!");
02748 break;
02749 }
02750 cur_ch = detail::do_narrow(*cur, conv);
02751 }
02752 }
02753 else
02754 cur_ch = detail::do_narrow(*cur, conv);
02755
02756
02757 if (cur_ch == '.') {
02758
02759 ++cur;
02760
02761
02762 if (cur >= format_end) {
02763 state |= std::ios_base::failbit;
02764 if (os.exceptions() & std::ios_base::failbit)
02765 throw format_error("xprintf: incomplete field at the end of format string!");
02766 break;
02767 }
02768
02769 cur = detail::read_number(cur, format_end, num, conv);
02770 cur_precision = num;
02771
02772
02773 if (cur >= format_end) {
02774 state |= std::ios_base::failbit;
02775 if (os.exceptions() & std::ios_base::failbit)
02776 throw format_error("xprintf: incomplete field at the end of format string!");
02777 break;
02778 }
02779 cur_ch = detail::do_narrow(*cur, conv);
02780 }
02781
02782 bool complete = false;
02783
02784
02785 for (; cur<format_end; ++cur) {
02786 cur_ch = detail::do_narrow(*cur, conv);
02787
02788 const detail::format_char_info& info = ft_info[(int)cur_ch];
02789
02790 if (info.type == detail::format_char_info::c_type) {
02791 cur_flags &= ~info.cflags;
02792 cur_flags |= info.sflags;
02793 complete = true;
02794 break;
02795 }
02796 if (info.type == detail::format_char_info::c_prefix) {
02797 cur_flags &= ~info.cflags;
02798 cur_flags |= info.sflags;
02799 continue;
02800 }
02801
02802 break;
02803 }
02804
02805
02806 if (cur >= format_end) {
02807 state |= std::ios_base::failbit;
02808 if (os.exceptions() & std::ios_base::failbit)
02809 throw format_error("xprintf: incomplete field at the end of format string!");
02810 break;
02811 }
02812
02813
02814 if (complete) {
02815 ++cur;
02816
02817 if (new_arg_index != -1)
02818 cur_arg_index = new_arg_index;
02819
02820 if (cur_arg_index-1 >= arg_end-arg_begin) {
02821 state |= std::ios_base::failbit;
02822 if (os.exceptions() & std::ios_base::failbit)
02823 throw argument_index_error("xprintf: argument index out of range");
02824 break;
02825 }
02826
02827 os.flags(cur_flags);
02828 os.precision(cur_precision);
02829 os.width(cur_width);
02830 in_argument = true;
02831 xprintf_one(os, perc_pos+1, perc_pos+1, arg_begin[cur_arg_index-1]);
02832 in_argument = false;
02833 if (!os.good())
02834 break;
02835 continue;
02836 }
02837
02838
02839 if (cur_ch == 'n') {
02840 ++cur;
02841 continue;
02842 }
02843
02844
02845 state |= std::ios_base::failbit;
02846 if (os.exceptions() & std::ios_base::failbit)
02847 throw format_error("xprintf: unrecognized format field!");
02848 break;
02849 }
02850 }
02851 }
02852 catch (...) {
02853 state |= os.rdstate();
02854 os.flags(saved_flags);
02855 os.precision(saved_precision);
02856
02857 if (state == std::ios_base::goodbit)
02858 state |= in_argument ? std::ios_base::failbit : std::ios_base::badbit;
02859
02860 try { os.setstate(state); } catch (...) {}
02861
02862 if (state & os.exceptions())
02863 throw;
02864 }
02865
02866 os.flags(saved_flags);
02867 os.precision(saved_precision);
02868 os.setstate(state);
02869 return os;
02870 }
02871
02872
02873
02874
02875
02876 template<typename _char_type, typename _traits_type>
02877 std::basic_istream<_char_type, _traits_type>&
02878 xscanf_one(std::basic_istream<_char_type, _traits_type>& is,
02879 const _char_type* format_begin,
02880 const _char_type* format_end,
02881 const detail::xscanf_argument_wrapper_base<_char_type, _traits_type>* argument_wrapper)
02882 {
02883 return argument_wrapper->do_scan(is, format_begin, format_end);
02884 }
02885
02886
02887 template<typename _char_type, typename _traits_type, typename _argument_type>
02888 std::basic_istream<_char_type, _traits_type>&
02889 xscanf_one(std::basic_istream<_char_type, _traits_type>& is,
02890 const _char_type*,
02891 const _char_type*,
02892 _argument_type& argument)
02893 {
02894 return is >> argument;
02895 }
02896
02897
02898
02899
02900
02901 template<typename _char_type, typename _traits_type>
02902 std::basic_istream<_char_type, _traits_type>&
02903 xscanf(std::basic_istream<_char_type, _traits_type>& is, const _char_type* format)
02904 {
02905 const detail::xscanf_argument_wrapper_base<_char_type, _traits_type>* args = 0;
02906
02907 return xscanf_range(is, format, format+_traits_type::length(format), &args, &args);
02908 }
02909
02910 template<
02911 typename _char_type,
02912 typename _traits_type,
02913 typename _argument1_type>
02914 std::basic_istream<_char_type, _traits_type>&
02915 xscanf(std::basic_istream<_char_type, _traits_type>& is,
02916 const _char_type* format,
02917 _argument1_type& arg1)
02918 {
02919 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument1_type> wrp1(arg1);
02920
02921 const detail::xscanf_argument_wrapper_base<_char_type, _traits_type>* args[] =
02922 {&wrp1};
02923
02924 return xscanf_range(is, format, format+_traits_type::length(format), args, args+1);
02925 }
02926
02927 template<
02928 typename _char_type,
02929 typename _traits_type,
02930 typename _argument1_type,
02931 typename _argument2_type>
02932 std::basic_istream<_char_type, _traits_type>&
02933 xscanf(std::basic_istream<_char_type, _traits_type>& is,
02934 const _char_type* format,
02935 _argument1_type& arg1,
02936 _argument2_type& arg2)
02937 {
02938 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument1_type> wrp1(arg1);
02939 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument2_type> wrp2(arg2);
02940
02941 const detail::xscanf_argument_wrapper_base<_char_type, _traits_type>* args[] =
02942 {&wrp1, &wrp2};
02943
02944 return xscanf_range(is, format, format+_traits_type::length(format), args, args+2);
02945 }
02946
02947 template<
02948 typename _char_type,
02949 typename _traits_type,
02950 typename _argument1_type,
02951 typename _argument2_type,
02952 typename _argument3_type>
02953 std::basic_istream<_char_type, _traits_type>&
02954 xscanf(std::basic_istream<_char_type, _traits_type>& is,
02955 const _char_type* format,
02956 _argument1_type& arg1,
02957 _argument2_type& arg2,
02958 _argument3_type& arg3)
02959 {
02960 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument1_type> wrp1(arg1);
02961 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument2_type> wrp2(arg2);
02962 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument3_type> wrp3(arg3);
02963
02964 const detail::xscanf_argument_wrapper_base<_char_type, _traits_type>* args[] =
02965 {&wrp1, &wrp2, &wrp3};
02966
02967 return xscanf_range(is, format, format+_traits_type::length(format), args, args+3);
02968 }
02969
02970 template<
02971 typename _char_type,
02972 typename _traits_type,
02973 typename _argument1_type,
02974 typename _argument2_type,
02975 typename _argument3_type,
02976 typename _argument4_type>
02977 std::basic_istream<_char_type, _traits_type>&
02978 xscanf(std::basic_istream<_char_type, _traits_type>& is,
02979 const _char_type* format,
02980 _argument1_type& arg1,
02981 _argument2_type& arg2,
02982 _argument3_type& arg3,
02983 _argument4_type& arg4)
02984 {
02985 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument1_type> wrp1(arg1);
02986 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument2_type> wrp2(arg2);
02987 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument3_type> wrp3(arg3);
02988 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument4_type> wrp4(arg4);
02989
02990 const detail::xscanf_argument_wrapper_base<_char_type, _traits_type>* args[] =
02991 {&wrp1, &wrp2, &wrp3, &wrp4};
02992
02993 return xscanf_range(is, format, format+_traits_type::length(format), args, args+4);
02994 }
02995
02996 template<
02997 typename _char_type,
02998 typename _traits_type,
02999 typename _argument1_type,
03000 typename _argument2_type,
03001 typename _argument3_type,
03002 typename _argument4_type,
03003 typename _argument5_type>
03004 std::basic_istream<_char_type, _traits_type>&
03005 xscanf(std::basic_istream<_char_type, _traits_type>& is,
03006 const _char_type* format,
03007 _argument1_type& arg1,
03008 _argument2_type& arg2,
03009 _argument3_type& arg3,
03010 _argument4_type& arg4,
03011 _argument5_type& arg5)
03012 {
03013 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument1_type> wrp1(arg1);
03014 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument2_type> wrp2(arg2);
03015 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument3_type> wrp3(arg3);
03016 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument4_type> wrp4(arg4);
03017 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument5_type> wrp5(arg5);
03018
03019 const detail::xscanf_argument_wrapper_base<_char_type, _traits_type>* args[] =
03020 {&wrp1, &wrp2, &wrp3, &wrp4, &wrp5};
03021
03022 return xscanf_range(is, format, format+_traits_type::length(format), args, args+5);
03023 }
03024
03025 template<
03026 typename _char_type,
03027 typename _traits_type,
03028 typename _argument1_type,
03029 typename _argument2_type,
03030 typename _argument3_type,
03031 typename _argument4_type,
03032 typename _argument5_type,
03033 typename _argument6_type>
03034 std::basic_istream<_char_type, _traits_type>&
03035 xscanf(std::basic_istream<_char_type, _traits_type>& is,
03036 const _char_type* format,
03037 _argument1_type& arg1,
03038 _argument2_type& arg2,
03039 _argument3_type& arg3,
03040 _argument4_type& arg4,
03041 _argument5_type& arg5,
03042 _argument6_type& arg6)
03043 {
03044 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument1_type> wrp1(arg1);
03045 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument2_type> wrp2(arg2);
03046 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument3_type> wrp3(arg3);
03047 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument4_type> wrp4(arg4);
03048 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument5_type> wrp5(arg5);
03049 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument6_type> wrp6(arg6);
03050
03051 const detail::xscanf_argument_wrapper_base<_char_type, _traits_type>* args[] =
03052 {&wrp1, &wrp2, &wrp3, &wrp4, &wrp5, &wrp6};
03053
03054 return xscanf_range(is, format, format+_traits_type::length(format), args, args+6);
03055 }
03056
03057 template<
03058 typename _char_type,
03059 typename _traits_type,
03060 typename _argument1_type,
03061 typename _argument2_type,
03062 typename _argument3_type,
03063 typename _argument4_type,
03064 typename _argument5_type,
03065 typename _argument6_type,
03066 typename _argument7_type>
03067 std::basic_istream<_char_type, _traits_type>&
03068 xscanf(std::basic_istream<_char_type, _traits_type>& is,
03069 const _char_type* format,
03070 _argument1_type& arg1,
03071 _argument2_type& arg2,
03072 _argument3_type& arg3,
03073 _argument4_type& arg4,
03074 _argument5_type& arg5,
03075 _argument6_type& arg6,
03076 _argument7_type& arg7)
03077 {
03078 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument1_type> wrp1(arg1);
03079 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument2_type> wrp2(arg2);
03080 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument3_type> wrp3(arg3);
03081 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument4_type> wrp4(arg4);
03082 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument5_type> wrp5(arg5);
03083 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument6_type> wrp6(arg6);
03084 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument7_type> wrp7(arg7);
03085
03086 const detail::xscanf_argument_wrapper_base<_char_type, _traits_type>* args[] =
03087 {&wrp1, &wrp2, &wrp3, &wrp4, &wrp5, &wrp6, &wrp7};
03088
03089 return xscanf_range(is, format, format+_traits_type::length(format), args, args+7);
03090 }
03091
03092 template<
03093 typename _char_type,
03094 typename _traits_type,
03095 typename _argument1_type,
03096 typename _argument2_type,
03097 typename _argument3_type,
03098 typename _argument4_type,
03099 typename _argument5_type,
03100 typename _argument6_type,
03101 typename _argument7_type,
03102 typename _argument8_type>
03103 std::basic_istream<_char_type, _traits_type>&
03104 xscanf(std::basic_istream<_char_type, _traits_type>& is,
03105 const _char_type* format,
03106 _argument1_type& arg1,
03107 _argument2_type& arg2,
03108 _argument3_type& arg3,
03109 _argument4_type& arg4,
03110 _argument5_type& arg5,
03111 _argument6_type& arg6,
03112 _argument7_type& arg7,
03113 _argument8_type& arg8)
03114 {
03115 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument1_type> wrp1(arg1);
03116 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument2_type> wrp2(arg2);
03117 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument3_type> wrp3(arg3);
03118 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument4_type> wrp4(arg4);
03119 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument5_type> wrp5(arg5);
03120 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument6_type> wrp6(arg6);
03121 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument7_type> wrp7(arg7);
03122 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument8_type> wrp8(arg8);
03123
03124 const detail::xscanf_argument_wrapper_base<_char_type, _traits_type>* args[] =
03125 {&wrp1, &wrp2, &wrp3, &wrp4, &wrp5, &wrp6, &wrp7, &wrp8};
03126
03127 return xscanf_range(is, format, format+_traits_type::length(format), args, args+8);
03128 }
03129
03130 template<
03131 typename _char_type,
03132 typename _traits_type,
03133 typename _argument1_type,
03134 typename _argument2_type,
03135 typename _argument3_type,
03136 typename _argument4_type,
03137 typename _argument5_type,
03138 typename _argument6_type,
03139 typename _argument7_type,
03140 typename _argument8_type,
03141 typename _argument9_type>
03142 std::basic_istream<_char_type, _traits_type>&
03143 xscanf(std::basic_istream<_char_type, _traits_type>& is,
03144 const _char_type* format,
03145 _argument1_type& arg1,
03146 _argument2_type& arg2,
03147 _argument3_type& arg3,
03148 _argument4_type& arg4,
03149 _argument5_type& arg5,
03150 _argument6_type& arg6,
03151 _argument7_type& arg7,
03152 _argument8_type& arg8,
03153 _argument9_type& arg9)
03154 {
03155 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument1_type> wrp1(arg1);
03156 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument2_type> wrp2(arg2);
03157 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument3_type> wrp3(arg3);
03158 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument4_type> wrp4(arg4);
03159 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument5_type> wrp5(arg5);
03160 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument6_type> wrp6(arg6);
03161 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument7_type> wrp7(arg7);
03162 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument8_type> wrp8(arg8);
03163 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument9_type> wrp9(arg9);
03164
03165 const detail::xscanf_argument_wrapper_base<_char_type, _traits_type>* args[] =
03166 {&wrp1, &wrp2, &wrp3, &wrp4, &wrp5, &wrp6, &wrp7, &wrp8, &wrp9};
03167
03168 return xscanf_range(is, format, format+_traits_type::length(format), args, args+9);
03169 }
03170
03171 template<
03172 typename _char_type,
03173 typename _traits_type,
03174 typename _argument1_type,
03175 typename _argument2_type,
03176 typename _argument3_type,
03177 typename _argument4_type,
03178 typename _argument5_type,
03179 typename _argument6_type,
03180 typename _argument7_type,
03181 typename _argument8_type,
03182 typename _argument9_type,
03183 typename _argument10_type>
03184 std::basic_istream<_char_type, _traits_type>&
03185 xscanf(std::basic_istream<_char_type, _traits_type>& is,
03186 const _char_type* format,
03187 _argument1_type& arg1,
03188 _argument2_type& arg2,
03189 _argument3_type& arg3,
03190 _argument4_type& arg4,
03191 _argument5_type& arg5,
03192 _argument6_type& arg6,
03193 _argument7_type& arg7,
03194 _argument8_type& arg8,
03195 _argument9_type& arg9,
03196 _argument10_type& arg10)
03197 {
03198 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument1_type> wrp1(arg1);
03199 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument2_type> wrp2(arg2);
03200 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument3_type> wrp3(arg3);
03201 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument4_type> wrp4(arg4);
03202 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument5_type> wrp5(arg5);
03203 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument6_type> wrp6(arg6);
03204 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument7_type> wrp7(arg7);
03205 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument8_type> wrp8(arg8);
03206 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument9_type> wrp9(arg9);
03207 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument10_type> wrp10(arg10);
03208
03209 const detail::xscanf_argument_wrapper_base<_char_type, _traits_type>* args[] =
03210 {&wrp1, &wrp2, &wrp3, &wrp4, &wrp5, &wrp6, &wrp7, &wrp8, &wrp9, &wrp10};
03211
03212 return xscanf_range(is, format, format+_traits_type::length(format), args, args+10);
03213 }
03214
03215
03216
03217
03218
03219
03220 template<
03221 typename _char_type,
03222 typename _traits_type,
03223 typename _alloc_type>
03224 std::ios_base::iostate
03225 xscanf(const std::basic_string<_char_type, _traits_type, _alloc_type>& str,
03226 const _char_type* format)
03227 {
03228 const detail::xscanf_argument_wrapper_base<_char_type, _traits_type>* args = 0;
03229
03230 std::basic_istringstream<_char_type, _traits_type> iss(str);
03231
03232 return xscanf_range(iss, format, format+_traits_type::length(format), &args, &args).rdstate();
03233 }
03234
03235 template<
03236 typename _char_type,
03237 typename _traits_type,
03238 typename _alloc_type,
03239 typename _argument1_type>
03240 std::ios_base::iostate
03241 xscanf(const std::basic_string<_char_type, _traits_type, _alloc_type>& str,
03242 const _char_type* format,
03243 _argument1_type& arg1)
03244 {
03245 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument1_type> wrp1(arg1);
03246
03247 const detail::xscanf_argument_wrapper_base<_char_type, _traits_type>* args[] =
03248 {&wrp1};
03249
03250 std::basic_istringstream<_char_type, _traits_type> iss(str);
03251
03252 return xscanf_range(iss, format, format+_traits_type::length(format), args, args+1).rdstate();
03253 }
03254
03255 template<
03256 typename _char_type,
03257 typename _traits_type,
03258 typename _alloc_type,
03259 typename _argument1_type,
03260 typename _argument2_type>
03261 std::ios_base::iostate
03262 xscanf(const std::basic_string<_char_type, _traits_type, _alloc_type>& str,
03263 const _char_type* format,
03264 _argument1_type& arg1,
03265 _argument2_type& arg2)
03266 {
03267 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument1_type> wrp1(arg1);
03268 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument2_type> wrp2(arg2);
03269
03270 const detail::xscanf_argument_wrapper_base<_char_type, _traits_type>* args[] =
03271 {&wrp1, &wrp2};
03272
03273 std::basic_istringstream<_char_type, _traits_type> iss(str);
03274
03275 return xscanf_range(iss, format, format+_traits_type::length(format), args, args+2).rdstate();
03276 }
03277
03278 template<
03279 typename _char_type,
03280 typename _traits_type,
03281 typename _alloc_type,
03282 typename _argument1_type,
03283 typename _argument2_type,
03284 typename _argument3_type>
03285 std::ios_base::iostate
03286 xscanf(const std::basic_string<_char_type, _traits_type, _alloc_type>& str,
03287 const _char_type* format,
03288 _argument1_type& arg1,
03289 _argument2_type& arg2,
03290 _argument3_type& arg3)
03291 {
03292 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument1_type> wrp1(arg1);
03293 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument2_type> wrp2(arg2);
03294 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument3_type> wrp3(arg3);
03295
03296 const detail::xscanf_argument_wrapper_base<_char_type, _traits_type>* args[] =
03297 {&wrp1, &wrp2, &wrp3};
03298
03299 std::basic_istringstream<_char_type, _traits_type> iss(str);
03300
03301 return xscanf_range(iss, format, format+_traits_type::length(format), args, args+3).rdstate();
03302 }
03303
03304 template<
03305 typename _char_type,
03306 typename _traits_type,
03307 typename _alloc_type,
03308 typename _argument1_type,
03309 typename _argument2_type,
03310 typename _argument3_type,
03311 typename _argument4_type>
03312 std::ios_base::iostate
03313 xscanf(const std::basic_string<_char_type, _traits_type, _alloc_type>& str,
03314 const _char_type* format,
03315 _argument1_type& arg1,
03316 _argument2_type& arg2,
03317 _argument3_type& arg3,
03318 _argument4_type& arg4)
03319 {
03320 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument1_type> wrp1(arg1);
03321 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument2_type> wrp2(arg2);
03322 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument3_type> wrp3(arg3);
03323 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument4_type> wrp4(arg4);
03324
03325 const detail::xscanf_argument_wrapper_base<_char_type, _traits_type>* args[] =
03326 {&wrp1, &wrp2, &wrp3, &wrp4};
03327
03328 std::basic_istringstream<_char_type, _traits_type> iss(str);
03329
03330 return xscanf_range(iss, format, format+_traits_type::length(format), args, args+4).rdstate();
03331 }
03332
03333 template<
03334 typename _char_type,
03335 typename _traits_type,
03336 typename _alloc_type,
03337 typename _argument1_type,
03338 typename _argument2_type,
03339 typename _argument3_type,
03340 typename _argument4_type,
03341 typename _argument5_type>
03342 std::ios_base::iostate
03343 xscanf(const std::basic_string<_char_type, _traits_type, _alloc_type>& str,
03344 const _char_type* format,
03345 _argument1_type& arg1,
03346 _argument2_type& arg2,
03347 _argument3_type& arg3,
03348 _argument4_type& arg4,
03349 _argument5_type& arg5)
03350 {
03351 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument1_type> wrp1(arg1);
03352 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument2_type> wrp2(arg2);
03353 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument3_type> wrp3(arg3);
03354 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument4_type> wrp4(arg4);
03355 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument5_type> wrp5(arg5);
03356
03357 const detail::xscanf_argument_wrapper_base<_char_type, _traits_type>* args[] =
03358 {&wrp1, &wrp2, &wrp3, &wrp4, &wrp5};
03359
03360 std::basic_istringstream<_char_type, _traits_type> iss(str);
03361
03362 return xscanf_range(iss, format, format+_traits_type::length(format), args, args+5).rdstate();
03363 }
03364
03365 template<
03366 typename _char_type,
03367 typename _traits_type,
03368 typename _alloc_type,
03369 typename _argument1_type,
03370 typename _argument2_type,
03371 typename _argument3_type,
03372 typename _argument4_type,
03373 typename _argument5_type,
03374 typename _argument6_type>
03375 std::ios_base::iostate
03376 xscanf(const std::basic_string<_char_type, _traits_type, _alloc_type>& str,
03377 const _char_type* format,
03378 _argument1_type& arg1,
03379 _argument2_type& arg2,
03380 _argument3_type& arg3,
03381 _argument4_type& arg4,
03382 _argument5_type& arg5,
03383 _argument6_type& arg6)
03384 {
03385 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument1_type> wrp1(arg1);
03386 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument2_type> wrp2(arg2);
03387 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument3_type> wrp3(arg3);
03388 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument4_type> wrp4(arg4);
03389 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument5_type> wrp5(arg5);
03390 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument6_type> wrp6(arg6);
03391
03392 const detail::xscanf_argument_wrapper_base<_char_type, _traits_type>* args[] =
03393 {&wrp1, &wrp2, &wrp3, &wrp4, &wrp5, &wrp6};
03394
03395 std::basic_istringstream<_char_type, _traits_type> iss(str);
03396
03397 return xscanf_range(iss, format, format+_traits_type::length(format), args, args+6).rdstate();
03398 }
03399
03400 template<
03401 typename _char_type,
03402 typename _traits_type,
03403 typename _alloc_type,
03404 typename _argument1_type,
03405 typename _argument2_type,
03406 typename _argument3_type,
03407 typename _argument4_type,
03408 typename _argument5_type,
03409 typename _argument6_type,
03410 typename _argument7_type>
03411 std::ios_base::iostate
03412 xscanf(const std::basic_string<_char_type, _traits_type, _alloc_type>& str,
03413 const _char_type* format,
03414 _argument1_type& arg1,
03415 _argument2_type& arg2,
03416 _argument3_type& arg3,
03417 _argument4_type& arg4,
03418 _argument5_type& arg5,
03419 _argument6_type& arg6,
03420 _argument7_type& arg7)
03421 {
03422 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument1_type> wrp1(arg1);
03423 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument2_type> wrp2(arg2);
03424 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument3_type> wrp3(arg3);
03425 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument4_type> wrp4(arg4);
03426 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument5_type> wrp5(arg5);
03427 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument6_type> wrp6(arg6);
03428 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument7_type> wrp7(arg7);
03429
03430 const detail::xscanf_argument_wrapper_base<_char_type, _traits_type>* args[] =
03431 {&wrp1, &wrp2, &wrp3, &wrp4, &wrp5, &wrp6, &wrp7};
03432
03433 std::basic_istringstream<_char_type, _traits_type> iss(str);
03434
03435 return xscanf_range(iss, format, format+_traits_type::length(format), args, args+7).rdstate();
03436 }
03437
03438 template<
03439 typename _char_type,
03440 typename _traits_type,
03441 typename _alloc_type,
03442 typename _argument1_type,
03443 typename _argument2_type,
03444 typename _argument3_type,
03445 typename _argument4_type,
03446 typename _argument5_type,
03447 typename _argument6_type,
03448 typename _argument7_type,
03449 typename _argument8_type>
03450 std::ios_base::iostate
03451 xscanf(const std::basic_string<_char_type, _traits_type, _alloc_type>& str,
03452 const _char_type* format,
03453 _argument1_type& arg1,
03454 _argument2_type& arg2,
03455 _argument3_type& arg3,
03456 _argument4_type& arg4,
03457 _argument5_type& arg5,
03458 _argument6_type& arg6,
03459 _argument7_type& arg7,
03460 _argument8_type& arg8)
03461 {
03462 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument1_type> wrp1(arg1);
03463 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument2_type> wrp2(arg2);
03464 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument3_type> wrp3(arg3);
03465 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument4_type> wrp4(arg4);
03466 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument5_type> wrp5(arg5);
03467 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument6_type> wrp6(arg6);
03468 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument7_type> wrp7(arg7);
03469 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument8_type> wrp8(arg8);
03470
03471 const detail::xscanf_argument_wrapper_base<_char_type, _traits_type>* args[] =
03472 {&wrp1, &wrp2, &wrp3, &wrp4, &wrp5, &wrp6, &wrp7, &wrp8};
03473
03474 std::basic_istringstream<_char_type, _traits_type> iss(str);
03475
03476 return xscanf_range(iss, format, format+_traits_type::length(format), args, args+8).rdstate();
03477 }
03478
03479 template<
03480 typename _char_type,
03481 typename _traits_type,
03482 typename _alloc_type,
03483 typename _argument1_type,
03484 typename _argument2_type,
03485 typename _argument3_type,
03486 typename _argument4_type,
03487 typename _argument5_type,
03488 typename _argument6_type,
03489 typename _argument7_type,
03490 typename _argument8_type,
03491 typename _argument9_type>
03492 std::ios_base::iostate
03493 xscanf(const std::basic_string<_char_type, _traits_type, _alloc_type>& str,
03494 const _char_type* format,
03495 _argument1_type& arg1,
03496 _argument2_type& arg2,
03497 _argument3_type& arg3,
03498 _argument4_type& arg4,
03499 _argument5_type& arg5,
03500 _argument6_type& arg6,
03501 _argument7_type& arg7,
03502 _argument8_type& arg8,
03503 _argument9_type& arg9)
03504 {
03505 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument1_type> wrp1(arg1);
03506 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument2_type> wrp2(arg2);
03507 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument3_type> wrp3(arg3);
03508 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument4_type> wrp4(arg4);
03509 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument5_type> wrp5(arg5);
03510 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument6_type> wrp6(arg6);
03511 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument7_type> wrp7(arg7);
03512 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument8_type> wrp8(arg8);
03513 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument9_type> wrp9(arg9);
03514
03515 const detail::xscanf_argument_wrapper_base<_char_type, _traits_type>* args[] =
03516 {&wrp1, &wrp2, &wrp3, &wrp4, &wrp5, &wrp6, &wrp7, &wrp8, &wrp9};
03517
03518 std::basic_istringstream<_char_type, _traits_type> iss(str);
03519
03520 return xscanf_range(iss, format, format+_traits_type::length(format), args, args+9).rdstate();
03521 }
03522
03523 template<
03524 typename _char_type,
03525 typename _traits_type,
03526 typename _alloc_type,
03527 typename _argument1_type,
03528 typename _argument2_type,
03529 typename _argument3_type,
03530 typename _argument4_type,
03531 typename _argument5_type,
03532 typename _argument6_type,
03533 typename _argument7_type,
03534 typename _argument8_type,
03535 typename _argument9_type,
03536 typename _argument10_type>
03537 std::ios_base::iostate
03538 xscanf(const std::basic_string<_char_type, _traits_type, _alloc_type>& str,
03539 const _char_type* format,
03540 _argument1_type& arg1,
03541 _argument2_type& arg2,
03542 _argument3_type& arg3,
03543 _argument4_type& arg4,
03544 _argument5_type& arg5,
03545 _argument6_type& arg6,
03546 _argument7_type& arg7,
03547 _argument8_type& arg8,
03548 _argument9_type& arg9,
03549 _argument10_type& arg10)
03550 {
03551 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument1_type> wrp1(arg1);
03552 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument2_type> wrp2(arg2);
03553 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument3_type> wrp3(arg3);
03554 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument4_type> wrp4(arg4);
03555 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument5_type> wrp5(arg5);
03556 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument6_type> wrp6(arg6);
03557 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument7_type> wrp7(arg7);
03558 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument8_type> wrp8(arg8);
03559 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument9_type> wrp9(arg9);
03560 detail::xscanf_argument_wrapper<_char_type, _traits_type, _argument10_type> wrp10(arg10);
03561
03562 const detail::xscanf_argument_wrapper_base<_char_type, _traits_type>* args[] =
03563 {&wrp1, &wrp2, &wrp3, &wrp4, &wrp5, &wrp6, &wrp7, &wrp8, &wrp9, &wrp10};
03564
03565 std::basic_istringstream<_char_type, _traits_type> iss(str);
03566
03567 return xscanf_range(iss, format, format+_traits_type::length(format), args, args+10).rdstate();
03568 }
03569
03570
03571
03572
03573
03574
03575
03576 template<typename _char_type, typename _traits_type, typename _argument_iter_type>
03577 std::basic_istream<_char_type, _traits_type>&
03578 xscanf_range(std::basic_istream<_char_type, _traits_type>& is,
03579 const _char_type* format,
03580 _argument_iter_type arg_begin,
03581 _argument_iter_type arg_end)
03582 {
03583 return xscanf_range(is, format, _traits_type::length(format), arg_begin, arg_end);
03584 }
03585
03586 template<typename _char_type, typename _traits_type, typename _argument_iter_type>
03587 std::basic_istream<_char_type, _traits_type>&
03588 xscanf_range(std::basic_istream<_char_type, _traits_type>& is,
03589 const _char_type* format_begin,
03590 const _char_type* format_end,
03591 _argument_iter_type arg_begin,
03592 _argument_iter_type arg_end)
03593 {
03594 typedef std::basic_istream<_char_type, _traits_type> istream_type;
03595 typedef detail::xformat_cache<_char_type, _traits_type> cache_type;
03596
03597 static const detail::format_char_info* ft_info = detail::format_char_info::get_defaults();
03598
03599 cache_type* cache = cache_type::get(is);
03600 const std::ctype<_char_type>& conv = *cache->conv;
03601 const _char_type ch_perc = cache->ch_perc;
03602 const _char_type ch_dollar = cache->ch_dollar;
03603 const _char_type ch_lb = cache->ch_lb;
03604 const _char_type ch_rb = cache->ch_rb;
03605
03606 const typename istream_type::sentry sentry(is);
03607
03608 if (!sentry)
03609 return is;
03610
03611 std::ios_base::iostate state = std::ios_base::goodbit;
03612 std::ios_base::fmtflags saved_flags = is.flags();
03613 std::streamsize saved_precision = is.precision();
03614 int cur_arg_index = 0;
03615 const _char_type* cur=format_begin;
03616 bool in_argument = false;
03617
03618 try {
03619 while (cur<format_end) {
03620 int new_arg_index = -1;
03621 const _char_type* perc_pos =0;
03622
03623 if (!is) {
03624 is.flags(saved_flags);
03625 is.precision(saved_precision);
03626 return is;
03627 }
03628
03629
03630 {
03631 std::istreambuf_iterator<_char_type, _traits_type> it(is), it_end;
03632
03633 for (;;) {
03634 if (cur >= format_end) {
03635 is.flags(saved_flags);
03636 is.precision(saved_precision);
03637 return is;
03638 }
03639
03640
03641 if (*cur == ch_perc) {
03642 perc_pos = cur;
03643 ++cur;
03644
03645 if (cur >= format_end) {
03646 state |= std::ios_base::failbit;
03647 if (is.exceptions() & std::ios_base::failbit)
03648 throw format_error("xscanf: incomplete field at the end of format string!");
03649 break;
03650 }
03651
03652
03653 if (*cur != ch_perc)
03654 break;
03655 }
03656
03657 if (it == it_end) {
03658 state |= std::ios_base::eofbit | std::ios_base::failbit;
03659 if (is.exceptions() & std::ios_base::failbit)
03660 throw input_mismatch_error("xscanf: input too short for the given format string!");
03661 break;
03662 }
03663
03664
03665 if (conv.is(std::ctype_base::space, *cur)) {
03666 while (it != it_end && conv.is(std::ctype_base::space, *it))
03667 ++it;
03668 ++cur;
03669 }
03670 else {
03671 if (*cur != *it) {
03672 state |= std::ios_base::failbit;
03673 if (is.exceptions() & std::ios_base::failbit)
03674 throw input_mismatch_error("xscanf: input not matching the format string!");
03675 break;
03676 }
03677 ++cur;
03678 ++it;
03679 }
03680 }
03681 }
03682
03683 if (state != std::ios_base::goodbit)
03684 break;
03685
03686 std::ios_base::fmtflags cur_flags = saved_flags;
03687 std::streamsize cur_precision = saved_precision;
03688 std::streamsize cur_width = 0;
03689 bool has_width = false;
03690
03691 int num;
03692
03693
03694 cur_arg_index++;
03695
03696
03697 cur = detail::read_number(cur, format_end, num, conv);
03698
03699
03700 if (cur >= format_end) {
03701 state |= std::ios_base::failbit;
03702 if (is.exceptions() & std::ios_base::failbit)
03703 throw format_error("xscanf: incomplete field at the end of format string!");
03704 break;
03705 }
03706
03707
03708 if (cur > perc_pos+1) {
03709
03710 if (*cur == ch_dollar) {
03711
03712 if (num-1 >= arg_end-arg_begin || num == 0) {
03713 state |= std::ios_base::failbit;
03714 if (is.exceptions() & std::ios_base::failbit)
03715 throw argument_index_error("xscanf: argument index out of range");
03716 break;
03717 }
03718
03719
03720 ++cur;
03721
03722
03723 if (cur >= format_end) {
03724 state |= std::ios_base::failbit;
03725 if (is.exceptions() & std::ios_base::failbit)
03726 throw format_error("xscanf: incomplete field at the end of format string!");
03727 break;
03728 }
03729
03730 new_arg_index = num;
03731 }
03732
03733 else {
03734 cur_width = num;
03735 has_width = true;
03736 }
03737 }
03738
03739
03740 if (!has_width && *cur == ch_lb) {
03741 ++cur;
03742
03743 const _char_type* subfmt_begin = cur;
03744 int balance = 1;
03745
03746 for (; cur<format_end; ++cur) {
03747 if (*cur == ch_rb)
03748 balance--;
03749 else if (*cur == ch_lb)
03750 balance++;
03751
03752 if (balance <= 0)
03753 break;
03754 }
03755
03756
03757 if (cur >= format_end) {
03758 state |= std::ios_base::failbit;
03759 if (is.exceptions() & std::ios_base::failbit)
03760 throw format_error("xscanf: field subformat not closed with a '}'");
03761 break;
03762 }
03763
03764 const _char_type* subfmt_end = cur;
03765
03766 ++cur;
03767
03768 if (new_arg_index != -1)
03769 cur_arg_index = new_arg_index;
03770
03771 if (cur_arg_index-1 >= arg_end-arg_begin) {
03772 state |= std::ios_base::failbit;
03773 if (is.exceptions() & std::ios_base::failbit)
03774 throw argument_index_error("xscanf: argument index out of range");
03775 break;
03776 }
03777
03778 is.flags(cur_flags);
03779 is.precision(cur_precision);
03780 is.width(cur_width);
03781 in_argument = true;
03782 xscanf_one(is, subfmt_begin, subfmt_end, arg_begin[cur_arg_index-1]);
03783 in_argument = false;
03784 if (!is.good())
03785 break;
03786 }
03787 else {
03788 char cur_ch =0;
03789
03790
03791 cur_flags &= ~(std::ios_base::adjustfield | std::ios_base::showpos | std::ios_base::showpoint
03792 | std::ios_base::showbase | std::ios_base::boolalpha);
03793 cur_flags |= std::ios_base::right;
03794
03795
03796 if (!has_width)
03797 {
03798 cur_ch = detail::do_narrow(*cur, conv);
03799
03800
03801 if (cur_ch >= '0' && cur_ch <= '9') {
03802 cur = detail::read_number(cur, format_end, num, conv);
03803 cur_width = num;
03804 has_width = true;
03805
03806
03807 if (cur >= format_end) {
03808 state |= std::ios_base::failbit;
03809 if (is.exceptions() & std::ios_base::failbit)
03810 throw format_error("xscanf: incomplete field at the end of format string!");
03811 break;
03812 }
03813 cur_ch = detail::do_narrow(*cur, conv);
03814 }
03815 }
03816 else
03817 cur_ch = detail::do_narrow(*cur, conv);
03818
03819 bool complete = false;
03820
03821
03822 for (; cur<format_end; ++cur) {
03823 cur_ch = detail::do_narrow(*cur, conv);
03824
03825 const detail::format_char_info& info = ft_info[(int)cur_ch];
03826
03827 if (info.type == detail::format_char_info::c_type) {
03828 cur_flags &= ~info.cflags;
03829 cur_flags |= info.sflags;
03830 complete = true;
03831 break;
03832 }
03833 if (info.type == detail::format_char_info::c_prefix) {
03834 cur_flags &= ~info.cflags;
03835 cur_flags |= info.sflags;
03836 continue;
03837 }
03838
03839 break;
03840 }
03841
03842
03843 if (cur >= format_end) {
03844 state |= std::ios_base::failbit;
03845 if (is.exceptions() & std::ios_base::failbit)
03846 throw format_error("xscanf: incomplete field at the end of format string!");
03847 break;
03848 }
03849
03850
03851 if (complete) {
03852 ++cur;
03853
03854 if (new_arg_index != -1)
03855 cur_arg_index = new_arg_index;
03856
03857 if (cur_arg_index-1 >= arg_end-arg_begin) {
03858 state |= std::ios_base::failbit;
03859 if (is.exceptions() & std::ios_base::failbit)
03860 throw argument_index_error("xscanf: argument index out of range");
03861 break;
03862 }
03863
03864 is.flags(cur_flags);
03865 is.precision(cur_precision);
03866 is.width(cur_width);
03867 in_argument = true;
03868 xscanf_one(is, perc_pos+1, perc_pos+1, arg_begin[cur_arg_index-1]);
03869 in_argument = false;
03870 if (!is.good())
03871 break;
03872 continue;
03873 }
03874
03875
03876 if (cur_ch == 'n') {
03877 ++cur;
03878 continue;
03879 }
03880
03881
03882 state |= std::ios_base::failbit;
03883 if (is.exceptions() & std::ios_base::failbit)
03884 throw format_error("xscanf: unrecognized format field!");
03885 break;
03886 }
03887 }
03888 }
03889 catch (...) {
03890 state |= is.rdstate();
03891 is.flags(saved_flags);
03892 is.precision(saved_precision);
03893
03894 if (state == std::ios_base::goodbit)
03895 state |= in_argument ? std::ios_base::failbit : std::ios_base::badbit;
03896
03897 try { is.setstate(state); } catch (...) {}
03898
03899 if (state & is.exceptions())
03900 throw;
03901 }
03902 is.flags(saved_flags);
03903 is.precision(saved_precision);
03904 is.setstate(state);
03905 return is;
03906 }
03907
03908
03909 }
03910
03911 #ifdef LITE_ASSERT_LOCAL
03912 #undef LITE_ASSERT
03913 #undef LITE_ASSERT_LOCAL
03914 #endif // LITE_ASSERT_LOCAL
03915
03916 #ifdef _MSC_VER
03917 #pragma warning (pop)
03918 #endif
03919
03920
03921 #endif // LITE_XFORMAT_HPP
