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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
// file : bbot/utility -*- C++ -*-
// copyright : Copyright (c) 2014-2017 Code Synthesis Ltd
// license : TBC; see accompanying LICENSE file
#ifndef BBOT_UTILITY
#define BBOT_UTILITY
#include <memory> // make_shared()
#include <string> // to_string(), stoull()
#include <utility> // move(), forward(), declval(), make_pair()
#include <cassert> // assert()
#include <iterator> // make_move_iterator()
#include <butl/ft/lang>
#include <butl/process>
#include <butl/utility> // casecmp(), reverse_iterate(), etc
#include <butl/fdstream>
#include <butl/filesystem>
#include <bbot/types>
#include <bbot/version-impl>
namespace bbot
{
using std::move;
using std::forward;
using std::declval;
using std::make_pair;
using std::make_shared;
using std::make_move_iterator;
using std::to_string;
using std::stoull;
// <butl/utility>
//
using butl::casecmp;
using butl::reverse_iterate;
using butl::exception_guard;
using butl::make_exception_guard;
// <butl/fdstream>
//
using butl::auto_fd;
// <butl/filesystem>
//
using butl::auto_rmdir;
using butl::auto_rmfile;
// Random number generator (currently not MT-safe and limited to RAND_MAX).
//
size_t
genrand ();
template <typename T>
inline T
genrand () {return static_cast<T> (genrand ());}
// Process execution.
//
class tracer;
using butl::process;
using butl::process_exit;
using butl::process_error;
template <typename I, typename O, typename E, typename P, typename... A>
void
run_io (tracer&, I&& in, O&& out, E&& err, P&&, A&&...);
template <typename I, typename O, typename E, typename P, typename... A>
process_exit::code_type
run_io_exit (tracer&, I&& in, O&& out, E&& err, P&&, A&&...);
template <typename I, typename O, typename E, typename P, typename... A>
process
run_io_start (tracer&,
I&& in,
O&& out,
E&& err,
const dir_path& cwd,
P&&,
A&&...);
template <typename P>
void
run_io_finish (tracer&, process&, P&&);
template <typename P>
process_exit::code_type
run_io_finish_exit (tracer&, process&, P&&);
template <typename P, typename... A>
inline void
run (tracer& t, P&& p, A&&... a)
{
run_io (t, butl::fdnull (), 2, 2, forward<P> (p), forward<A> (a)...);
}
template <typename P, typename... A>
inline process_exit::code_type
run_exit (tracer& t, P&& p, A&&... a)
{
return run_io_exit (
t, butl::fdnull (), 2, 2, forward<P> (p), forward<A> (a)...);
}
void
run_trace (tracer&, const char*[], size_t);
// Manifest parsing and serialization.
//
template <typename T>
T
parse_manifest (const path&, const char* what, bool ignore_unknown = true);
template <typename T>
void
serialize_manifest (const T&, const path&, const char* what);
template <typename T>
void
serialize_manifest (const T&,
ostream&,
const string& name,
const char* what);
}
#include <bbot/utility.txx>
#endif // BBOT_UTILITY
|
