Struct template basic

Struct template basic_process

boost::process::v2::basic_process — A class managing a subprocess.

Synopsis

// In header: <boost/process/v2/process.hpp>

template<typename Executor = boost::asio::any_io_executor> 
struct basic_process {
  // types
  typedef Executor                                 executor_type;       // The executor of the process. 
  typedef basic_process_handle< executor_type >    handle_type;         // The non-closing handle type. 
  typedef typename handle_type::native_handle_type native_handle_type;  // Provides access to underlying operating system facilities. 

  // member classes/structs/unions

  struct async_wait_op_ {

    // public member functions
    template<typename Self> void operator()(Self &&);
    template<typename Self> 
      void operator()(Self &&, error_code, native_exit_code_type);

    // public data members
    basic_process_handle< Executor > & handle;
    native_exit_code_type & res;
  };

  // Rebinds the process_handle to another executor.
  template<typename Executor1> 
  struct rebind_executor {
    // types
    typedef basic_process< Executor1 > other;  // The socket type when rebound to the specified executor. 
  };

  // construct/copy/destruct
  basic_process() = default;
  basic_process(const basic_process &) = delete;
  basic_process(basic_process &&) = default;
  template<typename Executor1> basic_process(basic_process< Executor1 > &&);
  template<typename ... Inits> 
    explicit basic_process(executor_type, const filesystem::path &, 
                           std::initializer_list< string_view >, Inits &&...);
  template<typename Args, typename ... Inits> 
    explicit basic_process(executor_type, const filesystem::path &, Args &&, 
                           Inits &&...);
  template<typename ExecutionContext, typename ... Inits> 
    explicit basic_process(ExecutionContext &, 
                           typename std::enable_if< std::is_convertible< ExecutionContext &, boost::asio::execution_context & >::value, const filesystem::path & >::type, 
                           std::initializer_list< string_view >, Inits &&...);
  template<typename ExecutionContext, typename Args, typename ... Inits> 
    explicit basic_process(ExecutionContext &, 
                           typename std::enable_if< std::is_convertible< ExecutionContext &, boost::asio::execution_context & >::value, const filesystem::path & >::type, 
                           Args &&, Inits &&...);
  explicit basic_process(executor_type, pid_type);
  explicit basic_process(executor_type, pid_type, native_handle_type);
  explicit basic_process(executor_type);
  template<typename ExecutionContext> 
    explicit basic_process(ExecutionContext &, pid_type, 
                           typename std::enable_if< std::is_convertible< ExecutionContext &, boost::asio::execution_context & >::value, void * >::type = nullptr);
  template<typename ExecutionContext> 
    explicit basic_process(ExecutionContext &, pid_type, native_handle_type, 
                           typename std::enable_if< std::is_convertible< ExecutionContext &, boost::asio::execution_context & >::value, void * >::type = nullptr);
  template<typename ExecutionContext> 
    explicit basic_process(ExecutionContext &, 
                           typename std::enable_if< is_convertible< ExecutionContext &, boost::asio::execution_context & >::value, void * >::type = nullptr);
  basic_process & operator=(const basic_process &) = delete;
  basic_process & operator=(basic_process &&) = default;
  ~basic_process();

  // public member functions
  executor_type get_executor();
  handle_type & handle();
  const handle_type & handle() const;
  void interrupt();
  void interrupt(error_code &);
  void request_exit();
  void request_exit(error_code &);
  void suspend(error_code &);
  void suspend();
  void resume(error_code &);
  void resume();
  void terminate();
  void terminate(error_code &);
  int wait();
  int wait(error_code &);
  handle_type detach();
  native_handle_type native_handle();
  int exit_code() const;
  pid_type id() const;
  native_exit_code_type native_exit_code() const;
  bool running();
  bool running(error_code &) noexcept;
  bool is_open() const;
  template<Token WaitHandler DEFAULT_TYPE> 
    deduced async_wait(WaitHandler &&handler );
};

Description

`basic_process` public construct/copy/destruct

```
basic_process() = default;
```
An empty process is similar to a default constructed thread. It holds an empty handle and is a place holder for a process that is to be launched later.

basic_process(const basic_process &) = delete;

```
basic_process(basic_process && lhs) = default;
```
Move construct the process. It will be detached from lhs.

template<typename Executor1> basic_process(basic_process< Executor1 > && lhs);

Move construct and rebind the executor.

template<typename ... Inits> 
  explicit basic_process(executor_type executor, const filesystem::path & exe, 
                         std::initializer_list< string_view > args, 
                         Inits &&... inits);

Construct a child from a property list and launch it using the default launcher..

template<typename Args, typename ... Inits> 
  explicit basic_process(executor_type executor, const filesystem::path & exe, 
                         Args && args, Inits &&... inits);

Construct a child from a property list and launch it using the default launcher..

template<typename ExecutionContext, typename ... Inits> 
  explicit basic_process(ExecutionContext & context, 
                         typename std::enable_if< std::is_convertible< ExecutionContext &, boost::asio::execution_context & >::value, const filesystem::path & >::type exe, 
                         std::initializer_list< string_view > args, 
                         Inits &&... inits);

Construct a child from a property list and launch it using the default launcher..

template<typename ExecutionContext, typename Args, typename ... Inits> 
  explicit basic_process(ExecutionContext & context, 
                         typename std::enable_if< std::is_convertible< ExecutionContext &, boost::asio::execution_context & >::value, const filesystem::path & >::type exe, 
                         Args && args, Inits &&... inits);

Construct a child from a property list and launch it using the default launcher.

explicit basic_process(executor_type exec, pid_type pid);

Attach to an existing process.

explicit basic_process(executor_type exec, pid_type pid, 
                       native_handle_type native_handle);

Attach to an existing process and the internal handle.

explicit basic_process(executor_type exec);

Create an invalid handle.

template<typename ExecutionContext> 
  explicit basic_process(ExecutionContext & context, pid_type pid, 
                         typename std::enable_if< std::is_convertible< ExecutionContext &, boost::asio::execution_context & >::value, void * >::type = nullptr);

Attach to an existing process.

template<typename ExecutionContext> 
  explicit basic_process(ExecutionContext & context, pid_type pid, 
                         native_handle_type native_handle, 
                         typename std::enable_if< std::is_convertible< ExecutionContext &, boost::asio::execution_context & >::value, void * >::type = nullptr);

Attach to an existing process and the internal handle.

template<typename ExecutionContext> 
  explicit basic_process(ExecutionContext & context, 
                         typename std::enable_if< is_convertible< ExecutionContext &, boost::asio::execution_context & >::value, void * >::type = nullptr);

Create an invalid handle.

basic_process & operator=(const basic_process &) = delete;

basic_process & operator=(basic_process && lhs) = default;

Move assign a process. It will be detached from lhs.

```
~basic_process();
```
Destruct the handle and terminate the process if it wasn't detached.

`basic_process` public member functions

```
executor_type get_executor();
```
Get the executor of the process.
```
handle_type & handle();
```
Get the underlying non-closing handle.
```
const handle_type & handle() const;
```
Get the underlying non-closing handle.
```
void interrupt();
```
Sends the process a signal to ask for an interrupt, which the process may interpret as a shutdown.
Maybe be ignored by the subprocess.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
```
void interrupt(error_code & ec);
```
```
void request_exit();
```
```
void request_exit(error_code & ec);
```
Sends the process a signal to ask for a graceful shutdown. Maybe be ignored by the subprocess.
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
```
void suspend(error_code & ec);
```
Send the process a signal requesting it to stop. This may rely on undocumented functions.
```
void suspend();
```
Send the process a signal requesting it to stop. This may rely on undocumented functions.
```
void resume(error_code & ec);
```
Send the process a signal requesting it to resume. This may rely on undocumented functions.
```
void resume();
```
Send the process a signal requesting it to resume. This may rely on undocumented functions.
```
void terminate();
```
```
void terminate(error_code & ec);
```
Unconditionally terminates the process and stores the exit code in exit_status.
```
int wait();
```
```
int wait(error_code & ec);
```
Waits for the process to exit, store the exit code internally and return it.
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
```
handle_type detach();
```
Detach the process.
```
native_handle_type native_handle();
```
Get the native.
```
int exit_code() const;
```
Return the evaluated exit_code.
```
pid_type id() const;
```
Get the id of the process;.
```
native_exit_code_type native_exit_code() const;
```
The native handle of the process.
This might be undefined on posix systems that only support signals
```
bool running();
```
Checks if the current process is running.
If it has already completed the exit code will be stored internally and can be obtained by calling `exit_code.
```
bool running(error_code & ec) noexcept;
```
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
```
bool is_open() const;
```
Check if the process is referring to an existing process.
Note that this might be a process that already exited.

template<Token WaitHandler DEFAULT_TYPE> 
  deduced async_wait(WaitHandler &&handler  DEFAULT);

Asynchronously wait for the process to exit and deliver the native exit-code in the completion handler.