pipe.hpp

Go to the documentation of this file.

#pragma once
 
#include "basic_types.hpp"
 
namespace subprocess {
    /*  You might be wondering why the C-like API. I played around with a more
        C++ like API but it gets hairy quite fast trying to support all the
        possible use-cases. My opinion is to simply roll a RAII class for
        when you need it that is specific to your needs. 1, or a set of RAII
        classes is too complex.
    */
    struct PipePair {
        PipePair(){};
        PipePair(PipeHandle input, PipeHandle output) : input(input), output(output) {}
        ~PipePair(){ close(); }
        // No copy, move only
        PipePair            (const PipePair&)=delete;
        PipePair& operator= (const PipePair&)=delete;
        PipePair            (PipePair&& other) { *this = std::move(other); }
        PipePair& operator= (PipePair&& other);
        /*  we make it const as outside of code shouldn't modify these.
            this might not be a good design as users may assume it's truly const.
            disown, close*, and move semantics overwrite these values.
        */
        const PipeHandle input    = kBadPipeValue;
        const PipeHandle output   = kBadPipeValue;
 
        void disown() {
            const_cast<PipeHandle&>(input) = const_cast<PipeHandle&>(output) = kBadPipeValue;
        }
        void close();
        void close_input();
        void close_output();
        explicit operator bool() const noexcept {
            return input != output;
        }
    };
 
    bool pipe_close(PipeHandle handle);
    PipePair pipe_create(bool inheritable = true);
    void pipe_set_inheritable(PipeHandle handle, bool inheritable);
 
    ssize_t pipe_read(PipeHandle, void* buffer, size_t size);
    ssize_t pipe_write(PipeHandle, const void* buffer, size_t size);
    void pipe_ignore_and_close(PipeHandle handle);
    std::string pipe_read_all(PipeHandle handle);
}