iutest_file.hpp

[詳解]

//======================================================================
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//======================================================================
#ifndef INCG_IRIS_IUTEST_FILE_HPP_77D2C2B9_F504_4BB5_BA56_D97A2EB37DC6_
#define INCG_IRIS_IUTEST_FILE_HPP_77D2C2B9_F504_4BB5_BA56_D97A2EB37DC6_
 
//======================================================================
// include
// IWYU pragma: begin_exports
#include "iutest_internal_defs.hpp"
#include "iutest_stream.hpp"
 
#if defined(IUTEST_OS_WINDOWS)
#include <io.h>
#include <fcntl.h>
#include <share.h>
#endif
// IWYU pragma: end_exports
 
namespace iutest
{
 
//======================================================================
// class
class IFile : public detail::IOutStream, public detail::IInStream
{
public:
    enum OpenFlag
    {
        OpenRead    = 0x00000001,   
        OpenWrite   = 0x00000002,   
        OpenAppend  = 0x00000003    
    };
public:
    virtual ~IFile() {}
 
public:
    bool Open(const char* filename, int mode)
    {
        return OpenImpl(filename, mode);
    }
 
#if IUTEST_HAS_STD_FILESYSTEM
    bool Open(const ::std::filesystem::path& path, int mode)
    {
        return Open(path.string().c_str(), mode);
    }
#endif
 
    virtual void Close() = 0;
private:
    virtual bool OpenImpl(const char* filename, int mode) = 0;
};
 
namespace detail
{
 
class IFileSystem
{
public:
    IFileSystem()
    {
        SetInstance(this);
    }
    virtual ~IFileSystem()
    {
        SetInstance(NULL);
    }
 
public:
    virtual void Initialize() {}
 
public:
    static IFileSystem* GetInstance() { return GetInstanceVariable().pInstance; }
 
public:
    static IFile* New()
    {
        IFileSystem* fs = GetInstance();
        if( fs == NULL )
        {
            return NULL;
        }
        IFile* p = fs->Create();
        return p;
    }
    static void Free(IFile* ptr)
    {
        IFileSystem* fs = GetInstance();
        if( fs == NULL )
        {
            return;
        }
        fs->Delete(ptr);
    }
 
    static bool ReadAll(const char* filename, ::std::string& dst)
    {
        IFile* fp = detail::IFileSystem::New();
        if(fp == NULL)
        {
            return false;
        }
 
        if(!fp->Open(filename, IFile::OpenRead))
        {
            detail::IFileSystem::Free(fp);
            return false;
        }
 
        dst = fp->ReadAll();
        detail::IFileSystem::Free(fp);
        return true;
    }
 
private:
    virtual IFile*  Create() = 0;
    virtual void    Delete(IFile*) = 0;
 
private:
    struct InstanceVariable
    {
        IFileSystem* pInstance;
    };
 
    static InstanceVariable& GetInstanceVariable() { static InstanceVariable v; return v; }
    static void SetInstance(IFileSystem* pFileSystem) { GetInstanceVariable().pInstance = pFileSystem; }
};
 
}   // end of namespace detail
}   // end of namespace iutest
 
namespace iutest
{
 
template<typename FILE>
class FileSystem IUTEST_CXX_FINAL : public detail::IFileSystem
{
private:
    virtual IFile*  Create() IUTEST_CXX_OVERRIDE { return new FILE; }
    virtual void    Delete(IFile* ptr) IUTEST_CXX_OVERRIDE { detail::Delete<FILE>(static_cast<FILE*>(ptr)); }
};
 
 
#if IUTEST_HAS_FOPEN
 
class StdioFile : public IFile
{
protected:
    FILE* m_fp;
public:
    StdioFile() IUTEST_CXX_NOEXCEPT_SPEC : m_fp(NULL) {}
    virtual ~StdioFile() { StdioFile::Close(); }
public:
    virtual void Close() IUTEST_CXX_OVERRIDE
    {
        if( m_fp != NULL )
        {
            fclose(m_fp);
            m_fp = NULL;
        }
    }
    virtual bool Write(const void* buf, size_t size, size_t cnt) IUTEST_CXX_OVERRIDE
    {
        if( fwrite(buf, size, cnt, m_fp) < cnt )
        {
            return false;
        }
        if( fflush(m_fp) != 0 )
        {
            return false;
        }
        return true;
    }
 
    virtual bool Read(void* buf, size_t size, size_t cnt) IUTEST_CXX_OVERRIDE
    {
        if( fread(buf, size, cnt, m_fp) < cnt )
        {
            return false;
        }
        return true;
    }
 
    virtual iu_uint_max_t GetSize() IUTEST_CXX_OVERRIDE
    {
        return GetSize(m_fp);
    }
 
public:
    void Flush()
    {
        fflush(m_fp);
    }
 
public:
    static iu_uint_max_t GetSize(FILE* fp)
    {
        return internal::posix::FileSize(fp);
    }
    static iu_uint_max_t GetSizeBySeekSet(FILE* fp)
    {
        return internal::posix::FileSizeBySeekSet(fp);
    }
private:
    virtual bool OpenImpl(const char* filename, int mode) IUTEST_CXX_OVERRIDE
    {
        Close();
        switch( mode )
        {
        case IFile::OpenRead:
            m_fp = internal::posix::FileOpen(filename, "rb");
            break;
        case IFile::OpenWrite:
            m_fp = internal::posix::FileOpen(filename, "wb");
            break;
        case IFile::OpenAppend:
            m_fp = internal::posix::FileOpen(filename, "ab");
            break;
        default:
            break;
        }
        return m_fp != NULL;
    }
};
 
class StdErrorFile : public StdioFile
{
public:
    StdErrorFile() IUTEST_CXX_NOEXCEPT_SPEC {}
    virtual ~StdErrorFile() { Close(); }
public:
    virtual void Close() IUTEST_CXX_OVERRIDE
    {
        m_fp = NULL;
    }
private:
    virtual bool OpenImpl(const char* , int ) IUTEST_CXX_OVERRIDE
    {
        m_fp = stderr;
        return true;
    }
};
 
class TempFile : public IFile
{
public:
    TempFile() IUTEST_CXX_NOEXCEPT_SPEC
        : m_fd(-1)
    {
    }
 
    virtual ~TempFile() { Close(); }
 
public:
    virtual void Close() IUTEST_CXX_OVERRIDE
    {
        m_file.Close();
        if( m_fd != -1 )
        {
            internal::posix::FdClose(m_fd);
            m_fd = -1;
        }
    }
    virtual bool Write(const void* buf, size_t size, size_t cnt) IUTEST_CXX_OVERRIDE
    {
        return m_file.Write(buf, size, cnt);
    }
 
    virtual bool Read(void* buf, size_t size, size_t cnt) IUTEST_CXX_OVERRIDE
    {
        return m_file.Read(buf, size, cnt);
    }
 
    virtual iu_uint_max_t GetSize() IUTEST_CXX_OVERRIDE
    {
        return m_file.GetSize();
    }
 
public:
    int GetDescriptor() const { return m_fd; }
    const ::std::string& GetFileName() const { return m_filename; }
 
    bool Open(int mode)
    {
        return OpenImpl(m_filename.c_str(), mode);
    }
 
    void Delete()
    {
        Close();
        if( !m_filename.empty() )
        {
            remove(m_filename.c_str());
            m_filename = "";
        }
    }
 
    bool Create(const char* basename)
    {
#if defined(IUTEST_OS_WINDOWS)
        char tmp_dir[IUTEST_MAX_PATH] = { '\0' };
        GetTempPathA(sizeof(tmp_dir), tmp_dir);
 
        char name_template[IUTEST_MAX_PATH] = { '\0' };
        UINT ret = GetTempFileNameA(tmp_dir, basename, 0, name_template);
        IUTEST_CHECK_(ret != 0) << "Unable to create a temporary file in " << tmp_dir;
#if defined(_CRT_FUNCTIONS_REQUIRED)
IUTEST_PRAGMA_CRT_SECURE_WARN_DISABLE_BEGIN()
        const int fd = _creat(name_template, _S_IREAD | _S_IWRITE);
IUTEST_PRAGMA_CRT_SECURE_WARN_DISABLE_END()
#else
#if defined(IUTEST_OS_WINDOWS_MINGW)
        const int fd = _sopen(name_template, _O_CREAT | _O_RDWR, _SH_DENYNO, _S_IREAD | _S_IWRITE);
#else
        int fd = -1;
        _sopen_s(&fd, name_template, _O_CREAT | _O_RDWR, _SH_DENYNO, _S_IREAD | _S_IWRITE);
#endif
#endif
#else
#if   defined(IUTEST_OS_LINUX_ANDROID)
        ::std::string name_template = "/data/local/tmp/";
#elif defined(IUTEST_OS_IOS)
        char user_temp_dir[IUTEST_MAX_PATH];
        ::confstr(_CS_DARWIN_USER_TEMP_DIR, user_temp_dir, sizeof(user_temp_dir));
        ::std::string name_template = user_temp_dir;
        name_template += "/";
#else
        ::std::string name_template = "/tmp/";
#endif
        name_template += basename;
        name_template += ".XXXXXX";
        const int fd = internal::posix::Mkstemp(const_cast<char*>(name_template.data()));
#endif
        m_fd = fd;
        m_filename = name_template;
        return m_fd != -1;
    }
 
private:
    bool Open(const char*, int);
 
    virtual bool OpenImpl(const char* filename, int mode) IUTEST_CXX_OVERRIDE
    {
        return m_file.Open(filename, mode);
    }
 
private:
    StdioFile m_file;
    int m_fd;
    ::std::string m_filename;
};
 
#endif
 
 
#if IUTEST_HAS_STRINGSTREAM
 
class StringStreamFile : public IFile
{
public:
    virtual ~StringStreamFile() { StringStreamFile::Close(); }
public:
    virtual void Close() IUTEST_CXX_OVERRIDE
    {
    }
 
    virtual bool Write(const void* buf, size_t size, size_t cnt) IUTEST_CXX_OVERRIDE
    {
        for( size_t i=0; i < cnt; ++i )
        {
            ss.write(static_cast<const char*>(buf), size);
        }
        return true;
    }
 
    virtual bool Read(void* buf, size_t size, size_t cnt) IUTEST_CXX_OVERRIDE
    {
        char* p = static_cast<char*>(buf);
        for( size_t i = 0; i < cnt; ++i )
        {
            ss.read(p, size);
            p += size;
        }
        return true;
    }
 
    virtual iu_uint_max_t GetSize() IUTEST_CXX_OVERRIDE
    {
        ::std::stringstream::pos_type pre = ss.tellg();
        ss.seekg(0, ::std::ios::end);
        ::std::stringstream::pos_type size = ss.tellg();
        ss.seekg(pre, ::std::ios::beg);
        return static_cast<iu_uint_max_t>(size);
    }
 
    virtual ::std::string ReadAll() IUTEST_CXX_OVERRIDE
    {
        return ss.str();
    }
private:
    virtual bool OpenImpl(const char* , int ) IUTEST_CXX_OVERRIDE
    {
        ss.clear();
        return true;
    }
protected:
    ::std::stringstream ss;
};
 
#endif
 
namespace detail
{
 
class NoEffectFile IUTEST_CXX_FINAL : public IFile
{
public:
    virtual void Close() IUTEST_CXX_OVERRIDE {}
    virtual bool Write(const void*, size_t, size_t) IUTEST_CXX_OVERRIDE { return true;  }
    virtual bool Read(void*, size_t, size_t) IUTEST_CXX_OVERRIDE { return true; }
    virtual iu_uint_max_t GetSize() IUTEST_CXX_OVERRIDE { return 0; }
private:
    virtual bool OpenImpl(const char*, int) IUTEST_CXX_OVERRIDE { return true; }
};
 
}   // end of namespace detail
}   // end of namespace iutest
 
#endif // INCG_IRIS_IUTEST_FILE_HPP_77D2C2B9_F504_4BB5_BA56_D97A2EB37DC6_