C++文件系统操作1 - 跨平台实现文件的创建和删除

#pragma once

#include <string>
#include <cstdio>
#include <cstdint>
#include "filetype.h"
#include "filepath.h"

namespace cutl
{

    /**
     * @brief The file guard class to manage the FILE pointer automatically.
     * file_guard object can close the FILE pointer automatically when his scope is exit.
     */
    class file_guard
    {
    public:
        /**
         * @brief Construct a new file guard object
         *
         * @param file the pointer of the FILE object
         */
        explicit file_guard(FILE *file);

        /**
         * @brief Destroy the file guard object
         *
         */
        ~file_guard();

        /**
         * @brief Get the FILE pointer.
         *
         * @return FILE*
         */
        FILE *getfd() const;

    private:
        FILE *file_;
    };

    /**
     * @brief Create a new file.
     *
     * @param path the filepath of the new file to be created
     * @return true if the file is created successfully, false otherwise.
     */
    bool createfile(const filepath &path);

    
    /**
     * @brief Create a symbolic link or shortcut.
     *
     * @param referenece the real path referenced by the symbolic link or shortcut
     * @param filepath the filepath of the symbolic link or shortcut to be created
     * @return true if the symbolic link or shortcut is created successfully, false otherwise.
     */
    bool createlink(const filepath &referenece, const filepath &filepath);

    /**
     * @brief Remove a regular file or symbolic link(shortcut on windows).
     *
     * @param path the filepath of the file or symbolic link to be removed
     * @return true if the file or symbolic link is removed successfully, false otherwise.
     */
    bool removefile(const filepath &path);

} // namespace cutl

#include <cstdio>
#include <map>
#include <iostream>
#include <cstring>
#include <sys/stat.h>
#include "fileutil.h"
#include "inner/logger.h"
#include "inner/filesystem.h"
#include "strutil.h"

namespace cutl
{
    file_guard::file_guard(FILE *file)
        : file_(file)
    {
    }

    file_guard::~file_guard()
    {
        if (file_)
        {
            // CUTL_DEBUG("close file");
            int ret = fclose(file_);
            if (ret != 0)
            {
                CUTL_ERROR("fail to close file, ret" + std::to_string(ret));
            }
            file_ = nullptr;
        }
        // ROBOLOG_DCHECK(file_ == nullptr);
    }

    FILE *file_guard::getfd() const
    {
        return file_;
    }

    bool createfile(const filepath &path)
    {
        auto dirPath = path.dirname();
        if (dirPath.empty())
        {
            CUTL_ERROR("invalid path: " + path.str());
            return false;
        }
        if (!cutl::path(dirPath).exists())
        {
            CUTL_ERROR("directory does not exist: " + dirPath);
            return false;
        }

        file_guard fg(fopen(path.str().c_str(), "w"));
        if (fg.getfd() == nullptr)
        {
            CUTL_ERROR("fail to open file:" + path.str());
            return false;
        }

        int ret = fflush(fg.getfd());
        if (0 != ret)
        {
            CUTL_ERROR("fail to flush file:" + path.str());
            return false;
        }

        if (!file_sync(fg.getfd()))
        {
            CUTL_ERROR("file_sync failed for " + path.str());
            return false;
        }

        return true;
    }

    bool createlink(const filepath &referenece, const filepath &filepath)
    {
        return file_createlink(referenece.str(), filepath.str());
    }

    bool removefile(const filepath &path)
    {
        int ret = remove(path.str().c_str());
        if (ret != 0)
        {
            CUTL_ERROR("remove " + path.str() + " error, ret:" + std::to_string(ret));
            return false;
        }
        return true;
    }

#include <vector>
#include <string>

#pragma once

namespace cutl
{
    // 创建软连接或快捷方式
    bool file_createlink(const std::string &referenece, const std::string &filepath);
} // namespace cutl

#if defined(_WIN32) || defined(__WIN32__)

#include <io.h>
#include <direct.h>
#include <Windows.h>
#include <stdlib.h>
#include "strutil.h"
#include "filesystem.h"
#include "logger.h"

namespace cutl
{
    bool file_createlink(const std::string &referenece, const std::string &filepath)
    {
        CUTL_ERROR("file_createlink() is not supported on Windows");
        return false;
    }
} // namespace cutl

#endif // defined(_WIN32) || defined(__WIN32__)

#if defined(_WIN32) || defined(__WIN32__)
// do nothing
#else

#include <unistd.h>
#include <sys/stat.h>
#include <dirent.h>
#include <stack>
#include <cstring>
#include <utime.h>
#include <stdlib.h>
#include <sys/time.h>
#include "filesystem.h"
#include "inner/logger.h"

namespace cutl
{
    bool file_createlink(const std::string &referenece, const std::string &filepath)
    {
        int ret = ::symlink(referenece.c_str(), filepath.c_str());
        if (ret != 0)
        {
            CUTL_ERROR("symlink error. filepath:" + filepath + ", referenece:" + referenece + ", error:" + strerror(errno));
            return false;
        }
        return true;
    }
} // namespace cutl

#endif // defined(_WIN32) || defined(__WIN32__)