File.h

Go to the documentation of this file.

#pragma once
#include <fcntl.h>
#include <filesystem>
#include <ftw.h>
#include <misc/gen/TDynamicBuffer.h>
#include <misc/global.h>
 
namespace sf::lnx
{
 
class _MISC_CLASS File
{
  public:
    typedef struct stat stat_type;
 
    File();
 
    explicit File(const std::filesystem::path& path, int flags = O_CREAT | O_RDWR | O_APPEND, mode_t mode = S_IREAD | S_IWRITE | S_IRGRP | S_IWGRP);
 
    ~File();
 
    void initialize(const std::filesystem::path& path, int flags = O_CREAT | O_RDWR | O_APPEND, mode_t mode = S_IREAD | S_IWRITE | S_IRGRP | S_IWGRP);
 
    void open(const std::string& path, int flags = O_CREAT | O_RDWR | O_APPEND, mode_t mode = S_IREAD | S_IWRITE | S_IRGRP | S_IWGRP);
 
    void createTemporary(const std::string& name_tpl, int flags = O_CREAT | O_RDWR);
 
    void allocate(size_t sz);
 
    void open(bool reopen = false);
 
    [[nodiscard]] bool isOpen() const;
 
    void close();
 
    bool close(bool exceptions);
 
    void write(const File& f, size_t pos, size_t sz, size_t buf_sz = 0);
 
    void write(const void* buf, size_t sz, size_t* written = nullptr);
 
    void write(const std::string& s);
 
    void write(const char* s);
 
    template<typename T>
    void write(const T& t);
 
    ssize_t read(void* buf, size_t pos, size_t sz) const;
 
    void read(DynamicBuffer buf, size_t pos, size_t sz) const;
 
    template<typename T>
    void read(T& t, size_t pos) const;
 
    void getStat(stat_type& s) const;
 
    [[nodiscard]] const stat_type& getStatus() const;
 
    const stat_type& getStatus(bool update);
 
    [[nodiscard]] std::string getStatText() const;
 
    void rename(const std::string& path, bool assign = false);
 
    void truncate(size_t length);
 
    void remove();
 
    void synchronise();
 
    [[nodiscard]] std::string getPath() const;
 
    [[nodiscard]] mode_t getMode() const;
 
    [[nodiscard]] int getFlags() const;
 
    [[nodiscard]] int getDescriptor() const;
 
    bool exists();
 
    void unlink();
 
  private:
    int setErrorNo(int error_no);
    std::filesystem::path _path;
    mode_t _mode{};
    mode_t _flags{};
    int _descriptor{};
    int _errorNo{};
    stat_type _stat{};
};
 
inline int File::getDescriptor() const
{
  return _descriptor;
}
 
inline std::string File::getPath() const
{
  return _path;
}
 
inline mode_t File::getMode() const
{
  return _mode;
}
 
inline int File::getFlags() const
{
  return _flags;
}
 
inline void File::close()
{
  close(true);
}
 
inline const File::stat_type& File::getStatus() const
{
  return _stat;
}
 
inline const File::stat_type& File::getStatus(bool update)
{
  if (update)
  {
    getStat(_stat);
  }
  return _stat;
}
 
inline void File::write(const std::string& s)
{
  write(s.c_str(), s.length());
}
 
inline void File::write(const char* s)
{
  write(s, strlen(s));
}
 
template<typename T>
inline void File::write(const T& t)
{
  write(&t, sizeof(T));
}
 
template<typename T>
inline void File::read(T& t, size_t pos) const
{
  read(&t, pos, sizeof(T));
}
 
inline bool File::isOpen() const
{
  return _descriptor != -1;
}
 
_MISC_FUNC std::ostream& operator<<(std::ostream& stream, const File& file);
 
}// namespace sf::lnx