CharsetDecoder Class Reference

#include <Charset.h>

Inheritance diagram for CharsetDecoder:

Public Member Functions
virtual int	decode (const byte_t *_in, size_t &_inCount, wchar_t *_out, size_t &_outCount)
size_t	getDecodedLength (const char *_mbs, size_t _mbslen) __DCL_THROWS1(CharsetConvertException *)
String	decode (const char *_mbs, size_t _mbslen=(size_t) -1) __DCL_THROWS1(CharsetConvertException *)
String	decode (const ByteString &_str) __DCL_THROWS1(CharsetConvertException *)
Public Member Functions inherited from Object
virtual String	toString () const
virtual void	destroy ()
String	className () const
bool	isInstanceOf (const std::type_info &typeinfo) const
virtual const std::type_info &	typeInfo () const

Protected Member Functions
	CharsetDecoder ()
virtual int	toWideChar (const byte_t *_mbs, size_t _mbslen, ucs4_t *_uc)=0
Protected Member Functions inherited from Object
virtual	~Object ()
	Object ()

Detailed Description

Definition at line 106 of file Charset.h.

Constructor & Destructor Documentation

CharsetDecoder()

CharsetDecoder::CharsetDecoder ( )

protected

Member Function Documentation

decode() [1/3]

int CharsetDecoder::decode ( const byte_t * _in, size_t & _inCount, wchar_t * _out, size_t & _outCount )

virtual

Definition at line 50 of file CharsetDecoder.cpp.

{
    __DCL_ASSERT(_in != NULL && _out != NULL);
 
    wchar_t* dst = _out;
    wchar_t* dstend = dst + _outCount;
 
    const byte_t* src = _in;
    const byte_t* srcend = src + _inCount;
    size_t srclen;
 
    int _mbslen = 0;
    while((srclen = srcend - src) > 0 && dst < dstend) {
        ucs4_t uc;
        _mbslen = toWideChar(src, srclen, &uc);
 
        if (_mbslen <= 0)
            break;
 
#if __SIZEOF_WCHAR_T__ == 2
        if (uc > 0xFFFF || (0xD800 <= uc && uc < 0xE000)) {
            _mbslen = ILLEGAL_UCS2;
            break;
        }
#endif
        *dst = (wchar_t)uc;
 
        src += (size_t)_mbslen;
        dst++;
    }
 
    _inCount = src - _in;
    _outCount = dst - _out;
    
    if (_mbslen >= 0)
        return CS_NOERROR;
 
    switch (_mbslen) {
        case ILLEGAL_UCS2 :
            return CS_ILLEGAL_UCS2;
        case ILLEGAL_SEQUENCE :
            return CS_ILLEGAL_SEQUENCE;
    }
    return CS_SOURCE_FEW;
}

decode() [2/3]

String CharsetDecoder::decode

(

const ByteString &

_str

)

Definition at line 162 of file CharsetDecoder.cpp.

{
    return decode(_str, _str.length());
}

decode() [3/3]

String CharsetDecoder::decode	(	const char *	_mbs,
		size_t	_mbslen = (size_t)-1 )

Definition at line 128 of file CharsetDecoder.cpp.

{
    __DCL_ASSERT(_mbs != NULL);
    if (_mbslen == (size_t) -1)
        _mbslen = ByteString::length(_mbs);
 
    String rstr;
    if (_mbslen) {
        const byte_t* _in = (const byte_t*) _mbs;
        size_t _inCount = _mbslen;
#if 0
        size_t _outCount = getDecodedLength(_mbs, _mbslen);
#else
        size_t _outCount = _mbslen;
#endif
 
        CharBuffer* buf = CharBuffer::create(_outCount);
        int rn = decode(_in, _inCount, buf->data(), _outCount);
        __DCL_ASSERT(_outCount <= buf->__allocLength);
        if (rn != CS_NOERROR) {
            buf->release();
            throw new CharsetConvertException(rn);
        }
        buf->data()[_outCount] = L'\0';
        buf->__dataLength = _outCount;
        CharBuffer::shrink(buf);
 
        rstr.assign(buf);
        buf->release();
    }
    return rstr;
}

getDecodedLength()

size_t CharsetDecoder::getDecodedLength	(	const char *	_mbs,
		size_t	_mbslen )

Definition at line 101 of file CharsetDecoder.cpp.

{
    const byte_t* _in = (const byte_t*)_mbs;
    size_t inTotal = _mbslen;
    size_t outTotal = 0;
    wchar_t buf[6];
 
    for ( ; ; ) {
        size_t _inCount = inTotal;
        size_t _outCount = __countof(buf, wchar_t);
        int r = decode(_in, _inCount, buf, _outCount);
        outTotal += _outCount;
        if (r == CS_NOERROR) {
            inTotal -= _inCount;
            if (inTotal == 0)
                break;
            // else buffer small
        }
        else {
            throw(new CharsetConvertException(r));
        }
        _in += _inCount;        
    }
    return outTotal;
}

toWideChar()

virtual int CharsetDecoder::toWideChar ( const byte_t * _mbs, size_t _mbslen, ucs4_t * _uc )

protectedpure virtual

Implemented in AsciiDecoder, Latin1Decoder, LocaleDecoder, UTF16Decoder, UTF32Decoder, and UTF8Decoder.

---

The documentation for this class was generated from the following files:

• Charset.h
• CharsetDecoder.cpp