process.h

#ifndef UVW_PROCESS_INCLUDE_H
#define UVW_PROCESS_INCLUDE_H
 
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include <uv.h>
#include "handle.hpp"
#include "loop.h"
#include "stream.h"
#include "util.h"
 
namespace uvw {
 
namespace details {
 
enum class UVProcessFlags : std::underlying_type_t<uv_process_flags> {
    SETUID = UV_PROCESS_SETUID,
    SETGID = UV_PROCESS_SETGID,
    WINDOWS_VERBATIM_ARGUMENTS = UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS,
    DETACHED = UV_PROCESS_DETACHED,
    WINDOWS_HIDE = UV_PROCESS_WINDOWS_HIDE,
    WINDOWS_HIDE_CONSOLE = UV_PROCESS_WINDOWS_HIDE_CONSOLE,
    WINDOWS_HIDE_GUI = UV_PROCESS_WINDOWS_HIDE_GUI
};
 
enum class UVStdIOFlags : std::underlying_type_t<uv_stdio_flags> {
    IGNORE_STREAM = UV_IGNORE,
    CREATE_PIPE = UV_CREATE_PIPE,
    INHERIT_FD = UV_INHERIT_FD,
    INHERIT_STREAM = UV_INHERIT_STREAM,
    READABLE_PIPE = UV_READABLE_PIPE,
    WRITABLE_PIPE = UV_WRITABLE_PIPE,
    OVERLAPPED_PIPE = UV_OVERLAPPED_PIPE
};
 
} // namespace details
 
struct ExitEvent {
    explicit ExitEvent(int64_t code, int sig) noexcept;
 
    int64_t status; 
    int signal;     
};
 
class ProcessHandle final: public Handle<ProcessHandle, uv_process_t> {
    static void exitCallback(uv_process_t *handle, int64_t exitStatus, int termSignal);
 
public:
    using Process = details::UVProcessFlags;
    using StdIO = details::UVStdIOFlags;
 
    ProcessHandle(ConstructorAccess ca, std::shared_ptr<Loop> ref);
 
    static void disableStdIOInheritance() noexcept;
 
    static bool kill(int pid, int signum) noexcept;
 
    bool init();
 
    void spawn(const char *file, char **args, char **env = nullptr);
 
    void kill(int signum);
 
    int pid() noexcept;
 
    ProcessHandle &cwd(const std::string &path) noexcept;
 
    ProcessHandle &flags(Flags<Process> flags) noexcept;
 
    template<typename T, typename U>
    ProcessHandle &stdio(StreamHandle<T, U> &stream, Flags<StdIO> flags) {
        uv_stdio_container_t container;
        Flags<StdIO>::Type fgs = flags;
        container.flags = static_cast<uv_stdio_flags>(fgs);
        container.data.stream = get<uv_stream_t>(stream);
        poStreamStdio.push_back(std::move(container));
        return *this;
    }
 
    ProcessHandle &stdio(FileHandle fd, Flags<StdIO> flags);
 
    ProcessHandle &uid(Uid id);
 
    ProcessHandle &gid(Gid id);
 
private:
    std::string poCwd;
    Flags<Process> poFlags;
    std::vector<uv_stdio_container_t> poFdStdio;
    std::vector<uv_stdio_container_t> poStreamStdio;
    Uid poUid;
    Gid poGid;
};
 
} // namespace uvw
 
#ifndef UVW_AS_LIB
#    include "process.cpp"
#endif
 
#endif // UVW_PROCESS_INCLUDE_H