FileInputStream.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#if __DCL_WINDOWS
    #include <windows.h>
#else
    #include <errno.h>
    #include <dcl/_stat.h>
#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
 
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/FileInputStream.cpp");
 
__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* _pFile)
        __DCL_THROWS1(IOException*)
{
    __buf = NULL;
    __bufSize = 0;
#if __DCL_WINDOWS
    switch (_pFile->fileType())
    {
    case File::REGULAR:
        __bufSize = 4096;
        break;
#if 0
    case File::PIPE:
        {
            DWORD dwInBufferSize = 0;
            if (GetNamedPipeInfo(_pFile->handle(), NULL, NULL, &dwInBufferSize, NULL))
                __bufSize = dwInBufferSize;
        }
        break;
#endif
    }
 
#else
    struct stat st;
    if (fstat(_pFile->handle(), &st))       // = -1
        throw new IOException(__file->path(), errno);
    if (S_ISBLK(st.st_mode))
        __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* pFile = new File(_handle, 0, false);
    try
    {
        init(pFile);
    }
    catch (Exception* e)
    {
        delete pFile;
        throw e;
    }
    __file = pFile;
    __closeDestroy = true;
}
 
void FileInputStream::open(const String& _path)
        __DCL_THROWS1(IOException*)
{
    if (__file)
        close();
 
    File* pFile = new File(_path, File::READONLY);
    try
    {
        init(pFile);
    }
    catch (Exception* e)
    {
        delete pFile;
        throw e;
    }
    __file = pFile;
    __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()
        __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) // == 0
    {
        // 버퍼링을 하지 않는다.
        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