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
|
#ifndef STAR_FORMAT_HPP
#define STAR_FORMAT_HPP
#include "StarMemory.hpp"
namespace Star {
struct FormatException : public std::exception {
FormatException(std::string what) : whatmsg(move(what)) {}
char const* what() const noexcept override {
return whatmsg.c_str();
}
std::string whatmsg;
};
}
#define TINYFORMAT_ERROR(reason) throw Star::FormatException(reason)
#include "tinyformat.h"
namespace Star {
template <typename... Args>
void format(std::ostream& out, char const* fmt, Args const&... args) {
tinyformat::format(out, fmt, args...);
}
// Automatically flushes, use format to avoid flushing.
template <typename... Args>
void coutf(char const* fmt, Args const&... args) {
format(std::cout, fmt, args...);
std::cout.flush();
}
// Automatically flushes, use format to avoid flushing.
template <typename... Args>
void cerrf(char const* fmt, Args const&... args) {
format(std::cerr, fmt, args...);
std::cerr.flush();
}
template <typename... Args>
std::string strf(char const* fmt, Args const&... args) {
std::ostringstream os;
format(os, fmt, args...);
return os.str();
}
namespace OutputAnyDetail {
template<typename T, typename CharT, typename Traits>
std::basic_ostream<CharT, Traits>& output(std::basic_ostream<CharT, Traits>& os, T const& t) {
return os << "<type " << typeid(T).name() << " at address: " << &t << ">";
}
namespace Operator {
template<typename T, typename CharT, typename Traits>
std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& os, T const& t) {
return output(os, t);
}
}
template <typename T>
struct Wrapper {
T const& wrapped;
};
template <typename T>
std::ostream& operator<<(std::ostream& os, Wrapper<T> const& wrapper) {
using namespace Operator;
return os << wrapper.wrapped;
}
}
// Wraps a type so that is printable no matter what.. If no operator<< is
// defined for a type, then will print <type [typeid] at address: [address]>
template <typename T>
OutputAnyDetail::Wrapper<T> outputAny(T const& t) {
return OutputAnyDetail::Wrapper<T>{t};
}
struct OutputProxy {
typedef function<void(std::ostream&)> PrintFunction;
OutputProxy(PrintFunction p)
: print(move(p)) {}
PrintFunction print;
};
inline std::ostream& operator<<(std::ostream& os, OutputProxy const& p) {
p.print(os);
return os;
}
}
#endif
|