23
23
#include < xrpl/beast/utility/instrumentation.h>
24
24
25
25
#include < charconv>
26
- #include < string>
27
26
#include < source_location>
28
27
#include < sstream>
28
+ #include < string>
29
+ #include < string_view>
29
30
#include < utility>
30
31
31
32
namespace ripple ::log {
@@ -88,44 +89,57 @@ class SimpleJsonWriter
88
89
void
89
90
startObject () const
90
91
{
91
- stream_.append ( " { " , 1 );
92
+ stream_.push_back ( ' { ' );
92
93
}
93
94
void
94
95
endObject () const
95
96
{
97
+ using namespace std ::string_view_literals;
96
98
stream_.pop_back ();
97
- stream_.append (" }," , 2 );
99
+ stream_.append (" }," sv );
98
100
}
99
101
void
100
102
writeKey (std::string_view key) const
101
103
{
102
104
writeString (key);
103
- * stream_.rbegin () = ' :' ;
105
+ stream_.back () = ' :' ;
104
106
}
105
107
void
106
108
startArray () const
107
109
{
108
- stream_.append ( " [ " , 1 );
110
+ stream_.push_back ( ' [ ' );
109
111
}
110
112
void
111
113
endArray () const
112
114
{
115
+ using namespace std ::string_view_literals;
113
116
stream_.pop_back ();
114
- stream_.append (" ]," , 2 );
117
+ stream_.append (" ]," sv );
115
118
}
116
119
void
117
120
writeString (std::string_view str) const
118
121
{
122
+ using namespace std ::string_view_literals;
119
123
stream_.push_back (' "' );
120
124
escape (str, stream_);
121
- stream_.append (" \" ," , 2 );
125
+ stream_.append (" \" ," sv);
126
+ }
127
+ std::string_view
128
+ writeInt (std::int32_t val) const
129
+ {
130
+ return pushNumber (val, stream_);
122
131
}
123
132
std::string_view
124
133
writeInt (std::int64_t val) const
125
134
{
126
135
return pushNumber (val, stream_);
127
136
}
128
137
std::string_view
138
+ writeUInt (std::uint32_t val) const
139
+ {
140
+ return pushNumber (val, stream_);
141
+ }
142
+ std::string_view
129
143
writeUInt (std::uint64_t val) const
130
144
{
131
145
return pushNumber (val, stream_);
@@ -138,38 +152,39 @@ class SimpleJsonWriter
138
152
std::string_view
139
153
writeBool (bool val) const
140
154
{
141
- auto str = val ? " true," : " false," ;
142
- stream_.append (str, std::strlen (str));
155
+ using namespace std ::string_view_literals;
156
+ auto str = val ? " true," sv : " false," sv;
157
+ stream_.append (str);
143
158
return str;
144
159
}
145
160
void
146
161
writeNull () const
147
162
{
148
- stream_. append ( " null " , std::strlen ( " null " )) ;
149
- stream_.push_back ( ' , ' );
163
+ using namespace std ::string_view_literals ;
164
+ stream_.append ( " null, " sv );
150
165
}
151
166
void
152
167
writeRaw (std::string_view str) const
153
168
{
154
169
stream_.append (str);
155
170
}
156
171
157
- [[nodiscard]] std::string
172
+ [[nodiscard]] std::string_view
158
173
finish ()
159
174
{
160
- stream_.pop_back ();
161
- return stream_;
175
+ return std::string_view{stream_.c_str (), stream_.size () - 1 };
162
176
}
163
177
164
178
private:
165
179
template <typename T>
166
180
static std::string_view
167
181
pushNumber (T val, std::string& stream)
168
182
{
169
- static char buffer[128 ];
183
+ thread_local char buffer[128 ];
170
184
auto result = std::to_chars (std::begin (buffer), std::end (buffer), val);
171
- *result.ptr = ' ,' ;
172
- auto len = result.ptr - std::begin (buffer);
185
+ auto ptr = result.ptr ;
186
+ *ptr = ' ,' ;
187
+ auto len = ptr - std::begin (buffer);
173
188
stream.append (buffer, len + 1 );
174
189
return {buffer, static_cast <size_t >(len)};
175
190
}
@@ -179,17 +194,19 @@ class SimpleJsonWriter
179
194
{
180
195
static constexpr char HEX[] = " 0123456789ABCDEF" ;
181
196
182
- const char * p = str.data ();
183
- const char * end = p + str.size ();
184
- const char * chunk = p;
197
+ char const * p = str.data ();
198
+ char const * end = p + str.size ();
199
+ char const * chunk = p;
185
200
186
- while (p < end) {
201
+ while (p < end)
202
+ {
187
203
auto c = static_cast <unsigned char >(*p);
188
204
189
205
// JSON requires escaping for <0x20 and the two specials below.
190
206
bool needsEscape = (c < 0x20 ) || (c == ' "' ) || (c == ' \\ ' );
191
207
192
- if (!needsEscape) {
208
+ if (!needsEscape)
209
+ {
193
210
++p;
194
211
continue ;
195
212
}
@@ -198,21 +215,33 @@ class SimpleJsonWriter
198
215
if (chunk != p)
199
216
os.append (chunk, p - chunk);
200
217
201
- switch (c) {
202
- case ' "' : os.append (" \\\" " , 2 ); break ;
203
- case ' \\ ' : os.append (" \\\\ " , 2 ); break ;
204
- case ' \b ' : os.append (" \\ b" , 2 ); break ;
205
- case ' \f ' : os.append (" \\ f" , 2 ); break ;
206
- case ' \n ' : os.append (" \\ n" , 2 ); break ;
207
- case ' \r ' : os.append (" \\ r" , 2 ); break ;
208
- case ' \t ' : os.append (" \\ t" , 2 ); break ;
218
+ switch (c)
219
+ {
220
+ case ' "' :
221
+ os.append (" \\\" " , 2 );
222
+ break ;
223
+ case ' \\ ' :
224
+ os.append (" \\\\ " , 2 );
225
+ break ;
226
+ case ' \b ' :
227
+ os.append (" \\ b" , 2 );
228
+ break ;
229
+ case ' \f ' :
230
+ os.append (" \\ f" , 2 );
231
+ break ;
232
+ case ' \n ' :
233
+ os.append (" \\ n" , 2 );
234
+ break ;
235
+ case ' \r ' :
236
+ os.append (" \\ r" , 2 );
237
+ break ;
238
+ case ' \t ' :
239
+ os.append (" \\ t" , 2 );
240
+ break ;
209
241
default : {
210
242
// Other C0 controls -> \u00XX (JSON compliant)
211
243
char buf[6 ]{
212
- ' \\ ' ,' u' ,' 0' ,' 0' ,
213
- HEX[(c >> 4 ) & 0xF ],
214
- HEX[c & 0xF ]
215
- };
244
+ ' \\ ' , ' u' , ' 0' , ' 0' , HEX[(c >> 4 ) & 0xF ], HEX[c & 0xF ]};
216
245
os.append (buf, 6 );
217
246
break ;
218
247
}
@@ -288,6 +317,7 @@ class Journal
288
317
public:
289
318
JsonLogContext () : messageParamsWriter_(buffer_)
290
319
{
320
+ buffer_.reserve (1024 * 5 );
291
321
}
292
322
293
323
SimpleJsonWriter&
@@ -300,7 +330,7 @@ class Journal
300
330
reset (
301
331
std::source_location location,
302
332
severities::Severity severity,
303
- std::string const & journalAttributesJson) noexcept ;
333
+ std::string_view journalAttributesJson) noexcept ;
304
334
};
305
335
306
336
private:
@@ -323,7 +353,7 @@ class Journal
323
353
std::source_location location,
324
354
severities::Severity severity) const ;
325
355
326
- static std::string
356
+ static std::string_view
327
357
formatLog (std::string&& message);
328
358
329
359
public:
@@ -830,9 +860,10 @@ namespace ripple::log {
830
860
namespace detail {
831
861
832
862
template <typename T>
833
- concept CanToChars = requires (T val)
834
- {
835
- { to_chars (std::declval<char *>(), std::declval<char *>(), val) } -> std::convertible_to<std::to_chars_result>;
863
+ concept CanToChars = requires (T val) {
864
+ {
865
+ to_chars (std::declval<char *>(), std::declval<char *>(), val)
866
+ } -> std::convertible_to<std::to_chars_result>;
836
867
};
837
868
838
869
template <typename T>
@@ -901,7 +932,8 @@ setJsonValue(
901
932
if constexpr (CanToChars<ValueType>)
902
933
{
903
934
char buffer[1024 ];
904
- std::to_chars_result result = to_chars (std::begin (buffer), std::end (buffer), value);
935
+ std::to_chars_result result =
936
+ to_chars (std::begin (buffer), std::end (buffer), value);
905
937
if (result.ec == std::errc{})
906
938
{
907
939
std::string_view sv;
@@ -925,7 +957,8 @@ setJsonValue(
925
957
926
958
if (outStream)
927
959
{
928
- outStream->write (str.c_str (), static_cast <std::streamsize>(str.size ()));
960
+ outStream->write (
961
+ str.c_str (), static_cast <std::streamsize>(str.size ()));
929
962
}
930
963
}
931
964
}
0 commit comments