InputStreamReader.cpp

Go to the documentation of this file.

 
#include <dcl/Config.h>
 
#if __DCL_WINDOWS
#include <windows.h>
#endif
 
#include <string.h>             // memcpy, memmove
#include <dcl/size_t.h>
#include <dcl/Charset.h>
#include <dcl/InputStreamReader.h>
 
#if __DCL_DEBUG
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/InputStreamReader.cpp");
#endif
 
__DCL_BEGIN_NAMESPACE
 
IMPLEMENT_CLASSINFO(InputStreamReader, Reader)
 
String InputStreamReader::toString() const
{
    StringBuilder r = className();
    if (__input)
    {
        r += __T("(") + __input->toString() + __T(",");
        if (__decoder)
            r += __decoder->className();
        else
            r += __T("null");
        r += __T(")");
    }
    else
        r += __T(" closed");
    return r;
}
 
InputStreamReader::InputStreamReader()
{
    __input = NULL;
    __decoder = NULL;
    __closeDestroy = false;
    __extraBytes = 0;
}
 
InputStreamReader::InputStreamReader(
        InputStream&     __noclose__ _input,
        CharsetDecoder&   _decoder
        )
{
    __input = &_input;
    __decoder = &_decoder;
    __closeDestroy = false;
    __extraBytes = 0;
}
 
InputStreamReader::InputStreamReader(
        InputStream*         __destroy__ _pInput ,        // new InputStream
        CharsetDecoder*   __destroy__ _pDecoder        // new CharsetDecoder
        ) __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT_PARAM(_pInput != NULL);
 
    __input = _pInput;
    __decoder = _pDecoder;
    __closeDestroy = true;
    __extraBytes = 0;
}
 
InputStreamReader::~InputStreamReader()
{
    if (__input)
    {
        try
        {
            close();
        }
        catch (Exception* e)
        {
            __DCL_TRACE1(L"%ls\n", e->toString().data());
            e->destroy();
        }
    }
}
 
void InputStreamReader::close()
            __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT_HANDLE(__input != NULL);
 
    Exception* e = NULL;
    InputStream* input = __input;
    CharsetDecoder* decoder = __decoder;
    __input = NULL;
    __decoder = NULL;
    __extraBytes = 0;
 
    if (__closeDestroy)
    {
        if (decoder)
            decoder->destroy();
 
        try
        {
            input->close();
        }
        catch (Exception* cause)
        {
            e = cause;
        }
        input->destroy();
    }
 
    if (e)
        throw e;
}
 
size_t InputStreamReader::read(wchar_t* _buf, size_t _n)
            __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT_HANDLE(__input != NULL);
    __DCL_ASSERT_PARAM(_buf != NULL);
 
    if (!_n)
        return 0;
 
    if (!__decoder)
    {
        char bom[4];
        if (__input->available() >= sizeof(bom))
        {
            size_t readCount = __input->read(bom, sizeof(bom));
            if ((readCount == 4) && IS_UTF32(bom))
                __decoder = new UTF32Decoder();
            else if ((readCount >= 3) && IS_UTF8(bom))
                __decoder = new UTF8Decoder();
            else if ((readCount >= 2) && IS_UTF16(bom))
                __decoder = new UTF16Decoder();
 
            memcpy(__extra, bom, readCount);
            __extraBytes = readCount;
        }
 
        if (!__decoder)
            __decoder = new LocaleDecoder();
    }
 
    wchar_t* outCur = _buf;
    wchar_t* outEnd = _buf + _n;
 
#define __BUFFER_SIZE__     1024
    byte_t inBuf[__BUFFER_SIZE__ + __EXTRA_MAX];
    size_t extraCount = __extraBytes;
 
    // Non-Block이 가능한 양 만큼
    size_t availCount = __input->available();
    memcpy(inBuf, __extra, extraCount);
 
    size_t outCount;
    while ((outCount = outEnd - outCur) && availCount)
    {
        size_t readCount = __MIN(__MAX(outCount, __EXTRA_MAX), availCount, __BUFFER_SIZE__);
        readCount = __input->read(inBuf + extraCount, readCount);
        availCount -= readCount;
 
        size_t inCount = readCount + extraCount;
        if (!inCount)
            break;
 
        size_t inCountSave = inCount;
        int r = __decoder->decode(inBuf, inCount, outCur, outCount);
        /*__DCL_TRACE4(__T("%ls read[%d], extra[%d], out[%d]\n"),
                __decoder->className(), readCount, extraCount, outCount);*/
        extraCount = inCountSave - inCount;
        switch (r)
        {
        case CS_SOURCE_FEW :
            __DCL_ASSERT(extraCount <= __EXTRA_MAX);
            if (inCount > 0)
                memmove(inBuf, inBuf + inCount, extraCount);
            break;
        case CS_NOERROR :
            __DCL_ASSERT(extraCount == 0);
            break;
        default :
            throw(new IOException(toString(), new CharsetConvertException(r)));
        }
        outCur += outCount;
    }
 
    // 이곳에서 Block 될 수 있다.
    if ((outCount = outEnd - outCur) > 0)
    {
        size_t readCount = __MIN(__MAX(outCount, __EXTRA_MAX), __BUFFER_SIZE__);
        readCount = __input->read(inBuf + extraCount, readCount);
        size_t inCount = readCount + extraCount;
 
        if (inCount)
        {
            size_t inCountSave = inCount;
            int r = __decoder->decode(inBuf, inCount, outCur, outCount);
            /*__DCL_TRACE4(__T("%ls read[%d], extra[%d], out[%d]\n"),
                    __decoder->className(), readCount, extraCount, outCount);*/
            extraCount = inCountSave - inCount;
            switch (r)
            {
            case CS_SOURCE_FEW :
                __DCL_ASSERT(extraCount <= __EXTRA_MAX);
                if (inCount > 0)
                    memmove(inBuf, inBuf + inCount, extraCount);
                break;
            case CS_NOERROR :
                __DCL_ASSERT(extraCount == 0);
                break;
            default :
                throw(new IOException(className(), new CharsetConvertException(r)));
            }
            outCur += outCount;
        }
    }
 
    memcpy(__extra, inBuf, extraCount);
    __extraBytes = extraCount;
 
    return outCur - _buf;
}
 
__DCL_END_NAMESPACE