FileOutputStream.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/Object.h>
#include <dcl/Thread.h>     // Thread::sleep
#include <dcl/FileOutputStream.h>
 
#if __DCL_HAVE_ALLOC_DEBUG
#undef __DCL_ALLOC_LEVEL
#define __DCL_ALLOC_LEVEL   __DCL_ALLOC_INTERNAL
#endif
 
#if __DCL_DEBUG
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/FileOutputStream.cpp");
#endif
 
__DCL_BEGIN_NAMESPACE
 
IMPLEMENT_CLASSINFO(FileOutputStream, OutputStream)
 
String FileOutputStream::toString() const
{
    StringBuilder r = className();
    if (__file)
        r += __T("(") + __file->toString() + __T(")");
    else
        r += __T(" closed");
    return r;
}
 
FileOutputStream::FileOutputStream(const String& _path, bool _truncate)
        __DCL_THROWS1(IOException*)
{
    __file = NULL;
    open(_path, _truncate);
}
 
void FileOutputStream::init(File* _pFile)
    __DCL_THROWS1(IOException*)
{
    __buf = NULL;
    __bufSize = 0;
#if __DCL_WINDOWS
    switch (_pFile->fileType())
    {
    case File::REGULAR:
        __bufSize = 4096;
        break;
    case File::PIPE:
        {
            DWORD dwOutBufferSize = 0;
            if (GetNamedPipeInfo(_pFile->handle(), NULL, &dwOutBufferSize, NULL, NULL))
                __bufSize = dwOutBufferSize;
        }
        break;
    }
#else
    struct stat st;
    if (fstat(_pFile->handle(), &st))       // = -1
        throw new IOException(_pFile->path(), errno);
    if (S_ISBLK(st.st_mode))
        __bufSize = st.st_blksize;
 
#endif
    __dataSize = 0;
}
 
FileOutputStream::FileOutputStream(File& _file)
        __DCL_THROWS1(IOException*)
{
    init(&_file);
    __file = &_file;
    __closeDestroy = false;
}
 
FileOutputStream::FileOutputStream(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;
}
 
FileOutputStream::FileOutputStream(File* __destroy__ _pFile)
        __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT(_pFile != NULL);
    try {
        init(_pFile);
    }
    catch (Exception* e) {
        delete _pFile;
        throw e;
    }
    __file = _pFile;
    __closeDestroy = true;
}
 
void FileOutputStream::open(const String& _path, bool _truncate)
        __DCL_THROWS1(IOException*)
{
    if (__file)
        close();
 
    File* pFile = new File(_path, File::WRITEONLY | File::CREATE
            | (_truncate ? File::TRUNCATE : File::APPEND));
    try
    {
        init(pFile);
    }
    catch (Exception* e)
    {
        delete pFile;
        throw e;
    }
    __file = pFile;
    __closeDestroy = true;
}
 
FileOutputStream::~FileOutputStream()
{
    if (__file != NULL)
    {
        try
        {
            close();
        }
        catch (IOException* e)
        {
            __DCL_TRACE1(L"~FileOutputStream close error! %ls\n", e->toString().data());
            e->destroy();
        }
    }
    __DCL_ASSERT(__buf == NULL);
}
 
void FileOutputStream::close()
        __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT_HANDLE(__file != NULL);
 
    Exception* e = NULL;
    try
    {
        flush();
    }
    catch (Exception* cause)
    {
        e = cause;
    }
 
    if (__buf)
    {
        free(__buf);
        __buf = NULL;
        __bufSize = 0;
        __dataSize = 0;
    }
 
    File* file = __file;
    __file = NULL;
    if (__closeDestroy)
    {
        try
        {
            file->close();
        }
        catch (Exception* cause)
        {
            if (!e)
                e = cause;
            else
                cause->destroy();
        }
        file->destroy();
    }
    if (e)
        throw e;
}
 
inline size_t __write(File* _file, const byte_t* _buf, size_t _nbytes)
{
    size_t written = 0;
    while (_nbytes)
    {
        size_t n = _file->write(_buf + written, _nbytes);
        if (n)
        {
            written += n;
            _nbytes -= n;
        }
        else
        {
            // errno == EAGAIN
            // retry after 10 milliseconds
            Thread::sleep(10);
        }
    }
    return written;
}
 
void FileOutputStream::flush()
        __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT_HANDLE(__file != NULL);
 
    if (__dataSize)
    {
        __write(__file, (const byte_t*)__buf, __dataSize);
        __dataSize = 0;
    }
}
 
OutputStream& FileOutputStream::write(const void* _buf, size_t _nbytes)
        __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT_HANDLE(__file != NULL);
    __DCL_ASSERT_PARAM(_buf != NULL);
 
    if (!_nbytes)
        return *this;
 
    if (!__bufSize) // == 0
    {
        // 버퍼링을 하지 않는다.
        __write(__file, (const byte_t*)_buf, _nbytes);
        return *this;
    }
 
    size_t n = (size_t)_nbytes;
    const byte_t* buf = (const byte_t*)_buf;
    size_t nCopySize = __bufSize - __dataSize;
    if ((__dataSize > 0) || (nCopySize > n))
    {
        // 이미 버퍼링을 하고 있으면 버퍼를 채워서 write 하고
        // 입력 데이터가 내부버퍼(__buf) 크기보다 작다면 버퍼링을 한다.
        if (!__buf)
        {
            __buf = (byte_t*)malloc(__bufSize);
            __DCL_ASSERT(__buf != NULL);    // out of memory
        }
 
        if (nCopySize > n)
            nCopySize = n;
        memcpy(__buf + __dataSize, buf, nCopySize);
        __dataSize += nCopySize;
 
        buf += nCopySize;
        n -= nCopySize;
 
        if (__dataSize == __bufSize)
        {
            __write(__file, (const byte_t*)__buf, __dataSize);
            __dataSize = 0;
        }
    }
 
    if (n)
    {
        __DCL_ASSERT(__dataSize == 0);
        // 남은 데이터가 있다.
        // 버퍼링 후 남은 데이터 이거나 
        // 내부버퍼(__buf)의 크기가 <= n 인 경우이다.
        // 블록단위로 wite하고 나머지는 내부버퍼에 복사한다.
 
        size_t nBlockWrite = (n / __bufSize) * __bufSize;
        nCopySize = n % __bufSize;
        if (nBlockWrite)
        {
            size_t written = __write(__file, buf, nBlockWrite);
            __DCL_ASSERT(written == nBlockWrite);
            buf += written;
//          __DCL_TRACE1("RAW Write : %d\n", nRet);
        }
 
        if (nCopySize)
        {
            if (!__buf)
            {
                // 버퍼의 크기 <= n 인 경우 이전의 버퍼가 없을 수도 있다.
                __buf = (byte_t*)malloc(__bufSize);
                __DCL_ASSERT(__buf != NULL);    // out of memory
            }
 
            memcpy(__buf, buf, nCopySize);
            __dataSize += nCopySize;
        }
    }
    return *this;
}
 
__DCL_END_NAMESPACE