extl/conversion/itos.h

   1 /* ///////////////////////////////////////////////////////////////////////
   2  * File:                itos.h
   3  *
   4  * Created:             08.03.03
   5  * Updated:             08.05.09
   6  *
   7  * Brief: integer ==> string
   8  *
   9  * [<Home>]
  10  * Copyright (c) 2008-2020, Waruqi All rights reserved.
  11  * //////////////////////////////////////////////////////////////////// */
  12 #ifndef EXTL_CONVERSION_ITOS_H
  13 #define EXTL_CONVERSION_ITOS_H
  14
  15 /*!\file itos.h
  16  * \brief integer ==> string
  17  *
  18  * - itos<>
  19  *   - Automatic symbol identification
  20  *   - Automatic type identification
  21  *   - support 64-bit integer conversion
  22  *   - support static array size determination
  23  *   - Multi-band conversion ==> Default: 10
  24  *     - itos<10> or itos Decimal(Default)
  25  *     - itos<16> Hexadecimal
  26  *     - itos<2>  Binary
  27  *
  28  * - uitos/sitos
  29  *   - Automatic type identification
  30  *   - support 64-bit integer conversion
  31  *   - support static array size determination
  32  *   - Multi-band conversion ==> Default: 10
  33  *   - Note: needs provide conversion buffer
  34  *
  35  * - i2s<> shim
  36  *   - Note: It's rather dangerous because the life cycle of it's buffer is so short
  37  *   - eg:
  38  *     - e_char_t *p = i2s<e_char_t>(0);
  39  *     - printf(p);                                                                     <== Undefined!
  40  *     - printf(i2s<e_char_t>(0));                                      <== Safe!
  41  *
  42  * Compatibility:
  43  * - WATCOM: Only support uitos(),sitos()
  44  * - VC6.0: Only support itos()
  45  * - VECTORC: When compiling i2s<> in unicode character-set will link failure
  46  *
  47  */
  48 #ifndef __cplusplus
  49 #       error itos.h need be supported by c++.
  50 #endif
  51
  52 /* ///////////////////////////////////////////////////////////////////////
  53  * Includes
  54  */
  55
  56 #include "prefix.h"
  57 #include "../type/traits/limit_traits.h"
  58 #include "../type/traits/is_signed.h"
  59 #include "../type/traits/is_unsigned.h"
  60 #include "../memory/stack_buffer.h"
  61
  62 #ifdef EXTL_CONVERSION_ITOS_TEST_ENABLE
  63 #       include "../counter/counter.h"
  64 #       ifdef EXTL_COMPILER_IS_GCC
  65 #               define ultoa_test       _ultot
  66 #       else
  67 #               define ultoa_test       _ultot
  68 #       endif
  69 #       define ltoa_test        _ltot
  70 #endif
  71
  72 /* ///////////////////////////////////////////////////////////////////////
  73  * Compatibility
  74  */
  75
  76 /* itos<N>() support */
  77 #ifdef EXTL_CONVERSION_ITOS_WITH_PARAM_SUPPORT
  78 #       undef EXTL_CONVERSION_ITOS_WITH_PARAM_SUPPORT
  79 #endif
  80
  81 #if !defined(EXTL_TEMPLATE_TYPE_REQUIRED_IN_ARGLIST) && \
  82                         defined(EXTL_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS_SUPPORT)
  83 #       define EXTL_CONVERSION_ITOS_WITH_PARAM_SUPPORT
  84 #endif
  85
  86 /* The maximum number of the string buffer */
  87 #define EXTL_ITOS_MAX_CHAR_NUM  (64 + 1)
  88
  89 /* ///////////////////////////////////////////////////////////////////////
  90  * ::extl::detail namespace
  91  */
  92 EXTL_BEGIN_NAMESPACE
  93 EXTL_DETAIL_BEGIN_NAMESPACE
  94
  95 /* Search Table */
  96 template < typename_param_k C >
  97 #ifdef EXTL_TEMPLATE_TYPE_REQUIRED_IN_ARGLIST /* WATCOM */
  98 inline C const* get_digit_char(C*)
  99 #else
 100 inline C const* get_digit_char()
 101 #endif
 102 {
 103     static C const s_char_table[31] =
 104     {
 105                   'F', 'E', 'D', 'C', 'B', 'A', '9', '8', '7', '6', '5', '4', '3', '2', '1'     /* Negative integer */
 106                 , '0'
 107                 , '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'     /* Positive integer */
 108     };
 109
 110     return s_char_table + 15;
 111 }
 112
 113 /* ///////////////////////////////////////////////////////////////////////
 114  * unsigned integer conversion implementaion
 115  */
 116 #ifdef EXTL_TEMPLATE_CLASS_DEFAULT_ARGUMENT_SUPPORT
 117 template < typename_param_k I, typename_param_k C, e_size_t N = 10 >
 118 #else
 119 template < typename_param_k I, typename_param_k C, e_size_t N >
 120 #endif
 121 struct uitos_impl
 122 {
 123         static inline C const* convert(I num, C* buf, e_size_t const& n)
 124         {
 125                 EXTL_MUST_BE_UNSIGNED(I);
 126
 127                 EXTL_ASSERT(NULL != buf);
 128                 if(NULL == buf) return NULL;
 129
 130                 EXTL_ASSERT(n >= 2);
 131                 if(n < 2)
 132                 {
 133                         buf[0] = static_cast<C>('\0');
 134                         return buf;
 135                 }
 136
 137                 /* convert from the tail */
 138                 C* p = buf + n - 1;
 139                 *p = 0;
 140
 141                 do
 142                 {
 143                         I index = static_cast<I>(num % static_cast<I>(N));
 144                         num = static_cast<I>(num / static_cast<I>(N));
 145
 146                         --p;
 147
 148                 #ifdef EXTL_COMPILER_IS_WATCOM
 149                         *p = get_digit_char(static_cast<C*>(NULL))[index];
 150                 #else
 151                 #       ifdef EXTL_TEMPLATE_TYPE_REQUIRED_IN_ARGLIST
 152                         *p = get_digit_char<C>(static_cast<C*>(NULL))[index];
 153                 #       else
 154                         *p = get_digit_char<C>()[index];
 155                 #       endif
 156                 #endif
 157
 158                 }
 159                 while (num != 0);
 160
 161                 EXTL_ASSERT((p >= buf));
 162
 163                 return p;
 164         }
 165
 166         static inline C const* convert(I num, C* buf, e_size_t const& n, e_size_t& result_count)
 167         {
 168                 C const* p = convert(num, buf, n);
 169                 result_count = n - (p - buf + 1);
 170                 return p;
 171         }
 172 };
 173
 174 /* ///////////////////////////////////////////////////////////////////////
 175  * signed integer conversion implementaion
 176  */
 177 #ifdef EXTL_TEMPLATE_CLASS_DEFAULT_ARGUMENT_SUPPORT
 178 template < typename_param_k I, typename_param_k C, e_size_t N = 10 >
 179 #else
 180 template < typename_param_k I, typename_param_k C, e_size_t N >
 181 #endif
 182 struct sitos_impl
 183 {
 184         static inline C const* convert(I num, C* buf, e_size_t const& n)
 185         {
 186                 EXTL_MUST_BE_SIGNED(I);
 187                 EXTL_ASSERT(NULL != buf);
 188                 if(NULL == buf) return NULL;
 189
 190                 C* p = buf + n - 1;
 191                 *p = 0;
 192
 193                 if((num < 0) && (N == 10)) /* Negative integer */
 194                 {
 195                         EXTL_ASSERT(n >= 3);
 196                         if(n < 3)
 197                         {
 198                                 buf[0] = static_cast<C>('\0');
 199                                 return buf;
 200                         }
 201
 202                         do
 203                         {
 204                                 I index = static_cast<I>(num % static_cast<I>(N));
 205                                 num = static_cast<I>(num / static_cast<I>(N));
 206
 207                                 --p;
 208
 209                         #ifdef EXTL_COMPILER_IS_WATCOM
 210                                 *p = get_digit_char(static_cast<C*>(NULL))[index];
 211                         #else
 212                         #       ifdef EXTL_TEMPLATE_TYPE_REQUIRED_IN_ARGLIST
 213                                 *p = get_digit_char<C>(static_cast<C*>(NULL))[index];
 214                         #       else
 215                                 *p = get_digit_char<C>()[index];
 216                         #       endif
 217                         #endif
 218
 219                         }
 220                         while (num != 0);
 221
 222                         *(--p) = C('-');
 223
 224                 }
 225                 else /* Positive integer */
 226                 {
 227                         EXTL_ASSERT(n >= 2);
 228                         if(n < 2)
 229                         {
 230                                 buf[0] = static_cast<C>('\0');
 231                                 return buf;
 232                         }
 233
 234                         do
 235                         {
 236                                 I index = static_cast<I>(num % static_cast<I>(N));
 237                                 num = static_cast<I>(num / static_cast<I>(N));
 238
 239                                 --p;
 240
 241                         #ifdef EXTL_COMPILER_IS_WATCOM
 242                                 *p = get_digit_char(static_cast<C*>(NULL))[index];
 243                         #else
 244                         #       ifdef EXTL_TEMPLATE_TYPE_REQUIRED_IN_ARGLIST
 245                                 *p = get_digit_char<C>(static_cast<C*>(NULL))[index];
 246                         #       else
 247                                 *p = get_digit_char<C>()[index];
 248                         #       endif
 249                         #endif
 250
 251                         }
 252                         while (num != 0);
 253                 }
 254
 255                 EXTL_ASSERT((p >= buf));
 256
 257                 return p;
 258         }
 259
 260         static inline C const* convert(I num, C* buf, e_size_t const& n, e_size_t& result_count)
 261         {
 262                 C const* p = convert(num, buf, n);
 263                 result_count = n - (p - buf + 1);
 264                 return p;
 265         }
 266 };
 267
 268 /* ///////////////////////////////////////////////////////////////////////
 269  * itos<N>() implementation
 270  * //////////////////////////////////////////////////////////////////// */
 271 #ifndef EXTL_TEMPLATE_TYPE_REQUIRED_IN_ARGLIST
 272 /* //////////////////////////////////////////////////////////////////// */
 273 #ifdef EXTL_TEMPLATE_PARTIAL_SPEC_SUPPORT
 274 #       ifdef EXTL_TEMPLATE_CLASS_DEFAULT_ARGUMENT_SUPPORT
 275 template < e_bool_t is_unsigned, e_bool_t is_signed, typename_param_k I, typename_param_k C, e_size_t N = 10 >
 276 struct sign_selector;
 277 #       else
 278 template < e_bool_t is_unsigned, e_bool_t is_signed, typename_param_k I, typename_param_k C, e_size_t N >
 279 struct sign_selector;
 280 #       endif
 281 #else
 282 template < e_bool_t is_unsigned, e_bool_t is_signed >
 283 struct sign_selector;
 284 #endif
 285
 286 /* Select unsigned integer conversion */
 287 #ifdef EXTL_TEMPLATE_PARTIAL_SPEC_SUPPORT
 288 template < typename_param_k I, typename_param_k C, e_size_t N >
 289 struct sign_selector< e_true_v, e_false_v, I, C, N >
 290 {
 291 #else
 292 EXTL_TEMPLATE_SPECIALISATION
 293 struct sign_selector< e_true_v, e_false_v >
 294 {
 295 #       ifdef EXTL_TEMPLATE_CLASS_DEFAULT_ARGUMENT_SUPPORT
 296         template < typename_param_k I, typename_param_k C, e_size_t N = 10 >
 297         struct itos_impl
 298         {
 299 #       else
 300         template < typename_param_k I, typename_param_k C, e_size_t N >
 301         struct itos_impl
 302         {
 303 #       endif
 304 #endif
 305                 static inline C const* convert(I num, C* buf, e_size_t const& n)
 306                 {
 307                         return uitos_impl<I, C, N>::convert(num, buf, n);
 308                 }
 309
 310                 static inline C const* convert(I num, C* buf, e_size_t const& n, e_size_t& result_count)
 311                 {
 312                         C const* p = convert(num, buf, n);
 313                         result_count = n - (p - buf + 1);
 314                         return p;
 315                 }
 316
 317 #ifndef EXTL_TEMPLATE_PARTIAL_SPEC_SUPPORT
 318         };
 319 #endif
 320 };
 321
 322 /* Select signed integer conversion */
 323 #ifdef EXTL_TEMPLATE_PARTIAL_SPEC_SUPPORT
 324 template < typename_param_k I, typename_param_k C, e_size_t N >
 325 struct sign_selector< e_false_v, e_true_v, I, C, N >
 326 {
 327 #else
 328 EXTL_TEMPLATE_SPECIALISATION
 329 struct sign_selector< e_false_v, e_true_v >
 330 {
 331 #       ifdef EXTL_TEMPLATE_CLASS_DEFAULT_ARGUMENT_SUPPORT
 332         template < typename_param_k I, typename_param_k C, e_size_t N = 10 >
 333         struct itos_impl
 334         {
 335 #       else
 336         template < typename_param_k I, typename_param_k C, e_size_t N >
 337         struct itos_impl
 338         {
 339 #       endif
 340 #endif
 341                 static inline C const* convert(I num, C* buf, e_size_t const& n)
 342                 {
 343                         return sitos_impl<I, C, N>::convert(num, buf, n);
 344                 }
 345
 346                 static inline C const* convert(I num, C* buf, e_size_t const& n, e_size_t& result_count)
 347                 {
 348                         C const* p = convert(num, buf, n);
 349                         result_count = n - (p - buf + 1);
 350                         return p;
 351                 }
 352
 353 #ifndef EXTL_TEMPLATE_PARTIAL_SPEC_SUPPORT
 354         };
 355 #endif
 356 };
 357 #endif /* EXTL_TEMPLATE_TYPE_REQUIRED_IN_ARGLIST */
 358 /* //////////////////////////////////////////////////////////////////// */
 359 EXTL_DETAIL_END_NAMESPACE /* ::extl::detail namespace */
 360 /* //////////////////////////////////////////////////////////////////// */
 361
 362 #if defined(EXTL_CONVERSION_ITOS_WITH_PARAM_SUPPORT)
 363
 364 /// uitos<N>()
 365 template < e_size_t N, typename_param_k I, typename_param_k C >
 366 inline C const* uitos(I num, C* buf, e_size_t const& n)
 367 {
 368         return EXTL_NS_DETAIL(uitos_impl)<I, C, N>::convert(num, buf, n);
 369 }
 370 /// uitos<N>()
 371 template < e_size_t N, typename_param_k I, typename_param_k C >
 372 inline C const* uitos(I num, C* buf, e_size_t const& n, e_size_t& result_count)
 373 {
 374         return EXTL_NS_DETAIL(uitos_impl)<I, C, N>::convert(num, buf, n, result_count);
 375 }
 376 /// sitos<N>()
 377 template < e_size_t N, typename_param_k I, typename_param_k C >
 378 inline C const* sitos(I num, C* buf, e_size_t const& n)
 379 {
 380         return EXTL_NS_DETAIL(sitos_impl)<I, C, N>::convert(num, buf, n);
 381 }
 382 /// sitos<N>()
 383 template < e_size_t N, typename_param_k I, typename_param_k C >
 384 inline C const* sitos(I num, C* buf, e_size_t const& n, e_size_t& result_count)
 385 {
 386         return EXTL_NS_DETAIL(sitos_impl)<I, C, N>::convert(num, buf, n, result_count);
 387 }
 388
 389 /// itos<N>()
 390 template < e_size_t N, typename_param_k I, typename_param_k C >
 391 inline C const* itos(I num, C* buf, e_size_t const& n)
 392 {
 393 #       ifdef EXTL_TEMPLATE_PARTIAL_SPEC_SUPPORT
 394         return EXTL_NS_DETAIL(sign_selector)
 395                 <
 396                 (is_unsigned<I>::value),
 397                 (is_signed<I>::value),
 398                 I, C, N
 399                 >::convert(num, buf, n);
 400 #       else
 401     return EXTL_NS_DETAIL(sign_selector)
 402                 <
 403                 (is_unsigned<I>::value),
 404                 (is_signed<I>::value)
 405                 >::template_qual_k itos_impl<I, C, N>::convert(num, buf, n);
 406 #       endif
 407 }
 408 /// itos<N>()
 409 template < e_size_t N, typename_param_k I, typename_param_k C >
 410 inline C const* itos(I num, C* buf, e_size_t const& n, e_size_t& result_count)
 411 {
 412         C const* p = itos<N, I, C>(num, buf, n);
 413         result_count = n - (p - buf + 1);
 414         return p;
 415 }
 416 /* ///////////////////////////////////////////////////////////////////////
 417  * Default: Decimal integer conversion
 418  */
 419
 420 /// uitos
 421 template < typename_param_k I, typename_param_k C >
 422 inline C const* uitos(I num, C* buf, e_size_t const& n)
 423 {
 424         return EXTL_NS_DETAIL(uitos_impl)<I, C>::convert(num, buf, n);
 425 }
 426 /// uitos
 427 template < typename_param_k I, typename_param_k C >
 428 inline C const* uitos(I num, C* buf, e_size_t const& n, e_size_t& result_count)
 429 {
 430         return EXTL_NS_DETAIL(uitos_impl)<I, C>::convert(num, buf, n, result_count);
 431 }
 432
 433 /// sitos
 434 template < typename_param_k I, typename_param_k C >
 435 inline C const* sitos(I num, C* buf, e_size_t const& n)
 436 {
 437         return EXTL_NS_DETAIL(sitos_impl)<I, C>::convert(num, buf, n);
 438 }
 439 /// sitos
 440 template < typename_param_k I, typename_param_k C >
 441 inline C const* sitos(I num, C* buf, e_size_t const& n, e_size_t& result_count)
 442 {
 443         return EXTL_NS_DETAIL(sitos_impl)<I, C>::convert(num, buf, n, result_count);
 444 }
 445
 446 /// itos
 447 template < typename_param_k I, typename_param_k C >
 448 inline C const* itos(I num, C* buf, e_size_t const& n)
 449 {
 450     return itos<10, I, C>(num, buf, n);
 451 }
 452 /// itos
 453 template < typename_param_k I, typename_param_k C >
 454 inline C const* itos(I num, C* buf, e_size_t const& n, e_size_t& result_count)
 455 {
 456     return itos<10, I, C>(num, buf, n, result_count);
 457 }
 458 /* ///////////////////////////////////////////////////////////////////////
 459  * static array size determination
 460  */
 461 #ifdef EXTL_STATIC_ARRAY_SIZE_DETERMINATION_SUPPORT
 462
 463 /// utos
 464 template < e_size_t N, typename_param_k I, typename_param_k C, e_size_t BUF_COUNT >
 465 inline C const* uitos(I num, C (&buf)[BUF_COUNT])
 466 {
 467         return EXTL_NS_DETAIL(uitos_impl)<I, C, N>::convert(num, buf, BUF_COUNT);
 468 }
 469 /// utos
 470 template < e_size_t N, typename_param_k I, typename_param_k C, e_size_t BUF_COUNT >
 471 inline C const* uitos(I num, C (&buf)[BUF_COUNT], e_size_t& result_count)
 472 {
 473         return EXTL_NS_DETAIL(uitos_impl)<I, C, N>::convert(num, buf, BUF_COUNT, result_count);
 474 }
 475 /// sitos
 476 template < e_size_t N, typename_param_k I, typename_param_k C, e_size_t BUF_COUNT >
 477 inline C const* sitos(I num, C (&buf)[BUF_COUNT])
 478 {
 479         return EXTL_NS_DETAIL(sitos_impl)<I, C, N>::convert(num, buf, BUF_COUNT);
 480 }
 481 /// sitos
 482 template < e_size_t N, typename_param_k I, typename_param_k C, e_size_t BUF_COUNT >
 483 inline C const* sitos(I num, C (&buf)[BUF_COUNT], e_size_t& result_count)
 484 {
 485         return EXTL_NS_DETAIL(sitos_impl)<I, C, N>::convert(num, buf, BUF_COUNT, result_count);
 486 }
 487 /// itos
 488 template < e_size_t N, typename_param_k I, typename_param_k C, e_size_t BUF_COUNT >
 489 inline C const* itos(I num, C (&buf)[BUF_COUNT])
 490 {
 491         return itos<N, I, C>(num, buf, BUF_COUNT);
 492 }
 493 /// itos
 494 template < e_size_t N, typename_param_k I, typename_param_k C, e_size_t BUF_COUNT >
 495 inline C const* itos(I num, C (&buf)[BUF_COUNT], e_size_t& result_count)
 496 {
 497         return itos<N, I, C>(num, buf, BUF_COUNT, result_count);
 498 }
 499 /* ///////////////////////////////////////////////////////////////////////
 500  * Default: Decimal integer conversion
 501  */
 502
 503 /// utos
 504 template < typename_param_k I, typename_param_k C, e_size_t BUF_COUNT >
 505 inline C const* uitos(I num, C (&buf)[BUF_COUNT])
 506 {
 507         return EXTL_NS_DETAIL(uitos_impl)<I, C>::convert(num, buf, BUF_COUNT);
 508 }
 509 /// utos
 510 template < typename_param_k I, typename_param_k C, e_size_t BUF_COUNT >
 511 inline C const* uitos(I num, C (&buf)[BUF_COUNT], e_size_t& result_count)
 512 {
 513         return EXTL_NS_DETAIL(uitos_impl)<I, C>::convert(num, buf, BUF_COUNT, result_count);
 514 }
 515 /// sitos
 516 template < typename_param_k I, typename_param_k C, e_size_t BUF_COUNT >
 517 inline C const* sitos(I num, C (&buf)[BUF_COUNT])
 518 {
 519         return EXTL_NS_DETAIL(sitos_impl)<I, C>::convert(num, buf, BUF_COUNT);
 520 }
 521 /// sitos
 522 template < typename_param_k I, typename_param_k C, e_size_t BUF_COUNT >
 523 inline C const* sitos(I num, C (&buf)[BUF_COUNT], e_size_t& result_count)
 524 {
 525         return EXTL_NS_DETAIL(sitos_impl)<I, C>::convert(num, buf, BUF_COUNT, result_count);
 526 }
 527 /// itos
 528 template < typename_param_k I, typename_param_k C, e_size_t BUF_COUNT >
 529 inline C const* itos(I num, C (&buf)[BUF_COUNT])
 530 {
 531         return itos<10, I, C>(num, buf, BUF_COUNT);
 532 }
 533 /// itos
 534 template < typename_param_k I, typename_param_k C, e_size_t BUF_COUNT >
 535 inline C const* itos(I num, C (&buf)[BUF_COUNT], e_size_t& result_count)
 536 {
 537         return itos<10, I, C>(num, buf, BUF_COUNT, result_count);
 538 }
 539 #endif
 540
 541 #else /* !defined(EXTL_CONVERSION_ITOS_WITH_PARAM_SUPPORT) */
 542
 543 /// uitos
 544 template < typename_param_k I, typename_param_k C >
 545 inline C const* uitos(I num, C* buf, e_size_t const& n)
 546 {
 547         return EXTL_NS_DETAIL(uitos_impl)<I, C, 10>::convert(num, buf, n);
 548 }
 549 /// uitos
 550 template < typename_param_k I, typename_param_k C >
 551 inline C const* uitos(I num, C* buf, e_size_t const& n, e_size_t& result_count)
 552 {
 553         return EXTL_NS_DETAIL(uitos_impl)<I, C, 10>::convert(num, buf, n, result_count);
 554 }
 555
 556 /// sitos
 557 template < typename_param_k I, typename_param_k C >
 558 inline C const* sitos(I num, C* buf, e_size_t const& n)
 559 {
 560         return EXTL_NS_DETAIL(sitos_impl)<I, C, 10>::convert(num, buf, n);
 561 }
 562 /// sitos
 563 template < typename_param_k I, typename_param_k C >
 564 inline C const* sitos(I num, C* buf, e_size_t const& n, e_size_t& result_count)
 565 {
 566         return EXTL_NS_DETAIL(sitos_impl)<I, C, 10>::convert(num, buf, n, result_count);
 567 }
 568
 569 #if defined(EXTL_TEMPLATE_PARTIAL_SPEC_SUPPORT) || \
 570                 defined(EXTL_TEMPLATE_CLASS_DEFAULT_ARGUMENT_SUPPORT)
 571 /// itos
 572 template < typename_param_k I, typename_param_k C >
 573 inline C const* itos(I num, C* buf, e_size_t const& n)
 574 {
 575 #       ifdef EXTL_TEMPLATE_PARTIAL_SPEC_SUPPORT
 576         return EXTL_NS_DETAIL(sign_selector)
 577                 <
 578                 (is_unsigned<I>::value),
 579                 (is_signed<I>::value),
 580                 I, C, 10
 581                 >::convert(num, buf, n);
 582 #       else
 583     return EXTL_NS_DETAIL(sign_selector)
 584                 <
 585                 (is_unsigned<I>::value),
 586                 (is_signed<I>::value)
 587                 >::template_qual_k itos_impl<I, C, 10>::convert(num, buf, n);
 588 #       endif
 589 }
 590 /// itos
 591 template < typename_param_k I, typename_param_k C >
 592 inline C const* itos(I num, C* buf, e_size_t const& n, e_size_t& result_count)
 593 {
 594     C const* p = itos(num, buf, n);
 595         result_count = n - (p - buf + 1);
 596         return p;
 597 }
 598 #endif /* defined(EXTL_TEMPLATE_PARTIAL_SPEC_SUPPORT) || \
 599                 defined(EXTL_TEMPLATE_CLASS_DEFAULT_ARGUMENT_SUPPORT) */
 600
 601 #       ifdef EXTL_STATIC_ARRAY_SIZE_DETERMINATION_SUPPORT
 602 /// utos
 603 template < typename_param_k I, typename_param_k C, e_size_t BUF_COUNT >
 604 inline C const* uitos(I num, C (&buf)[BUF_COUNT])
 605 {
 606         return EXTL_NS_DETAIL(uitos_impl)<I, C, 10>::convert(num, buf, BUF_COUNT);
 607 }
 608 /// utos
 609 template < typename_param_k I, typename_param_k C, e_size_t BUF_COUNT >
 610 inline C const* uitos(I num, C (&buf)[BUF_COUNT], e_size_t& result_count)
 611 {
 612         return EXTL_NS_DETAIL(uitos_impl)<I, C, 10>::convert(num, buf, BUF_COUNT, result_count);
 613 }
 614 /// sitos
 615 template < typename_param_k I, typename_param_k C, e_size_t BUF_COUNT >
 616 inline C const* sitos(I num, C (&buf)[BUF_COUNT])
 617 {
 618         return EXTL_NS_DETAIL(sitos_impl)<I, C, 10>::convert(num, buf, BUF_COUNT);
 619 }
 620 /// sitos
 621 template < typename_param_k I, typename_param_k C, e_size_t BUF_COUNT >
 622 inline C const* sitos(I num, C (&buf)[BUF_COUNT], e_size_t& result_count)
 623 {
 624         return EXTL_NS_DETAIL(sitos_impl)<I, C, 10>::convert(num, buf, BUF_COUNT, result_count);
 625 }
 626
 627 #               if defined(EXTL_TEMPLATE_PARTIAL_SPEC_SUPPORT) || \
 628                         defined(EXTL_TEMPLATE_CLASS_DEFAULT_ARGUMENT_SUPPORT)
 629 /// itos
 630 template < typename_param_k I, typename_param_k C, e_size_t BUF_COUNT >
 631 inline C const* itos(I num, C (&buf)[BUF_COUNT])
 632 {
 633         return itos(num, buf, BUF_COUNT);
 634 }
 635 /// itos
 636 template < typename_param_k I, typename_param_k C, e_size_t BUF_COUNT >
 637 inline C const* itos(I num, C (&buf)[BUF_COUNT], e_size_t& result_count)
 638 {
 639         return itos(num, buf, BUF_COUNT, result_count);
 640 }
 641 #               endif /* defined(EXTL_TEMPLATE_PARTIAL_SPEC_SUPPORT) || \
 642                         defined(EXTL_TEMPLATE_CLASS_DEFAULT_ARGUMENT_SUPPORT) */
 643
 644 #       endif /* EXTL_STATIC_ARRAY_SIZE_DETERMINATION_SUPPORT */
 645
 646 #endif /* !defined(EXTL_TEMPLATE_TYPE_REQUIRED_IN_ARGLIST) && \
 647                 defined(EXTL_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS_SUPPORT) */
 648
 649 /// i2s<> conversion shim
 650 #if defined(EXTL_TEMPLATE_PARTIAL_SPEC_SUPPORT) || \
 651                 defined(EXTL_TEMPLATE_CLASS_DEFAULT_ARGUMENT_SUPPORT)
 652
 653 #if defined(EXTL_CONVERSION_ITOS_WITH_PARAM_SUPPORT)
 654 #       ifdef EXTL_TEMPLATE_CLASS_DEFAULT_ARGUMENT_SUPPORT
 655 template < typename_param_k C = e_tchar_t, e_size_t N = 10 >
 656 #       else
 657 template < typename_param_k C, e_size_t N >
 658 #       endif
 659 #else
 660 template < typename_param_k C >
 661 #endif
 662
 663 class i2s
 664 #ifdef EXTL_TEMPLATE_CLASS_DEFAULT_ARGUMENT_SUPPORT
 665         : public stack_buffer<C, EXTL_ITOS_MAX_CHAR_NUM>
 666 #else
 667         : public stack_buffer   <       C
 668                                                         ,       EXTL_ITOS_MAX_CHAR_NUM
 669                                                         ,       typename_type_k memory_traits_selector<C>::memory_traits_type
 670                                                         >
 671 #endif
 672 {
 673         private:
 674
 675         #ifdef EXTL_TEMPLATE_CLASS_DEFAULT_ARGUMENT_SUPPORT
 676                 typedef stack_buffer<C, EXTL_ITOS_MAX_CHAR_NUM>                 base_type;
 677         #else
 678                 typedef stack_buffer<   C
 679                                                         ,       EXTL_ITOS_MAX_CHAR_NUM
 680                                                         ,       typename_type_k memory_traits_selector<C>::memory_traits_type
 681                                                         >       base_type;
 682         #endif
 683
 684         public:
 685         #if defined(EXTL_CONVERSION_ITOS_WITH_PARAM_SUPPORT)
 686                 typedef i2s<C, N>                                                                               class_type;
 687         #else
 688                 typedef i2s<C>                                                                                  class_type;
 689         #endif
 690                 typedef typename_type_k base_type::size_type                    size_type;
 691                 typedef typename_type_k base_type::value_type                   dest_type;
 692                 typedef typename_type_k base_type::pointer                              pointer;
 693                 typedef typename_type_k base_type::const_pointer                const_pointer;
 694
 695         private:
 696                 size_type                                                                                               m_result_count;
 697
 698         public:
 699                 template < typename_param_k I >
 700                 explicit_k i2s(I const& src)
 701                 :       base_type(EXTL_ITOS_MAX_CHAR_NUM), /* 64 + 1 */
 702                         m_result_count(0)
 703                 {
 704                         convert(src);
 705                 }
 706         public:
 707                 operator dest_type const*() const
 708                 {
 709                         const size_type n = base_type::size();
 710                         const_pointer buf = base_type::data();
 711
 712                         return (buf + n - m_result_count - 1);
 713                 }
 714         private:
 715                 template < typename_param_k I >
 716                 void convert(I const& src)
 717                 {
 718                         const size_type n = base_type::size();
 719                         const pointer buf = base_type::data();
 720
 721                 #if defined(EXTL_CONVERSION_ITOS_WITH_PARAM_SUPPORT)
 722                         itos<N, I, C>(src, buf, n, m_result_count);
 723                 #else
 724                         itos(src, buf, n, m_result_count);
 725                 #endif
 726                 }
 727 };
 728 #endif /* defined(EXTL_TEMPLATE_PARTIAL_SPEC_SUPPORT) || \
 729                         defined(EXTL_TEMPLATE_CLASS_DEFAULT_ARGUMENT_SUPPORT) */
 730
 731 /* ///////////////////////////////////////////////////////////////////////
 732  * Unit-testing
 733  */
 734 #ifdef EXTL_CONVERSION_ITOS_TEST_ENABLE
 735 #       include "unit_test/itos_test.h"
 736 #endif
 737 /* ///////////////////////////////////////////////////////////////////////
 738  * ::extl namespace
 739  */
 740 EXTL_END_NAMESPACE
 741
 742 /* //////////////////////////////////////////////////////////////////// */
 743 #endif /* EXTL_CONVERSION_ITOS_H */
 744 /* //////////////////////////////////////////////////////////////////// */