BufferedReader.cpp

Go to the documentation of this file.

#include <stdlib.h>     // malloc, realloc, free
#include <string.h>     // memset, memcpy
 
#include <dcl/BufferedReader.h>
#include <dcl/size_t.h>
 
#if __DCL_DEBUG
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/BufferedReader.cpp");
#endif
 
__DCL_BEGIN_NAMESPACE
 
IMPLEMENT_CLASSINFO(BufferedReader, Reader)
 
String BufferedReader::toString() const
{
    StringBuilder r = className();
    if (__reader)
        r += __T("(") + __reader->toString() + __T(")");
    else
        r += __T(" closed");
    return r;
}
 
BufferedReader::BufferedReader(Reader& __noclose__ _reader, size_t _bufSize)
{
    __DCL_ASSERT_PARAM(_bufSize > 0);
 
    __reader = &_reader;
    __closeDestroy = false;
 
    __buf = NULL;
    __bufSize = _bufSize;
    __begin = __end = NULL;
    __endLine = false;
}
 
BufferedReader::BufferedReader(Reader* __destroy__ _pReader, size_t _bufSize)
        __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT_PARAM(_pReader != NULL);
    __DCL_ASSERT_PARAM(_bufSize > 0);
 
    __reader = _pReader;
    __closeDestroy = true;
 
    __buf = NULL;
    __bufSize = _bufSize;
    __begin = __end = NULL;
    __endLine = false;
}
 
BufferedReader::~BufferedReader()
{
    if (__reader)
    {
        try
        {
            close();
        }
        catch (Exception* e)
        {
            __DCL_TRACE1(__T("Warning! %ls\n"), e->toString().data());
            e->destroy();
        }
    }
}
 
void BufferedReader::close()
            __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT_HANDLE(__reader != NULL);
 
    if (__buf)
    {
        free(__buf);
        __buf = NULL;
        __begin = __end = NULL;
    }
    __bufSize = 0;
 
    Reader* reader = __reader;
    __reader = NULL;
    if (__closeDestroy)
    {
        Exception* e = NULL;
        try
        {
            reader->close();
        }
        catch (Exception* cause)
        {
            e = cause;
        }
        reader->destroy();
        if (e)
            throw e;
    }
}
 
size_t BufferedReader::read(wchar_t* _buf, size_t _n)
            __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT_HANDLE(__reader != NULL);
    __DCL_ASSERT_PARAM(_buf != NULL);
 
    if (__endLine)
    {
        __endLine = false;
        // 이전에 CR 또는 LF 직전까지 읽었다. CRLF를 건너뛴다.
        // 이전의 CL, LF 또는 CRLF는 이전에 읽은 것이다.
        if (*__begin == L'\r')
            __begin++;
        if (*__begin == L'\n')
            __begin++;
    }
 
    size_t n = 0;
    if (__begin < __end)
    {
        __DCL_ASSERT(__buf != NULL);
 
        size_t nCopy = __MIN(__end - __begin, _n);
        memcpy(_buf, __begin, nCopy * sizeof(wchar_t));
        __begin += nCopy;
        n += nCopy;
        _n -= nCopy;
    }
 
    while (_n)
    {
        size_t nRead = __reader->read(_buf + n, _n);
        if (!nRead)
            break;      // EOF
        n += nRead;
        _n -= nRead;
    }
 
    return n;
}
 
bool BufferedReader::readLine(String& _r)
            __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT_HANDLE(__reader != NULL);
 
    StringBuilder sb((size_t) 0);
    bool assigned = false;
    if (__endLine) {
        __endLine = false;
        // 이전에 CR 또는 LF 직전까지 읽었다. CRLF를 건너뛴다.
        // 이전의 CL, LF 또는 CRLF는 이전에 읽은 것이다.
        if (*__begin == L'\r')
            __begin++;
        if (*__begin == L'\n')
            __begin++;
    }
 
    if (__begin < __end) {
        for (const wchar_t* cur = __begin; cur < __end; cur++) {
            if (*cur == L'\r' || *cur == L'\n') {
                __endLine = true;
                sb.assign(__begin, cur - __begin);
                __begin = cur;
 
                assigned = true;
                goto __done;
            }
        }
        sb.assign(__begin, __end - __begin);
        __begin = __end;
        assigned = true;
    }
 
    if (!__buf) {
        __buf = (wchar_t*)malloc(__bufSize * sizeof(wchar_t));
        if (!__buf) {
            throw new IOException(className(), IOException::NOMEM);
        }
    }
 
    size_t nRead;
    // 버퍼만큼 읽는다. 여기서 Block 될 수 있다.
    while ((nRead = __reader->read(__buf, __bufSize)) > 0) {
        __begin = __buf;
        __end = __buf + nRead;
        for (const wchar_t* cur = __begin; cur < __end; cur++) {
            if (*cur == L'\r' || *cur == L'\n') {
                __endLine = true;
                if (assigned)
                    sb.append(__begin, cur - __begin);
                else
                {
                    sb.assign(__begin, cur - __begin);
                    assigned = true;
                }
                __begin = cur;
 
                assigned = true;
                goto __done;
            }
        }
        // __bufSize 개수안에 CR, LF를 찾을 수 없다.
        if (assigned)
            sb.append(__begin, __end - __begin);
        else {
            sb.assign(__begin, __end - __begin);
            assigned = true;
        }
        __begin = __end;
    }
 
__done:
    _r = sb.toString();
    return assigned;
}
 
__DCL_END_NAMESPACE