# pod_char_traits.h

Go to the documentation of this file.

    00001 // POD character, std::char_traits specialization -*- C++ -*-
    00002
    00003 // Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
    00004 //
    00005 // This file is part of the GNU ISO C++ Library.  This library is free
    00006 // software; you can redistribute it and/or modify it under the
    00007 // terms of the GNU General Public License as published by the
    00008 // Free Software Foundation; either version 2, or (at your option)
    00009 // any later version.
    00010
    00011 // This library is distributed in the hope that it will be useful,
    00012 // but WITHOUT ANY WARRANTY; without even the implied warranty of
    00013 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    00014 // GNU General Public License for more details.
    00015
    00016 // You should have received a copy of the GNU General Public License along
    00017 // with this library; see the file COPYING.  If not, write to the Free
    00018 // Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
    00019 // USA.
    00020
    00021 // As a special exception, you may use this file as part of a free software
    00022 // library without restriction.  Specifically, if other files instantiate
    00023 // templates or use macros or inline functions from this file, or you compile
    00024 // this file and link it with other files to produce an executable, this
    00025 // file does not by itself cause the resulting executable to be covered by
    00026 // the GNU General Public License.  This exception does not however
    00027 // invalidate any other reasons why the executable file might be covered by
    00028 // the GNU General Public License.
    00029
    00030 /** @file ext/pod_char_traits.h
    00031  *  This file is a GNU extension to the Standard C++ Library.
    00032  */
    00033
    00034 // Gabriel Dos Reis <gdr@integrable-solutions.net>
    00035 // Benjamin Kosnik <bkoz@redhat.com>
    00036
    00037 #ifndef _POD_CHAR_TRAITS_H
    00038 #define _POD_CHAR_TRAITS_H 1
    00039
    00040 #include <string>
    00041
    00042 _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
    00043
    00044   // POD character abstraction.
    00045   // NB: The char_type parameter is a subset of int_type, as to allow
    00046   // int_type to properly hold the full range of char_type values as
    00047   // well as EOF.
    00048   /// @brief A POD class that serves as a character abstraction class.
    00049   template<typename V, typename I, typename S = mbstate_t>
    00050     struct character
    00051     {
    00052       typedef V             value_type;
    00053       typedef I             int_type;
    00054       typedef S             state_type;
    00055       typedef character<V, I, S>    char_type;
    00056
    00057       value_type    value;
    00058
    00059       template<typename V2>
    00060         static char_type
    00061         from(const V2& v)
    00062         {
    00063       char_type ret = { static_cast<value_type>(v) };
    00064       return ret;
    00065     }
    00066
    00067       template<typename V2>
    00068         static V2
    00069         to(const char_type& c)
    00070         {
    00071       V2 ret = { static_cast<V2>(c.value) };
    00072       return ret;
    00073     }
    00074
    00075     };
    00076
    00077   template<typename V, typename I, typename S>
    00078     inline bool
    00079     operator==(const character<V, I, S>& lhs, const character<V, I, S>& rhs)
    00080     { return lhs.value == rhs.value; }
    00081
    00082   template<typename V, typename I, typename S>
    00083     inline bool
    00084     operator<(const character<V, I, S>& lhs, const character<V, I, S>& rhs)
    00085     { return lhs.value < rhs.value; }
    00086
    00087 _GLIBCXX_END_NAMESPACE
    00088
    00089 _GLIBCXX_BEGIN_NAMESPACE(std)
    00090
    00091   /// char_traits<__gnu_cxx::character> specialization.
    00092   template<typename V, typename I, typename S>
    00093     struct char_traits<__gnu_cxx::character<V, I, S> >
    00094     {
    00095       typedef __gnu_cxx::character<V, I, S> char_type;
    00096       typedef typename char_type::int_type  int_type;
    00097       typedef typename char_type::state_type    state_type;
    00098       typedef fpos<state_type>          pos_type;
    00099       typedef streamoff             off_type;
    00100
    00101       static void
    00102       assign(char_type& __c1, const char_type& __c2)
    00103       { __c1 = __c2; }
    00104
    00105       static bool
    00106       eq(const char_type& __c1, const char_type& __c2)
    00107       { return __c1 == __c2; }
    00108
    00109       static bool
    00110       lt(const char_type& __c1, const char_type& __c2)
    00111       { return __c1 < __c2; }
    00112
    00113       static int
    00114       compare(const char_type* __s1, const char_type* __s2, size_t __n)
    00115       {
    00116     for (size_t __i = 0; __i < __n; ++__i)
    00117       if (!eq(__s1[__i], __s2[__i]))
    00118         return lt(__s1[__i], __s2[__i]) ? -1 : 1;
    00119     return 0;
    00120       }
    00121
    00122       static size_t
    00123       length(const char_type* __s)
    00124       {
    00125     const char_type* __p = __s;
    00126     while (__p->value)
    00127       ++__p;
    00128     return (__p - __s);
    00129       }
    00130
    00131       static const char_type*
    00132       find(const char_type* __s, size_t __n, const char_type& __a)
    00133       {
    00134     for (const char_type* __p = __s; size_t(__p - __s) < __n; ++__p)
    00135       if (*__p == __a)
    00136         return __p;
    00137     return 0;
    00138       }
    00139
    00140       static char_type*
    00141       move(char_type* __s1, const char_type* __s2, size_t __n)
    00142       {
    00143     return static_cast<char_type*>(std::memmove(__s1, __s2,
    00144                             __n * sizeof(char_type)));
    00145       }
    00146
    00147       static char_type*
    00148       copy(char_type* __s1, const char_type* __s2, size_t __n)
    00149       {
    00150     std::copy(__s2, __s2 + __n, __s1);
    00151     return __s1;
    00152       }
    00153
    00154       static char_type*
    00155       assign(char_type* __s, size_t __n, char_type __a)
    00156       {
    00157     std::fill_n(__s, __n, __a);
    00158         return __s;
    00159       }
    00160
    00161       static char_type
    00162       to_char_type(const int_type& __i)
    00163       { return char_type::template from(__i); }
    00164
    00165       static int_type
    00166       to_int_type(const char_type& __c)
    00167       { return char_type::template to<int_type>(__c); }
    00168
    00169       static bool
    00170       eq_int_type(const int_type& __c1, const int_type& __c2)
    00171       { return __c1 == __c2; }
    00172
    00173       static int_type
    00174       eof()
    00175       {
    00176     int_type __r = { -1 };
    00177     return __r;
    00178       }
    00179
    00180       static int_type
    00181       not_eof(const int_type& __c)
    00182       { return eq_int_type(__c, eof()) ? int_type() : __c; }
    00183     };
    00184
    00185 _GLIBCXX_END_NAMESPACE
    00186
    00187 #endif