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
00032
00033
00034
00035
00036
00037
00038
00039
00040
00047 #ifndef STLSOFT_INCL_STLSOFT_CONVERSION_HPP_INTEGER_TO_STRING
00048 #define STLSOFT_INCL_STLSOFT_CONVERSION_HPP_INTEGER_TO_STRING
00049
00050 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00051 # define STLSOFT_VER_STLSOFT_CONVERSION_HPP_INTEGER_TO_STRING_MAJOR 4
00052 # define STLSOFT_VER_STLSOFT_CONVERSION_HPP_INTEGER_TO_STRING_MINOR 1
00053 # define STLSOFT_VER_STLSOFT_CONVERSION_HPP_INTEGER_TO_STRING_REVISION 2
00054 # define STLSOFT_VER_STLSOFT_CONVERSION_HPP_INTEGER_TO_STRING_EDIT 79
00055 #endif
00056
00057
00058
00059
00060
00061 #ifndef STLSOFT_INCL_STLSOFT_H_STLSOFT
00062 # include <stlsoft/stlsoft.h>
00063 #endif
00064 #ifndef STLSOFT_CF_NEGATIVE_MODULUS_POSITIVE_GIVES_NEGATIVE_RESULT
00065 # ifndef STLSOFT_INCL_STLSOFT_UTIL_H_LIMIT_TRAITS
00066 # include <stlsoft/util/limit_traits.h>
00067 # endif
00068 # ifndef STLSOFT_INCL_STLSOFT_UTIL_HPP_SIGN_TRAITS
00069 # include <stlsoft/util/sign_traits.hpp>
00070 # endif
00071 # ifndef STLSOFT_INCL_STLSOFT_META_HPP_IS_SAME_TYPE
00072 # include <stlsoft/meta/is_same_type.hpp>
00073 # endif
00074 #endif
00075 #ifdef STLSOFT_UNITTEST
00076 # ifndef STLSOFT_INCL_STLSOFT_UTIL_H_LIMIT_TRAITS
00077 # include <stlsoft/util/limit_traits.h>
00078 # endif
00079 # include <stdio.h>
00080 # include <string.h>
00081 #endif
00082
00083
00084
00085
00086
00087 #ifndef _STLSOFT_NO_NAMESPACE
00088 namespace stlsoft
00089 {
00090 #endif
00091
00092
00093
00094
00095
00096 #ifdef __STLSOFT_INTEGER_TO_STRING_OPTIMISE_64BIT
00097 # error __STLSOFT_INTEGER_TO_STRING_OPTIMISE_64BIT is no longer supported. Instead, define STLSOFT_INTEGER_TO_STRING_OPTIMISE_64BIT
00098 #endif
00099
00100
00101
00102
00103
00104 #if 0
00105 namespace constants
00106 {
00107 enum
00108 {
00109 buffer_width = 21
00110 };
00111
00112 }
00113 #endif
00114
00115
00116
00117
00118
00119 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00120
00125 template <ss_typename_param_k C>
00126 #ifdef STLSOFT_CF_TEMPLATE_TYPE_REQUIRED_IN_ARGS
00127 inline C const* get_digit_character(C * )
00128 #else
00129 inline C const* get_digit_character()
00130 #endif
00131 {
00132 static C const s_characters[19] =
00133 {
00134 '9'
00135 , '8'
00136 , '7'
00137 , '6'
00138 , '5'
00139 , '4'
00140 , '3'
00141 , '2'
00142 , '1'
00143 , '0'
00144 , '1'
00145 , '2'
00146 , '3'
00147 , '4'
00148 , '5'
00149 , '6'
00150 , '7'
00151 , '8'
00152 , '9'
00153 };
00154 #if 0
00155 static C const *s_mid = s_characters + 9;
00156
00157 return s_mid;
00158 #else
00159 return s_characters + 9;
00160 #endif
00161 }
00162
00163 #endif
00164
00165
00166
00167
00168
00169 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00170
00185 template< ss_typename_param_k C
00186 , ss_typename_param_k I
00187 >
00188 inline C const* unsigned_integer_to_string(C *buf, ss_size_t cchBuf, I i)
00189 {
00190 C *psz = buf + cchBuf - 1;
00191
00192 *psz = 0;
00193
00194 do
00195 {
00196 #if defined(STLSOFT_COMPILER_IS_MSVC)
00197 typedef I rem_t;
00198 #else
00199 typedef ss_uint_t rem_t;
00200 #endif
00201
00202 rem_t lsd = static_cast<rem_t>(i % 10);
00203
00204 i = static_cast<I>(i / 10);
00205
00206 --psz;
00207
00208 #ifdef STLSOFT_CF_TEMPLATE_TYPE_REQUIRED_IN_ARGS
00209 *psz = get_digit_character(static_cast<C*>(NULL))[lsd];
00210 #else
00211 *psz = get_digit_character<C>()[lsd];
00212 #endif
00213
00214 } while(i != 0);
00215
00216 STLSOFT_ASSERT(!(psz < buf));
00217
00218 return psz;
00219 }
00220
00221
00237 template< ss_typename_param_k C
00238 , ss_typename_param_k I
00239 >
00240 inline C const* unsigned_integer_to_string(C* buf, ss_size_t cchBuf, I i, ss_size_t& cchRes)
00241 {
00242 C const* psz = unsigned_integer_to_string<C, I>(buf, cchBuf, i);
00243
00244 cchRes = cchBuf - (psz - (buf - 1));
00245
00246 return psz;
00247 }
00248
00249
00264 template< ss_typename_param_k C
00265 , ss_typename_param_k I
00266 >
00267 inline C const* signed_integer_to_string(C *buf, ss_size_t cchBuf, I i)
00268 {
00269 #ifndef STLSOFT_CF_NEGATIVE_MODULUS_POSITIVE_GIVES_NEGATIVE_RESULT
00270
00271
00272 typedef limit_traits<I> limit_traits_t;
00273 typedef sign_traits<I> sign_traits_t;
00274 typedef ss_typename_type_k sign_traits_t::signed_type signed_type_t;
00275 typedef ss_typename_type_k sign_traits_t::unsigned_type unsigned_type_t;
00276
00277
00278
00279 STLSOFT_STATIC_ASSERT((0 != is_same_type<signed_type_t, I>::value));
00280
00281 C const* psz;
00282
00283 if(i == limit_traits_t::minimum())
00284 {
00285 STLSOFT_ASSERT(i == -i);
00286
00287
00288
00289
00290
00291
00292
00293 psz = unsigned_integer_to_string(buf, cchBuf, static_cast<unsigned_type_t>(limit_traits_t::minimum()));
00294
00295 *const_cast<C*>(--psz) = C('-');
00296 }
00297 else
00298 {
00299
00300
00301
00302 psz = unsigned_integer_to_string(buf, cchBuf, i);
00303
00304 if(i < 0)
00305 {
00306 *const_cast<C*>(--psz) = C('-');
00307 }
00308 }
00309
00310 return psz;
00311 #else
00312
00313
00314
00315
00316 #if defined(STLSOFT_COMPILER_IS_MSVC)
00317 typedef I rem_t;
00318 #else
00319 typedef ss_sint_t rem_t;
00320 #endif
00321
00322 C *psz = buf + cchBuf - 1;
00323
00324 *psz = 0;
00325
00326 if(i < 0)
00327 {
00328 do
00329 {
00330 rem_t lsd = static_cast<rem_t>(i % 10);
00331
00332 i = static_cast<I>(i / 10);
00333
00334 --psz;
00335
00336 #ifdef STLSOFT_CF_TEMPLATE_TYPE_REQUIRED_IN_ARGS
00337 *psz = get_digit_character(static_cast<C*>(NULL))[lsd];
00338 #else
00339 *psz = get_digit_character<C>()[lsd];
00340 #endif
00341
00342 } while(i != 0);
00343
00344 *(--psz) = C('-');
00345 }
00346 else
00347 {
00348 do
00349 {
00350 rem_t lsd = static_cast<rem_t>(i % 10);
00351
00352 i = static_cast<I>(i / 10);
00353
00354 --psz;
00355
00356 #ifdef STLSOFT_CF_TEMPLATE_TYPE_REQUIRED_IN_ARGS
00357 *psz = get_digit_character(static_cast<C*>(NULL))[lsd];
00358 #else
00359 *psz = get_digit_character<C>()[lsd];
00360 #endif
00361
00362 } while(i != 0);
00363 }
00364
00365 STLSOFT_ASSERT(!(psz < buf));
00366
00367 return psz;
00368 #endif
00369 }
00370
00386 template< ss_typename_param_k C
00387 , ss_typename_param_k I
00388 >
00389 inline C const* signed_integer_to_string(C* buf, ss_size_t cchBuf, I i, ss_size_t& cchRes)
00390 {
00391 C const* psz = signed_integer_to_string<C, I>(buf, cchBuf, i);
00392
00393 cchRes = cchBuf - (psz - (buf - 1));
00394
00395 return psz;
00396 }
00397
00398 #endif
00399
00404 template <ss_typename_param_k C>
00405 inline C const* integer_to_string(C *buf, ss_size_t cchBuf, ss_sint8_t i)
00406 {
00407 return signed_integer_to_string(buf, cchBuf, i);
00408 }
00409
00414 template <ss_typename_param_k C>
00415 inline C const* integer_to_string(C *buf, ss_size_t cchBuf, ss_uint8_t i)
00416 {
00417 return unsigned_integer_to_string(buf, cchBuf, i);
00418 }
00419
00424 template <ss_typename_param_k C>
00425 inline C const* integer_to_string(C *buf, ss_size_t cchBuf, ss_sint16_t i)
00426 {
00427 return signed_integer_to_string(buf, cchBuf, i);
00428 }
00429
00434 template <ss_typename_param_k C>
00435 inline C const* integer_to_string(C *buf, ss_size_t cchBuf, ss_uint16_t i)
00436 {
00437 return unsigned_integer_to_string(buf, cchBuf, i);
00438 }
00439
00444 template <ss_typename_param_k C>
00445 inline C const* integer_to_string(C *buf, ss_size_t cchBuf, ss_sint32_t i)
00446 {
00447 return signed_integer_to_string(buf, cchBuf, i);
00448 }
00449
00454 template <ss_typename_param_k C>
00455 inline C const* integer_to_string(C *buf, ss_size_t cchBuf, ss_uint32_t i)
00456 {
00457 return unsigned_integer_to_string(buf, cchBuf, i);
00458 }
00459
00460 #ifdef STLSOFT_CF_64BIT_INT_SUPPORT
00461
00465 template <ss_typename_param_k C>
00466 inline C const* integer_to_string(C *buf, ss_size_t cchBuf, ss_sint64_t const& i)
00467 {
00468 #ifdef STLSOFT_INTEGER_TO_STRING_OPTIMISE_64BIT
00469 if(i < 0x80000000)
00470 {
00471 return signed_integer_to_string(buf, cchBuf, static_cast<ss_sint32_t>(i));
00472 }
00473 #endif // STLSOFT_INTEGER_TO_STRING_OPTIMISE_64BIT
00474
00475 return signed_integer_to_string(buf, cchBuf, i);
00476 }
00477
00482 template <ss_typename_param_k C>
00483 inline C const* integer_to_string(C *buf, ss_size_t cchBuf, ss_uint64_t const& i)
00484 {
00485 #ifdef STLSOFT_INTEGER_TO_STRING_OPTIMISE_64BIT
00486 if(i < 0x80000000)
00487 {
00488 return unsigned_integer_to_string(buf, cchBuf, static_cast<ss_uint32_t>(i));
00489 }
00490 #endif // STLSOFT_INTEGER_TO_STRING_OPTIMISE_64BIT
00491
00492 return unsigned_integer_to_string(buf, cchBuf, i);
00493 }
00494 #endif
00495
00496 #ifdef STLSOFT_CF_INT_DISTINCT_INT_TYPE
00497
00501 template <ss_typename_param_k C>
00502 inline C const* integer_to_string(C *buf, ss_size_t cchBuf, int i)
00503 {
00504 return signed_integer_to_string(buf, cchBuf, i);
00505 }
00506
00511 template <ss_typename_param_k C>
00512 inline C const* integer_to_string(C *buf, ss_size_t cchBuf, unsigned int i)
00513 {
00514 return unsigned_integer_to_string(buf, cchBuf, i);
00515 }
00516 #endif
00517
00518
00519 #ifdef STLSOFT_CF_LONG_DISTINCT_INT_TYPE
00520
00524 template <ss_typename_param_k C>
00525 inline C const* integer_to_string(C *buf, ss_size_t cchBuf, long i)
00526 {
00527 return signed_integer_to_string(buf, cchBuf, i);
00528 }
00529
00534 template <ss_typename_param_k C>
00535 inline C const* integer_to_string(C *buf, ss_size_t cchBuf, unsigned long i)
00536 {
00537 return unsigned_integer_to_string(buf, cchBuf, i);
00538 }
00539 #endif
00540
00541
00542 #ifdef STLSOFT_CF_STATIC_ARRAY_SIZE_DETERMINATION_SUPPORT
00543
00548 template< ss_typename_param_k C
00549 , ss_size_t N
00550 >
00551 inline C const* integer_to_string(C (&buf)[N], ss_sint8_t i)
00552 {
00553 STLSOFT_STATIC_ASSERT(!(N < 5));
00554
00555 return signed_integer_to_string(buf, N, i);
00556 }
00557
00562 template< ss_typename_param_k C
00563 , ss_size_t N
00564 >
00565 inline C const* integer_to_string(C (&buf)[N], ss_uint8_t i)
00566 {
00567 STLSOFT_STATIC_ASSERT(!(N < 4));
00568
00569 return unsigned_integer_to_string(buf, N, i);
00570 }
00571
00576 template< ss_typename_param_k C
00577 , ss_size_t N
00578 >
00579 inline C const* integer_to_string(C (&buf)[N], ss_sint16_t i)
00580 {
00581 STLSOFT_STATIC_ASSERT(!(N < 7));
00582
00583 return signed_integer_to_string(buf, N, i);
00584 }
00585
00590 template< ss_typename_param_k C
00591 , ss_size_t N
00592 >
00593 inline C const* integer_to_string(C (&buf)[N], ss_uint16_t i)
00594 {
00595 STLSOFT_STATIC_ASSERT(!(N < 6));
00596
00597 return unsigned_integer_to_string(buf, N, i);
00598 }
00599
00604 template< ss_typename_param_k C
00605 , ss_size_t N
00606 >
00607 inline C const* integer_to_string(C (&buf)[N], ss_sint32_t i)
00608 {
00609 STLSOFT_STATIC_ASSERT(!(N < 12));
00610
00611 return signed_integer_to_string(buf, N, i);
00612 }
00613
00618 template< ss_typename_param_k C
00619 , ss_size_t N
00620 >
00621 inline C const* integer_to_string(C (&buf)[N], ss_uint32_t i)
00622 {
00623 STLSOFT_STATIC_ASSERT(!(N < 11));
00624
00625 return unsigned_integer_to_string(buf, N, i);
00626 }
00627
00628 #ifdef STLSOFT_CF_64BIT_INT_SUPPORT
00629
00633 template< ss_typename_param_k C
00634 , ss_size_t N
00635 >
00636 inline C const* integer_to_string(C (&buf)[N], ss_sint64_t const& i)
00637 {
00638 STLSOFT_STATIC_ASSERT(!(N < 21));
00639
00640 #ifdef STLSOFT_INTEGER_TO_STRING_OPTIMISE_64BIT
00641 if(i < 0x80000000)
00642 {
00643 return signed_integer_to_string(buf, N, static_cast<ss_sint32_t>(i));
00644 }
00645 #endif // STLSOFT_INTEGER_TO_STRING_OPTIMISE_64BIT
00646
00647 return signed_integer_to_string(buf, N, i);
00648 }
00649
00654 template< ss_typename_param_k C
00655 , ss_size_t N
00656 >
00657 inline C const* integer_to_string(C (&buf)[N], ss_uint64_t const& i)
00658 {
00659 STLSOFT_STATIC_ASSERT(!(N < 21));
00660
00661 #ifdef STLSOFT_INTEGER_TO_STRING_OPTIMISE_64BIT
00662 if(i < 0x80000000)
00663 {
00664 return unsigned_integer_to_string(buf, N, static_cast<ss_uint32_t>(i));
00665 }
00666 #endif // STLSOFT_INTEGER_TO_STRING_OPTIMISE_64BIT
00667
00668 return unsigned_integer_to_string(buf, N, i);
00669 }
00670 #endif
00671
00672 #ifdef STLSOFT_CF_INT_DISTINCT_INT_TYPE
00673
00677 template< ss_typename_param_k C
00678 , ss_size_t N
00679 >
00680 inline C const* integer_to_string(C (&buf)[N], int i)
00681 {
00682 return signed_integer_to_string(buf, N, i);
00683 }
00684
00689 template< ss_typename_param_k C
00690 , ss_size_t N
00691 >
00692 inline C const* integer_to_string(C (&buf)[N], unsigned int i)
00693 {
00694 return signed_integer_to_string(buf, N, i);
00695 }
00696 #endif
00697
00698 #ifdef STLSOFT_CF_LONG_DISTINCT_INT_TYPE
00699
00703 template< ss_typename_param_k C
00704 , ss_size_t N
00705 >
00706 inline C const* integer_to_string(C (&buf)[N], long i)
00707 {
00708 return signed_integer_to_string(buf, N, i);
00709 }
00710
00715 template< ss_typename_param_k C
00716 , ss_size_t N
00717 >
00718 inline C const* integer_to_string(C (&buf)[N], unsigned long i)
00719 {
00720 return signed_integer_to_string(buf, N, i);
00721 }
00722 #endif
00723
00724 #endif
00725
00726 #if 0
00727 template <ss_typename_param_k C>
00728 inline C const* integer_to_string(C *buf, ss_size_t cchBuf, ss_int_t i)
00729 {
00730 return signed_integer_to_string(buf, cchBuf, i);
00731 }
00732
00733 template <ss_typename_param_k C>
00734 inline C const* integer_to_string(C *buf, ss_size_t cchBuf, ss_uint_t i)
00735 {
00736 return unsigned_integer_to_string(buf, cchBuf, i);
00737 }
00738
00739 template <ss_typename_param_k C>
00740 inline C const* integer_to_string(C *buf, ss_size_t cchBuf, ss_bool_t i);
00741
00742 template <ss_typename_param_k C>
00743 inline C const* integer_to_string(C *buf, ss_size_t cchBuf, ss_char_a_t i);
00744
00745 template <ss_typename_param_k C>
00746 inline C const* integer_to_string(C *buf, ss_size_t cchBuf, ss_char_w_t i);
00747 #endif
00748
00749
00750
00755 template <ss_typename_param_k C>
00756 inline C const* integer_to_string(C *buf, ss_size_t cchBuf, ss_sint8_t i, ss_size_t &cchRes)
00757 {
00758 return signed_integer_to_string(buf, cchBuf, i, cchRes);
00759 }
00760
00765 template <ss_typename_param_k C>
00766 inline C const* integer_to_string(C *buf, ss_size_t cchBuf, ss_uint8_t i, ss_size_t &cchRes)
00767 {
00768 return unsigned_integer_to_string(buf, cchBuf, i, cchRes);
00769 }
00770
00775 template <ss_typename_param_k C>
00776 inline C const* integer_to_string(C *buf, ss_size_t cchBuf, ss_sint16_t i, ss_size_t &cchRes)
00777 {
00778 return signed_integer_to_string(buf, cchBuf, i, cchRes);
00779 }
00780
00785 template <ss_typename_param_k C>
00786 inline C const* integer_to_string(C *buf, ss_size_t cchBuf, ss_uint16_t i, ss_size_t &cchRes)
00787 {
00788 return unsigned_integer_to_string(buf, cchBuf, i, cchRes);
00789 }
00790
00795 template <ss_typename_param_k C>
00796 inline C const* integer_to_string(C *buf, ss_size_t cchBuf, ss_sint32_t i, ss_size_t &cchRes)
00797 {
00798 return signed_integer_to_string(buf, cchBuf, i, cchRes);
00799 }
00800
00805 template <ss_typename_param_k C>
00806 inline C const* integer_to_string(C *buf, ss_size_t cchBuf, ss_uint32_t i, ss_size_t &cchRes)
00807 {
00808 return unsigned_integer_to_string(buf, cchBuf, i, cchRes);
00809 }
00810
00811 #ifdef STLSOFT_CF_64BIT_INT_SUPPORT
00812
00816 template <ss_typename_param_k C>
00817 inline C const* integer_to_string(C *buf, ss_size_t cchBuf, ss_sint64_t const& i, ss_size_t &cchRes)
00818 {
00819 return signed_integer_to_string(buf, cchBuf, i, cchRes);
00820 }
00821
00826 template <ss_typename_param_k C>
00827 inline C const* integer_to_string(C *buf, ss_size_t cchBuf, ss_uint64_t const& i, ss_size_t &cchRes)
00828 {
00829 return unsigned_integer_to_string(buf, cchBuf, i, cchRes);
00830 }
00831 #endif
00832
00833 #ifdef STLSOFT_CF_INT_DISTINCT_INT_TYPE
00834
00838 template <ss_typename_param_k C>
00839 inline C const* integer_to_string(C *buf, ss_size_t cchBuf, int i, ss_size_t &cchRes)
00840 {
00841 return signed_integer_to_string(buf, cchBuf, i, cchRes);
00842 }
00843
00848 template <ss_typename_param_k C>
00849 inline C const* integer_to_string(C *buf, ss_size_t cchBuf, unsigned int i, ss_size_t &cchRes)
00850 {
00851 return unsigned_integer_to_string(buf, cchBuf, i, cchRes);
00852 }
00853 #endif
00854
00855 #ifdef STLSOFT_CF_LONG_DISTINCT_INT_TYPE
00856
00860 template <ss_typename_param_k C>
00861 inline C const* integer_to_string(C *buf, ss_size_t cchBuf, long i, ss_size_t &cchRes)
00862 {
00863 return signed_integer_to_string(buf, cchBuf, i, cchRes);
00864 }
00865
00870 template <ss_typename_param_k C>
00871 inline C const* integer_to_string(C *buf, ss_size_t cchBuf, unsigned long i, ss_size_t &cchRes)
00872 {
00873 return unsigned_integer_to_string(buf, cchBuf, i, cchRes);
00874 }
00875 #endif
00876
00877
00879
00880
00881 #ifdef STLSOFT_UNITTEST
00882 # include "./unittest/integer_to_string_unittest_.h"
00883 #endif
00884
00885
00886
00887 #ifndef _STLSOFT_NO_NAMESPACE
00888 }
00889 #endif
00890
00891
00892
00893 #endif
00894
00895