arabica/SAX/helpers/StringAdaptor.h

#ifndef STRINGADAPTOR_H
#define STRINGADAPTOR_H
/*
 * $Id$
 */

#include <string>
#include <Utils/convertstream.h>
#include <Utils/utf16utf8_codecvt.h>

namespace SAX
{

template<class string_type>
class default_string_adaptor
{
public:
  typedef string_type stringT;
  typedef typename stringT::value_type value_type;

  value_type makeValueT(char c) const;
  stringT makeStringT(const char* str) const;
  stringT makeStringT(const char* str, int length) const;
  stringT makeStringT(const wchar_t* str) const;
  stringT makeStringT(const wchar_t* str, int length) const;

  // only used to constuct error strings - don't have to be highly efficient!
  std::string asStdString(const stringT& str) const;
#if !(__GNUG__ && (__GNUC__ < 3))
  std::wstring asStdWString(const stringT& str) const;
#endif // !(__GNUG__ && (__GNUC__ < 3))
}; // class default_string_maker

// specialize for std::string and std::wstring
template<>
class default_string_adaptor<std::string>
{
#if !(__GNUG__ && (__GNUC__ < 3))
    private:
  typedef basic_iconvertstream<wchar_t, std::char_traits<wchar_t>,
                               char, std::char_traits<char> > widener;
  typedef basic_oconvertstream<wchar_t, std::char_traits<wchar_t>,
                               char, std::char_traits<char> > narrower;
#endif // !(__GNUG__ && (__GNUC__ < 3))
public:
  char makeValueT(char c) const { return c; }

  std::string makeStringT(const char* str) const
  {
    return str ? std::string(str) : std::string();
  } // makeStringT
  std::string makeStringT(const char* str, int length) const
  {
    return std::string(str, length);
  } // makeStringT
#if !(__GNUG__ && (__GNUC__ < 3))
  std::string makeStringT(const wchar_t* str) const
  {
    std::wstring s;
    if(str)
      s = str;
    n_.str(s);
    return n_.str();
  } // makeStringT
  std::string makeStringT(const wchar_t* str, int length) const
  {
    n_.str(std::wstring(str, length));
    return n_.str();
  } // makeStringT
#endif // !(__GNUG__ && (__GNUC__ < 3))

  const std::string& asStdString(const std::string& str) const
  {
    return str;
  } // toStdString
#if !(__GNUG__ && (__GNUC__ < 3))
  std::wstring asStdWString(const std::string& str) const
  {
    w_.str(str);
    return w_.str();
  } // toStdWString
#endif // !(__GNUG__ && (__GNUC__ < 3))

      default_string_adaptor()
#if !(__GNUG__ && (__GNUC__ < 3))
#ifndef _MSC_VER
	: loc_(std::locale(), new utf16utf8_codecvt()),
#else
      : loc_(std::_Addfac(std::locale(), new utf16utf8_codecvt)),
#endif
    n_(),
    w_()
#endif // !(__GNUG__ && (__GNUC__ < 3))
  {
#if !(__GNUG__ && (__GNUC__ < 3))
    n_.imbue(loc_);
    w_.imbue(loc_);
#endif // !(__GNUG__ && (__GNUC__ < 3))
  } // default_string_adaptor 

private:
#if !(__GNUG__ && (__GNUC__ < 3))
  std::locale loc_;
  mutable narrower n_;
  mutable widener w_;
#endif // !(__GNUG__ && (__GNUC__ < 3))
}; // class default_string_adaptor

#if !(__GNUG__ && (__GNUC__ < 3))
template<>
class default_string_adaptor<std::wstring>
{
    private:
  typedef basic_iconvertstream<wchar_t, std::char_traits<wchar_t>,
                               char, std::char_traits<char> > widener;
  typedef basic_oconvertstream<wchar_t, std::char_traits<wchar_t>,
                               char, std::char_traits<char> > narrower;
public:
  wchar_t makeValueT(char c) const 
  { 
    return static_cast<wchar_t>(c);
  } // makeValueT

  std::wstring makeStringT(const char* str) const
  {
    if(str)
      w_.str(str);
    else
      w_.str("");
    return w_.str();
  } // makeStringT
  std::wstring makeStringT(const char* str, int length) const
  {
    w_.str(std::string(str, length));
    return w_.str();
  } // makeStringT
  std::wstring makeStringT(const wchar_t* str) const
  {
    return str ? std::wstring(str) : std::wstring();
  } // makeStringT
  std::wstring makeStringT(const wchar_t* str, int length) const
  {
    return std::wstring(str, length);
  } // makeStringT

  std::string asStdString(const std::wstring& str) const
  {
    n_.str(str);
    return n_.str();
  } // toStdString
  const std::wstring& asStdWString(const std::wstring& str) const
  {
    return str;
  } // toStdWString

  default_string_adaptor() :
#ifndef _MSC_VER
    loc_(std::locale(), new utf16utf8_codecvt()),
#else
    loc_(std::_Addfac(std::locale(), new utf16utf8_codecvt)),
#endif
    n_(), 
    w_()
  {
    n_.imbue(loc_);
    w_.imbue(loc_);
  } // default_string_adaptor 

private:
  std::locale loc_;
  mutable narrower n_;
  mutable widener w_;
}; // class default_string_adaptor
#endif // !(__GNUG__ && (__GNUC__ < 3))

} // namespace SAX

#endif
// end of file