itoa.h
Go to the documentation of this file.
1 // Tencent is pleased to support the open source community by making RapidJSON
2 // available.
3 //
4 // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All
5 // rights reserved.
6 //
7 // Licensed under the MIT License (the "License"); you may not use this file
8 // except in compliance with the License. You may obtain a copy of the License
9 // at
10 //
11 // http://opensource.org/licenses/MIT
12 //
13 // Unless required by applicable law or agreed to in writing, software
14 // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
15 // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
16 // License for the specific language governing permissions and limitations under
17 // the License.
18 
19 #ifndef RAPIDJSON_ITOA_
20 #define RAPIDJSON_ITOA_
21 
22 #include "../rapidjson.h"
23 
24 RAPIDJSON_NAMESPACE_BEGIN
25 namespace internal {
26 
27 inline const char *GetDigitsLut() {
28  static const char cDigitsLut[200] = {
29  '0', '0', '0', '1', '0', '2', '0', '3', '0', '4', '0', '5', '0', '6', '0',
30  '7', '0', '8', '0', '9', '1', '0', '1', '1', '1', '2', '1', '3', '1', '4',
31  '1', '5', '1', '6', '1', '7', '1', '8', '1', '9', '2', '0', '2', '1', '2',
32  '2', '2', '3', '2', '4', '2', '5', '2', '6', '2', '7', '2', '8', '2', '9',
33  '3', '0', '3', '1', '3', '2', '3', '3', '3', '4', '3', '5', '3', '6', '3',
34  '7', '3', '8', '3', '9', '4', '0', '4', '1', '4', '2', '4', '3', '4', '4',
35  '4', '5', '4', '6', '4', '7', '4', '8', '4', '9', '5', '0', '5', '1', '5',
36  '2', '5', '3', '5', '4', '5', '5', '5', '6', '5', '7', '5', '8', '5', '9',
37  '6', '0', '6', '1', '6', '2', '6', '3', '6', '4', '6', '5', '6', '6', '6',
38  '7', '6', '8', '6', '9', '7', '0', '7', '1', '7', '2', '7', '3', '7', '4',
39  '7', '5', '7', '6', '7', '7', '7', '8', '7', '9', '8', '0', '8', '1', '8',
40  '2', '8', '3', '8', '4', '8', '5', '8', '6', '8', '7', '8', '8', '8', '9',
41  '9', '0', '9', '1', '9', '2', '9', '3', '9', '4', '9', '5', '9', '6', '9',
42  '7', '9', '8', '9', '9'};
43  return cDigitsLut;
44 }
45 
46 inline char *u32toa(uint32_t value, char *buffer) {
47  RAPIDJSON_ASSERT(buffer != 0);
48 
49  const char *cDigitsLut = GetDigitsLut();
50 
51  if (value < 10000) {
52  const uint32_t d1 = (value / 100) << 1;
53  const uint32_t d2 = (value % 100) << 1;
54 
55  if (value >= 1000) *buffer++ = cDigitsLut[d1];
56  if (value >= 100) *buffer++ = cDigitsLut[d1 + 1];
57  if (value >= 10) *buffer++ = cDigitsLut[d2];
58  *buffer++ = cDigitsLut[d2 + 1];
59  } else if (value < 100000000) {
60  // value = bbbbcccc
61  const uint32_t b = value / 10000;
62  const uint32_t c = value % 10000;
63 
64  const uint32_t d1 = (b / 100) << 1;
65  const uint32_t d2 = (b % 100) << 1;
66 
67  const uint32_t d3 = (c / 100) << 1;
68  const uint32_t d4 = (c % 100) << 1;
69 
70  if (value >= 10000000) *buffer++ = cDigitsLut[d1];
71  if (value >= 1000000) *buffer++ = cDigitsLut[d1 + 1];
72  if (value >= 100000) *buffer++ = cDigitsLut[d2];
73  *buffer++ = cDigitsLut[d2 + 1];
74 
75  *buffer++ = cDigitsLut[d3];
76  *buffer++ = cDigitsLut[d3 + 1];
77  *buffer++ = cDigitsLut[d4];
78  *buffer++ = cDigitsLut[d4 + 1];
79  } else {
80  // value = aabbbbcccc in decimal
81 
82  const uint32_t a = value / 100000000; // 1 to 42
83  value %= 100000000;
84 
85  if (a >= 10) {
86  const unsigned i = a << 1;
87  *buffer++ = cDigitsLut[i];
88  *buffer++ = cDigitsLut[i + 1];
89  } else
90  *buffer++ = static_cast<char>('0' + static_cast<char>(a));
91 
92  const uint32_t b = value / 10000; // 0 to 9999
93  const uint32_t c = value % 10000; // 0 to 9999
94 
95  const uint32_t d1 = (b / 100) << 1;
96  const uint32_t d2 = (b % 100) << 1;
97 
98  const uint32_t d3 = (c / 100) << 1;
99  const uint32_t d4 = (c % 100) << 1;
100 
101  *buffer++ = cDigitsLut[d1];
102  *buffer++ = cDigitsLut[d1 + 1];
103  *buffer++ = cDigitsLut[d2];
104  *buffer++ = cDigitsLut[d2 + 1];
105  *buffer++ = cDigitsLut[d3];
106  *buffer++ = cDigitsLut[d3 + 1];
107  *buffer++ = cDigitsLut[d4];
108  *buffer++ = cDigitsLut[d4 + 1];
109  }
110  return buffer;
111 }
112 
113 inline char *i32toa(int32_t value, char *buffer) {
114  RAPIDJSON_ASSERT(buffer != 0);
115  uint32_t u = static_cast<uint32_t>(value);
116  if (value < 0) {
117  *buffer++ = '-';
118  u = ~u + 1;
119  }
120 
121  return u32toa(u, buffer);
122 }
123 
124 inline char *u64toa(uint64_t value, char *buffer) {
125  RAPIDJSON_ASSERT(buffer != 0);
126  const char *cDigitsLut = GetDigitsLut();
127  const uint64_t kTen8 = 100000000;
128  const uint64_t kTen9 = kTen8 * 10;
129  const uint64_t kTen10 = kTen8 * 100;
130  const uint64_t kTen11 = kTen8 * 1000;
131  const uint64_t kTen12 = kTen8 * 10000;
132  const uint64_t kTen13 = kTen8 * 100000;
133  const uint64_t kTen14 = kTen8 * 1000000;
134  const uint64_t kTen15 = kTen8 * 10000000;
135  const uint64_t kTen16 = kTen8 * kTen8;
136 
137  if (value < kTen8) {
138  uint32_t v = static_cast<uint32_t>(value);
139  if (v < 10000) {
140  const uint32_t d1 = (v / 100) << 1;
141  const uint32_t d2 = (v % 100) << 1;
142 
143  if (v >= 1000) *buffer++ = cDigitsLut[d1];
144  if (v >= 100) *buffer++ = cDigitsLut[d1 + 1];
145  if (v >= 10) *buffer++ = cDigitsLut[d2];
146  *buffer++ = cDigitsLut[d2 + 1];
147  } else {
148  // value = bbbbcccc
149  const uint32_t b = v / 10000;
150  const uint32_t c = v % 10000;
151 
152  const uint32_t d1 = (b / 100) << 1;
153  const uint32_t d2 = (b % 100) << 1;
154 
155  const uint32_t d3 = (c / 100) << 1;
156  const uint32_t d4 = (c % 100) << 1;
157 
158  if (value >= 10000000) *buffer++ = cDigitsLut[d1];
159  if (value >= 1000000) *buffer++ = cDigitsLut[d1 + 1];
160  if (value >= 100000) *buffer++ = cDigitsLut[d2];
161  *buffer++ = cDigitsLut[d2 + 1];
162 
163  *buffer++ = cDigitsLut[d3];
164  *buffer++ = cDigitsLut[d3 + 1];
165  *buffer++ = cDigitsLut[d4];
166  *buffer++ = cDigitsLut[d4 + 1];
167  }
168  } else if (value < kTen16) {
169  const uint32_t v0 = static_cast<uint32_t>(value / kTen8);
170  const uint32_t v1 = static_cast<uint32_t>(value % kTen8);
171 
172  const uint32_t b0 = v0 / 10000;
173  const uint32_t c0 = v0 % 10000;
174 
175  const uint32_t d1 = (b0 / 100) << 1;
176  const uint32_t d2 = (b0 % 100) << 1;
177 
178  const uint32_t d3 = (c0 / 100) << 1;
179  const uint32_t d4 = (c0 % 100) << 1;
180 
181  const uint32_t b1 = v1 / 10000;
182  const uint32_t c1 = v1 % 10000;
183 
184  const uint32_t d5 = (b1 / 100) << 1;
185  const uint32_t d6 = (b1 % 100) << 1;
186 
187  const uint32_t d7 = (c1 / 100) << 1;
188  const uint32_t d8 = (c1 % 100) << 1;
189 
190  if (value >= kTen15) *buffer++ = cDigitsLut[d1];
191  if (value >= kTen14) *buffer++ = cDigitsLut[d1 + 1];
192  if (value >= kTen13) *buffer++ = cDigitsLut[d2];
193  if (value >= kTen12) *buffer++ = cDigitsLut[d2 + 1];
194  if (value >= kTen11) *buffer++ = cDigitsLut[d3];
195  if (value >= kTen10) *buffer++ = cDigitsLut[d3 + 1];
196  if (value >= kTen9) *buffer++ = cDigitsLut[d4];
197 
198  *buffer++ = cDigitsLut[d4 + 1];
199  *buffer++ = cDigitsLut[d5];
200  *buffer++ = cDigitsLut[d5 + 1];
201  *buffer++ = cDigitsLut[d6];
202  *buffer++ = cDigitsLut[d6 + 1];
203  *buffer++ = cDigitsLut[d7];
204  *buffer++ = cDigitsLut[d7 + 1];
205  *buffer++ = cDigitsLut[d8];
206  *buffer++ = cDigitsLut[d8 + 1];
207  } else {
208  const uint32_t a = static_cast<uint32_t>(value / kTen16); // 1 to 1844
209  value %= kTen16;
210 
211  if (a < 10)
212  *buffer++ = static_cast<char>('0' + static_cast<char>(a));
213  else if (a < 100) {
214  const uint32_t i = a << 1;
215  *buffer++ = cDigitsLut[i];
216  *buffer++ = cDigitsLut[i + 1];
217  } else if (a < 1000) {
218  *buffer++ = static_cast<char>('0' + static_cast<char>(a / 100));
219 
220  const uint32_t i = (a % 100) << 1;
221  *buffer++ = cDigitsLut[i];
222  *buffer++ = cDigitsLut[i + 1];
223  } else {
224  const uint32_t i = (a / 100) << 1;
225  const uint32_t j = (a % 100) << 1;
226  *buffer++ = cDigitsLut[i];
227  *buffer++ = cDigitsLut[i + 1];
228  *buffer++ = cDigitsLut[j];
229  *buffer++ = cDigitsLut[j + 1];
230  }
231 
232  const uint32_t v0 = static_cast<uint32_t>(value / kTen8);
233  const uint32_t v1 = static_cast<uint32_t>(value % kTen8);
234 
235  const uint32_t b0 = v0 / 10000;
236  const uint32_t c0 = v0 % 10000;
237 
238  const uint32_t d1 = (b0 / 100) << 1;
239  const uint32_t d2 = (b0 % 100) << 1;
240 
241  const uint32_t d3 = (c0 / 100) << 1;
242  const uint32_t d4 = (c0 % 100) << 1;
243 
244  const uint32_t b1 = v1 / 10000;
245  const uint32_t c1 = v1 % 10000;
246 
247  const uint32_t d5 = (b1 / 100) << 1;
248  const uint32_t d6 = (b1 % 100) << 1;
249 
250  const uint32_t d7 = (c1 / 100) << 1;
251  const uint32_t d8 = (c1 % 100) << 1;
252 
253  *buffer++ = cDigitsLut[d1];
254  *buffer++ = cDigitsLut[d1 + 1];
255  *buffer++ = cDigitsLut[d2];
256  *buffer++ = cDigitsLut[d2 + 1];
257  *buffer++ = cDigitsLut[d3];
258  *buffer++ = cDigitsLut[d3 + 1];
259  *buffer++ = cDigitsLut[d4];
260  *buffer++ = cDigitsLut[d4 + 1];
261  *buffer++ = cDigitsLut[d5];
262  *buffer++ = cDigitsLut[d5 + 1];
263  *buffer++ = cDigitsLut[d6];
264  *buffer++ = cDigitsLut[d6 + 1];
265  *buffer++ = cDigitsLut[d7];
266  *buffer++ = cDigitsLut[d7 + 1];
267  *buffer++ = cDigitsLut[d8];
268  *buffer++ = cDigitsLut[d8 + 1];
269  }
270 
271  return buffer;
272 }
273 
274 inline char *i64toa(int64_t value, char *buffer) {
275  RAPIDJSON_ASSERT(buffer != 0);
276  uint64_t u = static_cast<uint64_t>(value);
277  if (value < 0) {
278  *buffer++ = '-';
279  u = ~u + 1;
280  }
281 
282  return u64toa(u, buffer);
283 }
284 
285 } // namespace internal
286 RAPIDJSON_NAMESPACE_END
287 
288 #endif // RAPIDJSON_ITOA_
internal::u64toa
char * u64toa(uint64_t value, char *buffer)
Definition: itoa.h:124
RAPIDJSON_ASSERT
#define RAPIDJSON_ASSERT(x)
Assertion.
Definition: rapidjson.h:433
RAPIDJSON_NAMESPACE_END
#define RAPIDJSON_NAMESPACE_END
provide custom rapidjson namespace (closing expression)
Definition: rapidjson.h:131
internal::GetDigitsLut
const char * GetDigitsLut()
Definition: itoa.h:27
RAPIDJSON_NAMESPACE_BEGIN
#define RAPIDJSON_NAMESPACE_BEGIN
provide custom rapidjson namespace (opening expression)
Definition: rapidjson.h:128
uint32_t
unsigned int uint32_t
Definition: stdint.h:127
uint64_t
unsigned __int64 uint64_t
Definition: stdint.h:137
internal::u32toa
char * u32toa(uint32_t value, char *buffer)
Definition: itoa.h:46
a
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1365
value
const GenericPointer< typename T::ValueType > T2 value
Definition: pointer.h:1518
int64_t
signed __int64 int64_t
Definition: stdint.h:136
int32_t
signed int int32_t
Definition: stdint.h:124
internal::i64toa
char * i64toa(int64_t value, char *buffer)
Definition: itoa.h:274
internal::i32toa
char * i32toa(int32_t value, char *buffer)
Definition: itoa.h:113

livox_ros_driver
Author(s): Livox Dev Team
autogenerated on Mon Mar 15 2021 02:40:46