17 #include <sys/resource.h> 20 #include <sys/types.h> 32 std::filesystem::path with_suffix(
const std::filesystem::path& path,
33 const std::string& suffix);
40 std::unique_ptr<struct stat> stat(
const char* pathname);
47 std::unique_ptr<struct stat> stat(
const std::string& pathname);
54 std::unique_ptr<struct stat> stat(
const std::filesystem::path& path);
60 void stat(
const char* pathname,
struct stat& st);
66 void stat(
const std::string& pathname,
struct stat& st);
72 void stat(
const std::filesystem::path& path,
struct stat& st);
79 [[deprecated(
"Use std::filesystem::is_directory")]]
bool 80 isdir(
const std::string& pathname);
83 [[deprecated(
"Use std::filesystem::is_block_file")]]
bool 84 isblk(
const std::string& pathname);
87 [[deprecated(
"Use std::filesystem::is_character_file")]]
bool 88 ischr(
const std::string& pathname);
91 [[deprecated(
"Use std::filesystem::is_fifo")]]
bool 92 isfifo(
const std::string& pathname);
95 [[deprecated(
"Use std::filesystem::is_symlink")]]
bool 96 islnk(
const std::string& pathname);
99 [[deprecated(
"Use std::filesystem::is_regular_file")]]
bool 100 isreg(
const std::string& pathname);
103 [[deprecated(
"Use std::filesystem::is_socket")]]
bool 104 issock(
const std::string& pathname);
107 time_t timestamp(
const std::filesystem::path& file);
110 time_t timestamp(
const std::filesystem::path& file, time_t def);
113 size_t size(
const std::filesystem::path& file);
116 size_t size(
const std::filesystem::path& file,
size_t def);
119 ino_t inode(
const std::filesystem::path& file);
122 ino_t inode(
const std::filesystem::path& file, ino_t def);
125 bool access(
const std::filesystem::path& s,
int m);
128 [[deprecated(
"Use std::filesystem::exists")]]
bool exists(
const std::string& s);
131 [[deprecated(
"Use std::filesystem::current_path")]] std::string getcwd();
134 [[deprecated(
"Use std::filesystem::current_path")]]
void 135 chdir(
const std::string& dir);
138 void chroot(
const std::filesystem::path& dir);
141 mode_t umask(mode_t mask);
144 [[deprecated(
"Use std::filesystem::canonical")]] std::string
145 abspath(
const std::string& pathname);
160 MMap(
void* addr,
size_t length);
163 MMap& operator=(
const MMap&) =
delete;
166 size_t size()
const {
return length; }
170 template <
typename T>
operator const T*()
const 172 return reinterpret_cast<const T*
>(addr);
175 template <
typename T>
operator T*()
const 177 return reinterpret_cast<T*
>(addr);
215 [[noreturn]]
virtual void throw_error(
const char* desc);
236 void fstat(
struct stat& st);
237 void fchmod(mode_t mode);
239 void futimens(const ::timespec ts[2]);
246 size_t read(
void* buf,
size_t count);
263 size_t write(
const void* buf,
size_t count);
265 template <
typename Container>
size_t write(
const Container& c)
267 return write(c.data(), c.size() *
sizeof(Container::value_type));
276 c.size() *
sizeof(
typename Container::value_type));
288 c.size() *
sizeof(
typename Container::value_type));
291 off_t lseek(off_t offset,
int whence = SEEK_SET);
293 size_t pread(
void* buf,
size_t count, off_t offset);
294 size_t pwrite(
const void* buf,
size_t count, off_t offset);
296 template <
typename Container>
297 size_t pwrite(
const Container& c, off_t offset)
299 return pwrite(c.data(),
300 c.size() *
sizeof(
typename Container::value_type),
304 void ftruncate(off_t length);
306 MMap mmap(
size_t length,
int prot,
int flags, off_t offset = 0);
325 bool ofd_setlkw(::flock&,
bool retry_on_signal =
true);
338 void setfl(
int flags);
340 operator int()
const {
return fd; }
363 std::filesystem::path path_;
375 [[noreturn]]
virtual void throw_error(
const char* desc)
override;
379 [[deprecated(
"use path() instead")]] std::string
name()
const 381 return path_.string();
383 const std::filesystem::path& path()
const {
return path_; }
391 using NamedFileDescriptor::NamedFileDescriptor;
420 using iterator_category = std::input_iterator_tag;
421 using value_type = ::dirent;
422 using difference_type = int;
423 using pointer = ::dirent*;
424 using reference = ::dirent&;
426 Path* path =
nullptr;
428 ::dirent* cur_entry =
nullptr;
438 o.cur_entry =
nullptr;
444 bool operator==(
const iterator& i)
const;
445 bool operator!=(
const iterator& i)
const;
446 ::dirent& operator*()
const {
return *cur_entry; }
447 ::dirent* operator->()
const {
return cur_entry; }
475 using ManagedNamedFileDescriptor::ManagedNamedFileDescriptor;
480 explicit Path(
const std::filesystem::path& pathname,
int flags = 0,
485 Path(
Path& parent,
const char* pathname,
int flags = 0, mode_t mode = 0777);
488 Path& operator=(
const Path&) =
delete;
492 void open(
int flags, mode_t mode = 0777);
502 int openat(
const char* pathname,
int flags, mode_t mode = 0777);
505 int openat_ifexists(
const char* pathname,
int flags, mode_t mode = 0777);
507 bool faccessat(
const char* pathname,
int mode,
int flags = 0);
509 void fstatat(
const char* pathname,
struct stat& st);
515 void lstatat(
const char* pathname,
struct stat& st);
520 void unlinkat(
const char* pathname);
522 void mkdirat(
const char* pathname, mode_t mode = 0777);
525 void rmdirat(
const char* pathname);
527 void symlinkat(
const char* target,
const char* linkpath);
529 std::string readlinkat(
const char* pathname);
538 static std::string mkdtemp(
const std::filesystem::path& prefix);
540 "Use mkdtemp(const std::filesystem::path&)")]]
static std::string
541 mkdtemp(
const std::string& prefix);
542 static std::string mkdtemp(
const char* prefix);
543 static std::string mkdtemp(
char* pathname_template);
552 using ManagedNamedFileDescriptor::ManagedNamedFileDescriptor;
560 explicit File(
const std::filesystem::path& path);
561 explicit File(
const char* path);
562 [[deprecated(
"Use File(const std::filesystem::path&)")]]
explicit File(
563 const std::string& path);
566 File(
const std::filesystem::path& path,
int flags, mode_t mode = 0777);
568 File& operator=(
const File&) =
delete;
572 void open(
int flags, mode_t mode = 0777);
580 static File mkstemp(
const std::filesystem::path& prefix);
581 [[deprecated(
"Use mkstemp(const std::filesysten::path&)")]]
static File 582 mkstemp(
const std::string& prefix);
583 static File mkstemp(
const char* prefix);
584 static File mkstemp(
char* pathname_template);
595 bool m_unlink_on_exit =
true;
599 explicit Tempfile(
const std::filesystem::path& prefix);
600 [[deprecated(
"Use Tempfile(const std::string&)")]]
explicit Tempfile(
601 const std::string& prefix);
602 explicit Tempfile(
const char* prefix);
621 bool m_rmtree_on_exit =
true;
625 explicit Tempdir(
const std::filesystem::path& prefix);
628 "std::filesystem::path&)")]]
explicit Tempdir(
const std::string&
630 explicit Tempdir(
const char* prefix);
638 std::string read_file(
const std::filesystem::path& file);
639 [[deprecated(
"Use read_file(const std::filesystem::path&)")]] std::string
640 read_file(
const std::string& file);
641 std::string read_file(
const char* file);
649 void write_file(
const std::filesystem::path& file,
const std::string& data,
651 [[deprecated(
"Use write_file(const std::filesystem::path&, …)")]]
void 652 write_file(
const std::string& file,
const std::string& data,
654 void write_file(
const char* file,
const std::string& data, mode_t mode = 0777);
662 void write_file(
const std::filesystem::path& file,
const void* data,
663 size_t size, mode_t mode = 0777);
664 [[deprecated(
"Use write_file(const std::filesystem::path&, …)")]]
void 665 write_file(
const std::string& file,
const void* data,
size_t size,
667 void write_file(
const char* file,
const void* data,
size_t size,
679 void write_file_atomically(
const std::filesystem::path& file,
680 const std::string& data, mode_t mode = 0777);
682 "Use write_file_atomically(const std::filesystem::path&, …)")]]
void 683 write_file_atomically(
const std::string& file,
const std::string& data,
685 void write_file_atomically(
const char* file,
const std::string& data,
697 void write_file_atomically(
const std::filesystem::path& file,
const void* data,
698 size_t size, mode_t mode = 0777);
700 "Use write_file_atomically(const std::filesystem::path&, …)")]]
void 701 write_file_atomically(
const std::string& file,
const void* data,
size_t size,
706 std::string mkdtemp(std::string templ);
710 void mkFilePath(
const std::string& file);
718 [[deprecated(
"use std::filesystem::remove")]]
bool 719 unlink_ifexists(
const char* file);
720 [[deprecated(
"use std::filesystem::remove")]]
bool 721 unlink_ifexists(
const std::string& file);
722 [[deprecated(
"use std::filesystem::remove")]]
bool 723 unlink_ifexists(
const std::filesystem::path& file);
730 bool rename_ifexists(
const std::filesystem::path& src,
731 const std::filesystem::path& dst);
741 [[deprecated(
"use std::filesystem::create_directory")]]
bool 742 mkdir_ifmissing(
const std::filesystem::path& path);
750 [[deprecated(
"use std::filesystem::create_directories")]]
bool 751 makedirs(
const std::filesystem::path& path);
760 std::filesystem::path which(
const std::string& name);
763 void unlink(
const std::filesystem::path& pathname);
766 void rmdir(
const std::filesystem::path& pathname);
769 void rmtree(
const std::filesystem::path& pathname);
776 bool rmtree_ifexists(
const std::filesystem::path& pathname);
777 [[deprecated(
"use rmtree_ifexists(const std::filesystem::path&)")]]
bool 778 rmtree_ifexists(
const std::string& pathname);
779 bool rmtree_ifexists(
const char* pathname);
787 [[deprecated(
"use std::filesystem::rename")]]
void 788 rename(
const std::string& src_pathname,
const std::string& dst_pathname);
795 void touch(
const std::filesystem::path& pathname, time_t ts);
802 bool touch_ifexists(
const std::filesystem::path& pathname, time_t ts);
807 void clock_gettime(::clockid_t clk_id, ::timespec& ts);
812 unsigned long long timesec_elapsed(const ::timespec& begin,
813 const ::timespec& until);
826 explicit Clock(::clockid_t clk_id);
839 void getrlimit(
int resource, ::rlimit& rlim);
843 void setrlimit(
int resource, const ::rlimit& rlim);
855 void set(rlim_t rlim);
862 bool was_set =
false;
863 std::string orig_value;
878 explicit TempBuffer(
size_t size) : buffer(
new T[size]) {}
885 T* data() {
return buffer; }
886 const T* data()
const {
return buffer; }
887 operator T*() {
return buffer; }
888 operator const T*()
const {
return buffer; }
virtual void throw_error(const char *desc)
Throw an exception based on errno and the given message.
std::string name() const
Return the file pathname.
Definition: sys.h:379
Clock(::clockid_t clk_id)
Initialize ts with the value of the given clock.
bool open_ifexists(int flags, mode_t mode=0777)
Wrap open(2) and return false instead of throwing an exception if open fails with ENOENT...
void unlink()
Unlink the file right now.
RAII mechanism to save restore file times at the end of some file operations.
Definition: sys.h:346
bool read_all_or_retry(void *buf, size_t count)
Read count bytes into bufr, retrying partial reads, stopping at EOF.
Wraps a mmapped memory area, unmapping it on destruction.
Definition: sys.h:152
bool is_open() const
Check if the file descriptor is open (that is, if it is not -1)
bool ofd_setlk(::flock &)
Open file description locks F_OFD_SETLK operation.
virtual void throw_runtime_error(const char *desc) override
Throw a runtime_error unrelated from errno.
void close()
Close the file descriptor, setting its value to -1.
Common operations on file descriptors.
Definition: sys.h:192
File in the file system.
Definition: sys.h:549
void write_all_or_throw(const void *buf, size_t count)
Write all the data in buf, throwing runtime_error in case of a partial write.
int getfl()
Get open flags for the file.
bool ofd_setlkw(::flock &, bool retry_on_signal=true)
Open file description locks F_OFD_SETLKW operation.
virtual void throw_runtime_error(const char *desc)
Throw a runtime_error unrelated from errno.
Override an environment variable for the duration of this object.
Definition: sys.h:859
iterator begin()
Begin iterator on all directory entries.
Path open_path(int flags=0) const
Return a Path object for this entry.
File descriptor with a name.
Definition: sys.h:360
void unlink_on_exit(bool val)
Change the unlink-on-exit behaviour.
RAII local memory buffer.
Definition: sys.h:873
void lstatat(const char *pathname, struct stat &st)
fstatat with the AT_SYMLINK_NOFOLLOW flag set
void write_all_or_retry(const void *buf, size_t count)
Write all the data in buf, retrying partial writes.
Iterator for directory entries.
Definition: sys.h:418
void rmtree_on_exit(bool val)
Change the rmtree-on-exit behaviour.
File descriptor that gets automatically closed in the object destructor.
Definition: sys.h:389
void open(int flags, mode_t mode=0777)
Wrapper around open(2)
Open a temporary directory.
Definition: sys.h:618
void setfl(int flags)
Set open flags for the file.
void open(int flags, mode_t mode=0777)
Wrapper around open(2) with flags | O_PATH.
Override a soft resource limit during the lifetime of the object.
Definition: sys.h:846
void read_all_or_throw(void *buf, size_t count)
Read all the data into buf, throwing runtime_error in case of a partial read.
iterator end()
End iterator on all directory entries.
String functions.
Definition: benchmark.h:13
unsigned long long elapsed()
Return the number of nanoseconds elapsed since the last time ts was updated.
void rmtree()
Delete the directory pointed to by this Path, with all its contents.
Path(const std::filesystem::path &pathname, int flags=0, mode_t mode=0777)
Open the given pathname with flags | O_PATH.
~ManagedNamedFileDescriptor()
The destructor closes the file descriptor, but does not check errors on ::close().
bool ofd_getlk(::flock &)
Open file description locks F_OFD_GETLK operation.
int openat_ifexists(const char *pathname, int flags, mode_t mode=0777)
Same as openat, but returns -1 if the file does not exist.
bool fstatat_ifexists(const char *pathname, struct stat &st)
fstatat, but in case of ENOENT returns false instead of throwing
bool lstatat_ifexists(const char *pathname, struct stat &st)
lstatat, but in case of ENOENT returns false instead of throwing
virtual void throw_error(const char *desc) override
Throw an exception based on errno and the given message.
Access to clock_gettime.
Definition: sys.h:818
Open a temporary file.
Definition: sys.h:592
Wrap a path on the file system opened with O_PATH.
Definition: sys.h:413
void rmdirat(const char *pathname)
unlinkat with the AT_REMOVEDIR flag set