Преобразовние Utf-16 <=> Utf-8

  struct Tab
  {
    unsigned char char_mask;
    unsigned char char_value;
    int shift;
    unsigned long wide_mask;
  };
 
  static const Tab tab[] =
  {
    { char(0x80),  char(0x00),   0*6,    0x7F,   },   // 1 byte sequence
    { char(0xE0),  char(0xC0),   1*6,    0x7FF,  },   // 2 byte sequence
    { char(0xF0),  char(0xE0),   2*6,    0xFFFF, },   // 3 byte sequence
    { 0,           0,            0,      0,      }    // end of table
  };
 
std::codecvt_base::result Arabica::convert::impl::utf8_2_ucs2(
                       const char* from, const char* from_end, const char*& from_next,
                       wchar_t* to, wchar_t* to_limit, wchar_t*& to_next)
{
  from_next = from;
  to_next = to;
 
    while((from_next < from_end) && (to_next < to_limit))
    {
    unsigned char start = static_cast<unsigned char>(*from_next);
 
    const Tab *t = tab;
    for(; t->char_mask; ++t)
    {
      if((start & t->char_mask) == t->char_value)
        break;
    }
 
    if((from_next + (t - tab)) >= from_end)
      break;
 
    unsigned long wide_mask = t->wide_mask;
 
    *to_next = start;
    for(; t != tab; --t)
    {
      from_next++;
      *to_next = (*to_next << 6) | ((*from_next ^ 0x80) & 0xff);
    }
    *to_next &= wide_mask;
 
    ++from_next;
    ++to_next;
  } // while
 
  return (from_next == from_end) ? std::codecvt_base::ok : std::codecvt_base::partial;
} // utf8_2_ucs2

    std::codecvt_base::result utf16_2_utf8(const char* from, const char* from_end, const char*& from_next,
            char* to, char* to_end, char*& to_next, bool utf16_be)
    {
        from_next = from;
        to_next = to;
        size_t from_size = (from_end - from);
        Impl::iconv_result state = convert(from_next, from_size, to_next, (to_end - to), 
                    (utf16_be ? "UTF-16BE" : "UTF-16LE"), "UTF-8");
        return state == Impl::iconv_ok ? std::codecvt_base::ok : 
          state == Impl::iconv_partial ? std::codecvt_base::partial : std::codecvt_base::error;
    }

template<class CharT>
std::codecvt_base::result ucs2_2_utf8(const CharT* from, const CharT* from_end, const CharT*& from_next,
                                      char* to, char* to_end, char*& to_next, bool ucs2_be)
{
    from_next = from;
    to_next = to;
    size_t from_size = (from_end - from) * sizeof(CharT);
    Impl::iconv_result state = Locale::Convert::convert(from_next, from_size, to_next, (to_end - to), 
            (ucs2_be ? "UCS-2BE" : "UCS-2LE"), "UTF-8");
    return state == Impl::iconv_ok ? std::codecvt_base::ok : 
      state == Impl::iconv_partial ? std::codecvt_base::partial : std::codecvt_base::error;
}

namespace Locale
{
namespace Convert
{
namespace Impl
{
    class IconvError:public std::logic_error
    {
    public:
        IconvError(const std::string& string):
            std::logic_error(string)
        {
        }
    };
    
    std::string errno_open();
    std::string errno_convert();
    
    //iconv representation of std::codecvt_base::result.
    enum iconv_result
    {
        iconv_error = std::codecvt_base::error,
        iconv_partial = std::codecvt_base::partial,
        iconv_ok = std::codecvt_base::ok
    };
}//namespace Impl
 
    /*
     * Convert from from_code encoding to to_code encoding using libiconv.
     *
     * @types@
     *    CharT - internal char representation
     *    ExternCharT - external char representation
     * @types@
     *
     * @params@
     *    in_pointer - reference to internal char pointer
     *    in_size - size of internal char buffer
     *    out_pointer - reference to external char pointer
     *    out_size - size of external char buffer
     *    from_code - title of the internal encoding
     *    to_code - title of the external encoding
     * @params@
     *
     * @return@
     *    return iconv_error if iconv can`t convert
     *    return iconv_partial if partial conversion was happened
     *    return iconv_ok if encoding is succesfull
     *    throw exception if iconv handler can`t be created
     * @return
    */ 
 
    template<class CharT, class ExternCharT>
    Impl::iconv_result convert(CharT*& in_pointer, size_t in_size, ExternCharT*& out_pointer, size_t out_size,
            const std::string& from_code, const std::string& to_code)
    {
        iconv_t converter = iconv_open(to_code.c_str(), from_code.c_str());
        if (converter == iconv_t(-1))
        {
            throw Impl::IconvError("Converter opening error: " + Impl::errno_open());
        }
        char* in_pointer_for_conv = (char*)in_pointer;
        char* out_pointer_for_conv = (char*)out_pointer;
        size_t result = iconv(converter, &in_pointer_for_conv, &in_size, &out_pointer_for_conv, &out_size);
        in_pointer = (CharT*)in_pointer_for_conv;
        out_pointer = (ExternCharT*)out_pointer_for_conv;
        if (result == size_t(-1))
        {
            iconv_close(converter);
            if(errno == E2BIG || errno == EINVAL)
                return Impl::iconv_partial;
            return Impl::iconv_error;
        }
        iconv_close(converter);
        return Impl::iconv_ok;
    }
}//namespace Convert
}//namespace Locale