Line | Branch | Exec | Source |
---|---|---|---|
1 | /** | ||
2 | * @file lib.CharTrait.hpp | ||
3 | * @author Sergey Baigudin, sergey@baigudin.software | ||
4 | * @copyright 2022, Sergey Baigudin, Baigudin Software | ||
5 | */ | ||
6 | #ifndef LIB_CHARTRAIT_HPP_ | ||
7 | #define LIB_CHARTRAIT_HPP_ | ||
8 | |||
9 | #include "Types.hpp" | ||
10 | |||
11 | namespace eoos | ||
12 | { | ||
13 | namespace lib | ||
14 | { | ||
15 | |||
16 | /** | ||
17 | * @struct CharTrait<T> | ||
18 | * @brief Abstract basic character operations. | ||
19 | * | ||
20 | * Has explicit template specializations for char_t, wchar_t, char16_t, char32_t, char8_t types. | ||
21 | * | ||
22 | * @tparam T A data type of string characters. | ||
23 | */ | ||
24 | template <typename T> | ||
25 | struct CharTrait | ||
26 | { | ||
27 | /** | ||
28 | * @brief Returns the terminating null character. | ||
29 | * | ||
30 | * @return A character means a null-terminated string is terminated. | ||
31 | */ | ||
32 | static T getTerminator(); | ||
33 | |||
34 | /** | ||
35 | * @brief Converts an integer to a character. | ||
36 | * | ||
37 | * @param val A value that would be converted to a character. | ||
38 | * @return Converted character as integer. | ||
39 | * | ||
40 | * @tparam I An integer data type to be converted. | ||
41 | */ | ||
42 | template <typename I> | ||
43 | static T convertDigitToChar(I val); | ||
44 | |||
45 | /** | ||
46 | * @brief Returns minus sign. | ||
47 | * | ||
48 | * @return Minus sign. | ||
49 | */ | ||
50 | static T getMinusSign(); | ||
51 | }; | ||
52 | |||
53 | |||
54 | /** | ||
55 | * @struct CharTrait<char_t> | ||
56 | * @brief Ordinary character literal. | ||
57 | */ | ||
58 | template <> | ||
59 | struct CharTrait<char_t> | ||
60 | { | ||
61 | /** | ||
62 | * @copydoc eoos::lib::CharTrait<T>::getTerminator() | ||
63 | */ | ||
64 | 1737 | static char_t getTerminator() | |
65 | { | ||
66 | 1737 | return '\0'; | |
67 | } | ||
68 | |||
69 | /** | ||
70 | * @copydoc eoos::lib::CharTrait<T>::convertDigitToChar(I) | ||
71 | */ | ||
72 | template <typename I> | ||
73 | 3020 | static char_t convertDigitToChar(I val) | |
74 | { | ||
75 | 3020 | char_t ch( ' ' ); | |
76 |
16/17✓ Branch 0 taken 63 times.
✓ Branch 1 taken 831 times.
✓ Branch 2 taken 56 times.
✓ Branch 3 taken 53 times.
✓ Branch 4 taken 48 times.
✓ Branch 5 taken 38 times.
✓ Branch 6 taken 36 times.
✓ Branch 7 taken 334 times.
✓ Branch 8 taken 29 times.
✓ Branch 9 taken 21 times.
✓ Branch 10 taken 18 times.
✓ Branch 11 taken 18 times.
✓ Branch 12 taken 15 times.
✓ Branch 13 taken 11 times.
✓ Branch 14 taken 9 times.
✓ Branch 15 taken 179 times.
✗ Branch 16 not taken.
|
3020 | switch(val) |
77 | { | ||
78 | 116 | case 0x00: { ch = '0'; break;} | |
79 | 1398 | case 0x01: { ch = '1'; break;} | |
80 | 106 | case 0x02: { ch = '2'; break;} | |
81 | 98 | case 0x03: { ch = '3'; break;} | |
82 | 86 | case 0x04: { ch = '4'; break;} | |
83 | 66 | case 0x05: { ch = '5'; break;} | |
84 | 66 | case 0x06: { ch = '6'; break;} | |
85 | 568 | case 0x07: { ch = '7'; break;} | |
86 | 52 | case 0x08: { ch = '8'; break;} | |
87 | 38 | case 0x09: { ch = '9'; break;} | |
88 | 34 | case 0x0A: { ch = 'a'; break;} | |
89 | 34 | case 0x0B: { ch = 'b'; break;} | |
90 | 28 | case 0x0C: { ch = 'c'; break;} | |
91 | 20 | case 0x0D: { ch = 'd'; break;} | |
92 | 16 | case 0x0E: { ch = 'e'; break;} | |
93 | 294 | case 0x0F: { ch = 'f'; break;} | |
94 | ✗ | default: { ch = ' '; break;} ///< UT Justified Branch: SCA dependency | |
95 | } | ||
96 | 3020 | return ch; | |
97 | } | ||
98 | |||
99 | /** | ||
100 | * @copydoc eoos::lib::CharTrait<T>::getMinusSign() | ||
101 | */ | ||
102 | 16 | static char_t getMinusSign() | |
103 | { | ||
104 | 16 | return '-'; | |
105 | } | ||
106 | }; | ||
107 | |||
108 | /** | ||
109 | * @struct CharTrait<wchar_t> | ||
110 | * @brief Wide character literal. | ||
111 | */ | ||
112 | template <> | ||
113 | struct CharTrait<wchar_t> | ||
114 | { | ||
115 | /** | ||
116 | * @copydoc eoos::lib::CharTrait<T>::getTerminator() | ||
117 | */ | ||
118 | static wchar_t getTerminator() | ||
119 | { | ||
120 | return L'\0'; | ||
121 | } | ||
122 | |||
123 | /** | ||
124 | * @copydoc eoos::lib::CharTrait<T>::convertDigitToChar(I) | ||
125 | */ | ||
126 | template <typename I> | ||
127 | static wchar_t convertDigitToChar(I val) | ||
128 | { | ||
129 | wchar_t ch( L' ' ); ///< SCA MISRA-C++:2008 Defected Rule 5-0-11 | ||
130 | switch(val) | ||
131 | { | ||
132 | case 0x00: { ch = L'0'; break;} ///< SCA MISRA-C++:2008 Defected Rule 5-0-11 | ||
133 | case 0x01: { ch = L'1'; break;} ///< SCA MISRA-C++:2008 Defected Rule 5-0-11 | ||
134 | case 0x02: { ch = L'2'; break;} ///< SCA MISRA-C++:2008 Defected Rule 5-0-11 | ||
135 | case 0x03: { ch = L'3'; break;} ///< SCA MISRA-C++:2008 Defected Rule 5-0-11 | ||
136 | case 0x04: { ch = L'4'; break;} ///< SCA MISRA-C++:2008 Defected Rule 5-0-11 | ||
137 | case 0x05: { ch = L'5'; break;} ///< SCA MISRA-C++:2008 Defected Rule 5-0-11 | ||
138 | case 0x06: { ch = L'6'; break;} ///< SCA MISRA-C++:2008 Defected Rule 5-0-11 | ||
139 | case 0x07: { ch = L'7'; break;} ///< SCA MISRA-C++:2008 Defected Rule 5-0-11 | ||
140 | case 0x08: { ch = L'8'; break;} ///< SCA MISRA-C++:2008 Defected Rule 5-0-11 | ||
141 | case 0x09: { ch = L'9'; break;} ///< SCA MISRA-C++:2008 Defected Rule 5-0-11 | ||
142 | case 0x0A: { ch = L'a'; break;} ///< SCA MISRA-C++:2008 Defected Rule 5-0-11 | ||
143 | case 0x0B: { ch = L'b'; break;} ///< SCA MISRA-C++:2008 Defected Rule 5-0-11 | ||
144 | case 0x0C: { ch = L'c'; break;} ///< SCA MISRA-C++:2008 Defected Rule 5-0-11 | ||
145 | case 0x0D: { ch = L'd'; break;} ///< SCA MISRA-C++:2008 Defected Rule 5-0-11 | ||
146 | case 0x0E: { ch = L'e'; break;} ///< SCA MISRA-C++:2008 Defected Rule 5-0-11 | ||
147 | case 0x0F: { ch = L'f'; break;} ///< SCA MISRA-C++:2008 Defected Rule 5-0-11 | ||
148 | default: { ch = L' '; break;} ///< SCA MISRA-C++:2008 Defected Rule 5-0-11 and UT Justified Branch: SCA dependency | ||
149 | } | ||
150 | return ch; | ||
151 | } | ||
152 | |||
153 | /** | ||
154 | * @copydoc eoos::lib::CharTrait<T>::getMinusSign() | ||
155 | */ | ||
156 | static wchar_t getMinusSign() | ||
157 | { | ||
158 | return L'-'; | ||
159 | } | ||
160 | }; | ||
161 | |||
162 | #if EOOS_CPP_STANDARD >= 2011 | ||
163 | |||
164 | /** | ||
165 | * @struct CharTrait<char16_t> | ||
166 | * @brief UTF-16 character literal. | ||
167 | */ | ||
168 | template <> | ||
169 | struct CharTrait<char16_t> | ||
170 | { | ||
171 | /** | ||
172 | * @copydoc eoos::lib::CharTrait<T>::getTerminator() | ||
173 | */ | ||
174 | static char16_t getTerminator() | ||
175 | { | ||
176 | return u'\0'; | ||
177 | } | ||
178 | |||
179 | /** | ||
180 | * @copydoc eoos::lib::CharTrait<T>::convertDigitToChar(I) | ||
181 | */ | ||
182 | template <typename I> | ||
183 | static char16_t convertDigitToChar(I val) | ||
184 | { | ||
185 | char16_t ch( u' ' ); | ||
186 | switch(val) | ||
187 | { | ||
188 | case 0x00: { ch = u'0'; break;} | ||
189 | case 0x01: { ch = u'1'; break;} | ||
190 | case 0x02: { ch = u'2'; break;} | ||
191 | case 0x03: { ch = u'3'; break;} | ||
192 | case 0x04: { ch = u'4'; break;} | ||
193 | case 0x05: { ch = u'5'; break;} | ||
194 | case 0x06: { ch = u'6'; break;} | ||
195 | case 0x07: { ch = u'7'; break;} | ||
196 | case 0x08: { ch = u'8'; break;} | ||
197 | case 0x09: { ch = u'9'; break;} | ||
198 | case 0x0A: { ch = u'a'; break;} | ||
199 | case 0x0B: { ch = u'b'; break;} | ||
200 | case 0x0C: { ch = u'c'; break;} | ||
201 | case 0x0D: { ch = u'd'; break;} | ||
202 | case 0x0E: { ch = u'e'; break;} | ||
203 | case 0x0F: { ch = u'f'; break;} | ||
204 | default: { ch = u' '; break;} ///< UT Justified Branch: SCA dependency | ||
205 | } | ||
206 | return ch; | ||
207 | } | ||
208 | |||
209 | /** | ||
210 | * @copydoc eoos::lib::CharTrait<T>::getMinusSign() | ||
211 | */ | ||
212 | static char16_t getMinusSign() | ||
213 | { | ||
214 | return u'-'; | ||
215 | } | ||
216 | }; | ||
217 | |||
218 | /** | ||
219 | * @struct CharTrait<char32_t> | ||
220 | * @brief UTF-32 character literal. | ||
221 | */ | ||
222 | template <> | ||
223 | struct CharTrait<char32_t> | ||
224 | { | ||
225 | /** | ||
226 | * @copydoc eoos::lib::CharTrait<T>::getTerminator() | ||
227 | */ | ||
228 | static char32_t getTerminator() | ||
229 | { | ||
230 | return U'\0'; | ||
231 | } | ||
232 | |||
233 | /** | ||
234 | * @copydoc eoos::lib::CharTrait<T>::convertDigitToChar(I) | ||
235 | */ | ||
236 | template <typename I> | ||
237 | static char32_t convertDigitToChar(I val) | ||
238 | { | ||
239 | char32_t ch( U' ' ); | ||
240 | switch(val) | ||
241 | { | ||
242 | case 0x00: { ch = U'0'; break;} | ||
243 | case 0x01: { ch = U'1'; break;} | ||
244 | case 0x02: { ch = U'2'; break;} | ||
245 | case 0x03: { ch = U'3'; break;} | ||
246 | case 0x04: { ch = U'4'; break;} | ||
247 | case 0x05: { ch = U'5'; break;} | ||
248 | case 0x06: { ch = U'6'; break;} | ||
249 | case 0x07: { ch = U'7'; break;} | ||
250 | case 0x08: { ch = U'8'; break;} | ||
251 | case 0x09: { ch = U'9'; break;} | ||
252 | case 0x0A: { ch = U'a'; break;} | ||
253 | case 0x0B: { ch = U'b'; break;} | ||
254 | case 0x0C: { ch = U'c'; break;} | ||
255 | case 0x0D: { ch = U'd'; break;} | ||
256 | case 0x0E: { ch = U'e'; break;} | ||
257 | case 0x0F: { ch = U'f'; break;} | ||
258 | default: { ch = U' '; break;} ///< UT Justified Branch: SCA dependency | ||
259 | } | ||
260 | return ch; | ||
261 | } | ||
262 | |||
263 | /** | ||
264 | * @copydoc eoos::lib::CharTrait<T>::getMinusSign() | ||
265 | */ | ||
266 | static char32_t getMinusSign() | ||
267 | { | ||
268 | return U'-'; | ||
269 | } | ||
270 | }; | ||
271 | |||
272 | #endif // EOOS_CPP_STANDARD >= 2011 | ||
273 | |||
274 | #if EOOS_CPP_STANDARD >= 2020 | ||
275 | |||
276 | /** | ||
277 | * @struct CharTrait<char8_t> | ||
278 | * @brief UTF-8 character literal. | ||
279 | */ | ||
280 | template <> | ||
281 | struct CharTrait<char8_t> | ||
282 | { | ||
283 | /** | ||
284 | * @copydoc eoos::lib::CharTrait<T>::getTerminator() | ||
285 | */ | ||
286 | static char8_t getTerminator() | ||
287 | { | ||
288 | return u8'\0'; | ||
289 | } | ||
290 | |||
291 | /** | ||
292 | * @copydoc eoos::lib::CharTrait<T>::convertDigitToChar(I) | ||
293 | */ | ||
294 | template <typename I> | ||
295 | static char8_t convertDigitToChar(I val) | ||
296 | { | ||
297 | char8_t ch( u8' ' ); | ||
298 | switch(val) | ||
299 | { | ||
300 | case 0x00: { ch = u8'0'; break;} | ||
301 | case 0x01: { ch = u8'1'; break;} | ||
302 | case 0x02: { ch = u8'2'; break;} | ||
303 | case 0x03: { ch = u8'3'; break;} | ||
304 | case 0x04: { ch = u8'4'; break;} | ||
305 | case 0x05: { ch = u8'5'; break;} | ||
306 | case 0x06: { ch = u8'6'; break;} | ||
307 | case 0x07: { ch = u8'7'; break;} | ||
308 | case 0x08: { ch = u8'8'; break;} | ||
309 | case 0x09: { ch = u8'9'; break;} | ||
310 | case 0x0A: { ch = u8'a'; break;} | ||
311 | case 0x0B: { ch = u8'b'; break;} | ||
312 | case 0x0C: { ch = u8'c'; break;} | ||
313 | case 0x0D: { ch = u8'd'; break;} | ||
314 | case 0x0E: { ch = u8'e'; break;} | ||
315 | case 0x0F: { ch = u8'f'; break;} | ||
316 | default: { ch = u8' '; break;} ///< UT Justified Branch: SCA dependency | ||
317 | } | ||
318 | return ch; | ||
319 | } | ||
320 | |||
321 | /** | ||
322 | * @copydoc eoos::lib::CharTrait<T>::getMinusSign() | ||
323 | */ | ||
324 | static char8_t getMinusSign() | ||
325 | { | ||
326 | return u8'-'; | ||
327 | } | ||
328 | }; | ||
329 | |||
330 | #endif // EOOS_CPP_STANDARD >= 2020 | ||
331 | |||
332 | } // namespace lib | ||
333 | } // namespace eoos | ||
334 | #endif // LIB_CHARTRAIT_HPP_ | ||
335 |