STLSoft: stlsoft/conversion/integer_to

00001 /* /////////////////////////////////////////////////////////////////////////
00002  * File:        stlsoft/conversion/integer_to_string.hpp
00003  *
00004  * Purpose:     Very efficient integer to string conversion functions.
00005  *
00006  * Created:     7th April 2002
00007  * Updated:     10th August 2009
00008  *
00009  * Home:        http://stlsoft.org/
00010  *
00011  * Copyright (c) 2002-2009, Matthew Wilson and Synesis Software
00012  * All rights reserved.
00013  *
00014  * Redistribution and use in source and binary forms, with or without
00015  * modification, are permitted provided that the following conditions are met:
00016  *
00017  * - Redistributions of source code must retain the above copyright notice, this
00018  *   list of conditions and the following disclaimer.
00019  * - Redistributions in binary form must reproduce the above copyright notice,
00020  *   this list of conditions and the following disclaimer in the documentation
00021  *   and/or other materials provided with the distribution.
00022  * - Neither the name(s) of Matthew Wilson and Synesis Software nor the names of
00023  *   any contributors may be used to endorse or promote products derived from
00024  *   this software without specific prior written permission.
00025  *
00026  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
00027  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
00028  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
00029  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
00030  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
00031  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
00032  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
00033  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
00034  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
00035  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
00036  * POSSIBILITY OF SUCH DAMAGE.
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 /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */
00056 
00057 /* /////////////////////////////////////////////////////////////////////////
00058  * Includes
00059  */
00060 
00061 #ifndef STLSOFT_INCL_STLSOFT_H_STLSOFT
00062 # include <stlsoft/stlsoft.h>
00063 #endif /* !STLSOFT_INCL_STLSOFT_H_STLSOFT */
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 /* !STLSOFT_INCL_STLSOFT_UTIL_H_LIMIT_TRAITS */
00068 # ifndef STLSOFT_INCL_STLSOFT_UTIL_HPP_SIGN_TRAITS
00069 #  include <stlsoft/util/sign_traits.hpp>
00070 # endif /* !STLSOFT_INCL_STLSOFT_UTIL_HPP_SIGN_TRAITS */
00071 # ifndef STLSOFT_INCL_STLSOFT_META_HPP_IS_SAME_TYPE
00072 #  include <stlsoft/meta/is_same_type.hpp>
00073 # endif /* !STLSOFT_INCL_STLSOFT_META_HPP_IS_SAME_TYPE */
00074 #endif /* !STLSOFT_CF_NEGATIVE_MODULUS_POSITIVE_GIVES_NEGATIVE_RESULT */
00075 #ifdef STLSOFT_UNITTEST
00076 # ifndef STLSOFT_INCL_STLSOFT_UTIL_H_LIMIT_TRAITS
00077 #  include <stlsoft/util/limit_traits.h>
00078 # endif /* !STLSOFT_INCL_STLSOFT_UTIL_H_LIMIT_TRAITS */
00079 # include <stdio.h>
00080 # include <string.h>
00081 #endif /* STLSOFT_UNITTEST */
00082 
00083 /* /////////////////////////////////////////////////////////////////////////
00084  * Namespace
00085  */
00086 
00087 #ifndef _STLSOFT_NO_NAMESPACE
00088 namespace stlsoft
00089 {
00090 #endif /* _STLSOFT_NO_NAMESPACE */
00091 
00092 /* /////////////////////////////////////////////////////////////////////////
00093  * Macros
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 /* __STLSOFT_INTEGER_TO_STRING_OPTIMISE_64BIT */
00099 
00100 /* /////////////////////////////////////////////////////////////////////////
00101  * Constants
00102  */
00103 
00104 #if 0
00105 namespace constants
00106 {
00107     enum
00108     {
00109         buffer_width = 21   
00110     };
00111 
00112 } // namespace int2str
00113 #endif /* 0 */
00114 
00115 /* /////////////////////////////////////////////////////////////////////////
00116  * Helper Functions
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 /* ? STLSOFT_CF_TEMPLATE_TYPE_REQUIRED_IN_ARGS */
00129 inline C const* get_digit_character()
00130 #endif /* STLSOFT_CF_TEMPLATE_TYPE_REQUIRED_IN_ARGS */
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 /* ? 0 */
00159     return s_characters + 9;
00160 #endif /* 0 */
00161 }
00162 
00163 #endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */
00164 
00165 /* /////////////////////////////////////////////////////////////////////////
00166  * Functions
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;  // Set pointer to last character.
00191 
00192     *psz = 0;   // Set the terminating null character.
00193 
00194     do
00195     {
00196 #if defined(STLSOFT_COMPILER_IS_MSVC)
00197         typedef I           rem_t;
00198 #else /* ? compiler */
00199         typedef ss_uint_t   rem_t;
00200 #endif /* compiler */
00201 
00202         rem_t   lsd = static_cast<rem_t>(i % 10);   // Determine the least significant digit.
00203 
00204         i = static_cast<I>(i / 10);                 // Deal with next most significant.
00205 
00206         --psz;                                      // Move back.
00207 
00208 #ifdef STLSOFT_CF_TEMPLATE_TYPE_REQUIRED_IN_ARGS
00209         *psz = get_digit_character(static_cast<C*>(NULL))[lsd];
00210 #else /* ? STLSOFT_CF_TEMPLATE_TYPE_REQUIRED_IN_ARGS */
00211         *psz = get_digit_character<C>()[lsd];
00212 #endif /* STLSOFT_CF_TEMPLATE_TYPE_REQUIRED_IN_ARGS */
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 // If the compiler does not evaluate -9 % 10 to equal -9, then we need to work
00271 // with it as if an unsigned, and prepend the -ve
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     // If this fires, something has happened to invoke this function on an
00278     // unsigned type.
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         // Special case of the (signed) minimum, since the maximum -ve value
00288         // of a signed integer cannot be negated.
00289         //
00290         // We instead take the equivalent value as an unsigned integer,
00291         // convert that (as unsigned), and prepend a '-'
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         // Just using the unsigned version here for the absence of
00300         // sign. Perversely, The invoked function is still a signed
00301         // specialisation.
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 /* ? STLSOFT_CF_NEGATIVE_MODULUS_POSITIVE_GIVES_NEGATIVE_RESULT */
00312 // Compiler evaluates -9 % 10 to equal -9, so use the full -ve algorithm. This
00313 // is chosen because it is more efficient on most compilers than calling the
00314 // unsigned peer and converting.
00315 
00316 #if defined(STLSOFT_COMPILER_IS_MSVC)
00317     typedef I           rem_t;
00318 #else /* ? compiler */
00319     typedef ss_sint_t   rem_t;
00320 #endif /* compiler */
00321 
00322     C   *psz    =   buf + cchBuf - 1;  // Set pointer to last character.
00323 
00324     *psz = 0;   // Set the terminating null character.
00325 
00326     if(i < 0)
00327     {
00328         do
00329         {
00330             rem_t   lsd = static_cast<rem_t>(i % 10);   // Determine the least significant digit.
00331 
00332             i = static_cast<I>(i / 10);                 // Deal with next most significant.
00333 
00334             --psz;                                      // Move back.
00335 
00336 #ifdef STLSOFT_CF_TEMPLATE_TYPE_REQUIRED_IN_ARGS
00337             *psz = get_digit_character(static_cast<C*>(NULL))[lsd];
00338 #else /* ? STLSOFT_CF_TEMPLATE_TYPE_REQUIRED_IN_ARGS */
00339             *psz = get_digit_character<C>()[lsd];
00340 #endif /* STLSOFT_CF_TEMPLATE_TYPE_REQUIRED_IN_ARGS */
00341 
00342         } while(i != 0);
00343 
00344         *(--psz) = C('-');              // Prepend the minus sign.
00345     }
00346     else
00347     {
00348         do
00349         {
00350             rem_t   lsd = static_cast<rem_t>(i % 10);   // Determine the least significant digit.
00351 
00352             i = static_cast<I>(i / 10);                 // Deal with next most significant.
00353 
00354             --psz;                                      // Move back.
00355 
00356 #ifdef STLSOFT_CF_TEMPLATE_TYPE_REQUIRED_IN_ARGS
00357             *psz = get_digit_character(static_cast<C*>(NULL))[lsd];
00358 #else /* ? STLSOFT_CF_TEMPLATE_TYPE_REQUIRED_IN_ARGS */
00359             *psz = get_digit_character<C>()[lsd];
00360 #endif /* STLSOFT_CF_TEMPLATE_TYPE_REQUIRED_IN_ARGS */
00361 
00362         } while(i != 0);
00363     }
00364 
00365     STLSOFT_ASSERT(!(psz < buf));
00366 
00367     return psz;
00368 #endif /* !STLSOFT_CF_NEGATIVE_MODULUS_POSITIVE_GIVES_NEGATIVE_RESULT */
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 /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */
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 /* STLSOFT_CF_64BIT_INT_SUPPORT */
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 /* !STLSOFT_CF_INT_DISTINCT_INT_TYPE */
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 /* !STLSOFT_CF_LONG_DISTINCT_INT_TYPE */
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 /* STLSOFT_CF_64BIT_INT_SUPPORT */
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 /* !STLSOFT_CF_INT_DISTINCT_INT_TYPE */
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 /* !STLSOFT_CF_LONG_DISTINCT_INT_TYPE */
00723 
00724 #endif /* STLSOFT_CF_STATIC_ARRAY_SIZE_DETERMINATION_SUPPORT */
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 /* 0 */
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 /* STLSOFT_CF_64BIT_INT_SUPPORT */
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 /* !STLSOFT_CF_INT_DISTINCT_INT_TYPE */
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 /* !STLSOFT_CF_LONG_DISTINCT_INT_TYPE */
00876 
00877 
00879 // Unit-testing
00880 
00881 #ifdef STLSOFT_UNITTEST
00882 # include "./unittest/integer_to_string_unittest_.h"
00883 #endif /* STLSOFT_UNITTEST */
00884 
00885 /* ////////////////////////////////////////////////////////////////////// */
00886 
00887 #ifndef _STLSOFT_NO_NAMESPACE
00888 } // namespace stlsoft
00889 #endif /* _STLSOFT_NO_NAMESPACE */
00890 
00891 /* ////////////////////////////////////////////////////////////////////// */
00892 
00893 #endif /* !STLSOFT_INCL_STLSOFT_CONVERSION_HPP_INTEGER_TO_STRING */
00894 
00895 /* ///////////////////////////// end of file //////////////////////////// */