Files.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#ifdef __WINNT__
    #include <windows.h>
    //#include <winsock.h>      // Files::available,  ioctlsock, Socket 클래스에서 override한다.
    #include <io.h>             // _waccess
    #include <stdio.h>          // _wrename, _wremove
    #include <wchar.h>          // _wgetenv
    #include <sys/stat.h>       // _wstat
#else
    #include <sys/ioctl.h>      // available
    #include <dcl/_fcntl.h>     // __open, __creat
    #include <dcl/_stat.h>       // __mkdir, __stat
    #include <dcl/_unistd.h>   // __chdir
    #include <dcl/_stdio.h>     //  __rename
    #include <dcl/_stdlib.h>   //  __realpath
#endif
 
#include <string.h>         // memmove
 
#include <dcl/size_t.h>
#include <dcl/Files.h>
#include <dcl/File.h>
#include <dcl/FileInputStream.h>
#include <dcl/InputStreamReader.h>
#include <dcl/FileReader.h>
#include <dcl/StringWriter.h>
#include <dcl/BytesOutputStream.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/Files.cpp");
#endif
 
__DCL_BEGIN_NAMESPACE
 
// File static functions
bool Files::access(const String& _path, int _mode)
{
    __DCL_ASSERT(_path.length() > 0);
#ifdef __WINNT__
    int types = 00;
    if (_mode & READ_OK)
        types |= 04;
    if (_mode & WRITE_OK)
        types |= 02;
 
    return _waccess(_path, types) == 0;
#else
    int types = F_OK;
    if (_mode & READ_OK)
        types |= R_OK;
    if (_mode & WRITE_OK)
        types |= W_OK;
    if (_mode & EXECUTE_OK)
        types |= X_OK;
 
    return __access(_path, types) == 0;
#endif
}
 
void Files::rename(const String& _oldpath, const String& _newpath)
    __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT(_oldpath.length() > 0);
    __DCL_ASSERT(_newpath.length() > 0);
#ifdef __WINNT__
#define __rename _wrename
#endif
    if (__rename(_oldpath, _newpath)) {
        StringBuilder sb = _oldpath;
        sb += __T("==>");
        sb += _newpath;
 
        throw new IOException(sb.toString(), errno);
    }
}
 
// unlink and rmdir
void Files::remove(const String& _path)
    __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT(_path.length() > 0);
#ifdef __WINNT__
#define __remove _wremove
#endif
    if (__remove(_path)) {
        throw new IOException(_path, errno);
    }
}
 
void Files::unlink(const String& _path)
    __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT(_path.length() > 0);
#ifdef __WINNT__
#define __unlink _wunlink
#endif
    if (__unlink(_path)) {
        throw new IOException(_path, errno);
    }
}
 
bool Files::exists(const String& _path)
{
    __DCL_ASSERT(_path.length() > 0);
    return access(_path, EXISTS);
}
 
bool Files::isDirectory(const String& _path)
{
    __DCL_ASSERT(!_path.isEmpty());
#ifdef __WINNT__
#define __stat _wstat
#define stat _stat
#endif
    struct stat sb;
    if (__stat(_path, &sb) == -1) {
        throw new IOException(_path, errno);
    }
    return (sb.st_mode & S_IFMT) == S_IFDIR;
}
 
DateTime Files::mtime(const String& _path)
    __DCL_THROWS1(IOException*)
{
    time_t mtime;
    if (!Files::time(_path,
        (time_t*)NULL, &mtime, (time_t*)NULL)) {
        throw (new IOException(_path, errno));
    }
    return DateTime(mtime);
}
 
bool Files::time(const String& _path,
        time_t* _atime, time_t* _mtime, time_t* _ctime)
{
    __DCL_ASSERT(!_path.isEmpty());
    struct stat sb;
    if (__stat(_path, &sb) == -1) {
        return false;
    }
    if (_atime) {
        *_atime = sb.st_atime;
    }
    if (_mtime) {
        *_mtime = sb.st_mtime;
    }
    if (_ctime) {
        *_ctime = sb.st_ctime;
    }
    return true;
}
 
uint64_t Files::size(const String& _path)
    __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT(!_path.isEmpty());
#ifdef __WINNT__
    WIN32_FIND_DATAW findData;
    HANDLE h = FindFirstFileW(_path, &findData);
    if (h == INVALID_HANDLE_VALUE)
        throw new IOException(_path, GetLastError());
    FindClose(h);
    LARGE_INTEGER size;
    size.HighPart = findData.nFileSizeHigh;
    size.LowPart = findData.nFileSizeLow;
    return size.QuadPart;
#else
    struct stat sb;
    if (__stat(_path, &sb) == -1)
        throw new IOException(_path, errno);
    return sb.st_size;
#endif
}
 
void Files::chdir(const String& _path)
    __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT(!_path.isEmpty());
#ifdef __WINNT__
#define __chdir _wchdir
#endif
    if (__chdir(_path)) {
        throw new IOException(_path, errno);
    }
}
 
String Files::getcwd() __DCL_THROWS1(IOException*)
{
#ifdef __WINNT__
    CharBuffer* buf = CharBuffer::create(PATH_MAX);
    wchar_t* s = _wgetcwd(buf->data(), PATH_MAX);
    if (s == NULL) {
        buf->release();
        throw new IOException(L"_wgetcwd", errno);
    }
    buf->__dataLength = String::length(buf->data());
    String r = buf;
    buf->release();
 
    r = r.replace('\\', '/');
#else
    String r;
    if (__getcwd(r)) {
        throw new IOException(L"getcwd", errno);
    }
#endif
    return r;
}
 
// 디렉토리 생성, windows에서 nMode 무시
void Files::mkdir(const String& _path, int _mode/* = 0755 */)
    __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT(!_path.isEmpty());
 
    if (
#ifdef __WINNT__
        _wmkdir(_path)
#else
        __mkdir(_path, _mode)
#endif
    ) {
        throw new IOException(_path, errno);
    }
}
 
// 디렉토리 삭제
void Files::rmdir(const String& _path)
    __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT(!_path.isEmpty());
#ifdef __WINNT__
#define __rmdir _wrmdir
#endif
    if (__rmdir(_path)) {
        throw IOException(_path, errno);
    }
}
 
inline bool __is_dir_delimiter(wchar_t _c)
{
    return _c == L'/' || _c == L'\\' || _c == L':';
}
 
String Files::basename(const String& _path)
{
    __DCL_ASSERT(_path.length() > 0);
 
    const wchar_t* end = _path.data() + _path.length();
    do {
        end--;
        if (__is_dir_delimiter(*end)) {
            return _path.right(_path.length() - (end + 1 - _path));
        }
    } while (_path.data() <= end);
 
    // not found
    return String();
}
 
String Files::dirname(const String& _path)
{
    __DCL_ASSERT(_path.length() > 0);
 
    const wchar_t* end = _path.data() + _path.length();
    do {
        end--;
        if (__is_dir_delimiter(*end)) {
            return _path.left(end - _path + 1);
        }
    } while (_path.data() <= end);
 
    // not found
    return L"./";
}
 
wchar_t Files::delimiter(const String& _path)
{
    const wchar_t* psz = _path;
    wchar_t ch = L'/';
    while(*psz) {
        if (__is_dir_delimiter(*psz)) {
            ch = *psz;
            break;
        }
        psz++;
    }
 
    return ch;
}
 
String Files::filename(
    const String& _dirname,
    const String& _basename
)
{
    __DCL_ASSERT(_basename.length() > 0);
 
    String str = _dirname;
    if (!str.isEmpty()) {
        if (!__is_dir_delimiter(str[str.length() - 1]))
            str = str + Files::delimiter(str);
    }
    str = str + _basename;
 
    return str;
}
 
String Files::temppath()
{
    String r;
#ifdef __WINNT__
    wchar_t* env = NULL;
    if ((env = _wgetenv(L"TMP"))
        || (env = _wgetenv(L"TEMP"))) {
        r = env;
    }
    else {
        CharBuffer* buf = CharBuffer::create(PATH_MAX);
        DWORD n = GetTempPathW(PATH_MAX, buf->data());
        __DCL_ASSERT(n <= PATH_MAX);
        buf->__dataLength = n;
        r = buf;
        buf->release();
    }
    r = r.replace('\\', '/');
#else
    if (__getenv(String(__T("TMP")), r)
        && __getenv(String(__T("TEMP")), r)) {
        r = L"/tmp";
    }
#endif
    if (!Files::exists(r)) {
        r = L".";
    }
    if (!r.endsWith(L"/")) {
        r = r + '/';
    }
    return r;
}
 
String Files::realpath(const String& _path)
    __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT(!_path.isEmpty());
 
#ifdef __WINNT__
    CharBuffer* buf = CharBuffer::create(PATH_MAX);
    wchar_t* pFilePart = NULL;
    DWORD dwLen = ::GetFullPathNameW(_path, PATH_MAX, buf->data(), &pFilePart);
    if (dwLen == 0) {
        buf->release();
        throw new IOException(_path, WINAPI_ERROR(::GetLastError()));
    }
    buf->__dataLength = dwLen;
    String resolved = buf;
    buf->release();
#else
    String resolved;
    int error = __realpath(_path, resolved);
    if (error) {
        throw new IOException(_path, errno);
    }
#endif
    return resolved;
}
 
String Files::unixpath(const String& _path)
{
    return _path.replace(L'\\', L'/');
}
 
bool Files::isAbsPath(const String& _path)
{
    const wchar_t* pszPath = _path;
    if (*pszPath == L'/' || *pszPath == L'\\')
        return true;
 
#ifdef __WINNT__
    if (iswalpha(*pszPath)
        && *(pszPath + 1) == L':'
        && (*(pszPath + 2) == L'\\' || (*(pszPath + 2) == L'/'))
        )
        return true;
#endif
 
    return false;
}
 
ByteString Files::readBytes(InputStream& _input, size_t _n)
    __DCL_THROWS1(IOException*)
{
    BytesOutputStream out;
    char buf[4096];
    size_t total = 0;
    for (; ; ) {
        size_t n = __MIN(_n - total, sizeof(buf));
        if (n && (n = _input.read(buf, n))) {
            out.write(buf, n);
            total += n;
        }
        else {
            break;
        }
    }
    return out.toByteString();
}
 
ByteString Files::readBytes(const String& _filename, size_t _n)
    __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT(_n == (size_t)-1 || _n < INT64_MAX);
    File file(_filename);
    size_t totalBytes = _n == (size_t) -1 ? file.size() : _n;
    ByteBuffer* buf = ByteBuffer::create(totalBytes);
 
    size_t read = file.read(buf->data(), totalBytes);
    buf->__dataLength = read;
    *(buf->data() + read) = '\0';
 
    ByteString r = buf;
    buf->release();
 
    __DCL_ASSERT(totalBytes == read);
    return r;
}
 
String Files::readText(const String& _filename)
    __DCL_THROWS1(IOException*)
{
    FileReader reader(_filename);
    StringWriter writer;
 
    wchar_t buf[1024];
    size_t readcCount = 0;
    while ((readcCount = reader.read(buf, __countof(buf, wchar_t))) > 0) {
        writer.write(buf, readcCount);
    }
 
    return writer.toString();
}
 
String Files::readText(const String& _filename, CharsetDecoder& _decoder)
    __DCL_THROWS1(IOException*)
{
#if 0
    FileInputStream input(_filename);
    InputStreamReader reader(input, _decoder);
    StringWriter writer;
 
    wchar_t buf[1024];
    size_t n = 0;
    while (n = reader.read(buf, __countof(buf, wchar_t))) {
        writer.write(buf, n);
    }
 
    return writer.toString();
#else
    File file(_filename);
    File::off_t totalBytes = file.size();
 
    // 디코드된 char_t의 최대 길이는 입력 파일이 UTF-8인 경우의 바이트 수 이다.
    CharBuffer* outBuf = CharBuffer::create(totalBytes);
    wchar_t* outCur = outBuf->data();
    wchar_t* outEnd = outCur + outBuf->__allocLength;
 
#define BUFFER_SIZE 4096
#define EXTRA_SIZE  20
    byte_t inBuf[BUFFER_SIZE + EXTRA_SIZE];
    size_t extraCount = 0;
    size_t readCount;
    while ((readCount = file.read(inBuf + extraCount, BUFFER_SIZE)) > 0) {
        size_t inCount = readCount + extraCount;
        size_t inCountSave = inCount;
        size_t outCount = outEnd - outCur;
        int r = _decoder.decode(inBuf, inCount, outCur, outCount);
        extraCount = inCountSave - inCount;
        /*__DCL_TRACE4(__T("%ls read[%d], extra[%d], out[%d]\n"),
            _decoder.className(), readCount, extraCount, outCount);*/
        switch (r) {
        case CS_SOURCE_FEW:
            __DCL_ASSERT(extraCount <= EXTRA_SIZE);
            if (inCount > 0) {
                memmove(inBuf, inBuf + inCount, extraCount);
            }
        case CS_NOERROR:
            break;
        default:
            outBuf->release();
            throw(new IOException(_filename, new CharsetConvertException(r)));
        }
        outCur += outCount;
    }
    __DCL_ASSERT(outCur <= outEnd);
#ifdef __DCL_DEBUG
    if (extraCount) {
        __DCL_TRACE1(__T("Warning! Illegal sequence at the end of the text. [%d]\n"),
            extraCount);
    }
#endif
 
    *outCur = __T('\0');
    outBuf->__dataLength = outCur - outBuf->data();
    String r = outBuf;
    outBuf->release();
 
    return r;
#endif
}
 
size_t Files::copy(InputStream& _input, OutputStream& _output)
    __DCL_THROWS1(IOException*)
{
    char buf[4096];
    size_t total = 0;
    size_t read;
    while ((read = _input.read(buf, sizeof(buf))) > 0) {
        _output.write(buf, read);
        total += read;
    }
    return total;
}
 
__DCL_END_NAMESPACE