FileLibrary.cpp

Go to the documentation of this file.

/**
* @file FileLibrary.cpp
* @brief The FileLibrary Class Implementation.
* @author Travis Vroman.
*/
 
#include "Pchheader.h"
#include "FileLibrary.h"
 
#include <commdlg.h>
 
namespace Spices {
 
    bool FileLibrary::FileLibrary_Exists(const char* path)
    {
        SPICES_PROFILE_ZONE;
 
        struct _stat buffer {};
        return _stat (path, &buffer) == 0;
    }
 
    bool FileLibrary::FileLibrary_Open(const char* path, FileModes mode, bool binary, FileHandle* out_handle)
    {
        SPICES_PROFILE_ZONE;
 
        out_handle->is_valid = false;
        out_handle->handle   = nullptr;
        const char* mode_str;
 
        if ((mode & FILE_MODE_READ) != 0 && (mode & FILE_MODE_WRITE) != 0)
        {
            mode_str = binary ? "w+b" : "w+";
        }
        else if ((mode & FILE_MODE_READ) != 0 && (mode & FILE_MODE_WRITE) == 0)
        {
            mode_str = binary ? "rb" : "r";
        }
        else if ((mode & FILE_MODE_READ) == 0 && (mode & FILE_MODE_WRITE) != 0)
        {
            mode_str = binary ? "wb" : "w";
        }
        else
        {
            SPICES_CORE_INFO("Invalid mode passed while trying to open file")
            return false;
        }
 
        FILE* file;
        auto state = fopen_s(&file, path, mode_str);
 
        if (!file)
        {
            std::stringstream ss;
            ss << "Error opening file: " << path;
 
            SPICES_CORE_WARN(ss.str().c_str())
            return false;
        }
 
        out_handle->handle = file;
        out_handle->is_valid = true;
 
        return true;
    }
 
    void FileLibrary::FileLibrary_Close(FileHandle* handle)
    {
        SPICES_PROFILE_ZONE;
 
        if (handle->handle)
        {
            auto state = fclose(static_cast<FILE*>(handle->handle));
            handle->handle = nullptr;
            handle->is_valid = false;
        }
    }
 
    bool FileLibrary::FileLibrary_Size(const FileHandle* handle, uint64_t* out_size)
    {
        SPICES_PROFILE_ZONE;
 
        if (handle->handle)
        {
            auto state = fseek(static_cast<FILE*>(handle->handle), 0, SEEK_END);
            *out_size = ftell(static_cast<FILE*>(handle->handle));
            rewind(static_cast<FILE*>(handle->handle));
            return true;
        }
        return false;
    }
 
    bool FileLibrary::FileLibrary_Read(const FileHandle* handle, uint64_t data_size, void* out_data, uint64_t* out_bytes_read)
    {
        SPICES_PROFILE_ZONE;
 
        if (handle->handle && out_data)
        {
            *out_bytes_read = fread(out_data, 1, data_size, static_cast<FILE*>(handle->handle));
            if (*out_bytes_read != data_size)
            {
                return false;
            }
            return true;
        }
        return false;
    }
 
    bool FileLibrary::FileLibrary_Read_Line(const FileHandle* handle, uint64_t max_length, char* line_buf, uint64_t* out_line_length)
    {
        SPICES_PROFILE_ZONE;
 
        if (handle->handle && line_buf && out_line_length && max_length > 0)
        {
            if (fgets(line_buf, static_cast<int>(max_length), static_cast<FILE*>(handle->handle)) != nullptr)
            {
                *out_line_length = strlen(line_buf);
                return true;
            }
        }
        return false;
    }
 
    bool FileLibrary::FileLibrary_Read_all_bytes(const FileHandle* handle, char* out_bytes, uint64_t* out_bytes_read)
    {
        SPICES_PROFILE_ZONE;
 
        if (handle->handle && out_bytes && out_bytes_read)
        {
            uint64_t size = 0;
            if (!FileLibrary_Size(handle, &size))
            {
                return false;
            }
 
            *out_bytes_read = fread(out_bytes, 1, size, static_cast<FILE*>(handle->handle));
            return *out_bytes_read == size;
        }
        return false;
    }
 
    bool FileLibrary::FileLibrary_Write(const FileHandle* handle, uint64_t data_size, const void* data, uint64_t* out_bytes_written)
    {
        SPICES_PROFILE_ZONE;
 
        if (handle->handle)
        {
            *out_bytes_written = fwrite(data, 1, data_size, static_cast<FILE*>(handle->handle));
            if (*out_bytes_written != data_size)
            {
                return false;
            }
            auto state = fflush(static_cast<FILE*>(handle->handle));
            return true;
        }
        return false;
    }
 
    bool FileLibrary::FileLibrary_Write_Line(const FileHandle* handle, const char* text)
    {
        SPICES_PROFILE_ZONE;
 
        if (handle->handle)
        {
            int result = fputs(text, static_cast<FILE*>(handle->handle));
            if (result != EOF)
            {
                result = fputc('\n', static_cast<FILE*>(handle->handle));
            }
 
            // Make sure to flush the stream so it is written to the file immediately.
            // This prevents data loss in the event of a crash.
            auto state = fflush(static_cast<FILE*>(handle->handle));
            return result != EOF;
        }
        return false;
    }
 
    std::string FileLibrary::FileLibrary_OpenInExplore(const char* filter, HWND hwnd)
    {
        SPICES_PROFILE_ZONE;
 
        OPENFILENAMEA ofn;           // common dialog box structure
        CHAR szFile[260] = { 0 };    // if using TCHAR macros
        // Initialize OPEN FILENAME
        ZeroMemory(&ofn, sizeof(OPENFILENAMEA));
        ofn.lStructSize = sizeof(OPENFILENAMEA);
        ofn.hwndOwner = hwnd;
        ofn.lpstrFile = szFile;
        ofn.nMaxFile = sizeof(szFile);
        ofn.lpstrFilter = filter;
        ofn.nFilterIndex = 1;
        ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST | OFN_NOCHANGEDIR;
        if (GetOpenFileNameA(&ofn) == TRUE)
        {
            return ofn.lpstrFile;
        }
        return "";
    }
 
    std::string FileLibrary::FileLibrary_SaveInExplore(const char* filter, HWND hwnd)
    {
        SPICES_PROFILE_ZONE;
 
        OPENFILENAMEA ofn;           // common dialog box structure
        CHAR szFile[260] = { 0 };    // if using TCHAR macros
        // Initialize OPEN FILENAME
        ZeroMemory(&ofn, sizeof(OPENFILENAMEA));
        ofn.lStructSize = sizeof(OPENFILENAMEA);
        ofn.hwndOwner = hwnd;
        ofn.lpstrFile = szFile;
        ofn.nMaxFile = sizeof(szFile);
        ofn.lpstrFilter = filter;
        ofn.nFilterIndex = 1;
        ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST | OFN_NOCHANGEDIR;
        if (GetSaveFileNameA(&ofn) == TRUE)
        {
            return ofn.lpstrFile;
        }
        return "";
    }
 
    bool FileLibrary::FileLibrary_CopyFile(std::string srcFilePath, std::string dstFilePath)
    {
        SPICES_PROFILE_ZONE;
 
        if (!FileLibrary_Exists(srcFilePath.c_str()))
        {
            std::stringstream ss;
            ss << "File path: " << srcFilePath << " was not found.";
 
            SPICES_CORE_WARN(ss.str())
            return false;
        }
 
        std::ifstream src(srcFilePath, std::ios::binary);
        std::ofstream dst(dstFilePath, std::ios::binary);
 
        dst << src.rdbuf();
 
        return true;
    }
 
    bool FileLibrary::FileLibrary_Delete(const char* filePath)
    {
        SPICES_PROFILE_ZONE;
 
        if (FileLibrary_Exists(filePath))
        {
            if (remove(filePath) != 0)
            {
                std::stringstream ss;
                ss << "File path: " << filePath << " delete failed.";
 
                SPICES_CORE_WARN(ss.str())
                return false;
            }
        }
 
        return true;
    }
}