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
135
136
137
138
139
140
141
142
|
#ifndef UTILS_HPP
#define UTILS_HPP
#include "../sanity.hpp"
#include <cstdio>
#include <cstring>
#include <type_traits>
#include "../strings/fwd.hpp"
#include "../strings/vstring.hpp"
#include "../io/fwd.hpp"
#include "const_array.hpp"
#include "operators.hpp"
#include "utils2.hpp"
template<class T>
struct is_trivially_copyable
: std::integral_constant<bool,
// come back when GCC actually implements the public traits properly
__has_trivial_copy(T)
&& __has_trivial_assign(T)
&& __has_trivial_destructor(T)>
{};
bool e_mail_check(XString email);
int config_switch (ZString str);
bool split_key_value(ZString line, XString *w1, ZString *w2);
inline
void really_memcpy(uint8_t *dest, const uint8_t *src, size_t n)
{
memcpy(dest, src, n);
}
inline
void really_memmove(uint8_t *dest, const uint8_t *src, size_t n)
{
memmove(dest, src, n);
}
inline
bool really_memequal(const uint8_t *a, const uint8_t *b, size_t n)
{
return memcmp(a, b, n) == 0;
}
inline
void really_memset0(uint8_t *dest, size_t n)
{
memset(dest, '\0', n);
}
template<class T>
void really_memzero_this(T *v)
{
static_assert(is_trivially_copyable<T>::value, "only for mostly-pod types");
static_assert(std::is_class<T>::value || std::is_union<T>::value, "Only for user-defined structures (for now)");
memset(v, '\0', sizeof(*v));
}
template<class T, size_t n>
void really_memzero_this(T (&)[n]) = delete;
// Exists in place of time_t, to give it a predictable printf-format.
// (on x86 and amd64, time_t == long, but not on x32)
static_assert(sizeof(long long) >= sizeof(time_t), "long long >= time_t");
struct TimeT : Comparable
{
long long value;
// conversion
TimeT(time_t t=0) : value(t) {}
TimeT(struct tm t) : value(timegm(&t)) {}
operator time_t() const { return value; }
operator struct tm() const { time_t v = value; return *gmtime(&v); }
explicit operator bool() const { return value; }
bool operator !() const { return !value; }
// prevent surprises
template<class T>
TimeT(T) = delete;
template<class T>
operator T() const = delete;
static
TimeT now()
{
// poisoned, but this is still in header-land
return time(NULL);
}
bool error() const
{
return value == -1;
}
bool okay() const
{
return !error();
}
};
inline
long long convert_for_printf(TimeT t)
{
return t.value;
}
inline
long long& convert_for_scanf(TimeT& t)
{
return t.value;
}
struct timestamp_seconds_buffer : VString<19> {};
struct timestamp_milliseconds_buffer : VString<23> {};
void stamp_time(timestamp_seconds_buffer&, const TimeT *t=nullptr);
void stamp_time(timestamp_milliseconds_buffer&);
void log_with_timestamp(io::WriteFile& out, XString line);
// TODO VString?
#define TIMESTAMP_DUMMY "YYYY-MM-DD HH:MM:SS"
static_assert(sizeof(TIMESTAMP_DUMMY) == sizeof(timestamp_seconds_buffer),
"timestamp size");
#define WITH_TIMESTAMP(str) str TIMESTAMP_DUMMY
// str: prefix: YYYY-MM-DD HH:MM:SS
// sizeof: 01234567890123456789012345678
// str + sizeof: ^
// -1: ^
// there's probably a better way to do this now
#define REPLACE_TIMESTAMP(str, t) \
stamp_time( \
reinterpret_cast<timestamp_seconds_buffer *>( \
str + sizeof(str) \
)[-1], \
&t \
)
#endif //UTILS_HPP
|
