FileInputStream.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#ifdef __WINNT__
    #include <windows.h>
#else
    #include <errno.h>
    #include <unistd.h>     // isatty
    #include <sys/stat.h>   // fstat
#endif
 
#include <string.h>         // memcpy
#include <stdlib.h>         // malloc, free
 
#include <dcl/size_t.h>
#include <dcl/Object.h>
#include <dcl/FileInputStream.h>
 
#if __DCL_HAVE_ALLOC_DEBUG
#undef __DCL_ALLOC_LEVEL
#define __DCL_ALLOC_LEVEL   __DCL_ALLOC_INTERNAL
#endif
 
#if __DCL_HAVE_THIS_FILE__
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/FileInputStream.cpp");
#endif
 
__DCL_BEGIN_NAMESPACE
 
IMPLEMENT_CLASSINFO(FileInputStream, InputStream)
 
String FileInputStream::toString() const
{
    StringBuilder r = className();
    if (__file)
        r += __T("(") + __file->toString() + __T(")");
    else
        r += __T(" closed");
    return r;
}
 
FileInputStream::FileInputStream(const String& _path)
    __DCL_THROWS1(IOException*)
{
    __file = NULL;
    open(_path);
}
 
#ifdef _MSC_VER
FileInputStream::FileInputStream(const wchar_t* _path)
    __DCL_THROWS1(IOException*) 
{
    __file = NULL;
    open(_path);
}
#endif
 
void FileInputStream::init(File* _file)
    __DCL_THROWS1(IOException*)
{
    __buf = NULL;
    __bufSize = 0;
#ifdef __WINNT__
    switch (_file->fileType()) {
        case File::REGULAR:
            __bufSize = 4096;
            break;
#if 0
        case File::PIPE: {
            DWORD dwInBufferSize = 0;
            if (GetNamedPipeInfo(_file->handle(), NULL, NULL, &dwInBufferSize, NULL))
                __bufSize = dwInBufferSize;
            break;
        }
#endif
        default: {
            // __bufSize = 0;
        }
    }
 
#else
    if (!isatty(_file->handle())) {
        struct stat st;
        if (fstat(_file->handle(), &st)) {
            throw new IOException(_file->path(), errno);
        }
        __bufSize = st.st_blksize;
    }
#endif
    __cacheStart = NULL;
    __cacheSize = 0;
}
 
FileInputStream::FileInputStream(File& _file)
    __DCL_THROWS1(IOException*)
{
    init(&_file);
    __file = &_file;
    __closeDestroy = false;
}
 
FileInputStream::FileInputStream(File::HandleType _handle)
    __DCL_THROWS1(IOException*)
{
    File* file = new File(_handle, 0, false);
    try {
        init(file);
    }
    catch (Exception* _e) {
        delete file;
        throw _e;
    }
    __file = file;
    __closeDestroy = true;
}
 
void FileInputStream::open(const String& _path)
    __DCL_THROWS1(IOException*)
{
    if (__file) {
        close();
    }
 
    File* file = new File(_path, File::READONLY);
    try {
        init(file);
    }
    catch (Exception* _e) {
        delete file;
        throw _e;
    }
    __file = file;
    __closeDestroy = true;
}
 
FileInputStream::~FileInputStream()
{
    if (__file != NULL) {
        try {
            close();
        }
        catch (IOException* _e) {
            __DCL_TRACE1(L"!FileInputStream close error! %ls\n",
                _e->toString().data());
            _e->destroy();
        }
    }
    __DCL_ASSERT(__buf == NULL);
}
 
void FileInputStream::close()
    __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT_HANDLE(__file != NULL);
 
    if (__buf) {
        free(__buf);
        __cacheStart = __buf = NULL;
        __cacheSize = __bufSize = 0;
    }
 
    Exception* e = NULL;
    File* file = __file;
    __file = NULL;
    if (__closeDestroy) {
        try {
            file->close();
        }
        catch (Exception* _cause) {
            e = _cause;
        }
        file->destroy();
    }
    if (e) {
        throw e;
    }
}
 
size_t FileInputStream::available() const
    __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT_HANDLE(__file != NULL);
 
    return __ADD_OVERFLOW_MAX(__file->available(), __cacheSize);
}
 
size_t FileInputStream::read(void* _buf, size_t _nbytes) 
    __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT_HANDLE(__file != NULL);
    __DCL_ASSERT_PARAM(_buf != NULL);
 
    if (!_nbytes)
        return 0;
 
    if (!__bufSize) {
        // 버퍼링을 하지 않는다.
        return __file->read(_buf, _nbytes);
    }
 
    size_t nbytes = _nbytes;
    byte_t* buf = (byte_t*)_buf;
 
    if (__cacheSize) {
        __DCL_ASSERT(__buf != NULL);
        __DCL_ASSERT(__cacheStart != NULL);
 
        size_t nCopy = __MIN(__cacheSize, nbytes);
        memcpy(buf, __cacheStart, nCopy);
        __cacheStart += nCopy;
        __cacheSize -= nCopy;
 
        buf += nCopy;
        nbytes -= nCopy;
    }
 
    if (nbytes) {
        // 이미 캐시되어 있는 데이터는 복사했다.
        __DCL_ASSERT(__cacheSize == 0);
 
        // Non-Block이 가능한 양만큼 __file에서 직접 읽는다.
        size_t nAvail = (__MIN(nbytes, __file->available()) / __bufSize) * __bufSize;
        if (nAvail) {
            size_t nRead = __file->read(buf, nAvail);
            if (nRead) {
                buf += nRead;
                nbytes -= nRead;
                nAvail -= nRead;
            }
        }
 
        if (!nAvail) {
            // Non-Block에서 읽을 것이 없었거나, 또는 모두 읽었다면 더 읽는다.
            // Non-Block에서 요구된 것 보다 덜 읽었다면 다음을 실패할 가능성이 높다.
            size_t nCacheRead = nbytes % __bufSize;
            if (nCacheRead) {
                if (!__buf) {
                    __buf = (byte_t*)malloc(__bufSize);
                    __DCL_ASSERT(__buf != NULL);    // out of memory
                }
 
                // 이곳에서 Block 될 수 있다.
                size_t nRead = __file->read(__buf, __bufSize);
                if (nRead) {
        //          __DCL_TRACE2("CacheRead : %d, %d\n", __bufSize, nRead);
                    __cacheStart = __buf;
                    __cacheSize = nRead;
 
                    size_t nCopy = __MIN(__cacheSize, nbytes);
                    memcpy(buf, __cacheStart, nCopy);
                    __cacheStart += nCopy;
                    __cacheSize -= nCopy;
 
            //      buf += nCopySize;
                    nbytes -= nCopy;
                }
            }
        }
    }
 
    return _nbytes - nbytes;
}
 
__DCL_END_NAMESPACE