blob: 02642bc6c1bab7d47ada6377d3a1c58b03316e98 (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
|
/*
* This source code is released into the public domain.
*/
module;
#include <cerrno>
#include <cstring>
#include <expected>
#include <format>
#include <optional>
#include <system_error>
#include <utility>
#include <sys/types.h>
#include <sys/wait.h>
module nihil.posix;
import nihil.error;
namespace nihil {
auto wait_result::okay(this wait_result const &self) -> bool
{
return self.status() == 0;
}
wait_result::operator bool(this wait_result const &self)
{
return self.okay();
}
auto wait_result::status(this wait_result const &self) -> std::optional<int>
{
if (WIFEXITED(self._status))
return WEXITSTATUS(self._status);
return {};
}
auto wait_result::signal(this wait_result const &self) -> std::optional<int>
{
if (WIFSIGNALED(self._status))
return WTERMSIG(self._status);
return {};
}
wait_result::wait_result(int status)
: _status(status)
{}
process::process(::pid_t pid)
: m_pid(pid)
{}
process::~process() {
if (m_pid == -1)
return;
auto status = int{};
std::ignore = waitpid(m_pid, &status, WEXITED);
}
process::process(process &&other) noexcept
: m_pid(std::exchange(other.m_pid, -1))
{
}
auto process::operator=(this process &self, process &&other) noexcept
-> process &
{
if (&self != &other) {
self.m_pid = std::exchange(other.m_pid, -1);
}
return self;
}
// Get the child's process id.
auto process::pid(this process const &self) noexcept -> ::pid_t
{
return self.m_pid;
}
auto process::wait(this process &&self) -> std::expected<wait_result, error>
{
auto status = int{};
auto ret = waitpid(self.m_pid, &status, 0);
if (ret == -1)
return std::unexpected(error(std::errc(errno)));
return wait_result(status);
}
auto process::release(this process &&self) -> ::pid_t
{
auto const ret = self.pid();
self.m_pid = -1;
return ret;
}
} // namespace nihil
|
