LCOV - code coverage report
Current view: top level - usr/include/c++/4.9/bits - char_traits.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 0 8 0.0 %
Date: 2016-09-12 13:07:23 Functions: 0 4 0.0 %

          Line data    Source code
       1             : // Character Traits for use by standard string and iostream -*- C++ -*-
       2             : 
       3             : // Copyright (C) 1997-2014 Free Software Foundation, Inc.
       4             : //
       5             : // This file is part of the GNU ISO C++ Library.  This library is free
       6             : // software; you can redistribute it and/or modify it under the
       7             : // terms of the GNU General Public License as published by the
       8             : // Free Software Foundation; either version 3, or (at your option)
       9             : // any later version.
      10             : 
      11             : // This library is distributed in the hope that it will be useful,
      12             : // but WITHOUT ANY WARRANTY; without even the implied warranty of
      13             : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14             : // GNU General Public License for more details.
      15             : 
      16             : // Under Section 7 of GPL version 3, you are granted additional
      17             : // permissions described in the GCC Runtime Library Exception, version
      18             : // 3.1, as published by the Free Software Foundation.
      19             : 
      20             : // You should have received a copy of the GNU General Public License and
      21             : // a copy of the GCC Runtime Library Exception along with this program;
      22             : // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
      23             : // <http://www.gnu.org/licenses/>.
      24             : 
      25             : /** @file bits/char_traits.h
      26             :  *  This is an internal header file, included by other library headers.
      27             :  *  Do not attempt to use it directly. @headername{string}
      28             :  */
      29             : 
      30             : //
      31             : // ISO C++ 14882: 21  Strings library
      32             : //
      33             : 
      34             : #ifndef _CHAR_TRAITS_H
      35             : #define _CHAR_TRAITS_H 1
      36             : 
      37             : #pragma GCC system_header
      38             : 
      39             : #include <bits/stl_algobase.h>  // std::copy, std::fill_n
      40             : #include <bits/postypes.h>      // For streampos
      41             : #include <cwchar>               // For WEOF, wmemmove, wmemset, etc.
      42             : 
      43             : namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
      44             : {
      45             : _GLIBCXX_BEGIN_NAMESPACE_VERSION
      46             : 
      47             :   /**
      48             :    *  @brief  Mapping from character type to associated types.
      49             :    *
      50             :    *  @note This is an implementation class for the generic version
      51             :    *  of char_traits.  It defines int_type, off_type, pos_type, and
      52             :    *  state_type.  By default these are unsigned long, streamoff,
      53             :    *  streampos, and mbstate_t.  Users who need a different set of
      54             :    *  types, but who don't need to change the definitions of any function
      55             :    *  defined in char_traits, can specialize __gnu_cxx::_Char_types
      56             :    *  while leaving __gnu_cxx::char_traits alone. */
      57             :   template<typename _CharT>
      58             :     struct _Char_types
      59             :     {
      60             :       typedef unsigned long   int_type;
      61             :       typedef std::streampos  pos_type;
      62             :       typedef std::streamoff  off_type;
      63             :       typedef std::mbstate_t  state_type;
      64             :     };
      65             : 
      66             : 
      67             :   /**
      68             :    *  @brief  Base class used to implement std::char_traits.
      69             :    *
      70             :    *  @note For any given actual character type, this definition is
      71             :    *  probably wrong.  (Most of the member functions are likely to be
      72             :    *  right, but the int_type and state_type typedefs, and the eof()
      73             :    *  member function, are likely to be wrong.)  The reason this class
      74             :    *  exists is so users can specialize it.  Classes in namespace std
      75             :    *  may not be specialized for fundamental types, but classes in
      76             :    *  namespace __gnu_cxx may be.
      77             :    *
      78             :    *  See http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt05ch13s03.html
      79             :    *  for advice on how to make use of this class for @a unusual character
      80             :    *  types. Also, check out include/ext/pod_char_traits.h.  
      81             :    */
      82             :   template<typename _CharT>
      83             :     struct char_traits
      84             :     {
      85             :       typedef _CharT                                    char_type;
      86             :       typedef typename _Char_types<_CharT>::int_type    int_type;
      87             :       typedef typename _Char_types<_CharT>::pos_type    pos_type;
      88             :       typedef typename _Char_types<_CharT>::off_type    off_type;
      89             :       typedef typename _Char_types<_CharT>::state_type  state_type;
      90             : 
      91             :       static void
      92             :       assign(char_type& __c1, const char_type& __c2)
      93             :       { __c1 = __c2; }
      94             : 
      95             :       static _GLIBCXX_CONSTEXPR bool
      96             :       eq(const char_type& __c1, const char_type& __c2)
      97             :       { return __c1 == __c2; }
      98             : 
      99             :       static _GLIBCXX_CONSTEXPR bool
     100             :       lt(const char_type& __c1, const char_type& __c2)
     101             :       { return __c1 < __c2; }
     102             : 
     103             :       static int
     104             :       compare(const char_type* __s1, const char_type* __s2, std::size_t __n);
     105             : 
     106             :       static std::size_t
     107             :       length(const char_type* __s);
     108             : 
     109             :       static const char_type*
     110             :       find(const char_type* __s, std::size_t __n, const char_type& __a);
     111             : 
     112             :       static char_type*
     113             :       move(char_type* __s1, const char_type* __s2, std::size_t __n);
     114             : 
     115             :       static char_type*
     116             :       copy(char_type* __s1, const char_type* __s2, std::size_t __n);
     117             : 
     118             :       static char_type*
     119             :       assign(char_type* __s, std::size_t __n, char_type __a);
     120             : 
     121             :       static _GLIBCXX_CONSTEXPR char_type
     122             :       to_char_type(const int_type& __c)
     123             :       { return static_cast<char_type>(__c); }
     124             : 
     125             :       static _GLIBCXX_CONSTEXPR int_type
     126             :       to_int_type(const char_type& __c)
     127             :       { return static_cast<int_type>(__c); }
     128             : 
     129             :       static _GLIBCXX_CONSTEXPR bool
     130             :       eq_int_type(const int_type& __c1, const int_type& __c2)
     131             :       { return __c1 == __c2; }
     132             : 
     133             :       static _GLIBCXX_CONSTEXPR int_type
     134             :       eof()
     135             :       { return static_cast<int_type>(_GLIBCXX_STDIO_EOF); }
     136             : 
     137             :       static _GLIBCXX_CONSTEXPR int_type
     138             :       not_eof(const int_type& __c)
     139             :       { return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); }
     140             :     };
     141             : 
     142             :   template<typename _CharT>
     143             :     int
     144             :     char_traits<_CharT>::
     145             :     compare(const char_type* __s1, const char_type* __s2, std::size_t __n)
     146             :     {
     147             :       for (std::size_t __i = 0; __i < __n; ++__i)
     148             :         if (lt(__s1[__i], __s2[__i]))
     149             :           return -1;
     150             :         else if (lt(__s2[__i], __s1[__i]))
     151             :           return 1;
     152             :       return 0;
     153             :     }
     154             : 
     155             :   template<typename _CharT>
     156             :     std::size_t
     157             :     char_traits<_CharT>::
     158             :     length(const char_type* __p)
     159             :     {
     160             :       std::size_t __i = 0;
     161             :       while (!eq(__p[__i], char_type()))
     162             :         ++__i;
     163             :       return __i;
     164             :     }
     165             : 
     166             :   template<typename _CharT>
     167             :     const typename char_traits<_CharT>::char_type*
     168             :     char_traits<_CharT>::
     169             :     find(const char_type* __s, std::size_t __n, const char_type& __a)
     170             :     {
     171             :       for (std::size_t __i = 0; __i < __n; ++__i)
     172             :         if (eq(__s[__i], __a))
     173             :           return __s + __i;
     174             :       return 0;
     175             :     }
     176             : 
     177             :   template<typename _CharT>
     178             :     typename char_traits<_CharT>::char_type*
     179             :     char_traits<_CharT>::
     180             :     move(char_type* __s1, const char_type* __s2, std::size_t __n)
     181             :     {
     182             :       return static_cast<_CharT*>(__builtin_memmove(__s1, __s2,
     183             :                                                     __n * sizeof(char_type)));
     184             :     }
     185             : 
     186             :   template<typename _CharT>
     187             :     typename char_traits<_CharT>::char_type*
     188             :     char_traits<_CharT>::
     189             :     copy(char_type* __s1, const char_type* __s2, std::size_t __n)
     190             :     {
     191             :       // NB: Inline std::copy so no recursive dependencies.
     192             :       std::copy(__s2, __s2 + __n, __s1);
     193             :       return __s1;
     194             :     }
     195             : 
     196             :   template<typename _CharT>
     197             :     typename char_traits<_CharT>::char_type*
     198             :     char_traits<_CharT>::
     199             :     assign(char_type* __s, std::size_t __n, char_type __a)
     200             :     {
     201             :       // NB: Inline std::fill_n so no recursive dependencies.
     202             :       std::fill_n(__s, __n, __a);
     203             :       return __s;
     204             :     }
     205             : 
     206             : _GLIBCXX_END_NAMESPACE_VERSION
     207             : } // namespace
     208             : 
     209             : namespace std _GLIBCXX_VISIBILITY(default)
     210             : {
     211             : _GLIBCXX_BEGIN_NAMESPACE_VERSION
     212             : 
     213             :   // 21.1
     214             :   /**
     215             :    *  @brief  Basis for explicit traits specializations.
     216             :    *
     217             :    *  @note  For any given actual character type, this definition is
     218             :    *  probably wrong.  Since this is just a thin wrapper around
     219             :    *  __gnu_cxx::char_traits, it is possible to achieve a more
     220             :    *  appropriate definition by specializing __gnu_cxx::char_traits.
     221             :    *
     222             :    *  See http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt05ch13s03.html
     223             :    *  for advice on how to make use of this class for @a unusual character
     224             :    *  types. Also, check out include/ext/pod_char_traits.h.
     225             :   */
     226             :   template<class _CharT>
     227             :     struct char_traits : public __gnu_cxx::char_traits<_CharT>
     228             :     { };
     229             : 
     230             : 
     231             :   /// 21.1.3.1  char_traits specializations
     232             :   template<>
     233             :     struct char_traits<char>
     234             :     {
     235             :       typedef char              char_type;
     236             :       typedef int               int_type;
     237             :       typedef streampos         pos_type;
     238             :       typedef streamoff         off_type;
     239             :       typedef mbstate_t         state_type;
     240             : 
     241             :       static void
     242           0 :       assign(char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT
     243           0 :       { __c1 = __c2; }
     244             : 
     245             :       static _GLIBCXX_CONSTEXPR bool
     246             :       eq(const char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT
     247             :       { return __c1 == __c2; }
     248             : 
     249             :       static _GLIBCXX_CONSTEXPR bool
     250             :       lt(const char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT
     251             :       {
     252             :         // LWG 467.
     253             :         return (static_cast<unsigned char>(__c1)
     254             :                 < static_cast<unsigned char>(__c2));
     255             :       }
     256             : 
     257             :       static int
     258           0 :       compare(const char_type* __s1, const char_type* __s2, size_t __n)
     259           0 :       { return __builtin_memcmp(__s1, __s2, __n); }
     260             : 
     261             :       static size_t
     262           0 :       length(const char_type* __s)
     263           0 :       { return __builtin_strlen(__s); }
     264             : 
     265             :       static const char_type*
     266             :       find(const char_type* __s, size_t __n, const char_type& __a)
     267             :       { return static_cast<const char_type*>(__builtin_memchr(__s, __a, __n)); }
     268             : 
     269             :       static char_type*
     270             :       move(char_type* __s1, const char_type* __s2, size_t __n)
     271             :       { return static_cast<char_type*>(__builtin_memmove(__s1, __s2, __n)); }
     272             : 
     273             :       static char_type*
     274           0 :       copy(char_type* __s1, const char_type* __s2, size_t __n)
     275           0 :       { return static_cast<char_type*>(__builtin_memcpy(__s1, __s2, __n)); }
     276             : 
     277             :       static char_type*
     278             :       assign(char_type* __s, size_t __n, char_type __a)
     279             :       { return static_cast<char_type*>(__builtin_memset(__s, __a, __n)); }
     280             : 
     281             :       static _GLIBCXX_CONSTEXPR char_type
     282             :       to_char_type(const int_type& __c) _GLIBCXX_NOEXCEPT
     283             :       { return static_cast<char_type>(__c); }
     284             : 
     285             :       // To keep both the byte 0xff and the eof symbol 0xffffffff
     286             :       // from ending up as 0xffffffff.
     287             :       static _GLIBCXX_CONSTEXPR int_type
     288             :       to_int_type(const char_type& __c) _GLIBCXX_NOEXCEPT
     289             :       { return static_cast<int_type>(static_cast<unsigned char>(__c)); }
     290             : 
     291             :       static _GLIBCXX_CONSTEXPR bool
     292             :       eq_int_type(const int_type& __c1, const int_type& __c2) _GLIBCXX_NOEXCEPT
     293             :       { return __c1 == __c2; }
     294             : 
     295             :       static _GLIBCXX_CONSTEXPR int_type
     296             :       eof() _GLIBCXX_NOEXCEPT
     297             :       { return static_cast<int_type>(_GLIBCXX_STDIO_EOF); }
     298             : 
     299             :       static _GLIBCXX_CONSTEXPR int_type
     300             :       not_eof(const int_type& __c) _GLIBCXX_NOEXCEPT
     301             :       { return (__c == eof()) ? 0 : __c; }
     302             :   };
     303             : 
     304             : 
     305             : #ifdef _GLIBCXX_USE_WCHAR_T
     306             :   /// 21.1.3.2  char_traits specializations
     307             :   template<>
     308             :     struct char_traits<wchar_t>
     309             :     {
     310             :       typedef wchar_t           char_type;
     311             :       typedef wint_t            int_type;
     312             :       typedef streamoff         off_type;
     313             :       typedef wstreampos        pos_type;
     314             :       typedef mbstate_t         state_type;
     315             : 
     316             :       static void
     317             :       assign(char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT
     318             :       { __c1 = __c2; }
     319             : 
     320             :       static _GLIBCXX_CONSTEXPR bool
     321             :       eq(const char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT
     322             :       { return __c1 == __c2; }
     323             : 
     324             :       static _GLIBCXX_CONSTEXPR bool
     325             :       lt(const char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT
     326             :       { return __c1 < __c2; }
     327             : 
     328             :       static int
     329             :       compare(const char_type* __s1, const char_type* __s2, size_t __n)
     330             :       { return wmemcmp(__s1, __s2, __n); }
     331             : 
     332             :       static size_t
     333             :       length(const char_type* __s)
     334             :       { return wcslen(__s); }
     335             : 
     336             :       static const char_type*
     337             :       find(const char_type* __s, size_t __n, const char_type& __a)
     338             :       { return wmemchr(__s, __a, __n); }
     339             : 
     340             :       static char_type*
     341             :       move(char_type* __s1, const char_type* __s2, size_t __n)
     342             :       { return wmemmove(__s1, __s2, __n); }
     343             : 
     344             :       static char_type*
     345             :       copy(char_type* __s1, const char_type* __s2, size_t __n)
     346             :       { return wmemcpy(__s1, __s2, __n); }
     347             : 
     348             :       static char_type*
     349             :       assign(char_type* __s, size_t __n, char_type __a)
     350             :       { return wmemset(__s, __a, __n); }
     351             : 
     352             :       static _GLIBCXX_CONSTEXPR char_type
     353             :       to_char_type(const int_type& __c) _GLIBCXX_NOEXCEPT
     354             :       { return char_type(__c); }
     355             : 
     356             :       static _GLIBCXX_CONSTEXPR int_type
     357             :       to_int_type(const char_type& __c) _GLIBCXX_NOEXCEPT
     358             :       { return int_type(__c); }
     359             : 
     360             :       static _GLIBCXX_CONSTEXPR bool
     361             :       eq_int_type(const int_type& __c1, const int_type& __c2) _GLIBCXX_NOEXCEPT
     362             :       { return __c1 == __c2; }
     363             : 
     364             :       static _GLIBCXX_CONSTEXPR int_type
     365             :       eof() _GLIBCXX_NOEXCEPT
     366             :       { return static_cast<int_type>(WEOF); }
     367             : 
     368             :       static _GLIBCXX_CONSTEXPR int_type
     369             :       not_eof(const int_type& __c) _GLIBCXX_NOEXCEPT
     370             :       { return eq_int_type(__c, eof()) ? 0 : __c; }
     371             :   };
     372             : #endif //_GLIBCXX_USE_WCHAR_T
     373             : 
     374             : _GLIBCXX_END_NAMESPACE_VERSION
     375             : } // namespace
     376             : 
     377             : #if ((__cplusplus >= 201103L) \
     378             :      && defined(_GLIBCXX_USE_C99_STDINT_TR1))
     379             : 
     380             : #include <cstdint>
     381             : 
     382             : namespace std _GLIBCXX_VISIBILITY(default)
     383             : {
     384             : _GLIBCXX_BEGIN_NAMESPACE_VERSION
     385             : 
     386             :   template<>
     387             :     struct char_traits<char16_t>
     388             :     {
     389             :       typedef char16_t          char_type;
     390             :       typedef uint_least16_t    int_type;
     391             :       typedef streamoff         off_type;
     392             :       typedef u16streampos      pos_type;
     393             :       typedef mbstate_t         state_type;
     394             : 
     395             :       static void
     396             :       assign(char_type& __c1, const char_type& __c2) noexcept
     397             :       { __c1 = __c2; }
     398             : 
     399             :       static constexpr bool
     400             :       eq(const char_type& __c1, const char_type& __c2) noexcept
     401             :       { return __c1 == __c2; }
     402             : 
     403             :       static constexpr bool
     404             :       lt(const char_type& __c1, const char_type& __c2) noexcept
     405             :       { return __c1 < __c2; }
     406             : 
     407             :       static int
     408             :       compare(const char_type* __s1, const char_type* __s2, size_t __n)
     409             :       {
     410             :         for (size_t __i = 0; __i < __n; ++__i)
     411             :           if (lt(__s1[__i], __s2[__i]))
     412             :             return -1;
     413             :           else if (lt(__s2[__i], __s1[__i]))
     414             :             return 1;
     415             :         return 0;
     416             :       }
     417             : 
     418             :       static size_t
     419             :       length(const char_type* __s)
     420             :       {
     421             :         size_t __i = 0;
     422             :         while (!eq(__s[__i], char_type()))
     423             :           ++__i;
     424             :         return __i;
     425             :       }
     426             : 
     427             :       static const char_type*
     428             :       find(const char_type* __s, size_t __n, const char_type& __a)
     429             :       {
     430             :         for (size_t __i = 0; __i < __n; ++__i)
     431             :           if (eq(__s[__i], __a))
     432             :             return __s + __i;
     433             :         return 0;
     434             :       }
     435             : 
     436             :       static char_type*
     437             :       move(char_type* __s1, const char_type* __s2, size_t __n)
     438             :       {
     439             :         return (static_cast<char_type*>
     440             :                 (__builtin_memmove(__s1, __s2, __n * sizeof(char_type))));
     441             :       }
     442             : 
     443             :       static char_type*
     444             :       copy(char_type* __s1, const char_type* __s2, size_t __n)
     445             :       {
     446             :         return (static_cast<char_type*>
     447             :                 (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type))));
     448             :       }
     449             : 
     450             :       static char_type*
     451             :       assign(char_type* __s, size_t __n, char_type __a)
     452             :       {
     453             :         for (size_t __i = 0; __i < __n; ++__i)
     454             :           assign(__s[__i], __a);
     455             :         return __s;
     456             :       }
     457             : 
     458             :       static constexpr char_type
     459             :       to_char_type(const int_type& __c) noexcept
     460             :       { return char_type(__c); }
     461             : 
     462             :       static constexpr int_type
     463             :       to_int_type(const char_type& __c) noexcept
     464             :       { return int_type(__c); }
     465             : 
     466             :       static constexpr bool
     467             :       eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
     468             :       { return __c1 == __c2; }
     469             : 
     470             :       static constexpr int_type
     471             :       eof() noexcept
     472             :       { return static_cast<int_type>(-1); }
     473             : 
     474             :       static constexpr int_type
     475             :       not_eof(const int_type& __c) noexcept
     476             :       { return eq_int_type(__c, eof()) ? 0 : __c; }
     477             :     };
     478             : 
     479             :   template<>
     480             :     struct char_traits<char32_t>
     481             :     {
     482             :       typedef char32_t          char_type;
     483             :       typedef uint_least32_t    int_type;
     484             :       typedef streamoff         off_type;
     485             :       typedef u32streampos      pos_type;
     486             :       typedef mbstate_t         state_type;
     487             : 
     488             :       static void
     489             :       assign(char_type& __c1, const char_type& __c2) noexcept
     490             :       { __c1 = __c2; }
     491             : 
     492             :       static constexpr bool
     493             :       eq(const char_type& __c1, const char_type& __c2) noexcept
     494             :       { return __c1 == __c2; }
     495             : 
     496             :       static constexpr bool
     497             :       lt(const char_type& __c1, const char_type& __c2) noexcept
     498             :       { return __c1 < __c2; }
     499             : 
     500             :       static int
     501             :       compare(const char_type* __s1, const char_type* __s2, size_t __n)
     502             :       {
     503             :         for (size_t __i = 0; __i < __n; ++__i)
     504             :           if (lt(__s1[__i], __s2[__i]))
     505             :             return -1;
     506             :           else if (lt(__s2[__i], __s1[__i]))
     507             :             return 1;
     508             :         return 0;
     509             :       }
     510             : 
     511             :       static size_t
     512             :       length(const char_type* __s)
     513             :       {
     514             :         size_t __i = 0;
     515             :         while (!eq(__s[__i], char_type()))
     516             :           ++__i;
     517             :         return __i;
     518             :       }
     519             : 
     520             :       static const char_type*
     521             :       find(const char_type* __s, size_t __n, const char_type& __a)
     522             :       {
     523             :         for (size_t __i = 0; __i < __n; ++__i)
     524             :           if (eq(__s[__i], __a))
     525             :             return __s + __i;
     526             :         return 0;
     527             :       }
     528             : 
     529             :       static char_type*
     530             :       move(char_type* __s1, const char_type* __s2, size_t __n)
     531             :       {
     532             :         return (static_cast<char_type*>
     533             :                 (__builtin_memmove(__s1, __s2, __n * sizeof(char_type))));
     534             :       }
     535             : 
     536             :       static char_type*
     537             :       copy(char_type* __s1, const char_type* __s2, size_t __n)
     538             :       { 
     539             :         return (static_cast<char_type*>
     540             :                 (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type))));
     541             :       }
     542             : 
     543             :       static char_type*
     544             :       assign(char_type* __s, size_t __n, char_type __a)
     545             :       {
     546             :         for (size_t __i = 0; __i < __n; ++__i)
     547             :           assign(__s[__i], __a);
     548             :         return __s;
     549             :       }
     550             : 
     551             :       static constexpr char_type
     552             :       to_char_type(const int_type& __c) noexcept
     553             :       { return char_type(__c); }
     554             : 
     555             :       static constexpr int_type
     556             :       to_int_type(const char_type& __c) noexcept
     557             :       { return int_type(__c); }
     558             : 
     559             :       static constexpr bool
     560             :       eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
     561             :       { return __c1 == __c2; }
     562             : 
     563             :       static constexpr int_type
     564             :       eof() noexcept
     565             :       { return static_cast<int_type>(-1); }
     566             : 
     567             :       static constexpr int_type
     568             :       not_eof(const int_type& __c) noexcept
     569             :       { return eq_int_type(__c, eof()) ? 0 : __c; }
     570             :     };
     571             : 
     572             : _GLIBCXX_END_NAMESPACE_VERSION
     573             : } // namespace
     574             : 
     575             : #endif 
     576             : 
     577             : #endif // _CHAR_TRAITS_H

Generated by: LCOV version 1.11