File.hpp

Go to the documentation of this file.

// The Reactive C++ Toolbox.
// Copyright (C) 2013-2019 Swirly Cloud Limited
// Copyright (C) 2022 Reactive Markets Limited
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#ifndef TOOLBOX_IO_FILE_HPP
#define TOOLBOX_IO_FILE_HPP
 
#include <toolbox/io/Buffer.hpp>
#include <toolbox/io/Handle.hpp>
#include <toolbox/sys/Error.hpp>
#include <toolbox/contrib/libutil.h>
 
#include <fcntl.h>
#include <stdio.h>
#include <sys/stat.h>
 
namespace toolbox {
namespace os {
 
inline FileHandle open(const char* path, int flags, mode_t mode, std::error_code& ec) noexcept
{
    const auto fd = ::open(path, flags, mode);
    if (fd < 0) {
        ec = make_error(errno);
    }
    return fd;
}
 
inline FileHandle open(const char* path, int flags, mode_t mode)
{
    const auto fd = ::open(path, flags, mode);
    if (fd < 0) {
        throw std::system_error{make_error(errno), "open"};
    }
    return fd;
}
 
inline FileHandle open(const char* path, int flags, std::error_code& ec) noexcept
{
    const auto fd = ::open(path, flags);
    if (fd < 0) {
        ec = make_error(errno);
    }
    return fd;
}
 
inline FileHandle open(const char* path, int flags)
{
    const auto fd = ::open(path, flags);
    if (fd < 0) {
        throw std::system_error{make_error(errno), "open"};
    }
    return fd;
}
 
inline void rename(const char* oldpath, const char* newpath, std::error_code& ec)
{
    const auto ret = ::rename(oldpath, newpath);
    if (ret < 0) {
        ec = make_error(errno);
    }
}
 
inline void rename(const char* oldpath, const char* newpath)
{
    const auto ret = ::rename(oldpath, newpath);
    if (ret < 0) {
        throw std::system_error{make_error(errno), "rename"};
    }
}
 
inline int remove(const char* path)
{
    const auto ret = ::remove(path);
    if (ret < 0) {
        throw std::system_error{make_error(errno), "remove"};
    }
    return ret;
}
 
inline int remove(const char* path, std::error_code& ec) noexcept
{
    const auto ret = ::remove(path);
    if (ret < 0) {
        ec = make_error(errno);
    }
    return ret;
}
 
inline std::pair<FileHandle, FileHandle> pipe2(int flags, std::error_code& ec) noexcept
{
    int pipefd[2];
    if (::pipe2(pipefd, flags) < 0) {
        ec = make_error(errno);
    }
    return {FileHandle{pipefd[0]}, FileHandle{pipefd[1]}};
}
 
inline std::pair<FileHandle, FileHandle> pipe2(int flags)
{
    int pipefd[2];
    if (::pipe2(pipefd, flags) < 0) {
        throw std::system_error{make_error(errno), "pipe2"};
    }
    return {FileHandle{pipefd[0]}, FileHandle{pipefd[1]}};
}
 
inline void fstat(int fd, struct stat& statbuf, std::error_code& ec) noexcept
{
    const auto ret = ::fstat(fd, &statbuf);
    if (ret < 0) {
        ec = make_error(errno);
    }
}
 
inline void fstat(int fd, struct stat& statbuf)
{
    const auto ret = ::fstat(fd, &statbuf);
    if (ret < 0) {
        throw std::system_error{make_error(errno), "fstat"};
    }
}
 
inline void ftruncate(int fd, off_t length, std::error_code& ec) noexcept
{
    const auto ret = ::ftruncate(fd, length);
    if (ret < 0) {
        ec = make_error(errno);
    }
}
 
inline void ftruncate(int fd, off_t length)
{
    const auto ret = ::ftruncate(fd, length);
    if (ret < 0) {
        throw std::system_error{make_error(errno), "ftruncate"};
    }
}
 
inline ssize_t read(int fd, void* buf, std::size_t len, std::error_code& ec) noexcept
{
    const auto ret = ::read(fd, buf, len);
    if (ret < 0) {
        ec = make_error(errno);
    }
    return ret;
}
 
inline std::size_t read(int fd, void* buf, std::size_t len)
{
    const auto ret = ::read(fd, buf, len);
    if (ret < 0) {
        throw std::system_error{make_error(errno), "read"};
    }
    return ret;
}
 
inline ssize_t read(int fd, MutableBuffer buf, std::error_code& ec) noexcept
{
    return read(fd, static_cast<void*>(buf.data()), buffer_size(buf), ec);
}
 
inline std::size_t read(int fd, MutableBuffer buf) noexcept
{
    return read(fd, static_cast<void*>(buf.data()), buffer_size(buf));
}
 
inline ssize_t write(int fd, const void* buf, std::size_t len, std::error_code& ec) noexcept
{
    const auto ret = ::write(fd, buf, len);
    if (ret < 0) {
        ec = make_error(errno);
    }
    return ret;
}
 
inline std::size_t write(int fd, const void* buf, std::size_t len)
{
    const auto ret = ::write(fd, buf, len);
    if (ret < 0) {
        throw std::system_error{make_error(errno), "write"};
    }
    return ret;
}
 
inline ssize_t write(int fd, ConstBuffer buf, std::error_code& ec) noexcept
{
    return write(fd, static_cast<const void*>(buf.data()), buffer_size(buf), ec);
}
 
inline std::size_t write(int fd, ConstBuffer buf)
{
    return write(fd, static_cast<const void*>(buf.data()), buffer_size(buf));
}
 
inline int fcntl(int fd, int cmd, std::error_code& ec) noexcept
{
    const auto ret = ::fcntl(fd, cmd);
    if (ret < 0) {
        ec = make_error(errno);
    }
    return ret;
}
 
template <typename ArgT>
inline int fcntl(int fd, int cmd, ArgT arg, std::error_code& ec) noexcept
{
    const auto ret = ::fcntl(fd, cmd, arg);
    if (ret < 0) {
        ec = make_error(errno);
    }
    return ret;
}
 
inline int fcntl(int fd, int cmd)
{
    const auto ret = ::fcntl(fd, cmd);
    if (ret < 0) {
        throw std::system_error{make_error(errno), "fcntl"};
    }
    return ret;
}
 
template <typename ArgT>
inline int fcntl(int fd, int cmd, ArgT arg)
{
    const auto ret = ::fcntl(fd, cmd, arg);
    if (ret < 0) {
        throw std::system_error{make_error(errno), "fcntl"};
    }
    return ret;
}
 
} // namespace os
inline namespace io {
 
inline std::size_t file_size(int fd)
{
    struct stat st; // NOLINT(hicpp-member-init)
    os::fstat(fd, st);
    return st.st_size;
}
 
inline mode_t file_mode() noexcept
{
    mode_t mode{umask(0)};
    umask(mode);
    return mode;
}
 
inline void set_non_block(int fd, std::error_code& ec) noexcept
{
    os::fcntl(fd, F_SETFL, O_NONBLOCK, ec);
}
 
inline void set_non_block(int fd)
{
    os::fcntl(fd, F_SETFL, O_NONBLOCK);
}
 
// Reliably open and lock a file
inline FileHandle flopen(const char* path, int flags, mode_t mode, std::error_code& ec)
{
    // flopen comes from library 'libbsd'
    const auto fd = ::flopen(path, flags, mode);
    if (fd < 0) {
        ec = make_error(errno);
    }
    return fd;
}
 
// Reliably open and lock a file
inline FileHandle flopen(const char* path, int flags, mode_t mode)
{
    // flopen comes from library 'libbsd'
    const auto fd = ::flopen(path, flags, mode);
    if (fd < 0) {
        throw std::system_error{make_error(errno), "flopen"};
    }
    return fd;
}
 
 
} // namespace io
} // namespace toolbox
 
#endif // TOOLBOX_IO_FILE_HPP