charset_utf16.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2014 Patrick P. Frey
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */

#ifndef __TEXTWOLF_CHARSET_UTF16_HPP__
#define __TEXTWOLF_CHARSET_UTF16_HPP__
#include "textwolf/char.hpp"
#include "textwolf/charset_interface.hpp"
#include "textwolf/exception.hpp"
#include <cstddef>

namespace textwolf {
namespace charset {

template <int encoding=ByteOrder::BE>
class UTF16
{
private:
        enum
        {
                LSB=(encoding==ByteOrder::BE),                  //< least significant byte index (0 or 1)
                MSB=(encoding==ByteOrder::LE),                  //< most significant byte index (0 or 1)
                Print1shift=(encoding==ByteOrder::BE)?8:0,      //< value to shift with to get the 1st character to print
                Print2shift=(encoding==ByteOrder::LE)?8:0       //< value to shift with to get the 2nd character to print
        };

public:
        enum
        {
                MaxChar=0x10FFFFU                               //< maximum character in alphabet
        };

public:
        template <class Iterator>
        static inline void fetchbytes( char* buf, unsigned int& bufpos, Iterator& itr)
        {
                if (bufpos<2)
                {
                        if (bufpos<1)
                        {
                                buf[0] = *itr;
                                ++itr;
                                ++bufpos;
                        }
                        buf[1] = *itr;
                        ++itr;
                        ++bufpos;
                }
        }

        template <class Iterator>
        static inline unsigned int size( char* buf, unsigned int& bufpos, Iterator& itr)
        {
                fetchbytes( buf, bufpos, itr);

                UChar rt = (unsigned char)buf[ MSB];
                if ((rt - 0xD8) > 0x03)
                {
                        return 2;
                }
                else
                {
                        return 4;
                }
        }

        template <class Iterator>
        static inline void skip( char* buf, unsigned int& bufpos, Iterator& itr)
        {
                unsigned int bufsize = size( buf, bufpos, itr);
                for (;bufpos < bufsize; ++bufpos)
                {
                        ++itr;
                }
        }

        template <class Iterator>
        static inline signed char asciichar( char* buf, unsigned int& bufpos, Iterator& itr)
        {
                UChar ch = value_impl( buf, bufpos, itr);
                return (ch > 127)?-1:(char)ch;
        }

        template <class Iterator>
        static UChar value_impl( char* buf, unsigned int& bufpos, Iterator& itr)
        {
                unsigned int bufsize = size( buf, bufpos, itr);

                UChar rt = (unsigned char)buf[ MSB];
                rt = (rt << 8) + (unsigned char)buf[ LSB];

                if (bufsize == 4)
                {
                        // 2 teilig
                        while (bufpos < bufsize)
                        {
                                buf[bufpos] = *itr;
                                ++itr;
                                ++bufpos;
                        }
                        rt -= 0xD800;
                        rt *= 0x400;
                        unsigned short lo = (unsigned char)buf[ 2+MSB];
                        if ((lo - 0xDC) > 0x03) return 0xFFFF;
                        lo = (lo << 8) + (unsigned char)buf[ 2+LSB];
                        return rt + lo - 0xDC00 + 0x010000;
                }
                return rt;
        }

        template <class Iterator>
        inline UChar value( char* buf, unsigned int& bufpos, Iterator& itr) const
        {
                return value_impl( buf, bufpos, itr);
        }

        template <class Buffer_>
        void print( UChar ch, Buffer_& buf) const
        {
                if (ch <= 0xFFFF)
                {
                        if ((ch - 0xD800) < 0x400)
                        {
                                //... reserved for encoding of characters in range [0xFFFF..0x10FFFF]
                        }
                        else
                        {
                                buf.push_back( (char)(unsigned char)((ch >> Print1shift) & 0xFF));
                                buf.push_back( (char)(unsigned char)((ch >> Print2shift) & 0xFF));
                                return;
                        }
                }
                else if (ch <= 0x10FFFF)
                {
                        ch -= 0x10000;
                        unsigned short hi = (unsigned short )((ch / 0x400) + 0xD800);
                        unsigned short lo = (unsigned short )((ch % 0x400) + 0xDC00);
                        buf.push_back( (char)(unsigned char)((hi >> Print1shift) & 0xFF));
                        buf.push_back( (char)(unsigned char)((hi >> Print2shift) & 0xFF));
                        buf.push_back( (char)(unsigned char)((lo >> Print1shift) & 0xFF));
                        buf.push_back( (char)(unsigned char)((lo >> Print2shift) & 0xFF));
                        return;
                }
                char tb[ 32];
                char* cc = tb;
                Encoder::encode( ch, tb, sizeof(tb));
                while (*cc)
                {
                        buf.push_back( (char)(unsigned char)(((UChar)*cc >> Print1shift) & 0xFF));
                        buf.push_back( (char)(unsigned char)(((UChar)*cc >> Print2shift) & 0xFF));
                        ++cc;
                }
        }

        static inline bool is_equal( const UTF16&, const UTF16&)
        {
                return true;
        }
};

struct UTF16LE :public UTF16<ByteOrder::LE> {};
struct UTF16BE :public UTF16<ByteOrder::BE> {};

}//namespace
}//namespace
#endif