InputStreamReader.cpp

Go to the documentation of this file.

 
#include <dcl/Config.h>
 
#ifdef __WINNT__
#include <windows.h>
#endif
 
#include <string.h>             // memcpy, memmove
#include <dcl/size_t.h>
#include <dcl/Charset.h>
#include <dcl/InputStreamReader.h>
 
#if __DCL_HAVE_THIS_FILE__
#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