FileOutputStream.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/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_HAVE_THIS_FILE__
#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* _file)
    __DCL_THROWS1(IOException*)
{
    __buf = NULL;
    __bufSize = 0;
#ifdef __WINNT__
    switch (_file->fileType()) {
        case File::REGULAR: {
            __bufSize = 4096;
            break;
        }
        case File::PIPE: {
            DWORD dwOutBufferSize = 0;
            if (GetNamedPipeInfo(_file->handle(), NULL, &dwOutBufferSize, NULL, NULL)) {
                __bufSize = dwOutBufferSize;
            }
            break;
        }
        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
    __dataSize = 0;
}
 
FileOutputStream::FileOutputStream(File& _file)
    __DCL_THROWS1(IOException*)
{
    init(&_file);
    __file = &_file;
    __closeDestroy = false;
}
 
FileOutputStream::FileOutputStream(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;
}
 
FileOutputStream::FileOutputStream(File* __destroy__ _file)
    __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT(_file != NULL);
    try {
        init(_file);
    }
    catch (Exception* _e) {
        delete _file;
        throw _e;
    }
    __file = _file;
    __closeDestroy = true;
}
 
void FileOutputStream::open(const String& _path, bool _truncate)
    __DCL_THROWS1(IOException*)
{
    if (__file)
        close();
 
    File* file = new File(_path, File::WRITEONLY | File::CREATE
            | (_truncate ? File::TRUNCATE : File::APPEND));
    try {
        init(file);
    }
    catch (Exception* _e) {
        delete file;
        throw _e;
    }
    __file = file;
    __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) {
        // 버퍼링을 하지 않는다.
        __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