Boost C++ Libraries

explicit child(pid_t & pid);

Construct the child from a pid.

	Note
	There is no guarantee that this will work. The process need the right access rights, which are very platform specific.

child(child && lhs);

Move-Constructor.

template<typename ... Args> explicit child(Args &&... args);

Construct a child from a property list and launch it The standard version is to create a subprocess, which will spawn the process.

child() = default;

Construct an empty child.

child & operator=(child && lhs);

Move assign.

~child();

Destructor.

	Note
	Will call terminate (without warning) when the child was neither joined nor detached.

void detach();

Detach the child, i.e. let it run after this handle dies.

void join();

Join the child. This just calls wait, but that way the naming is similar to std::thread

bool joinable();

Check if the child is joinable.

native_handle_t native_handle() const;

Get the native handle for the child process.

int exit_code() const;

Get the exit_code. The return value is without any meaning if the child wasn't waited for or if it was terminated.

pid_t id() const;

Get the Process Identifier.

int native_exit_code() const;

Get the native, uninterpreted exit code. The return value is without any meaning if the child wasn't waited for or if it was terminated.

bool running();

Check if the child process is running.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

bool running(std::error_code & ec) noexcept;

void wait();

Wait for the child process to exit.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void wait(std::error_code & ec) noexcept;

template<typename Rep, typename Period> 
  bool wait_for(const std::chrono::duration< Rep, Period > & rel_time);

Wait for the child process to exit for a period of time. This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

bool wait_for(const std::chrono::duration< Rep, Period > & rel_time, 
              std::error_code & ec) noexcept;

template<typename Clock, typename Duration> 
  bool wait_until(const std::chrono::time_point< Clock, Duration > & timeout_time);

Wait for the child process to exit until a point in time. This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

bool wait_until(const std::chrono::time_point< Clock, Duration > & timeout_time, 
                std::error_code & ec) noexcept;

bool valid() const;

Check if this handle holds a child process.

	Note
	That does not mean, that the process is still running. It only means, that the handle does or did exist.

explicit operator bool() const;

Same as valid, for convenience.

bool in_group() const;

Check if the the chlid process is in any process group.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

bool in_group(std::error_code & ec) const noexcept;

void terminate();

Terminate the child process.

This function will cause the child process to unconditionally and immediately exit. It is implement with SIGKILL on posix and TerminateProcess on windows.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void terminate(std::error_code & ec) noexcept;