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 disown_input() {
            const_cast<PipeHandle&>(input) = kBadPipeValue;
        }
        void disown_output() {
            const_cast<PipeHandle&>(output) = kBadPipeValue;
        }
 
        void close();
        void close_input();
        void close_output();
        explicit operator bool() const noexcept {
            return input != output;
        }
    };
 
    ssize_t pipe_peak_bytes(PipeHandle pipe);
 
    bool pipe_close(PipeHandle handle);
 
    PipePair pipe_create(bool inheritable = false);
 
    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);
 
    bool pipe_set_blocking(PipeHandle, bool should_block);
 
    void pipe_ignore_and_close(PipeHandle handle);
 
    std::string pipe_read_all(PipeHandle handle);
 
    int pipe_wait_for_read(
        PipeHandle pipe,
        double seconds
    );
 
    ssize_t pipe_read_some(PipeHandle, void* buffer, size_t size);
 
    PipeHandle pipe_file(const char* filename, const char* mode);
 
    #if 0
    /*  Obviously this is possible. The problem is the API around it, I really
        want to stop calling pipe_close. To be fair in python's subprocess
        library you also have to close things either manually or use `with`.
        Maybe it's just not possible.
    */
    class UniquePipeHandle {
    public:
        UniquePipeHandle(){}
        ~UniquePipeHandle(){
            pipe_close(handle);
            handle = kBadPipeValue;
        }
        explicit UniquePipeHandle(PipeHandle handle): handle(handle){}
        UniquePipeHandle(UniquePipeHandle&& other) {
            pipe_close(handle);
            handle = other.handle;
            other.handle = kBadPipeValue;
        }
        UniquePipeHandle& operator=(UniquePipeHandle&& other) {
            pipe_close(handle);
            handle = other.handle;
            other.handle = kBadPipeValue;
            return *this;
        }
        UniquePipeHandle(const UniquePipeHandle&)=delete;
        UniquePipeHandle operator=(const UniquePipeHandle&)=delete;
 
        PipeHandle get() { return handle; }
    private:
        PipeHandle handle = kBadPipeValue;
    };
    #endif
}