BufferedInputStream.cpp

Go to the documentation of this file.

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