lfilesystem_File.h

Go to the documentation of this file.

/*
 * ======================================================================================
 *  __    ____  __  __  ____  ___
 * (  )  (_  _)(  \/  )( ___)/ __)
 *  )(__  _)(_  )    (  )__) \__ \
 * (____)(____)(_/\/\_)(____)(___/
 *
 *  This file is part of the Limes open source library and is licensed under the terms of the GNU Public License.
 *
 *  Commercial licenses are available; contact the maintainers at ben.the.vining@gmail.com to inquire for details.
 *
 * ======================================================================================
 */
 
#pragma once
 
#include <cstddef>  // for size_t
#include <string>   // for string
#include <string_view>
#include <vector>      // for vector
#include <functional>  // for std::hash
#include <optional>
#include <fstream>
#include <memory>
#include <iterator>
#include "lfilesystem/lfilesystem_Export.h"
#include "lfilesystem/lfilesystem_FilesystemEntry.h"    // for FilesystemEntry, Path
#include "lfilesystem/lfilesystem_CFile.h"
 
namespace limes::files
{
 
#pragma mark   File
#pragma region File
 
class LFILE_EXPORT File : public FilesystemEntry
{
public:
    using FilesystemEntry::FilesystemEntry;
 
    File (const File&) = default;
    File& operator= (const File&) = default;
 
    File (File&&) = default;
    File& operator= (File&&) = default;
 
 
    [[nodiscard]] std::string getFilename (bool includeExtension = false) const;
 
    [[nodiscard]] std::string getFileExtension() const;
 
    [[nodiscard]] bool hasFileExtension (const std::string_view& extension) const;
 
    [[nodiscard]] bool hasFileExtension() const;
 
    [[nodiscard]] bool isMacOSBundle() const noexcept;
 
    [[nodiscard]] bool isFile() const noexcept final;
    [[nodiscard]] bool isDirectory() const noexcept final;
    [[nodiscard]] bool isSymLink() const noexcept final;
 
 
 
    bool replaceFileExtension (const std::string_view& newFileExtension,
                               bool                    renameOnDisk = true);
 
    File& operator= (const Path& newPath);
 
    File& operator= (const std::string_view& newPath);
 
 
 
    [[nodiscard]] std::string loadAsString() const noexcept;
 
    [[nodiscard]] std::vector<std::string> loadAsLines() const;
 
    [[nodiscard]] std::unique_ptr<std::ifstream> getInputStream() const;
 
 
 
    bool overwrite (const char* const data, std::size_t numBytes) const noexcept;
    bool overwrite (const std::string_view& text) const noexcept;
 
    [[nodiscard]] std::unique_ptr<std::ofstream> getOutputStream() const;
 
 
 
    bool append (const char* const data, std::size_t numBytes) const noexcept;
    bool append (const std::string_view& text) const noexcept;
 
 
    bool prepend (const char* const data, std::size_t numBytes) const noexcept;
    bool prepend (const std::string_view& text) const noexcept;
 
    bool resize (std::uintmax_t newSizeInBytes, bool allowTruncation = true, bool allowIncreasing = true) const noexcept;
 
 
    std::optional<File> createHardLink (const Path& path) const;
 
    [[nodiscard]] std::uintmax_t getHardLinkCount() const noexcept;
 
 
    std::optional<File> duplicate() const noexcept;
 
    [[nodiscard]] CFile getCfile (CFile::Mode mode = CFile::Mode::Read) const noexcept;
 
    struct LFILE_EXPORT Iterator final
    {
    public:
        using iterator_category = std::forward_iterator_tag;
        using value_type        = std::string;
        using difference_type   = std::ptrdiff_t;
        using pointer           = std::string*;
        using reference         = std::string&;
 
        Iterator&              operator++();
        [[nodiscard]] Iterator operator++ (int);
        bool                   operator== (Iterator other);
        bool                   operator!= (Iterator other);
 
        reference operator*() const;
        pointer   operator->() const;
 
        explicit Iterator();
 
        Iterator (const Iterator&) = default;
        Iterator& operator= (const Iterator&) = default;
 
        Iterator (Iterator&&) = default;
        Iterator& operator= (Iterator&&) = default;
 
    private:
        using VectorType = std::vector<std::string>;
 
        explicit Iterator (VectorType&& v);
 
        std::shared_ptr<VectorType> lines { nullptr };
 
        VectorType::size_type idx { 0UL };
 
        friend class File;
    };
 
    [[nodiscard]] Iterator begin() const;
 
    [[nodiscard]] Iterator end() const;
 
    [[nodiscard]] static File getCurrentExecutable();
 
    [[nodiscard]] static File getCurrentModule();
 
private:
    [[nodiscard]] bool write_data (const char* const data, std::size_t numBytes, bool overwrite) const noexcept;
};
 
/*-------------------------------------------------------------------------------------------------------------------------*/
 
#pragma mark TempFile
#pragma endregion
#pragma region TempFile
 
class LFILE_EXPORT TempFile final : public File
{
public:
    explicit TempFile (const Path& filepath,
                       bool        destroyOnDelete = true);
 
    ~TempFile() final;
 
    TempFile (const TempFile&) = delete;
    TempFile& operator= (const TempFile&) = delete;
 
 
    TempFile (TempFile&& other) noexcept;
 
    TempFile& operator= (TempFile&& other) noexcept;
 
    [[nodiscard]] static TempFile getNextFile();
 
private:
    bool shouldDelete { true };
};
 
std::ostream& operator<< (std::ostream& os, const File& file);
 
std::istream& operator>> (std::istream& is, const File& file);
 
}  // namespace limes::files
 
namespace std
{
 
template <>
struct LFILE_EXPORT hash<limes::files::File> final
{
    size_t operator() (const limes::files::File& f) const noexcept;
};
}  // namespace std