nlib
MpDirectWriter.h
Go to the documentation of this file.
1 
2 /*--------------------------------------------------------------------------------*
3  Project: CrossRoad
4  Copyright (C)Nintendo All rights reserved.
5 
6  These coded instructions, statements, and computer programs contain proprietary
7  information of Nintendo and/or its licensed developers and are protected by
8  national and international copyright laws. They may not be disclosed to third
9  parties or copied or duplicated in any form, in whole or in part, without the
10  prior written consent of Nintendo.
11 
12  The content herein is highly confidential and should be handled accordingly.
13  *--------------------------------------------------------------------------------*/
14 
15 #pragma once
16 #ifndef INCLUDE_NN_NLIB_MSGPACK_MPDIRECTWRITER_H_
17 #define INCLUDE_NN_NLIB_MSGPACK_MPDIRECTWRITER_H_
18 
19 #include "nn/nlib/Config.h"
20 
21 NLIB_NAMESPACE_BEGIN
22 namespace msgpack {
24  static nlib_byte_t* WriteUint8(nlib_byte_t* p, nlib_byte_t* pend, uint8_t val) NLIB_NOEXCEPT;
25  static nlib_byte_t* WriteUint16(nlib_byte_t* p, nlib_byte_t* pend, uint16_t val) NLIB_NOEXCEPT;
26  static nlib_byte_t* WriteUint32(nlib_byte_t* p, nlib_byte_t* pend, uint32_t val) NLIB_NOEXCEPT;
27  static nlib_byte_t* WriteUint64(nlib_byte_t* p, nlib_byte_t* pend, uint64_t val) NLIB_NOEXCEPT;
28  static nlib_byte_t* WriteInt8(nlib_byte_t* p, nlib_byte_t* pend, int8_t val) NLIB_NOEXCEPT;
29  static nlib_byte_t* WriteInt16(nlib_byte_t* p, nlib_byte_t* pend, int16_t val) NLIB_NOEXCEPT;
30  static nlib_byte_t* WriteInt32(nlib_byte_t* p, nlib_byte_t* pend, int32_t val) NLIB_NOEXCEPT;
31  static nlib_byte_t* WriteInt64(nlib_byte_t* p, nlib_byte_t* pend, int64_t val) NLIB_NOEXCEPT;
32  static nlib_byte_t* WriteNil(nlib_byte_t* p, nlib_byte_t* pend) NLIB_NOEXCEPT;
33  static nlib_byte_t* WriteBoolean(nlib_byte_t* p, nlib_byte_t* pend, bool val) NLIB_NOEXCEPT;
34  static nlib_byte_t* WriteFloat(nlib_byte_t* p, nlib_byte_t* pend, float val) NLIB_NOEXCEPT;
35  static nlib_byte_t* WriteDouble(nlib_byte_t* p, nlib_byte_t* pend, double val) NLIB_NOEXCEPT;
36  static nlib_byte_t*
37  WriteString(nlib_byte_t* p, nlib_byte_t* pend, const char* str, uint32_t len) NLIB_NOEXCEPT;
38  static nlib_byte_t*
39  WriteString(nlib_byte_t* p, nlib_byte_t* pend, const char* str) NLIB_NOEXCEPT;
40  static nlib_byte_t*
41  WriteStringHeader(nlib_byte_t* p, nlib_byte_t* pend, uint32_t len) NLIB_NOEXCEPT;
42  static nlib_byte_t*
43  WriteBin(nlib_byte_t* p, nlib_byte_t* pend, const nlib_byte_t* bin, uint32_t n) NLIB_NOEXCEPT;
44  static nlib_byte_t* WriteBinHeader(nlib_byte_t* p, nlib_byte_t* pend, uint32_t n) NLIB_NOEXCEPT;
45  static nlib_byte_t* WriteExt(nlib_byte_t* p, nlib_byte_t* pend, int8_t type,
46  const nlib_byte_t* data, uint32_t n) NLIB_NOEXCEPT;
47  static nlib_byte_t*
48  WriteExtHeader(nlib_byte_t* p, nlib_byte_t* pend, int8_t type, uint32_t n) NLIB_NOEXCEPT;
49  static nlib_byte_t*
50  WriteArrayHeader(nlib_byte_t* p, nlib_byte_t* pend, uint32_t count) NLIB_NOEXCEPT;
51  static nlib_byte_t*
52  WriteMapHeader(nlib_byte_t* p, nlib_byte_t* pend, uint32_t count) NLIB_NOEXCEPT;
53  static nlib_byte_t*
54  WriteUnsignedInt(nlib_byte_t* p, nlib_byte_t* pend, uint8_t val) NLIB_NOEXCEPT;
55  static nlib_byte_t*
56  WriteUnsignedInt(nlib_byte_t* p, nlib_byte_t* pend, uint16_t val) NLIB_NOEXCEPT;
57  static nlib_byte_t*
58  WriteUnsignedInt(nlib_byte_t* p, nlib_byte_t* pend, uint32_t val) NLIB_NOEXCEPT;
59  static nlib_byte_t*
60  WriteUnsignedInt(nlib_byte_t* p, nlib_byte_t* pend, uint64_t val) NLIB_NOEXCEPT;
61  static nlib_byte_t* WriteInt(nlib_byte_t* p, nlib_byte_t* pend, int8_t val) NLIB_NOEXCEPT;
62  static nlib_byte_t* WriteInt(nlib_byte_t* p, nlib_byte_t* pend, int16_t val) NLIB_NOEXCEPT;
63  static nlib_byte_t* WriteInt(nlib_byte_t* p, nlib_byte_t* pend, int32_t val) NLIB_NOEXCEPT;
64  static nlib_byte_t* WriteInt(nlib_byte_t* p, nlib_byte_t* pend, int64_t val) NLIB_NOEXCEPT;
65  static nlib_byte_t*
66  WriteTimestamp(nlib_byte_t* p, nlib_byte_t* pend, int64_t sec, uint32_t nsec) NLIB_NOEXCEPT;
67  static nlib_byte_t*
68  WriteTimestamp(nlib_byte_t* p, nlib_byte_t* pend, nlib_time val) NLIB_NOEXCEPT;
69 
70  private:
71  static NLIB_ALWAYS_INLINE void EncU16(nlib_byte_t* p, uint16_t val) NLIB_NOEXCEPT {
72 #ifdef NLIB_LITTLE_ENDIAN
73  val = nlib_bswap16(val);
74 #endif
75  nlib_memcpy(p, 2, &val, 2);
76  }
77  static NLIB_ALWAYS_INLINE void EncU32(nlib_byte_t* p, uint32_t val) NLIB_NOEXCEPT {
78 #ifdef NLIB_LITTLE_ENDIAN
79  val = nlib_bswap32(val);
80 #endif
81  nlib_memcpy(p, 4, &val, 4);
82  }
83  static NLIB_ALWAYS_INLINE void EncU64(nlib_byte_t* p, uint64_t val) NLIB_NOEXCEPT {
84 #ifdef NLIB_LITTLE_ENDIAN
85  val = nlib_bswap64(val);
86 #endif
87  nlib_memcpy(p, 8, &val, 8);
88  }
89 
90  private:
92 };
93 #define NLIB_CHK_(p, n, pend) \
94  if (NLIB_UNLIKELY((p) + (n) > (pend))) { \
95  NLIB_ASSERT((p) + (n) <= (pend)); \
96  return nullptr; \
97  }
98 
100 MpDirectWriter::WriteUint8(nlib_byte_t* p, nlib_byte_t* pend, uint8_t val) NLIB_NOEXCEPT {
101  NLIB_CHK_(p, 2, pend);
102  if (NLIB_UNLIKELY(p + 2 > pend)) return nullptr;
103  p[0] = static_cast<nlib_byte_t>(0xcc);
104  p[1] = static_cast<nlib_byte_t>(val);
105  return p + 2;
106 }
108 MpDirectWriter::WriteUint16(nlib_byte_t* p, nlib_byte_t* pend, uint16_t val) NLIB_NOEXCEPT {
109  NLIB_CHK_(p, 3, pend);
110  p[0] = static_cast<nlib_byte_t>(0xcd);
111  EncU16(p + 1, val);
112  return p + 3;
113 }
115 MpDirectWriter::WriteUint32(nlib_byte_t* p, nlib_byte_t* pend, uint32_t val) NLIB_NOEXCEPT {
116  NLIB_CHK_(p, 5, pend);
117  p[0] = static_cast<nlib_byte_t>(0xce);
118  EncU32(p + 1, val);
119  return p + 5;
120 }
122 MpDirectWriter::WriteUint64(nlib_byte_t* p, nlib_byte_t* pend, uint64_t val) NLIB_NOEXCEPT {
123  NLIB_CHK_(p, 9, pend);
124  p[0] = static_cast<nlib_byte_t>(0xcf);
125  EncU64(p + 1, val);
126  return p + 9;
127 }
129 MpDirectWriter::WriteInt8(nlib_byte_t* p, nlib_byte_t* pend, int8_t val) NLIB_NOEXCEPT {
130  NLIB_CHK_(p, 2, pend);
131  p[0] = static_cast<nlib_byte_t>(0xd0);
132  p[1] = static_cast<nlib_byte_t>(val);
133  return p + 2;
134 }
136 MpDirectWriter::WriteInt16(nlib_byte_t* p, nlib_byte_t* pend, int16_t val) NLIB_NOEXCEPT {
137  NLIB_CHK_(p, 3, pend);
138  p[0] = static_cast<nlib_byte_t>(0xd1);
139  EncU16(p + 1, static_cast<uint16_t>(val));
140  return p + 3;
141 }
143 MpDirectWriter::WriteInt32(nlib_byte_t* p, nlib_byte_t* pend, int32_t val) NLIB_NOEXCEPT {
144  NLIB_CHK_(p, 5, pend);
145  p[0] = static_cast<nlib_byte_t>(0xd2);
146  EncU32(p + 1, static_cast<uint32_t>(val));
147  return p + 5;
148 }
150 MpDirectWriter::WriteInt64(nlib_byte_t* p, nlib_byte_t* pend, int64_t val) NLIB_NOEXCEPT {
151  NLIB_CHK_(p, 9, pend);
152  p[0] = static_cast<nlib_byte_t>(0xd3);
153  EncU64(p + 1, static_cast<uint64_t>(val));
154  return p + 9;
155 }
157 MpDirectWriter::WriteNil(nlib_byte_t* p, nlib_byte_t* pend) NLIB_NOEXCEPT {
158  NLIB_CHK_(p, 1, pend);
159  *p = static_cast<nlib_byte_t>(0xc0);
160  return p + 1;
161 }
163 MpDirectWriter::WriteBoolean(nlib_byte_t* p, nlib_byte_t* pend, bool val) NLIB_NOEXCEPT {
164  NLIB_CHK_(p, 1, pend);
165  *p = static_cast<nlib_byte_t>(val ? 0xc3 : 0xc2);
166  return p + 1;
167 }
169 MpDirectWriter::WriteFloat(nlib_byte_t* p, nlib_byte_t* pend, float val) NLIB_NOEXCEPT {
170  NLIB_CHK_(p, 5, pend);
171  p[0] = static_cast<nlib_byte_t>(0xca);
172  union {
173  float f32;
174  uint32_t u32;
175  } tmp;
176  tmp.f32 = val;
177  EncU32(p + 1, tmp.u32);
178  return p + 5;
179 }
181 MpDirectWriter::WriteDouble(nlib_byte_t* p, nlib_byte_t* pend, double val) NLIB_NOEXCEPT {
182  NLIB_CHK_(p, 9, pend);
183  p[0] = static_cast<nlib_byte_t>(0xcb);
184  union {
185  double f64;
186  uint64_t u64;
187  } tmp;
188  tmp.f64 = val;
189  EncU64(p + 1, tmp.u64);
190  return p + 9;
191 }
192 inline nlib_byte_t*
193 MpDirectWriter::WriteStringHeader(nlib_byte_t* p, nlib_byte_t* pend, uint32_t len) NLIB_NOEXCEPT {
194  if (len < 32U) {
195  NLIB_CHK_(p, 1, pend);
196  p[0] = static_cast<nlib_byte_t>(0xa0 | len);
197  return p + 1;
198  } else if (len < 256U) {
199  NLIB_CHK_(p, 2, pend);
200  p[0] = static_cast<nlib_byte_t>(0xd9);
201  p[1] = static_cast<nlib_byte_t>(len);
202  return p + 2;
203  } else if (len < 65536U) {
204  NLIB_CHK_(p, 3, pend);
205  p[0] = static_cast<nlib_byte_t>(0xda);
206  EncU16(p + 1, static_cast<uint16_t>(len));
207  return p + 3;
208  } else {
209  NLIB_CHK_(p, 5, pend);
210  p[0] = static_cast<nlib_byte_t>(0xdb);
211  EncU32(p + 1, len);
212  return p + 5;
213  }
214 }
215 inline nlib_byte_t* MpDirectWriter::WriteString(nlib_byte_t* p, nlib_byte_t* pend, const char* str,
216  uint32_t len) NLIB_NOEXCEPT {
217  if (len < 32U) {
218  NLIB_CHK_(p, 1 + len, pend);
219  p[0] = static_cast<nlib_byte_t>(0xa0 | len);
220  nlib_memcpy(p + 1, len, str, len);
221  return p + 1 + len;
222  } else if (len < 256U) {
223  NLIB_CHK_(p, 2 + len, pend);
224  p[0] = static_cast<nlib_byte_t>(0xd9);
225  p[1] = static_cast<nlib_byte_t>(len);
226  nlib_memcpy(p + 2, len, str, len);
227  return p + 2 + len;
228  } else if (len < 65536U) {
229  NLIB_CHK_(p, 3 + len, pend);
230  p[0] = static_cast<nlib_byte_t>(0xda);
231  EncU16(p + 1, static_cast<uint16_t>(len));
232  nlib_memcpy(p + 3, len, str, len);
233  return p + 3 + len;
234  } else {
235  NLIB_CHK_(p, 5 + len, pend);
236  p[0] = static_cast<nlib_byte_t>(0xdb);
237  EncU32(p + 1, len);
238  nlib_memcpy(p + 5, len, str, len);
239  return p + 5 + len;
240  }
241 }
242 inline nlib_byte_t*
243 MpDirectWriter::WriteString(nlib_byte_t* p, nlib_byte_t* pend, const char* str) NLIB_NOEXCEPT {
244  return WriteString(p, pend, str, static_cast<uint32_t>(nlib_strlen(str)));
245 }
246 inline nlib_byte_t*
247 MpDirectWriter::WriteBinHeader(nlib_byte_t* p, nlib_byte_t* pend, uint32_t n) NLIB_NOEXCEPT {
248  if (n < 256U) {
249  NLIB_CHK_(p, 2, pend);
250  p[0] = static_cast<nlib_byte_t>(0xc4);
251  p[1] = static_cast<nlib_byte_t>(n);
252  return p + 2;
253  } else if (n < 65536U) {
254  NLIB_CHK_(p, 3, pend);
255  p[0] = static_cast<nlib_byte_t>(0xc5);
256  EncU16(p + 1, static_cast<uint16_t>(n));
257  return p + 3;
258  } else {
259  NLIB_CHK_(p, 5, pend);
260  p[0] = static_cast<nlib_byte_t>(0xc6);
261  EncU32(p + 1, n);
262  return p + 5;
263  }
264 }
265 inline nlib_byte_t* MpDirectWriter::WriteBin(nlib_byte_t* p, nlib_byte_t* pend,
266  const nlib_byte_t* bin, uint32_t n) NLIB_NOEXCEPT {
267  if (n < 256U) {
268  NLIB_CHK_(p, 2 + n, pend);
269  p[0] = static_cast<nlib_byte_t>(0xc4);
270  p[1] = static_cast<nlib_byte_t>(n);
271  nlib_memcpy(p + 2, n, bin, n);
272  return p + 2 + n;
273  } else if (n < 65536U) {
274  NLIB_CHK_(p, 3 + n, pend);
275  p[0] = static_cast<nlib_byte_t>(0xc5);
276  EncU16(p + 1, static_cast<uint16_t>(n));
277  nlib_memcpy(p + 3, n, bin, n);
278  return p + 3 + n;
279  } else {
280  NLIB_CHK_(p, 5 + n, pend);
281  p[0] = static_cast<nlib_byte_t>(0xc6);
282  EncU32(p + 1, n);
283  nlib_memcpy(p + 5, n, bin, n);
284  return p + 5 + n;
285  }
286 }
287 inline nlib_byte_t* MpDirectWriter::WriteExtHeader(nlib_byte_t* p, nlib_byte_t* pend, int8_t type,
288  uint32_t n) NLIB_NOEXCEPT {
289  if (n < 256U) {
290  switch (n) {
291  case 1:
292  NLIB_CHK_(p, 2, pend);
293  p[0] = static_cast<nlib_byte_t>(0xd4);
294  p[1] = static_cast<nlib_byte_t>(type);
295  return p + 2;
296  case 2:
297  NLIB_CHK_(p, 2, pend);
298  p[0] = static_cast<nlib_byte_t>(0xd5);
299  p[1] = static_cast<nlib_byte_t>(type);
300  return p + 2;
301  case 4:
302  NLIB_CHK_(p, 2, pend);
303  p[0] = static_cast<nlib_byte_t>(0xd6);
304  p[1] = static_cast<nlib_byte_t>(type);
305  return p + 2;
306  case 8:
307  NLIB_CHK_(p, 2, pend);
308  p[0] = static_cast<nlib_byte_t>(0xd7);
309  p[1] = static_cast<nlib_byte_t>(type);
310  return p + 2;
311  case 16:
312  NLIB_CHK_(p, 2, pend);
313  p[0] = static_cast<nlib_byte_t>(0xd8);
314  p[1] = static_cast<nlib_byte_t>(type);
315  return p + 2;
316  default:
317  NLIB_CHK_(p, 3 + n, pend);
318  p[0] = static_cast<nlib_byte_t>(0xc7);
319  p[1] = static_cast<nlib_byte_t>(n);
320  p[2] = static_cast<nlib_byte_t>(type);
321  return p + 3;
322  }
323  } else if (n < 65536U) {
324  NLIB_CHK_(p, 4, pend);
325  p[0] = static_cast<nlib_byte_t>(0xc8);
326  EncU16(p + 1, static_cast<uint16_t>(n));
327  p[3] = static_cast<nlib_byte_t>(type);
328  return p + 4;
329  } else {
330  NLIB_CHK_(p, 6, pend);
331  p[0] = static_cast<nlib_byte_t>(0xc9);
332  EncU32(p + 1, n);
333  p[5] = static_cast<nlib_byte_t>(type);
334  return p + 6;
335  }
336 }
337 inline nlib_byte_t* MpDirectWriter::WriteExt(nlib_byte_t* p, nlib_byte_t* pend, int8_t type,
338  const nlib_byte_t* data, uint32_t n) NLIB_NOEXCEPT {
339  if (n < 256U) {
340  switch (n) {
341  case 1:
342  NLIB_CHK_(p, 3, pend);
343  p[0] = static_cast<nlib_byte_t>(0xd4);
344  p[1] = static_cast<nlib_byte_t>(type);
345  p[2] = data[0];
346  return p + 3;
347  case 2:
348  NLIB_CHK_(p, 4, pend);
349  p[0] = static_cast<nlib_byte_t>(0xd5);
350  p[1] = static_cast<nlib_byte_t>(type);
351  p[2] = data[0];
352  p[3] = data[1];
353  return p + 4;
354  case 4:
355  NLIB_CHK_(p, 6, pend);
356  p[0] = static_cast<nlib_byte_t>(0xd6);
357  p[1] = static_cast<nlib_byte_t>(type);
358  nlib_memcpy(p + 2, 4, data, 4);
359  return p + 6;
360  case 8:
361  NLIB_CHK_(p, 10, pend);
362  p[0] = static_cast<nlib_byte_t>(0xd7);
363  p[1] = static_cast<nlib_byte_t>(type);
364  nlib_memcpy(p + 2, 8, data, 8);
365  return p + 10;
366  case 16:
367  NLIB_CHK_(p, 18, pend);
368  p[0] = static_cast<nlib_byte_t>(0xd8);
369  p[1] = static_cast<nlib_byte_t>(type);
370  nlib_memcpy(p + 2, 16, data, 16);
371  return p + 18;
372  default:
373  NLIB_CHK_(p, 3 + n, pend);
374  p[0] = static_cast<nlib_byte_t>(0xc7);
375  p[1] = static_cast<nlib_byte_t>(n);
376  p[2] = static_cast<nlib_byte_t>(type);
377  nlib_memcpy(p + 3, n, data, n);
378  return p + 3 + n;
379  }
380  } else if (n < 65536U) {
381  NLIB_CHK_(p, 4 + n, pend);
382  p[0] = static_cast<nlib_byte_t>(0xc8);
383  EncU16(p + 1, static_cast<uint16_t>(n));
384  p[3] = static_cast<nlib_byte_t>(type);
385  nlib_memcpy(p + 4, n, data, n);
386  return p + 4 + n;
387  } else {
388  NLIB_CHK_(p, 6 + n, pend);
389  p[0] = static_cast<nlib_byte_t>(0xc9);
390  EncU32(p + 1, n);
391  p[5] = static_cast<nlib_byte_t>(type);
392  nlib_memcpy(p + 6, n, data, n);
393  return p + 6 + n;
394  }
395 }
396 inline nlib_byte_t*
397 MpDirectWriter::WriteArrayHeader(nlib_byte_t* p, nlib_byte_t* pend, uint32_t count) NLIB_NOEXCEPT {
398  if (count < 16U) {
399  NLIB_CHK_(p, 1, pend);
400  *p = static_cast<nlib_byte_t>(0x90 | count);
401  return p + 1;
402  } else if (count < 65536U) {
403  NLIB_CHK_(p, 3, pend);
404  p[0] = static_cast<nlib_byte_t>(0xdc);
405  EncU16(p + 1, static_cast<uint16_t>(count));
406  return p + 3;
407  } else {
408  NLIB_CHK_(p, 5, pend);
409  p[0] = static_cast<nlib_byte_t>(0xdd);
410  EncU32(p + 1, count);
411  return p + 5;
412  }
413 }
414 inline nlib_byte_t*
415 MpDirectWriter::WriteMapHeader(nlib_byte_t* p, nlib_byte_t* pend, uint32_t count) NLIB_NOEXCEPT {
416  if (count < 16U) {
417  NLIB_CHK_(p, 1, pend);
418  *p = static_cast<nlib_byte_t>(0x80 | count);
419  return p + 1;
420  } else if (count < 65536U) {
421  NLIB_CHK_(p, 3, pend);
422  p[0] = static_cast<nlib_byte_t>(0xde);
423  EncU16(p + 1, static_cast<uint16_t>(count));
424  return p + 3;
425  } else {
426  NLIB_CHK_(p, 5, pend);
427  p[0] = static_cast<nlib_byte_t>(0xdf);
428  EncU32(p + 1, count);
429  return p + 5;
430  }
431 }
432 inline nlib_byte_t*
433 MpDirectWriter::WriteUnsignedInt(nlib_byte_t* p, nlib_byte_t* pend, uint8_t val) NLIB_NOEXCEPT {
434  if (val < 128U) {
435  NLIB_CHK_(p, 1, pend);
436  p[0] = static_cast<nlib_byte_t>(val);
437  return p + 1;
438  } else {
439  return WriteUint8(p, pend, static_cast<uint8_t>(val));
440  }
441 }
442 inline nlib_byte_t*
443 MpDirectWriter::WriteUnsignedInt(nlib_byte_t* p, nlib_byte_t* pend, uint16_t val) NLIB_NOEXCEPT {
444  if (val < 128U) {
445  NLIB_CHK_(p, 1, pend);
446  p[0] = static_cast<nlib_byte_t>(val);
447  return p + 1;
448  } else if (val < 256U) {
449  return WriteUint8(p, pend, static_cast<uint8_t>(val));
450  } else {
451  return WriteUint16(p, pend, static_cast<uint16_t>(val));
452  }
453 }
454 inline nlib_byte_t*
455 MpDirectWriter::WriteUnsignedInt(nlib_byte_t* p, nlib_byte_t* pend, uint32_t val) NLIB_NOEXCEPT {
456  if (val < 256U) {
457  if (val < 128U) {
458  NLIB_CHK_(p, 1, pend);
459  p[0] = static_cast<nlib_byte_t>(val);
460  return p + 1;
461  } else {
462  return WriteUint8(p, pend, static_cast<uint8_t>(val));
463  }
464  } else if (val < 65536U) {
465  return WriteUint16(p, pend, static_cast<uint16_t>(val));
466  } else {
467  return WriteUint32(p, pend, val);
468  }
469 }
470 inline nlib_byte_t*
471 MpDirectWriter::WriteUnsignedInt(nlib_byte_t* p, nlib_byte_t* pend, uint64_t val) NLIB_NOEXCEPT {
472  if (val < 0x100000000ULL) {
473  return WriteUnsignedInt(p, pend, static_cast<uint32_t>(val));
474  } else {
475  return WriteUint64(p, pend, val);
476  }
477 }
478 inline nlib_byte_t*
479 MpDirectWriter::WriteInt(nlib_byte_t* p, nlib_byte_t* pend, int8_t val) NLIB_NOEXCEPT {
480  if (val < -32) {
481  return WriteInt8(p, pend, static_cast<int8_t>(val));
482  } else {
483  NLIB_CHK_(p, 1, pend);
484  p[0] = static_cast<nlib_byte_t>(val);
485  return p + 1;
486  }
487 }
488 inline nlib_byte_t*
489 MpDirectWriter::WriteInt(nlib_byte_t* p, nlib_byte_t* pend, int16_t val) NLIB_NOEXCEPT {
490  if (val < 0) {
491  if (val < INT8_MIN) {
492  return WriteInt16(p, pend, static_cast<int16_t>(val));
493  } else if (val < -32) {
494  return WriteInt8(p, pend, static_cast<int8_t>(val));
495  } else {
496  NLIB_CHK_(p, 1, pend);
497  p[0] = static_cast<nlib_byte_t>(val);
498  return p + 1;
499  }
500  } else {
501  return WriteUnsignedInt(p, pend, static_cast<uint16_t>(val));
502  }
503 }
504 inline nlib_byte_t*
505 MpDirectWriter::WriteInt(nlib_byte_t* p, nlib_byte_t* pend, int32_t val) NLIB_NOEXCEPT {
506  if (val < 0) {
507  if (val < INT8_MIN) {
508  if (val < INT16_MIN) {
509  return WriteInt32(p, pend, val);
510  } else {
511  return WriteInt16(p, pend, static_cast<int16_t>(val));
512  }
513  } else if (val < -32) {
514  return WriteInt8(p, pend, static_cast<int8_t>(val));
515  } else {
516  NLIB_CHK_(p, 1, pend);
517  p[0] = static_cast<nlib_byte_t>(val);
518  return p + 1;
519  }
520  } else {
521  return WriteUnsignedInt(p, pend, static_cast<uint32_t>(val));
522  }
523 }
524 inline nlib_byte_t*
525 MpDirectWriter::WriteInt(nlib_byte_t* p, nlib_byte_t* pend, int64_t val) NLIB_NOEXCEPT {
526  if (val < 0) {
527  if (val < INT32_MIN) {
528  return WriteInt64(p, pend, val);
529  } else {
530  return WriteInt(p, pend, static_cast<int32_t>(val));
531  }
532  } else {
533  return WriteUnsignedInt(p, pend, static_cast<uint64_t>(val));
534  }
535 }
536 inline nlib_byte_t* MpDirectWriter::WriteTimestamp(nlib_byte_t* p, nlib_byte_t* pend, int64_t sec,
537  uint32_t nsec) NLIB_NOEXCEPT {
538  if (NLIB_LIKELY((sec >> 34) == 0)) {
539  uint64_t data64 = (static_cast<uint64_t>(nsec) << 34) | static_cast<uint64_t>(sec);
540  if (data64 < 0x100000000ULL) {
541  // timestamp 32
542  NLIB_CHK_(p, 6, pend);
543  p[0] = static_cast<nlib_byte_t>(0xd6);
544  p[1] = static_cast<nlib_byte_t>(-1);
545  EncU32(p + 2, static_cast<uint32_t>(data64));
546  return p + 6;
547  } else {
548  // timestamp 64
549  NLIB_CHK_(p, 10, pend);
550  p[0] = static_cast<nlib_byte_t>(0xd7);
551  p[1] = static_cast<nlib_byte_t>(-1);
552  EncU64(p + 2, data64);
553  return p + 10;
554  }
555  }
556  // timestamp96
557  NLIB_CHK_(p, 15, pend);
558  p[0] = static_cast<nlib_byte_t>(0xc7);
559  p[1] = static_cast<nlib_byte_t>(12);
560  p[2] = static_cast<nlib_byte_t>(-1);
561  EncU32(p + 3, static_cast<uint32_t>(nsec));
562  EncU64(p + 7, static_cast<uint64_t>(sec));
563  return p + 15;
564 }
565 inline nlib_byte_t*
566 MpDirectWriter::WriteTimestamp(nlib_byte_t* p, nlib_byte_t* pend, nlib_time val) NLIB_NOEXCEPT {
567  int64_t sec;
568  uint32_t nsec;
569  NLIB_TO_SEC_NSEC(sec, nsec, val);
570  return WriteTimestamp(p, pend, sec, nsec);
571 }
572 
573 #undef NLIB_CHK_
574 } // namespace msgpack
575 NLIB_NAMESPACE_END
576 
577 #endif // INCLUDE_NN_NLIB_MSGPACK_MPDIRECTWRITER_H_
#define NLIB_ALWAYS_INLINE
Indicates that the compiler is forced to perform inline expansion of functions.
Definition: Platform_unix.h:95
static uint16_t nlib_bswap16(uint16_t x)
Returns __builtin_bswap16(x) or _byteswap_ushort(x).
Definition: Platform.h:2313
#define NLIB_UNLIKELY(x)
Indicates to the compiler that condition x is likely to be false.
Definition: Platform_unix.h:98
int64_t nlib_time
The type expressing the time in increments of 100 ns from the zero starting point of 1970-01-01...
Definition: Platform.h:452
static uint64_t nlib_bswap64(uint64_t x)
Returns __builtin_bswap64(x) or _byteswap_uint64(x).
Definition: Platform.h:2315
#define NLIB_LIKELY(x)
Indicates to the compiler that condition x is likely to be true.
Definition: Platform_unix.h:97
#define NLIB_NOEXCEPT
Defines noexcept geared to the environment, or the equivalent.
Definition: Config.h:109
A file that contains the configuration information for each development environment.
size_t nlib_strlen(const char *s)
Internally calls strlen(). In some cases, it may operate as an independent implementation.
static uint32_t nlib_bswap32(uint32_t x)
Returns __builtin_bswap32(x) or _byteswap_ulong(x).
Definition: Platform.h:2314
Defines various static member functions for directly writing MessagePack into memory.
unsigned char nlib_byte_t
This type will be defined as std::byte in a typedef of C++17 or later.
Definition: Platform.h:314