nlib
MpDirectWriter.h
[詳解]
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* WriteString(nlib_byte_t* p, nlib_byte_t* pend,
37  const char* str, uint32_t len) NLIB_NOEXCEPT;
38  static nlib_byte_t* WriteString(nlib_byte_t* p, nlib_byte_t* pend,
39  const char* str) NLIB_NOEXCEPT;
40  static nlib_byte_t* WriteStringHeader(nlib_byte_t* p, nlib_byte_t* pend,
41  uint32_t len) NLIB_NOEXCEPT;
42  static nlib_byte_t* WriteBin(nlib_byte_t* p, nlib_byte_t* pend,
43  const nlib_byte_t* bin, uint32_t n) NLIB_NOEXCEPT;
44  static nlib_byte_t* WriteBinHeader(nlib_byte_t* p, nlib_byte_t* pend,
45  uint32_t n) NLIB_NOEXCEPT;
46  static nlib_byte_t* WriteExt(nlib_byte_t* p, nlib_byte_t* pend, int8_t type,
47  const nlib_byte_t* data, uint32_t n) NLIB_NOEXCEPT;
48  static nlib_byte_t* WriteExtHeader(nlib_byte_t* p, nlib_byte_t* pend, int8_t type,
49  uint32_t n) NLIB_NOEXCEPT;
50  static nlib_byte_t* WriteArrayHeader(nlib_byte_t* p, nlib_byte_t* pend,
51  uint32_t count) NLIB_NOEXCEPT;
52  static nlib_byte_t* WriteMapHeader(nlib_byte_t* p, nlib_byte_t* pend,
53  uint32_t count) NLIB_NOEXCEPT;
54  static nlib_byte_t* WriteUnsignedInt(nlib_byte_t* p, nlib_byte_t* pend,
55  uint8_t val) NLIB_NOEXCEPT;
56  static nlib_byte_t* WriteUnsignedInt(nlib_byte_t* p, nlib_byte_t* pend,
57  uint16_t val) NLIB_NOEXCEPT;
58  static nlib_byte_t* WriteUnsignedInt(nlib_byte_t* p, nlib_byte_t* pend,
59  uint32_t val) NLIB_NOEXCEPT;
60  static nlib_byte_t* WriteUnsignedInt(nlib_byte_t* p, nlib_byte_t* pend,
61  uint64_t val) NLIB_NOEXCEPT;
62  static nlib_byte_t* WriteInt(nlib_byte_t* p, nlib_byte_t* pend, int8_t val) NLIB_NOEXCEPT;
63  static nlib_byte_t* WriteInt(nlib_byte_t* p, nlib_byte_t* pend, int16_t val) NLIB_NOEXCEPT;
64  static nlib_byte_t* WriteInt(nlib_byte_t* p, nlib_byte_t* pend, int32_t val) NLIB_NOEXCEPT;
65  static nlib_byte_t* WriteInt(nlib_byte_t* p, nlib_byte_t* pend, int64_t val) NLIB_NOEXCEPT;
66  static nlib_byte_t* WriteTimestamp(nlib_byte_t* p, nlib_byte_t* pend,
67  int64_t sec, uint32_t nsec) NLIB_NOEXCEPT;
68  static nlib_byte_t* WriteTimestamp(nlib_byte_t* p, nlib_byte_t* pend,
70 
71  private:
72  static NLIB_ALWAYS_INLINE void EncU16(nlib_byte_t* p, uint16_t val) NLIB_NOEXCEPT {
73 #ifdef NLIB_LITTLE_ENDIAN
74  val = nlib_bswap16(val);
75 #endif
76  nlib_memcpy(p, 2, &val, 2);
77  }
78  static NLIB_ALWAYS_INLINE void EncU32(nlib_byte_t* p, uint32_t val) NLIB_NOEXCEPT {
79 #ifdef NLIB_LITTLE_ENDIAN
80  val = nlib_bswap32(val);
81 #endif
82  nlib_memcpy(p, 4, &val, 4);
83  }
84  static NLIB_ALWAYS_INLINE void EncU64(nlib_byte_t* p, uint64_t val) NLIB_NOEXCEPT {
85 #ifdef NLIB_LITTLE_ENDIAN
86  val = nlib_bswap64(val);
87 #endif
88  nlib_memcpy(p, 8, &val, 8);
89  }
90 
91  private:
93 };
94 #define NLIB_CHK_(p, n, pend) if (NLIB_UNLIKELY((p) + (n) > (pend))) { \
95  NLIB_ASSERT((p) + (n) <= (pend)); \
96  return nullptr; \
97 }
99 MpDirectWriter::WriteUint8(nlib_byte_t* p, nlib_byte_t* pend, uint8_t val) NLIB_NOEXCEPT {
100  NLIB_CHK_(p, 2, pend);
101  if (NLIB_UNLIKELY(p + 2 > pend)) return nullptr;
102  p[0] = static_cast<nlib_byte_t>(0xcc);
103  p[1] = static_cast<nlib_byte_t>(val);
104  return p + 2;
105 }
107 MpDirectWriter::WriteUint16(nlib_byte_t* p, nlib_byte_t* pend, uint16_t val) NLIB_NOEXCEPT {
108  NLIB_CHK_(p, 3, pend);
109  p[0] = static_cast<nlib_byte_t>(0xcd);
110  EncU16(p + 1, val);
111  return p + 3;
112 }
114 MpDirectWriter::WriteUint32(nlib_byte_t* p, nlib_byte_t* pend, uint32_t val) NLIB_NOEXCEPT {
115  NLIB_CHK_(p, 5, pend);
116  p[0] = static_cast<nlib_byte_t>(0xce);
117  EncU32(p + 1, val);
118  return p + 5;
119 }
121 MpDirectWriter::WriteUint64(nlib_byte_t* p, nlib_byte_t* pend, uint64_t val) NLIB_NOEXCEPT {
122  NLIB_CHK_(p, 9, pend);
123  p[0] = static_cast<nlib_byte_t>(0xcf);
124  EncU64(p + 1, val);
125  return p + 9;
126 }
128 MpDirectWriter::WriteInt8(nlib_byte_t* p, nlib_byte_t* pend, int8_t val) NLIB_NOEXCEPT {
129  NLIB_CHK_(p, 2, pend);
130  p[0] = static_cast<nlib_byte_t>(0xd0);
131  p[1] = static_cast<nlib_byte_t>(val);
132  return p + 2;
133 }
135 MpDirectWriter::WriteInt16(nlib_byte_t* p, nlib_byte_t* pend, int16_t val) NLIB_NOEXCEPT {
136  NLIB_CHK_(p, 3, pend);
137  p[0] = static_cast<nlib_byte_t>(0xd1);
138  EncU16(p + 1, static_cast<uint16_t>(val));
139  return p + 3;
140 }
142 MpDirectWriter::WriteInt32(nlib_byte_t* p, nlib_byte_t* pend, int32_t val) NLIB_NOEXCEPT {
143  NLIB_CHK_(p, 5, pend);
144  p[0] = static_cast<nlib_byte_t>(0xd2);
145  EncU32(p + 1, static_cast<uint32_t>(val));
146  return p + 5;
147 }
149 MpDirectWriter::WriteInt64(nlib_byte_t* p, nlib_byte_t* pend, int64_t val) NLIB_NOEXCEPT {
150  NLIB_CHK_(p, 9, pend);
151  p[0] = static_cast<nlib_byte_t>(0xd3);
152  EncU64(p + 1, static_cast<uint64_t>(val));
153  return p + 9;
154 }
156 MpDirectWriter::WriteNil(nlib_byte_t* p, nlib_byte_t* pend) NLIB_NOEXCEPT {
157  NLIB_CHK_(p, 1, pend);
158  *p = static_cast<nlib_byte_t>(0xc0);
159  return p + 1;
160 }
162 MpDirectWriter::WriteBoolean(nlib_byte_t* p, nlib_byte_t* pend, bool val) NLIB_NOEXCEPT {
163  NLIB_CHK_(p, 1, pend);
164  *p = static_cast<nlib_byte_t>(val ? 0xc3 : 0xc2);
165  return p + 1;
166 }
168 MpDirectWriter::WriteFloat(nlib_byte_t* p, nlib_byte_t* pend, float val) NLIB_NOEXCEPT {
169  NLIB_CHK_(p, 5, pend);
170  p[0] = static_cast<nlib_byte_t>(0xca);
171  union {
172  float f32;
173  uint32_t u32;
174  } tmp;
175  tmp.f32 = val;
176  EncU32(p + 1, tmp.u32);
177  return p + 5;
178 }
180 MpDirectWriter::WriteDouble(nlib_byte_t* p, nlib_byte_t* pend, double val) NLIB_NOEXCEPT {
181  NLIB_CHK_(p, 9, pend);
182  p[0] = static_cast<nlib_byte_t>(0xcb);
183  union {
184  double f64;
185  uint64_t u64;
186  } tmp;
187  tmp.f64 = val;
188  EncU64(p + 1, tmp.u64);
189  return p + 9;
190 }
191 inline nlib_byte_t*
192 MpDirectWriter::WriteStringHeader(nlib_byte_t* p, nlib_byte_t* pend,
193  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*
216 MpDirectWriter::WriteString(nlib_byte_t* p, nlib_byte_t* pend,
217  const char* str, uint32_t len) NLIB_NOEXCEPT {
218  if (len < 32U) {
219  NLIB_CHK_(p, 1 + len, pend);
220  p[0] = static_cast<nlib_byte_t>(0xa0 | len);
221  nlib_memcpy(p + 1, len, str, len);
222  return p + 1 + len;
223  } else if (len < 256U) {
224  NLIB_CHK_(p, 2 + len, pend);
225  p[0] = static_cast<nlib_byte_t>(0xd9);
226  p[1] = static_cast<nlib_byte_t>(len);
227  nlib_memcpy(p + 2, len, str, len);
228  return p + 2 + len;
229  } else if (len < 65536U) {
230  NLIB_CHK_(p, 3 + len, pend);
231  p[0] = static_cast<nlib_byte_t>(0xda);
232  EncU16(p + 1, static_cast<uint16_t>(len));
233  nlib_memcpy(p + 3, len, str, len);
234  return p + 3 + len;
235  } else {
236  NLIB_CHK_(p, 5 + len, pend);
237  p[0] = static_cast<nlib_byte_t>(0xdb);
238  EncU32(p + 1, len);
239  nlib_memcpy(p + 5, len, str, len);
240  return p + 5 + len;
241  }
242 }
243 inline nlib_byte_t*
244 MpDirectWriter::WriteString(nlib_byte_t* p, nlib_byte_t* pend,
245  const char* str) NLIB_NOEXCEPT {
246  return WriteString(p, pend, str, static_cast<uint32_t>(nlib_strlen(str)));
247 }
248 inline nlib_byte_t*
249 MpDirectWriter::WriteBinHeader(nlib_byte_t* p, nlib_byte_t* pend, uint32_t n) NLIB_NOEXCEPT {
250  if (n < 256U) {
251  NLIB_CHK_(p, 2, pend);
252  p[0] = static_cast<nlib_byte_t>(0xc4);
253  p[1] = static_cast<nlib_byte_t>(n);
254  return p + 2;
255  } else if (n < 65536U) {
256  NLIB_CHK_(p, 3, pend);
257  p[0] = static_cast<nlib_byte_t>(0xc5);
258  EncU16(p + 1, static_cast<uint16_t>(n));
259  return p + 3;
260  } else {
261  NLIB_CHK_(p, 5, pend);
262  p[0] = static_cast<nlib_byte_t>(0xc6);
263  EncU32(p + 1, n);
264  return p + 5;
265  }
266 }
267 inline nlib_byte_t*
268 MpDirectWriter::WriteBin(nlib_byte_t* p, nlib_byte_t* pend,
269  const nlib_byte_t* bin, uint32_t n) NLIB_NOEXCEPT {
270  if (n < 256U) {
271  NLIB_CHK_(p, 2 + n, pend);
272  p[0] = static_cast<nlib_byte_t>(0xc4);
273  p[1] = static_cast<nlib_byte_t>(n);
274  nlib_memcpy(p + 2, n, bin, n);
275  return p + 2 + n;
276  } else if (n < 65536U) {
277  NLIB_CHK_(p, 3 + n, pend);
278  p[0] = static_cast<nlib_byte_t>(0xc5);
279  EncU16(p + 1, static_cast<uint16_t>(n));
280  nlib_memcpy(p + 3, n, bin, n);
281  return p + 3 + n;
282  } else {
283  NLIB_CHK_(p, 5 + n, pend);
284  p[0] = static_cast<nlib_byte_t>(0xc6);
285  EncU32(p + 1, n);
286  nlib_memcpy(p + 5, n, bin, n);
287  return p + 5 + n;
288  }
289 }
290 inline nlib_byte_t*
291 MpDirectWriter::WriteExtHeader(nlib_byte_t* p, nlib_byte_t* pend, int8_t type,
292  uint32_t n) NLIB_NOEXCEPT {
293  if (n < 256U) {
294  switch (n) {
295  case 1:
296  NLIB_CHK_(p, 2, pend);
297  p[0] = static_cast<nlib_byte_t>(0xd4);
298  p[1] = static_cast<nlib_byte_t>(type);
299  return p + 2;
300  case 2:
301  NLIB_CHK_(p, 2, pend);
302  p[0] = static_cast<nlib_byte_t>(0xd5);
303  p[1] = static_cast<nlib_byte_t>(type);
304  return p + 2;
305  case 4:
306  NLIB_CHK_(p, 2, pend);
307  p[0] = static_cast<nlib_byte_t>(0xd6);
308  p[1] = static_cast<nlib_byte_t>(type);
309  return p + 2;
310  case 8:
311  NLIB_CHK_(p, 2, pend);
312  p[0] = static_cast<nlib_byte_t>(0xd7);
313  p[1] = static_cast<nlib_byte_t>(type);
314  return p + 2;
315  case 16:
316  NLIB_CHK_(p, 2, pend);
317  p[0] = static_cast<nlib_byte_t>(0xd8);
318  p[1] = static_cast<nlib_byte_t>(type);
319  return p + 2;
320  default:
321  NLIB_CHK_(p, 3 + n, pend);
322  p[0] = static_cast<nlib_byte_t>(0xc7);
323  p[1] = static_cast<nlib_byte_t>(n);
324  p[2] = static_cast<nlib_byte_t>(type);
325  return p + 3;
326  }
327  } else if (n < 65536U) {
328  NLIB_CHK_(p, 4, pend);
329  p[0] = static_cast<nlib_byte_t>(0xc8);
330  EncU16(p + 1, static_cast<uint16_t>(n));
331  p[3] = static_cast<nlib_byte_t>(type);
332  return p + 4;
333  } else {
334  NLIB_CHK_(p, 6, pend);
335  p[0] = static_cast<nlib_byte_t>(0xc9);
336  EncU32(p + 1, n);
337  p[5] = static_cast<nlib_byte_t>(type);
338  return p + 6;
339  }
340 }
341 inline nlib_byte_t*
342 MpDirectWriter::WriteExt(nlib_byte_t* p, nlib_byte_t* pend, int8_t type,
343  const nlib_byte_t* data, uint32_t n) NLIB_NOEXCEPT {
344  if (n < 256U) {
345  switch (n) {
346  case 1:
347  NLIB_CHK_(p, 3, pend);
348  p[0] = static_cast<nlib_byte_t>(0xd4);
349  p[1] = static_cast<nlib_byte_t>(type);
350  p[2] = data[0];
351  return p + 3;
352  case 2:
353  NLIB_CHK_(p, 4, pend);
354  p[0] = static_cast<nlib_byte_t>(0xd5);
355  p[1] = static_cast<nlib_byte_t>(type);
356  p[2] = data[0];
357  p[3] = data[1];
358  return p + 4;
359  case 4:
360  NLIB_CHK_(p, 6, pend);
361  p[0] = static_cast<nlib_byte_t>(0xd6);
362  p[1] = static_cast<nlib_byte_t>(type);
363  nlib_memcpy(p + 2, 4, data, 4);
364  return p + 6;
365  case 8:
366  NLIB_CHK_(p, 10, pend);
367  p[0] = static_cast<nlib_byte_t>(0xd7);
368  p[1] = static_cast<nlib_byte_t>(type);
369  nlib_memcpy(p + 2, 8, data, 8);
370  return p + 10;
371  case 16:
372  NLIB_CHK_(p, 18, pend);
373  p[0] = static_cast<nlib_byte_t>(0xd8);
374  p[1] = static_cast<nlib_byte_t>(type);
375  nlib_memcpy(p + 2, 16, data, 16);
376  return p + 18;
377  default:
378  NLIB_CHK_(p, 3 + n, pend);
379  p[0] = static_cast<nlib_byte_t>(0xc7);
380  p[1] = static_cast<nlib_byte_t>(n);
381  p[2] = static_cast<nlib_byte_t>(type);
382  nlib_memcpy(p + 3, n, data, n);
383  return p + 3 + n;
384  }
385  } else if (n < 65536U) {
386  NLIB_CHK_(p, 4 + n, pend);
387  p[0] = static_cast<nlib_byte_t>(0xc8);
388  EncU16(p + 1, static_cast<uint16_t>(n));
389  p[3] = static_cast<nlib_byte_t>(type);
390  nlib_memcpy(p + 4, n, data, n);
391  return p + 4 + n;
392  } else {
393  NLIB_CHK_(p, 6 + n, pend);
394  p[0] = static_cast<nlib_byte_t>(0xc9);
395  EncU32(p + 1, n);
396  p[5] = static_cast<nlib_byte_t>(type);
397  nlib_memcpy(p + 6, n, data, n);
398  return p + 6 + n;
399  }
400 }
401 inline nlib_byte_t*
402 MpDirectWriter::WriteArrayHeader(nlib_byte_t* p, nlib_byte_t* pend,
403  uint32_t count) NLIB_NOEXCEPT {
404  if (count < 16U) {
405  NLIB_CHK_(p, 1, pend);
406  *p = static_cast<nlib_byte_t>(0x90 | count);
407  return p + 1;
408  } else if (count < 65536U) {
409  NLIB_CHK_(p, 3, pend);
410  p[0] = static_cast<nlib_byte_t>(0xdc);
411  EncU16(p + 1, static_cast<uint16_t>(count));
412  return p + 3;
413  } else {
414  NLIB_CHK_(p, 5, pend);
415  p[0] = static_cast<nlib_byte_t>(0xdd);
416  EncU32(p + 1, count);
417  return p + 5;
418  }
419 }
420 inline nlib_byte_t*
421 MpDirectWriter::WriteMapHeader(nlib_byte_t* p, nlib_byte_t* pend,
422  uint32_t count) NLIB_NOEXCEPT {
423  if (count < 16U) {
424  NLIB_CHK_(p, 1, pend);
425  *p = static_cast<nlib_byte_t>(0x80 | count);
426  return p + 1;
427  } else if (count < 65536U) {
428  NLIB_CHK_(p, 3, pend);
429  p[0] = static_cast<nlib_byte_t>(0xde);
430  EncU16(p + 1, static_cast<uint16_t>(count));
431  return p + 3;
432  } else {
433  NLIB_CHK_(p, 5, pend);
434  p[0] = static_cast<nlib_byte_t>(0xdf);
435  EncU32(p + 1, count);
436  return p + 5;
437  }
438 }
439 inline nlib_byte_t*
440 MpDirectWriter::WriteUnsignedInt(nlib_byte_t* p, nlib_byte_t* pend,
441  uint8_t val) NLIB_NOEXCEPT {
442  if (val < 128U) {
443  NLIB_CHK_(p, 1, pend);
444  p[0] = static_cast<nlib_byte_t>(val);
445  return p + 1;
446  } else {
447  return WriteUint8(p, pend, static_cast<uint8_t>(val));
448  }
449 }
450 inline nlib_byte_t*
451 MpDirectWriter::WriteUnsignedInt(nlib_byte_t* p, nlib_byte_t* pend,
452  uint16_t val) NLIB_NOEXCEPT {
453  if (val < 128U) {
454  NLIB_CHK_(p, 1, pend);
455  p[0] = static_cast<nlib_byte_t>(val);
456  return p + 1;
457  } else if (val < 256U) {
458  return WriteUint8(p, pend, static_cast<uint8_t>(val));
459  } else {
460  return WriteUint16(p, pend, static_cast<uint16_t>(val));
461  }
462 }
463 inline nlib_byte_t*
464 MpDirectWriter::WriteUnsignedInt(nlib_byte_t* p, nlib_byte_t* pend,
465  uint32_t val) NLIB_NOEXCEPT {
466  if (val < 256U) {
467  if (val < 128U) {
468  NLIB_CHK_(p, 1, pend);
469  p[0] = static_cast<nlib_byte_t>(val);
470  return p + 1;
471  } else {
472  return WriteUint8(p, pend, static_cast<uint8_t>(val));
473  }
474  } else if (val < 65536U) {
475  return WriteUint16(p, pend, static_cast<uint16_t>(val));
476  } else {
477  return WriteUint32(p, pend, val);
478  }
479 }
480 inline nlib_byte_t*
481 MpDirectWriter::WriteUnsignedInt(nlib_byte_t* p, nlib_byte_t* pend,
482  uint64_t val) NLIB_NOEXCEPT {
483  if (val < 0x100000000ULL) {
484  return WriteUnsignedInt(p, pend, static_cast<uint32_t>(val));
485  } else {
486  return WriteUint64(p, pend, val);
487  }
488 }
489 inline nlib_byte_t*
490 MpDirectWriter::WriteInt(nlib_byte_t* p, nlib_byte_t* pend, int8_t val) NLIB_NOEXCEPT {
491  if (val < -32) {
492  return WriteInt8(p, pend, static_cast<int8_t>(val));
493  } else {
494  NLIB_CHK_(p, 1, pend);
495  p[0] = static_cast<nlib_byte_t>(val);
496  return p + 1;
497  }
498 }
499 inline nlib_byte_t*
500 MpDirectWriter::WriteInt(nlib_byte_t* p, nlib_byte_t* pend, int16_t val) NLIB_NOEXCEPT {
501  if (val < 0) {
502  if (val < INT8_MIN) {
503  return WriteInt16(p, pend, static_cast<int16_t>(val));
504  } else if (val < -32) {
505  return WriteInt8(p, pend, static_cast<int8_t>(val));
506  } else {
507  NLIB_CHK_(p, 1, pend);
508  p[0] = static_cast<nlib_byte_t>(val);
509  return p + 1;
510  }
511  } else {
512  return WriteUnsignedInt(p, pend, static_cast<uint16_t>(val));
513  }
514 }
515 inline nlib_byte_t*
516 MpDirectWriter::WriteInt(nlib_byte_t* p, nlib_byte_t* pend, int32_t val) NLIB_NOEXCEPT {
517  if (val < 0) {
518  if (val < INT8_MIN) {
519  if (val < INT16_MIN) {
520  return WriteInt32(p, pend, val);
521  } else {
522  return WriteInt16(p, pend, static_cast<int16_t>(val));
523  }
524  } else if (val < -32) {
525  return WriteInt8(p, pend, static_cast<int8_t>(val));
526  } else {
527  NLIB_CHK_(p, 1, pend);
528  p[0] = static_cast<nlib_byte_t>(val);
529  return p + 1;
530  }
531  } else {
532  return WriteUnsignedInt(p, pend, static_cast<uint32_t>(val));
533  }
534 }
535 inline nlib_byte_t*
536 MpDirectWriter::WriteInt(nlib_byte_t* p, nlib_byte_t* pend, int64_t val) NLIB_NOEXCEPT {
537  if (val < 0) {
538  if (val < INT32_MIN) {
539  return WriteInt64(p, pend, val);
540  } else {
541  return WriteInt(p, pend, static_cast<int32_t>(val));
542  }
543  } else {
544  return WriteUnsignedInt(p, pend, static_cast<uint64_t>(val));
545  }
546 }
547 inline nlib_byte_t*
548 MpDirectWriter::WriteTimestamp(nlib_byte_t* p, nlib_byte_t* pend,
549  int64_t sec, uint32_t nsec) NLIB_NOEXCEPT {
550  if (NLIB_LIKELY((sec >> 34) == 0)) {
551  uint64_t data64 = (static_cast<uint64_t>(nsec) << 34) | static_cast<uint64_t>(sec);
552  if (data64 < 0x100000000ULL) {
553  // timestamp 32
554  NLIB_CHK_(p, 6, pend);
555  p[0] = static_cast<nlib_byte_t>(0xd6);
556  p[1] = static_cast<nlib_byte_t>(-1);
557  EncU32(p + 2, static_cast<uint32_t>(data64));
558  return p + 6;
559  } else {
560  // timestamp 64
561  NLIB_CHK_(p, 10, pend);
562  p[0] = static_cast<nlib_byte_t>(0xd7);
563  p[1] = static_cast<nlib_byte_t>(-1);
564  EncU64(p + 2, data64);
565  return p + 10;
566  }
567  }
568  // timestamp96
569  NLIB_CHK_(p, 15, pend);
570  p[0] = static_cast<nlib_byte_t>(0xc7);
571  p[1] = static_cast<nlib_byte_t>(12);
572  p[2] = static_cast<nlib_byte_t>(-1);
573  EncU32(p + 3, static_cast<uint32_t>(nsec));
574  EncU64(p + 7, static_cast<uint64_t>(sec));
575  return p + 15;
576 }
577 inline nlib_byte_t*
578 MpDirectWriter::WriteTimestamp(nlib_byte_t* p, nlib_byte_t* pend,
579  nlib_time val) NLIB_NOEXCEPT {
580  int64_t sec;
581  uint32_t nsec;
582  NLIB_TO_SEC_NSEC(sec, nsec, val);
583  return WriteTimestamp(p, pend, sec, nsec);
584 }
585 
586 #undef NLIB_CHK_
587 } // namespace msgpack
588 NLIB_NAMESPACE_END
589 
590 #endif // INCLUDE_NN_NLIB_MSGPACK_MPDIRECTWRITER_H_
#define NLIB_ALWAYS_INLINE
コンパイラに関数をインライン展開するように強く示します。
Definition: Platform_unix.h:97
static uint16_t nlib_bswap16(uint16_t x)
__builtin_bswap16(x)や_byteswap_ushort(x)を返します。
Definition: Platform.h:2333
#define NLIB_UNLIKELY(x)
条件xが偽になる傾向が高いことをコンパイラに示します。
int64_t nlib_time
1970/01/01を起点(0)としてから100ns刻みで時刻を表現する型です。64bit符号付き整数です。 ...
Definition: Platform.h:457
static uint64_t nlib_bswap64(uint64_t x)
__builtin_bswap64(x)や_byteswap_uint64(x)を返します。
Definition: Platform.h:2335
#define NLIB_LIKELY(x)
条件xが真になる傾向が高いことをコンパイラに示します。
Definition: Platform_unix.h:99
static errno_t nlib_memcpy(void *s1, size_t s1max, const void *s2, size_t n)
N1078のmemcpy_sに相当する実装です。
Definition: Platform.h:2437
#define NLIB_NOEXCEPT
環境に合わせてnoexcept 又は同等の定義がされます。
Definition: Config.h:105
開発環境別の設定が書かれるファイルです。
size_t nlib_strlen(const char *s)
内部でstrlen()を呼び出します。独自の実装が動作する場合もあります。
static uint32_t nlib_bswap32(uint32_t x)
__builtin_bswap32(x)や_byteswap_ulong(x)を返します。
Definition: Platform.h:2334
MessagePackをメモリに直接書き込むための各種静的メンバ関数が定義されています。
unsigned char nlib_byte_t
C++17以降でstd::byteにtypedefされる型です。
Definition: Platform.h:319