codecvt_specializations.h File Reference

#include <bits/c++config.h>
#include <locale>
#include <iconv.h>

Go to the source code of this file.

Functions
namespace __gnu_cxx	_GLIBCXX_VISIBILITY (default)

Detailed Description

This file is a GNU extension to the Standard C++ Library.

Function Documentation

namespace __gnu_cxx _GLIBCXX_VISIBILITY

(

default

)

Extension to use iconv for dealing with character encodings.

encoding_char_traits

codecvt<InternT, _ExternT, encoding_state> specialization.

{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

  // This includes conversions and comparisons between various character
  // sets.  This object encapsulates data that may need to be shared between
  // char_traits, codecvt and ctype.
  class encoding_state
  {
  public:
    // Types: 
    // NB: A conversion descriptor subsumes and enhances the
    // functionality of a simple state type such as mbstate_t.
    typedef iconv_t descriptor_type;
    
  protected:
    // Name of internal character set encoding.
    std::string         _M_int_enc;

    // Name of external character set encoding.
    std::string     _M_ext_enc;

    // Conversion descriptor between external encoding to internal encoding.
    descriptor_type _M_in_desc;

    // Conversion descriptor between internal encoding to external encoding.
    descriptor_type _M_out_desc;

    // The byte-order marker for the external encoding, if necessary.
    int         _M_ext_bom;

    // The byte-order marker for the internal encoding, if necessary.
    int         _M_int_bom;

    // Number of external bytes needed to construct one complete
    // character in the internal encoding.
    // NB: -1 indicates variable, or stateful, encodings.
    int         _M_bytes;

  public:
    explicit 
    encoding_state() 
    : _M_in_desc(0), _M_out_desc(0), _M_ext_bom(0), _M_int_bom(0), _M_bytes(0)
    { }

    explicit 
    encoding_state(const char* __int, const char* __ext, 
           int __ibom = 0, int __ebom = 0, int __bytes = 1)
    : _M_int_enc(__int), _M_ext_enc(__ext), _M_in_desc(0), _M_out_desc(0), 
      _M_ext_bom(__ebom), _M_int_bom(__ibom), _M_bytes(__bytes)
    { init(); }

    // 21.1.2 traits typedefs
    // p4
    // typedef STATE_T state_type
    // requires: state_type shall meet the requirements of
    // CopyConstructible types (20.1.3)
    // NB: This does not preserve the actual state of the conversion
    // descriptor member, but it does duplicate the encoding
    // information.
    encoding_state(const encoding_state& __obj) : _M_in_desc(0), _M_out_desc(0)
    { construct(__obj); }

    // Need assignment operator as well.
    encoding_state&
    operator=(const encoding_state& __obj)
    {
      construct(__obj);
      return *this;
    }

    ~encoding_state()
    { destroy(); } 

    bool
    good() const throw()
    { 
      const descriptor_type __err = (iconv_t)(-1);
      bool __test = _M_in_desc && _M_in_desc != __err; 
      __test &=  _M_out_desc && _M_out_desc != __err;
      return __test;
    }
    
    int
    character_ratio() const
    { return _M_bytes; }

    const std::string
    internal_encoding() const
    { return _M_int_enc; }

    int 
    internal_bom() const
    { return _M_int_bom; }

    const std::string
    external_encoding() const
    { return _M_ext_enc; }

    int 
    external_bom() const
    { return _M_ext_bom; }

    const descriptor_type&
    in_descriptor() const
    { return _M_in_desc; }

    const descriptor_type&
    out_descriptor() const
    { return _M_out_desc; }

  protected:
    void
    init()
    {
      const descriptor_type __err = (iconv_t)(-1);
      const bool __have_encodings = _M_int_enc.size() && _M_ext_enc.size();
      if (!_M_in_desc && __have_encodings)
    {
      _M_in_desc = iconv_open(_M_int_enc.c_str(), _M_ext_enc.c_str());
      if (_M_in_desc == __err)
        std::__throw_runtime_error(__N("encoding_state::_M_init "
                    "creating iconv input descriptor failed"));
    }
      if (!_M_out_desc && __have_encodings)
    {
      _M_out_desc = iconv_open(_M_ext_enc.c_str(), _M_int_enc.c_str());
      if (_M_out_desc == __err)
        std::__throw_runtime_error(__N("encoding_state::_M_init "
                  "creating iconv output descriptor failed"));
    }
    }

    void
    construct(const encoding_state& __obj)
    {
      destroy();
      _M_int_enc = __obj._M_int_enc;
      _M_ext_enc = __obj._M_ext_enc;
      _M_ext_bom = __obj._M_ext_bom;
      _M_int_bom = __obj._M_int_bom;
      _M_bytes = __obj._M_bytes;
      init();
    }

    void
    destroy() throw()
    {
      const descriptor_type __err = (iconv_t)(-1);
      if (_M_in_desc && _M_in_desc != __err) 
    {
      iconv_close(_M_in_desc);
      _M_in_desc = 0;
    }
      if (_M_out_desc && _M_out_desc != __err) 
    {
      iconv_close(_M_out_desc);
      _M_out_desc = 0;
    }
    }
  };

  // Custom traits type with encoding_state for the state type, and the
  // associated fpos<encoding_state> for the position type, all other
  // bits equivalent to the required char_traits instantiations.
  template<typename _CharT>
    struct encoding_char_traits : public std::char_traits<_CharT>
    {
      typedef encoding_state                state_type;
      typedef typename std::fpos<state_type>        pos_type;
    };

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace