pipe.hpp

Go to the documentation of this file.

#pragma once
 
/// @file userver/engine/io/pipe.hpp
/// @brief @copybrief engine::io::Pipe
 
#include <userver/engine/deadline.hpp>
#include <userver/engine/io/common.hpp>
#include <userver/engine/io/exception.hpp>
#include <userver/engine/io/fd_control_holder.hpp>
 
USERVER_NAMESPACE_BEGIN
 
namespace engine::io {
 
namespace impl {
class FdControl;
}  // namespace impl
 
/// Reading end of an unidirectional pipe
class PipeReader final : public ReadableBase {
public:
    /// Whether the reading end of the pipe is valid.
    bool IsValid() const override;
 
    /// Suspends current task until the pipe has data available.
    /// @returns false on timeout or on task cancellations; true otherwise.
    [[nodiscard]] bool WaitReadable(Deadline) override;
 
    /// Receives at least one bytes from the pipe.
    /// @returns count of bytes read from the pipe
    [[nodiscard]] size_t ReadSome(void* buf, size_t len, Deadline deadline) override;
 
    /// Receives exactly len bytes from the pipe.
    /// @note Can return less than len if pipe is closed by peer.
    /// @returns count of bytes read from the pipe
    [[nodiscard]] size_t ReadAll(void* buf, size_t len, Deadline deadline) override;
 
    /// File descriptor corresponding to the read end of the pipe.
    int Fd() const;
 
    /// Releases reading end file descriptor and invalidates it.
    [[nodiscard]] int Release() noexcept;
 
    /// Closes and invalidates the reading end of the pipe.
    /// @warning You should not call Close with pending I/O. This may work okay
    /// sometimes but it's loosely predictable.
    void Close();
 
private:
    friend class Pipe;
 
    PipeReader() = default;
    explicit PipeReader(int fd);
 
    impl::FdControlHolder fd_control_;
};
class PipeReader final : public ReadableBase {…};
 
/// Writing end of an unidirectional pipe
class PipeWriter final : public WritableBase {
public:
    /// Whether the writing end of the pipe is valid.
    bool IsValid() const;
 
    /// Suspends current task until the pipe can accept more data.
    /// @returns false on timeout or on task cancellations; true otherwise.
    [[nodiscard]] bool WaitWriteable(Deadline) override;
 
    /// Sends exactly len bytes to the pipe.
    /// @note Can return less than len if pipe is closed by peer.
    /// @returns count of bytes written to the pipe
    [[nodiscard]] size_t WriteAll(const void* buf, size_t len, Deadline deadline) override;
 
    /// File descriptor corresponding to the write end of the pipe.
    int Fd() const;
 
    /// Releases writing end file descriptor and invalidates it.
    [[nodiscard]] int Release() noexcept;
 
    /// Closes and invalidates the writing end of the pipe.
    /// @warning You should not call Close with pending I/O. This may work okay
    /// sometimes but it's loosely predictable.
    void Close();
 
private:
    friend class Pipe;
 
    PipeWriter() = default;
    explicit PipeWriter(int fd);
 
    impl::FdControlHolder fd_control_;
};
class PipeWriter final : public WritableBase {…};
 
/// Unidirectional pipe representation
class Pipe final {
public:
    /// Constructs a unidirectional pipe
    Pipe();
 
    PipeReader reader;
    PipeWriter writer;
};
class Pipe final {…};
 
}  // namespace engine::io
 
USERVER_NAMESPACE_END