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