STLSoft: stlsoft/util/integral_printf

00001 /* /////////////////////////////////////////////////////////////////////////
00002  * File:        stlsoft/util/integral_printf_traits.hpp (formerly stlsoft/util/printf_traits.hpp)
00003  *
00004  * Purpose:     integral_printf_traits classes.
00005  *
00006  * Created:     16th January 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
00016  * met:
00017  *
00018  * - Redistributions of source code must retain the above copyright notice,
00019  *   this list of conditions and the following disclaimer.
00020  * - Redistributions in binary form must reproduce the above copyright
00021  *   notice, this list of conditions and the following disclaimer in the
00022  *   documentation and/or other materials provided with the distribution.
00023  * - Neither the name(s) of Matthew Wilson and Synesis Software nor the
00024  *   names of any contributors may be used to endorse or promote products
00025  *   derived from this software without specific prior written permission.
00026  *
00027  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
00028  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
00029  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
00030  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
00031  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
00032  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
00033  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
00034  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
00035  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
00036  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
00037  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00038  *
00039  * ////////////////////////////////////////////////////////////////////// */
00040 
00041 
00049 #ifndef STLSOFT_INCL_STLSOFT_UTIL_HPP_INTEGRAL_PRINTF_TRAITS
00050 #define STLSOFT_INCL_STLSOFT_UTIL_HPP_INTEGRAL_PRINTF_TRAITS
00051 
00052 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00053 # define STLSOFT_VER_STLSOFT_UTIL_HPP_INTEGRAL_PRINTF_TRAITS_MAJOR      5
00054 # define STLSOFT_VER_STLSOFT_UTIL_HPP_INTEGRAL_PRINTF_TRAITS_MINOR      1
00055 # define STLSOFT_VER_STLSOFT_UTIL_HPP_INTEGRAL_PRINTF_TRAITS_REVISION   6
00056 # define STLSOFT_VER_STLSOFT_UTIL_HPP_INTEGRAL_PRINTF_TRAITS_EDIT       66
00057 #endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */
00058 
00059 /* /////////////////////////////////////////////////////////////////////////
00060  * Includes
00061  */
00062 
00063 #ifndef STLSOFT_INCL_STLSOFT_H_STLSOFT
00064 # include <stlsoft/stlsoft.h>
00065 #endif /* !STLSOFT_INCL_STLSOFT_H_STLSOFT */
00066 
00067 #ifdef STLSOFT_UNITTEST
00068 # include <stlsoft/util/limit_traits.h>
00069 # include <stlsoft/meta/yesno.hpp>
00070 # include <stlsoft/util/std/stdio_overload_detectors.hpp>
00071 # include <stdarg.h>
00072 # include <stdio.h>
00073 # include <string.h>
00074 # include <wchar.h>
00075 #endif /* STLSOFT_UNITTEST */
00076 
00077 /* /////////////////////////////////////////////////////////////////////////
00078  * Namespace
00079  */
00080 
00081 #ifndef _STLSOFT_NO_NAMESPACE
00082 namespace stlsoft
00083 {
00084 #endif /* _STLSOFT_NO_NAMESPACE */
00085 
00086 /* /////////////////////////////////////////////////////////////////////////
00087  * Constants & definitions
00088  */
00089 
00090 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00091 
00092 # define STLSOFT_INTEGRAL_PRINTF_TRAITS_SINT8_MIN       -128
00093 # define STLSOFT_INTEGRAL_PRINTF_TRAITS_SINT8_MAX       127
00094 
00095 # define STLSOFT_INTEGRAL_PRINTF_TRAITS_UINT8_MIN       0
00096 # define STLSOFT_INTEGRAL_PRINTF_TRAITS_UINT8_MAX       255
00097 
00098 # define STLSOFT_INTEGRAL_PRINTF_TRAITS_SINT16_MIN      -32768
00099 # define STLSOFT_INTEGRAL_PRINTF_TRAITS_SINT16_MAX      32767
00100 
00101 # define STLSOFT_INTEGRAL_PRINTF_TRAITS_UINT16_MIN      0
00102 # define STLSOFT_INTEGRAL_PRINTF_TRAITS_UINT16_MAX      65535
00103 
00104 # define STLSOFT_INTEGRAL_PRINTF_TRAITS_SINT32_MIN      -2147483648
00105 # define STLSOFT_INTEGRAL_PRINTF_TRAITS_SINT32_MAX      2147483647
00106 
00107 # define STLSOFT_INTEGRAL_PRINTF_TRAITS_UINT32_MIN      0
00108 # define STLSOFT_INTEGRAL_PRINTF_TRAITS_UINT32_MAX      4294967295
00109 
00110 # define STLSOFT_INTEGRAL_PRINTF_TRAITS_SINT64_MIN      -9223372036854775808
00111 # define STLSOFT_INTEGRAL_PRINTF_TRAITS_SINT64_MAX      9223372036854775807
00112 
00113 # define STLSOFT_INTEGRAL_PRINTF_TRAITS_UINT64_MIN      0
00114 # define STLSOFT_INTEGRAL_PRINTF_TRAITS_UINT64_MAX      18446744073709551615
00115 
00116 
00117 
00118  /* char */
00119 # if _STLSOFT_SIZEOF_CHAR == 1
00120 
00121 #  define STLSOFT_INTEGRAL_PRINTF_TRAITS_SCHAR_MIN          STLSOFT_INTEGRAL_PRINTF_TRAITS_SINT8_MIN
00122 #  define STLSOFT_INTEGRAL_PRINTF_TRAITS_SCHAR_MAX          STLSOFT_INTEGRAL_PRINTF_TRAITS_SINT8_MAX
00123 
00124 #  define STLSOFT_INTEGRAL_PRINTF_TRAITS_UCHAR_MIN          STLSOFT_INTEGRAL_PRINTF_TRAITS_UINT8_MIN
00125 #  define STLSOFT_INTEGRAL_PRINTF_TRAITS_UCHAR_MAX          STLSOFT_INTEGRAL_PRINTF_TRAITS_UINT8_MAX
00126 
00127 #  ifdef STLSOFT_CF_CHAR_IS_UNSIGNED
00128 #   define STLSOFT_INTEGRAL_PRINTF_TRAITS_CHAR_MIN          STLSOFT_INTEGRAL_PRINTF_TRAITS_UCHAR_MIN
00129 #   define STLSOFT_INTEGRAL_PRINTF_TRAITS_CHAR_MAX          STLSOFT_INTEGRAL_PRINTF_TRAITS_UCHAR_MAX
00130 #  else /* ? STLSOFT_CF_CHAR_IS_UNSIGNED */
00131 #   define STLSOFT_INTEGRAL_PRINTF_TRAITS_CHAR_MIN          STLSOFT_INTEGRAL_PRINTF_TRAITS_SCHAR_MIN
00132 #   define STLSOFT_INTEGRAL_PRINTF_TRAITS_CHAR_MAX          STLSOFT_INTEGRAL_PRINTF_TRAITS_SCHAR_MAX
00133 #  endif /* STLSOFT_CF_CHAR_IS_UNSIGNED */
00134 
00135 # else /* ? _STLSOFT_SIZEOF_CHAR */
00136 #  error Cannot operate with a compiler for which sizeof(char) != 1
00137 # endif /* _STLSOFT_SIZEOF_CHAR */
00138 
00139 
00140  /* short */
00141 # if _STLSOFT_SIZEOF_SHORT == 2
00142 
00143 #  define STLSOFT_INTEGRAL_PRINTF_TRAITS_SHORT_MIN          STLSOFT_INTEGRAL_PRINTF_TRAITS_SINT16_MIN
00144 #  define STLSOFT_INTEGRAL_PRINTF_TRAITS_SHORT_MAX          STLSOFT_INTEGRAL_PRINTF_TRAITS_SINT16_MAX
00145 
00146 #  define STLSOFT_INTEGRAL_PRINTF_TRAITS_USHORT_MIN         STLSOFT_INTEGRAL_PRINTF_TRAITS_UINT16_MIN
00147 #  define STLSOFT_INTEGRAL_PRINTF_TRAITS_USHORT_MAX         STLSOFT_INTEGRAL_PRINTF_TRAITS_UINT16_MAX
00148 
00149 # elif _STLSOFT_SIZEOF_SHORT == 4
00150 
00151 #  define STLSOFT_INTEGRAL_PRINTF_TRAITS_SHORT_MIN          STLSOFT_INTEGRAL_PRINTF_TRAITS_SINT16_MIN
00152 #  define STLSOFT_INTEGRAL_PRINTF_TRAITS_SHORT_MAX          STLSOFT_INTEGRAL_PRINTF_TRAITS_SINT16_MAX
00153 
00154 #  define STLSOFT_INTEGRAL_PRINTF_TRAITS_USHORT_MIN         STLSOFT_INTEGRAL_PRINTF_TRAITS_UINT16_MIN
00155 #  define STLSOFT_INTEGRAL_PRINTF_TRAITS_USHORT_MAX         STLSOFT_INTEGRAL_PRINTF_TRAITS_UINT16_MAX
00156 
00157 # else /* ? _STLSOFT_SIZEOF_SHORT */
00158 #  error Cannot operate with a compiler for which sizeof(short) != 2 && sizeof(short) != 4
00159 # endif /* _STLSOFT_SIZEOF_SHORT */
00160 
00161 
00162  /* int */
00163 # if _STLSOFT_SIZEOF_INT == 2
00164 
00165 #  define STLSOFT_INTEGRAL_PRINTF_TRAITS_INT_MIN            STLSOFT_INTEGRAL_PRINTF_TRAITS_SINT16_MIN
00166 #  define STLSOFT_INTEGRAL_PRINTF_TRAITS_INT_MAX            STLSOFT_INTEGRAL_PRINTF_TRAITS_SINT16_MAX
00167 
00168 #  define STLSOFT_INTEGRAL_PRINTF_TRAITS_UINT_MIN           STLSOFT_INTEGRAL_PRINTF_TRAITS_UINT16_MIN
00169 #  define STLSOFT_INTEGRAL_PRINTF_TRAITS_UINT_MAX           STLSOFT_INTEGRAL_PRINTF_TRAITS_UINT16_MAX
00170 
00171 # elif _STLSOFT_SIZEOF_INT == 4
00172 
00173 #  define STLSOFT_INTEGRAL_PRINTF_TRAITS_INT_MIN            STLSOFT_INTEGRAL_PRINTF_TRAITS_SINT32_MIN
00174 #  define STLSOFT_INTEGRAL_PRINTF_TRAITS_INT_MAX            STLSOFT_INTEGRAL_PRINTF_TRAITS_SINT32_MAX
00175 
00176 #  define STLSOFT_INTEGRAL_PRINTF_TRAITS_UINT_MIN           STLSOFT_INTEGRAL_PRINTF_TRAITS_UINT32_MIN
00177 #  define STLSOFT_INTEGRAL_PRINTF_TRAITS_UINT_MAX           STLSOFT_INTEGRAL_PRINTF_TRAITS_UINT32_MAX
00178 
00179 # elif _STLSOFT_SIZEOF_INT == 8
00180 
00181 #  define STLSOFT_INTEGRAL_PRINTF_TRAITS_INT_MIN            STLSOFT_INTEGRAL_PRINTF_TRAITS_SINT64_MIN
00182 #  define STLSOFT_INTEGRAL_PRINTF_TRAITS_INT_MAX            STLSOFT_INTEGRAL_PRINTF_TRAITS_SINT64_MAX
00183 
00184 #  define STLSOFT_INTEGRAL_PRINTF_TRAITS_UINT_MIN           STLSOFT_INTEGRAL_PRINTF_TRAITS_UINT64_MIN
00185 #  define STLSOFT_INTEGRAL_PRINTF_TRAITS_UINT_MAX           STLSOFT_INTEGRAL_PRINTF_TRAITS_UINT64_MAX
00186 
00187 # else /* ? _STLSOFT_SIZEOF_INT */
00188 #  error Cannot operate with a compiler for which sizeof(int) != 2 && sizeof(int) != 4 && sizeof(int) != 8
00189 # endif /* _STLSOFT_SIZEOF_INT */
00190 
00191 
00192  /* long */
00193 # if _STLSOFT_SIZEOF_LONG == 2
00194 
00195 #  define STLSOFT_INTEGRAL_PRINTF_TRAITS_LONG_MIN           STLSOFT_INTEGRAL_PRINTF_TRAITS_SINT16_MIN
00196 #  define STLSOFT_INTEGRAL_PRINTF_TRAITS_LONG_MAX           STLSOFT_INTEGRAL_PRINTF_TRAITS_SINT16_MAX
00197 
00198 #  define STLSOFT_INTEGRAL_PRINTF_TRAITS_ULONG_MIN          STLSOFT_INTEGRAL_PRINTF_TRAITS_UINT16_MIN
00199 #  define STLSOFT_INTEGRAL_PRINTF_TRAITS_ULONG_MAX          STLSOFT_INTEGRAL_PRINTF_TRAITS_UINT16_MAX
00200 
00201 # elif _STLSOFT_SIZEOF_LONG == 4
00202 
00203 #  define STLSOFT_INTEGRAL_PRINTF_TRAITS_LONG_MIN           STLSOFT_INTEGRAL_PRINTF_TRAITS_SINT32_MIN
00204 #  define STLSOFT_INTEGRAL_PRINTF_TRAITS_LONG_MAX           STLSOFT_INTEGRAL_PRINTF_TRAITS_SINT32_MAX
00205 
00206 #  define STLSOFT_INTEGRAL_PRINTF_TRAITS_ULONG_MIN          STLSOFT_INTEGRAL_PRINTF_TRAITS_UINT32_MIN
00207 #  define STLSOFT_INTEGRAL_PRINTF_TRAITS_ULONG_MAX          STLSOFT_INTEGRAL_PRINTF_TRAITS_UINT32_MAX
00208 
00209 # elif _STLSOFT_SIZEOF_LONG == 8
00210 
00211 #  define STLSOFT_INTEGRAL_PRINTF_TRAITS_LONG_MIN           STLSOFT_INTEGRAL_PRINTF_TRAITS_SINT64_MIN
00212 #  define STLSOFT_INTEGRAL_PRINTF_TRAITS_LONG_MAX           STLSOFT_INTEGRAL_PRINTF_TRAITS_SINT64_MAX
00213 
00214 #  define STLSOFT_INTEGRAL_PRINTF_TRAITS_ULONG_MIN          STLSOFT_INTEGRAL_PRINTF_TRAITS_UINT64_MIN
00215 #  define STLSOFT_INTEGRAL_PRINTF_TRAITS_ULONG_MAX          STLSOFT_INTEGRAL_PRINTF_TRAITS_UINT64_MAX
00216 
00217 # else /* ? _STLSOFT_SIZEOF_LONG */
00218 #  error Cannot operate with a compiler for which sizeof(long) != 2 && sizeof(long) != 4 && sizeof(long) != 8
00219 # endif /* _STLSOFT_SIZEOF_LONG */
00220 
00221 
00222  /* long long */
00223 # ifdef STLSOFT_CF_BUILTIN_long_long_SUPPORT
00224 #  if _STLSOFT_SIZEOF_LONG_LONG == 8
00225 
00226 #   define STLSOFT_INTEGRAL_PRINTF_TRAITS_LONG_LONG_MIN     STLSOFT_INTEGRAL_PRINTF_TRAITS_SINT64_MIN
00227 #   define STLSOFT_INTEGRAL_PRINTF_TRAITS_LONG_LONG_MAX     STLSOFT_INTEGRAL_PRINTF_TRAITS_SINT64_MAX
00228 
00229 #   define STLSOFT_INTEGRAL_PRINTF_TRAITS_ULONG_LONG_MIN    STLSOFT_INTEGRAL_PRINTF_TRAITS_UINT64_MIN
00230 #   define STLSOFT_INTEGRAL_PRINTF_TRAITS_ULONG_LONG_MAX    STLSOFT_INTEGRAL_PRINTF_TRAITS_UINT64_MAX
00231 
00232 #  else /* ? _STLSOFT_SIZEOF_LONG_LONG */
00233 #   error Cannot operate with a compiler for which sizeof(long long) != 8
00234 #  endif /* _STLSOFT_SIZEOF_LONG_LONG */
00235 # endif /* STLSOFT_CF_BUILTIN_long_long_SUPPORT */
00236 
00237 #endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */
00238 
00239 /* /////////////////////////////////////////////////////////////////////////
00240  * Macros
00241  */
00242 
00243 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00244 
00245 #ifdef STLSOFT_CF_64_BIT_PRINTF_USES_I64
00246 # undef STLSOFT_CF_64_BIT_PRINTF_USES_I64
00247 #endif /* STLSOFT_CF_64_BIT_PRINTF_USES_I64 */
00248 
00249 #ifdef STLSOFT_CF_64_BIT_PRINTF_USES_LL
00250 # undef STLSOFT_CF_64_BIT_PRINTF_USES_LL
00251 #endif /* STLSOFT_CF_64_BIT_PRINTF_USES_LL */
00252 
00253 # if defined(STLSOFT_COMPILER_IS_BORLAND) || \
00254      (  defined(STLSOFT_COMPILER_IS_COMO) && \
00255         defined(_MSC_VER)) || \
00256      (  defined(WIN32) && \
00257         (   defined(STLSOFT_COMPILER_IS_GCC)) || \
00258             defined(STLSOFT_COMPILER_IS_INTEL)) || \
00259      defined(STLSOFT_COMPILER_IS_MSVC) || \
00260      defined(STLSOFT_COMPILER_IS_VECTORC) || \
00261      defined(STLSOFT_COMPILER_IS_WATCOM)
00262 #  define STLSOFT_CF_64_BIT_PRINTF_USES_I64
00263 # elif defined(STLSOFT_COMPILER_IS_COMO) || \
00264        defined(STLSOFT_COMPILER_IS_DMC) || \
00265        defined(STLSOFT_COMPILER_IS_GCC) || \
00266        defined(STLSOFT_COMPILER_IS_INTEL) || \
00267        defined(STLSOFT_COMPILER_IS_MSVC) || \
00268        defined(STLSOFT_COMPILER_IS_MWERKS) || \
00269        defined(STLSOFT_COMPILER_IS_SUNPRO)
00270 #  define STLSOFT_CF_64_BIT_PRINTF_USES_LL
00271 # else /* ? compiler */
00272 #  error Further compiler discrimination is required
00273 # endif /* printf-64 */
00274 
00275 #endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */
00276 
00277 /* /////////////////////////////////////////////////////////////////////////
00278  * Classes
00279  */
00280 
00281 // struct integral_printf_traits
00282 
00283 #ifdef STLSOFT_DOCUMENTATION_SKIP_SECTION
00284 
00304 template <ss_typename_param_k T>
00305 struct integral_printf_traits
00306 {
00307     enum
00308     {
00309             size_min    
00310         ,   size_max    
00311         ,   size        
00312     };
00313 
00315     static ss_char_a_t const* format_a();
00317     static ss_char_w_t const* format_w();
00318 
00320     static ss_char_a_t const* hex_format_a();
00322     static ss_char_w_t const* hex_format_w();
00323 };
00324 
00325 #else /* ? STLSOFT_DOCUMENTATION_SKIP_SECTION */
00326 
00327 template <ss_typename_param_k T>
00328 struct integral_printf_traits;
00329 
00330 template <ss_typename_param_k T>
00331 struct integral_printf_traits_base;
00332 
00333 
00334  /* char */
00335 
00336 STLSOFT_TEMPLATE_SPECIALISATION
00337 struct integral_printf_traits_base<char>
00338 {
00339     enum
00340     {
00341             size_min = int(sizeof(STLSOFT_STRINGIZE(STLSOFT_INTEGRAL_PRINTF_TRAITS_CHAR_MIN)))
00342         ,   size_max = int(sizeof(STLSOFT_STRINGIZE(STLSOFT_INTEGRAL_PRINTF_TRAITS_CHAR_MAX)))
00343         ,   size = (size_min < size_max) ? size_max : size_min
00344     };
00345 
00346     static ss_char_a_t const* format_a()
00347     {
00348 #  ifdef STLSOFT_CF_CHAR_IS_UNSIGNED
00349         return  "%u";
00350 #  else /* ? STLSOFT_CF_CHAR_IS_UNSIGNED */
00351         return  "%d";
00352 #  endif /* STLSOFT_CF_CHAR_IS_UNSIGNED */
00353     }
00354     static ss_char_w_t const* format_w()
00355     {
00356 #  ifdef STLSOFT_CF_CHAR_IS_UNSIGNED
00357         return L"%u";
00358 #  else /* ? STLSOFT_CF_CHAR_IS_UNSIGNED */
00359         return L"%d";
00360 #  endif /* STLSOFT_CF_CHAR_IS_UNSIGNED */
00361     }
00362 
00363     static ss_char_a_t const* hex_format_a()
00364     {
00365         return  "%x";
00366     }
00367     static ss_char_w_t const* hex_format_w()
00368     {
00369         return L"%x";
00370     }
00371 };
00372 
00373 STLSOFT_TEMPLATE_SPECIALISATION
00374 struct integral_printf_traits_base<unsigned char>
00375 {
00376     enum
00377     {
00378             size_min = int(sizeof(STLSOFT_STRINGIZE(STLSOFT_INTEGRAL_PRINTF_TRAITS_UCHAR_MIN)))
00379         ,   size_max = int(sizeof(STLSOFT_STRINGIZE(STLSOFT_INTEGRAL_PRINTF_TRAITS_UCHAR_MAX)))
00380         ,   size = (size_min < size_max) ? size_max : size_min
00381     };
00382 
00383     static ss_char_a_t const* format_a()
00384     {
00385         return  "%u";
00386     }
00387     static ss_char_w_t const* format_w()
00388     {
00389         return L"%u";
00390     }
00391 
00392     static ss_char_a_t const* hex_format_a()
00393     {
00394         return  "%x";
00395     }
00396     static ss_char_w_t const* hex_format_w()
00397     {
00398         return L"%x";
00399     }
00400 };
00401 
00402 STLSOFT_TEMPLATE_SPECIALISATION
00403 struct integral_printf_traits_base<signed char>
00404 {
00405     enum
00406     {
00407             size_min = int(sizeof(STLSOFT_STRINGIZE(STLSOFT_INTEGRAL_PRINTF_TRAITS_SCHAR_MIN)))
00408         ,   size_max = int(sizeof(STLSOFT_STRINGIZE(STLSOFT_INTEGRAL_PRINTF_TRAITS_SCHAR_MAX)))
00409         ,   size = (size_min < size_max) ? size_max : size_min
00410     };
00411 
00412     static ss_char_a_t const* format_a()
00413     {
00414         return  "%d";
00415     }
00416     static ss_char_w_t const* format_w()
00417     {
00418         return L"%d";
00419     }
00420 
00421     static ss_char_a_t const* hex_format_a()
00422     {
00423         return  "%x";
00424     }
00425     static ss_char_w_t const* hex_format_w()
00426     {
00427         return L"%x";
00428     }
00429 };
00430 
00431 
00432  /* short */
00433 
00434 STLSOFT_TEMPLATE_SPECIALISATION
00435 struct integral_printf_traits_base<short>
00436 {
00437     enum
00438     {
00439             size_min = int(sizeof(STLSOFT_STRINGIZE(STLSOFT_INTEGRAL_PRINTF_TRAITS_SHORT_MIN)))
00440         ,   size_max = int(sizeof(STLSOFT_STRINGIZE(STLSOFT_INTEGRAL_PRINTF_TRAITS_SHORT_MAX)))
00441         ,   size = (size_min < size_max) ? size_max : size_min
00442     };
00443 
00444     static ss_char_a_t const* format_a()
00445     {
00446         return  "%d";
00447     }
00448     static ss_char_w_t const* format_w()
00449     {
00450         return L"%d";
00451     }
00452 
00453     static ss_char_a_t const* hex_format_a()
00454     {
00455         return  "%x";
00456     }
00457     static ss_char_w_t const* hex_format_w()
00458     {
00459         return L"%x";
00460     }
00461 };
00462 
00463 STLSOFT_TEMPLATE_SPECIALISATION
00464 struct integral_printf_traits_base<unsigned short>
00465 {
00466     enum
00467     {
00468             size_min = int(sizeof(STLSOFT_STRINGIZE(STLSOFT_INTEGRAL_PRINTF_TRAITS_USHORT_MIN)))
00469         ,   size_max = int(sizeof(STLSOFT_STRINGIZE(STLSOFT_INTEGRAL_PRINTF_TRAITS_USHORT_MAX)))
00470         ,   size = (size_min < size_max) ? size_max : size_min
00471     };
00472 
00473     static ss_char_a_t const* format_a()
00474     {
00475         return  "%u";
00476     }
00477     static ss_char_w_t const* format_w()
00478     {
00479         return L"%u";
00480     }
00481 
00482     static ss_char_a_t const* hex_format_a()
00483     {
00484         return  "%x";
00485     }
00486     static ss_char_w_t const* hex_format_w()
00487     {
00488         return L"%x";
00489     }
00490 };
00491 
00492 
00493  /* int */
00494 
00495 STLSOFT_TEMPLATE_SPECIALISATION
00496 struct integral_printf_traits_base<int>
00497 {
00498     enum
00499     {
00500             size_min = int(sizeof(STLSOFT_STRINGIZE(STLSOFT_INTEGRAL_PRINTF_TRAITS_INT_MIN)))
00501         ,   size_max = int(sizeof(STLSOFT_STRINGIZE(STLSOFT_INTEGRAL_PRINTF_TRAITS_INT_MAX)))
00502         ,   size = (size_min < size_max) ? size_max : size_min
00503     };
00504 
00505     static ss_char_a_t const* format_a()
00506     {
00507         return  "%d";
00508     }
00509     static ss_char_w_t const* format_w()
00510     {
00511         return L"%d";
00512     }
00513 
00514     static ss_char_a_t const* hex_format_a()
00515     {
00516         return  "%x";
00517     }
00518     static ss_char_w_t const* hex_format_w()
00519     {
00520         return L"%x";
00521     }
00522 };
00523 
00524 STLSOFT_TEMPLATE_SPECIALISATION
00525 struct integral_printf_traits_base<unsigned int>
00526 {
00527     enum
00528     {
00529             size_min = int(sizeof(STLSOFT_STRINGIZE(STLSOFT_INTEGRAL_PRINTF_TRAITS_UINT_MIN)))
00530         ,   size_max = int(sizeof(STLSOFT_STRINGIZE(STLSOFT_INTEGRAL_PRINTF_TRAITS_UINT_MAX)))
00531         ,   size = (size_min < size_max) ? size_max : size_min
00532     };
00533 
00534     static ss_char_a_t const* format_a()
00535     {
00536         return  "%u";
00537     }
00538     static ss_char_w_t const* format_w()
00539     {
00540         return L"%u";
00541     }
00542 
00543     static ss_char_a_t const* hex_format_a()
00544     {
00545         return  "%x";
00546     }
00547     static ss_char_w_t const* hex_format_w()
00548     {
00549         return L"%x";
00550     }
00551 };
00552 
00553 
00554  /* long */
00555 
00556 STLSOFT_TEMPLATE_SPECIALISATION
00557 struct integral_printf_traits_base<long>
00558 {
00559     enum
00560     {
00561             size_min = int(sizeof(STLSOFT_STRINGIZE(STLSOFT_INTEGRAL_PRINTF_TRAITS_LONG_MIN)))
00562         ,   size_max = int(sizeof(STLSOFT_STRINGIZE(STLSOFT_INTEGRAL_PRINTF_TRAITS_LONG_MAX)))
00563         ,   size = (size_min < size_max) ? size_max : size_min
00564     };
00565 
00566     static ss_char_a_t const* format_a()
00567     {
00568         return  "%ld";
00569     }
00570     static ss_char_w_t const* format_w()
00571     {
00572         return L"%ld";
00573     }
00574 
00575     static ss_char_a_t const* hex_format_a()
00576     {
00577         return  "%lx";
00578     }
00579     static ss_char_w_t const* hex_format_w()
00580     {
00581         return L"%lx";
00582     }
00583 };
00584 
00585 STLSOFT_TEMPLATE_SPECIALISATION
00586 struct integral_printf_traits_base<unsigned long>
00587 {
00588     enum
00589     {
00590             size_min = int(sizeof(STLSOFT_STRINGIZE(STLSOFT_INTEGRAL_PRINTF_TRAITS_ULONG_MIN)))
00591         ,   size_max = int(sizeof(STLSOFT_STRINGIZE(STLSOFT_INTEGRAL_PRINTF_TRAITS_ULONG_MAX)))
00592         ,   size = (size_min < size_max) ? size_max : size_min
00593     };
00594 
00595     static ss_char_a_t const* format_a()
00596     {
00597         return  "%lu";
00598     }
00599     static ss_char_w_t const* format_w()
00600     {
00601         return L"%lu";
00602     }
00603 
00604     static ss_char_a_t const* hex_format_a()
00605     {
00606         return  "%lx";
00607     }
00608     static ss_char_w_t const* hex_format_w()
00609     {
00610         return L"%lx";
00611     }
00612 };
00613 
00614 
00615  /* long long */
00616 
00617 #ifdef STLSOFT_CF_64BIT_INT_SUPPORT
00618 
00619 STLSOFT_TEMPLATE_SPECIALISATION
00620 struct integral_printf_traits_base<ss_sint64_t>
00621 {
00622     enum
00623     {
00624             size_min = int(sizeof(STLSOFT_STRINGIZE(STLSOFT_INTEGRAL_PRINTF_TRAITS_SINT64_MIN)))
00625         ,   size_max = int(sizeof(STLSOFT_STRINGIZE(STLSOFT_INTEGRAL_PRINTF_TRAITS_SINT64_MAX)))
00626         ,   size = (size_min < size_max) ? size_max : size_min
00627     };
00628 
00629     static ss_char_a_t const* format_a()
00630     {
00631 #if defined(STLSOFT_CF_64_BIT_PRINTF_USES_I64)
00632         return  "%I64d";
00633 #elif defined(STLSOFT_CF_64_BIT_PRINTF_USES_LL)
00634         return  "%lld";
00635 #else
00636 # error Further compiler discrimination is required
00637 #endif /* printf-64 */
00638     }
00639     static ss_char_w_t const* format_w()
00640     {
00641 #if defined(STLSOFT_CF_64_BIT_PRINTF_USES_I64)
00642         return L"%I64d";
00643 #elif defined(STLSOFT_CF_64_BIT_PRINTF_USES_LL)
00644         return L"%lld";
00645 #else
00646 # error Further compiler discrimination is required
00647 #endif /* printf-64 */
00648     }
00649 
00650     static ss_char_a_t const* hex_format_a()
00651     {
00652 #if defined(STLSOFT_CF_64_BIT_PRINTF_USES_I64)
00653         return  "%I64x";
00654 #elif defined(STLSOFT_CF_64_BIT_PRINTF_USES_LL)
00655         return  "%llx";
00656 #else
00657 # error Further compiler discrimination is required
00658 #endif /* printf-64 */
00659     }
00660     static ss_char_w_t const* hex_format_w()
00661     {
00662 #if defined(STLSOFT_CF_64_BIT_PRINTF_USES_I64)
00663         return L"%I64x";
00664 #elif defined(STLSOFT_CF_64_BIT_PRINTF_USES_LL)
00665         return L"%llx";
00666 #else
00667 # error Further compiler discrimination is required
00668 #endif /* printf-64 */
00669     }
00670 };
00671 
00672 STLSOFT_TEMPLATE_SPECIALISATION
00673 struct integral_printf_traits_base<ss_uint64_t>
00674 {
00675     enum
00676     {
00677             size_min = int(sizeof(STLSOFT_STRINGIZE(STLSOFT_INTEGRAL_PRINTF_TRAITS_UINT64_MIN)))
00678         ,   size_max = int(sizeof(STLSOFT_STRINGIZE(STLSOFT_INTEGRAL_PRINTF_TRAITS_UINT64_MAX)))
00679         ,   size = (size_min < size_max) ? size_max : size_min
00680     };
00681 
00682     static ss_char_a_t const* format_a()
00683     {
00684 #if defined(STLSOFT_CF_64_BIT_PRINTF_USES_I64)
00685         return  "%I64u";
00686 #elif defined(STLSOFT_CF_64_BIT_PRINTF_USES_LL)
00687         return  "%llu";
00688 #else
00689 # error Further compiler discrimination is required
00690 #endif /* printf-64 */
00691     }
00692     static ss_char_w_t const* format_w()
00693     {
00694 #if defined(STLSOFT_CF_64_BIT_PRINTF_USES_I64)
00695         return L"%I64u";
00696 #elif defined(STLSOFT_CF_64_BIT_PRINTF_USES_LL)
00697         return L"%llu";
00698 #else
00699 # error Further compiler discrimination is required
00700 #endif /* printf-64 */
00701     }
00702 
00703     static ss_char_a_t const* hex_format_a()
00704     {
00705 #if defined(STLSOFT_CF_64_BIT_PRINTF_USES_I64)
00706         return  "%I64x";
00707 #elif defined(STLSOFT_CF_64_BIT_PRINTF_USES_LL)
00708         return  "%llx";
00709 #else
00710 # error Further compiler discrimination is required
00711 #endif /* printf-64 */
00712     }
00713     static ss_char_w_t const* hex_format_w()
00714     {
00715 #if defined(STLSOFT_CF_64_BIT_PRINTF_USES_I64)
00716         return L"%I64x";
00717 #elif defined(STLSOFT_CF_64_BIT_PRINTF_USES_LL)
00718         return L"%llx";
00719 #else
00720 # error Further compiler discrimination is required
00721 #endif /* printf-64 */
00722     }
00723 };
00724 
00725 
00726 #endif /* STLSOFT_CF_64BIT_INT_SUPPORT */
00727 
00728 
00729 
00730 STLSOFT_TEMPLATE_SPECIALISATION
00731 struct integral_printf_traits<char>
00732     : public integral_printf_traits_base<char>
00733 {};
00734 STLSOFT_TEMPLATE_SPECIALISATION
00735 struct integral_printf_traits<signed char>
00736     : public integral_printf_traits_base<signed char>
00737 {};
00738 STLSOFT_TEMPLATE_SPECIALISATION
00739 struct integral_printf_traits<unsigned char>
00740     : public integral_printf_traits_base<unsigned char>
00741 {};
00742 
00743 STLSOFT_TEMPLATE_SPECIALISATION
00744 struct integral_printf_traits<short>
00745     : public integral_printf_traits_base<short>
00746 {};
00747 STLSOFT_TEMPLATE_SPECIALISATION
00748 struct integral_printf_traits<unsigned short>
00749     : public integral_printf_traits_base<unsigned short>
00750 {};
00751 
00752 STLSOFT_TEMPLATE_SPECIALISATION
00753 struct integral_printf_traits<int>
00754     : public integral_printf_traits_base<int>
00755 {};
00756 STLSOFT_TEMPLATE_SPECIALISATION
00757 struct integral_printf_traits<unsigned int>
00758     : public integral_printf_traits_base<unsigned int>
00759 {};
00760 
00761 STLSOFT_TEMPLATE_SPECIALISATION
00762 struct integral_printf_traits<long>
00763     : public integral_printf_traits_base<long>
00764 {};
00765 STLSOFT_TEMPLATE_SPECIALISATION
00766 struct integral_printf_traits<unsigned long>
00767     : public integral_printf_traits_base<unsigned long>
00768 {};
00769 
00770 STLSOFT_TEMPLATE_SPECIALISATION
00771 struct integral_printf_traits<ss_sint64_t>
00772     : public integral_printf_traits_base<ss_sint64_t>
00773 {};
00774 STLSOFT_TEMPLATE_SPECIALISATION
00775 struct integral_printf_traits<ss_uint64_t>
00776     : public integral_printf_traits_base<ss_uint64_t>
00777 {};
00778 
00779 
00780 #ifdef STLSOFT_CF_CHAR_DISTINCT_INT_TYPE
00781 # if _STLSOFT_SIZEOF_CHAR == 1
00782 STLSOFT_TEMPLATE_SPECIALISATION
00783 struct integral_printf_traits<ss_sint8_t>
00784     : public integral_printf_traits_base<signed char>
00785 {};
00786 STLSOFT_TEMPLATE_SPECIALISATION
00787 struct integral_printf_traits<ss_uint8_t>
00788     : public integral_printf_traits_base<unsigned char>
00789 {};
00790 # endif /* _STLSOFT_SIZEOF_CHAR == 1 */
00791 #endif /* STLSOFT_CF_CHAR_DISTINCT_INT_TYPE */
00792 
00793 #ifdef STLSOFT_CF_SHORT_DISTINCT_INT_TYPE
00794 # if _STLSOFT_SIZEOF_SHORT == 2
00795 STLSOFT_TEMPLATE_SPECIALISATION
00796 struct integral_printf_traits<ss_sint16_t>
00797     : public integral_printf_traits_base<short>
00798 {};
00799 STLSOFT_TEMPLATE_SPECIALISATION
00800 struct integral_printf_traits<ss_uint16_t>
00801     : public integral_printf_traits_base<unsigned short>
00802 {};
00803 # endif /* _STLSOFT_SIZEOF_SHORT == 2 */
00804 #endif /* STLSOFT_CF_SHORT_DISTINCT_INT_TYPE */
00805 
00806 #ifdef STLSOFT_CF_INT_DISTINCT_INT_TYPE
00807 # if _STLSOFT_SIZEOF_INT == 4
00808 STLSOFT_TEMPLATE_SPECIALISATION
00809 struct integral_printf_traits<ss_sint32_t>
00810     : public integral_printf_traits_base<int>
00811 {};
00812 STLSOFT_TEMPLATE_SPECIALISATION
00813 struct integral_printf_traits<ss_uint32_t>
00814     : public integral_printf_traits_base<unsigned int>
00815 {};
00816 # endif /* _STLSOFT_SIZEOF_INT == 4 */
00817 #endif /* STLSOFT_CF_INT_DISTINCT_INT_TYPE */
00818 
00819 #endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */
00820 
00822 // Unit-testing
00823 
00824 #ifdef STLSOFT_UNITTEST
00825 # include "./unittest/integral_printf_traits_unittest_.h"
00826 #endif /* STLSOFT_UNITTEST */
00827 
00828 /* ////////////////////////////////////////////////////////////////////// */
00829 
00830 #ifndef _STLSOFT_NO_NAMESPACE
00831 } // namespace stlsoft
00832 #endif /* _STLSOFT_NO_NAMESPACE */
00833 
00834 /* ////////////////////////////////////////////////////////////////////// */
00835 
00836 #endif /* !STLSOFT_INCL_STLSOFT_UTIL_HPP_INTEGRAL_PRINTF_TRAITS */
00837 
00838 /* ///////////////////////////// end of file //////////////////////////// */