unicode.H

/*
 * This file is part of the "Archon" framework.
 * (http://files3d.sourceforge.net)
 *
 * Copyright © 2002 by Kristian Spangsege and Brian Kristiansen.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation under the terms of the GNU General Public License is
 * hereby granted. No representations are made about the suitability of
 * this software for any purpose. It is provided "as is" without express
 * or implied warranty. See the GNU General Public License
 * (http://www.gnu.org/copyleft/gpl.html) for more details.
 *
 * The characters in this file are ISO8859-1 encoded.
 *
 * The documentation in this file is in "Doxygen" style
 * (http://www.doxygen.org).
 */

#ifndef ARCHON_UTILITIES_UNICODE_H
#define ARCHON_UTILITIES_UNICODE_H

#include <string>

#if !defined __GNUC__ || __GNUC__ > 2
namespace std 
{
  template<>
  struct char_traits<unsigned>
  {
    typedef unsigned char_type;
    typedef unsigned int_type;
    typedef streampos pos_type;
    typedef streamoff off_type;
    typedef mbstate_t state_type;
      
    static void assign(char_type &__c1, const char_type &__c2)
    {
      __c1 = __c2;
    }

    static bool eq(const char_type &__c1, const char_type &__c2)
    {
      return __c1 == __c2;
    }

    static bool lt(const char_type &__c1, const char_type &__c2)
    {
      return __c1 < __c2;
    }

    static int compare(const char_type *__s1, const char_type *__s2, size_t __n)
    { 
      for (size_t __i = 0; __i < __n; ++__i)
        if (!eq(__s1[__i], __s2[__i]))
          return lt(__s1[__i], __s2[__i]) ? -1 : 1;
      return 0; 
    }

    static size_t length(const char_type *__s)
    { 
      const char_type *__p = __s; 
      while (*__p) ++__p; 
      return (__p - __s); 
    }

    static const char_type *find(const char_type *__s, size_t __n, const char_type &__a)
    {
      for (const char_type* __p = __s; size_t(__p - __s) < __n; ++__p)
        if (*__p == __a) return __p;
      return 0;
    }

    static char_type *move(char_type *__s1, const char_type *__s2, size_t __n)
    {
      return static_cast<char_type *>(memmove(__s1, __s2, __n * sizeof(char_type)));
    }

    static char_type *copy(char_type *__s1, const char_type *__s2, size_t __n)
    {
      return static_cast<char_type *>(memcpy(__s1, __s2, __n * sizeof(char_type)));
    }

    static char_type *assign(char_type *__s, size_t __n, char_type __a)
    { 
      for (char_type *__p = __s; __p < __s + __n; ++__p) 
        assign(*__p, __a);
      return __s; 
    }

    static char_type to_char_type(const int_type &__c)
    {
      return char_type(__c);
    }

    static int_type to_int_type(const char_type &__c)
    {
      return int_type(__c);
    }

    static bool eq_int_type(const int_type &__c1, const int_type &__c2)
    {
      return __c1 == __c2;
    }

    static int_type eof()
    {
      return static_cast<int_type>(-1);
    }

    static int_type not_eof(const int_type &__c)
    {
      return eq_int_type(__c, eof()) ? int_type(0) : __c;
    }
  };
}
#endif

namespace Archon
{
  namespace Utilities
  {
    using namespace std;

    typedef unsigned uchar;              // One unicode character MUST ALWAYS BE EXACTLY 4 BYTES WIDE
    typedef basic_string<uchar> ustring; // A string of unicode characters

    namespace Unicode
    {
      string encodeUtf8(ustring);

      ustring decodeUtf8(string s);

      int decodeUtf8(const char *in, int inSize, uchar *out, int &outSize);
    }
  }
}

#endif // ARCHON_UTILITIES_UNICODE_H

---