]> git.tdb.fi Git - libs/core.git/blob - source/core/process.h
f21ecb337d76d5c8718b056478597968f04c0f9a
[libs/core.git] / source / core / process.h
1 #ifndef MSP_CORE_PROCESS_H_
2 #define MSP_CORE_PROCESS_H_
3
4 #include <string>
5 #include <vector>
6 #include <msp/fs/path.h>
7 #include <msp/io/base.h>
8 #include "noncopyable.h"
9
10 namespace Msp {
11
12 /**
13 Provides an interface for running and controlling programs.
14
15 The creation of a new system-level process does not happen immediately when a
16 Process object is created, but only when exexute is called.  If called on the
17 object obtained with self(), the process is replaced with a new program
18 immediately.  In particular, destructors are not invoked.
19
20 Output redirections can be specified before calling execute.  To feed input to
21 the process or capture its output, use an IO::Pipe.  Redirections performed on
22 the self object take effect immediately.  It is recommended to perform such
23 redirections directly on the Console objects.
24 */
25 class Process: private NonCopyable
26 {
27 public:
28         typedef std::vector<std::string> Arguments;
29
30 private:
31         struct Private;
32
33         Private *priv = 0;
34         FS::Path work_dir;
35         bool redirect = false;
36         IO::Base *cin = 0;
37         IO::Base *cout = 0;
38         IO::Base *cerr = 0;
39         bool running = false;
40         bool finished = false;
41         unsigned exit_code = 0;
42
43         static Process *_self;
44
45         Process(const Private &);
46 public:
47         Process();
48         ~Process();
49
50         /** Returns an object referring to the current process. */
51         static Process &self();
52 private:
53         static void platform_get_self_info(Private &);
54
55 public:
56         /** Sets the working directory for the new process.  By default, the working
57         directory is not changed. */
58         void set_working_directory(const FS::Path &);
59
60         /** Redirects console input from an I/O object. */
61         void redirect_cin(IO::Base &);
62
63         /** Redirects console output to an I/O object. */
64         void redirect_cout(IO::Base &);
65
66         /** Redirects error output to an I/O object. */
67         void redirect_cerr(IO::Base &);
68 private:
69         void do_redirect(IO::Base *&, IO::Base &);
70
71 public:
72         /** Executes a command, searching for it in the standard locations. */
73         void execute(const std::string &, const Arguments &);
74
75         /** Executes a command specified by a full path. */
76         void execute(const FS::Path &, const Arguments &);
77
78 private:
79         void execute(const std::string &, bool, const Arguments &);
80
81 public:
82         bool is_running() const { return running; }
83         bool has_finished() const { return finished; }
84
85         /** Checks the status of a running process.  If block is true, waits for the
86         process to finish. */
87         bool wait(bool block = true);
88
89         /** Returns the exit code for a finished process. */
90         unsigned get_exit_code() const;
91
92         /** Terminates the process. */
93         void terminate();
94
95         /** Brutally murders the process.  It is not given a chance to terminate
96         gracefully. */
97         void kill();
98
99         /** Sends the process an interrupt signal, as if ^C was pressed. */
100         void interrupt();
101 };
102
103 } // namespace Msp
104
105 #endif