Line data Source code
1 : /********************************************************************************
2 : * Copyright (c) 2026 Accenture
3 : *
4 : * This program and the accompanying materials are made available under the
5 : * terms of the Apache License Version 2.0 which is available at
6 : * https://www.apache.org/licenses/LICENSE-2.0
7 : *
8 : * SPDX-License-Identifier: Apache-2.0
9 : ********************************************************************************/
10 :
11 : #pragma once
12 :
13 : #include <cstdint>
14 :
15 : namespace someip
16 : {
17 : enum class Encoding : uint8_t
18 : {
19 : SOMEIP_ENCODING_UNKNOWN,
20 : SOMEIP_ENCODING_UTF8,
21 : SOMEIP_ENCODING_UTF16LE,
22 : SOMEIP_ENCODING_UTF16BE,
23 : SOMEIP_ENCODING_UTF8_NO_ZERO,
24 : SOMEIP_ENCODING_NO_BOM_NO_ZERO,
25 : SOMEIP_ENCODING_NO_BOM
26 : };
27 :
28 : struct UTF8
29 : {
30 : static uint32_t const BOM_LENGTH = 3U;
31 : static uint32_t const TERMINATION_LENGTH = 1U;
32 :
33 : UTF8() = delete;
34 : UTF8(UTF8 const&) = delete;
35 : UTF8& operator=(UTF8 const&) = delete;
36 :
37 : struct MinStringLength
38 : {
39 : static uint32_t const value = BOM_LENGTH + TERMINATION_LENGTH;
40 : };
41 :
42 : template<uint32_t N>
43 : struct MaxStringLength
44 : {
45 : static uint32_t const value = (N - BOM_LENGTH) - TERMINATION_LENGTH;
46 : };
47 :
48 11 : static char const* BOM()
49 : {
50 11 : char const* const bom = "\xEF\xBB\xBF";
51 11 : return bom;
52 : }
53 : };
54 :
55 : struct UTF16LE
56 : {
57 : static uint32_t const BOM_LENGTH = 2U;
58 : static uint32_t const TERMINATION_LENGTH = 2U;
59 :
60 : UTF16LE() = delete;
61 : UTF16LE(UTF16LE const&) = delete;
62 : UTF16LE& operator=(UTF16LE const&) = delete;
63 :
64 : struct MinStringLength
65 : {
66 : static uint32_t const value = BOM_LENGTH + TERMINATION_LENGTH;
67 : };
68 :
69 : template<uint32_t N>
70 : struct MaxStringLength
71 : {
72 : static uint32_t const value
73 : = (N - BOM_LENGTH)
74 : - (((N % 2U) == 1U) ? (TERMINATION_LENGTH + 1U) : TERMINATION_LENGTH);
75 : };
76 :
77 10 : static char const* BOM()
78 : {
79 10 : char const* const bom = "\xFF\xFE";
80 10 : return bom;
81 : }
82 : };
83 :
84 : struct UTF16BE
85 : {
86 : static uint32_t const BOM_LENGTH = 2U;
87 : static uint32_t const TERMINATION_LENGTH = 2U;
88 :
89 : UTF16BE() = delete;
90 : UTF16BE(UTF16BE const&) = delete;
91 : UTF16BE& operator=(UTF16BE const&) = delete;
92 :
93 : struct MinStringLength
94 : {
95 : static uint32_t const value = BOM_LENGTH + TERMINATION_LENGTH;
96 : };
97 :
98 : template<uint32_t N>
99 : struct MaxStringLength
100 : {
101 : static uint32_t const value
102 : = (N - BOM_LENGTH)
103 : - (((N % 2U) == 1U) ? (TERMINATION_LENGTH + 1U) : TERMINATION_LENGTH);
104 : };
105 :
106 4 : static char const* BOM()
107 : {
108 4 : char const* const bom = "\xFE\xFF";
109 4 : return bom;
110 : }
111 : };
112 :
113 : struct UTF8NoZero
114 : {
115 : static uint32_t const BOM_LENGTH = 3U;
116 : static uint32_t const TERMINATION_LENGTH = 0U;
117 :
118 : UTF8NoZero() = delete;
119 : UTF8NoZero(UTF8NoZero const&) = delete;
120 : UTF8NoZero& operator=(UTF8NoZero const&) = delete;
121 :
122 : struct MinStringLength
123 : {
124 : static uint32_t const value = BOM_LENGTH;
125 : };
126 :
127 : template<uint32_t N>
128 : struct MaxStringLength
129 : {
130 : static uint32_t const value = N - BOM_LENGTH;
131 : };
132 :
133 2 : static char const* BOM()
134 : {
135 2 : char const* const bom = "\xEF\xBB\xBF";
136 2 : return bom;
137 : }
138 : };
139 :
140 : struct NoBomNoZero
141 : {
142 : static uint32_t const BOM_LENGTH = 0U;
143 : static uint32_t const TERMINATION_LENGTH = 0U;
144 :
145 : NoBomNoZero() = delete;
146 : NoBomNoZero(NoBomNoZero const&) = delete;
147 : NoBomNoZero& operator=(NoBomNoZero const&) = delete;
148 :
149 : struct MinStringLength
150 : {
151 : static uint32_t const value = 0U;
152 : };
153 :
154 : template<uint32_t N>
155 : struct MaxStringLength
156 : {
157 : static uint32_t const value = N;
158 : };
159 :
160 2 : static char const* BOM()
161 : {
162 2 : char const* const bom = "";
163 2 : return bom;
164 : }
165 : };
166 :
167 : struct NoBom
168 : {
169 : static uint32_t const BOM_LENGTH = 0U;
170 : static uint32_t const TERMINATION_LENGTH = 1U;
171 :
172 : NoBom() = delete;
173 : NoBom(NoBom const&) = delete;
174 : NoBom& operator=(NoBom const&) = delete;
175 :
176 : struct MinStringLength
177 : {
178 : static uint32_t const value = TERMINATION_LENGTH;
179 : };
180 :
181 : template<uint32_t N>
182 : struct MaxStringLength
183 : {
184 : static uint32_t const value = N - TERMINATION_LENGTH;
185 : };
186 :
187 2 : static char const* BOM()
188 : {
189 2 : char const* const bom = "";
190 2 : return bom;
191 : }
192 : };
193 :
194 : } // namespace someip
195 :
196 : namespace someip
197 : {
198 : namespace internal
199 : {
200 : struct EncodingHelper
201 : {
202 : EncodingHelper() = delete;
203 : EncodingHelper(EncodingHelper const&) = delete;
204 : EncodingHelper& operator=(EncodingHelper const&) = delete;
205 :
206 33 : static uint32_t encodingLength(Encoding const e)
207 : {
208 33 : switch (e)
209 : {
210 13 : case Encoding::SOMEIP_ENCODING_UTF8:
211 : {
212 13 : return UTF8::BOM_LENGTH;
213 : }
214 10 : case Encoding::SOMEIP_ENCODING_UTF16LE:
215 : {
216 10 : return UTF16LE::BOM_LENGTH;
217 : }
218 4 : case Encoding::SOMEIP_ENCODING_UTF16BE:
219 : {
220 4 : return UTF16BE::BOM_LENGTH;
221 : }
222 2 : case Encoding::SOMEIP_ENCODING_UTF8_NO_ZERO:
223 : {
224 2 : return UTF8NoZero::BOM_LENGTH;
225 : }
226 2 : case Encoding::SOMEIP_ENCODING_NO_BOM_NO_ZERO:
227 : {
228 2 : return NoBomNoZero::BOM_LENGTH;
229 : }
230 2 : case Encoding::SOMEIP_ENCODING_NO_BOM:
231 : {
232 2 : return NoBom::BOM_LENGTH;
233 : }
234 0 : default:
235 : {
236 0 : return 0U;
237 : }
238 : }
239 : }
240 :
241 34 : static uint32_t terminationLength(Encoding const e)
242 : {
243 34 : switch (e)
244 : {
245 13 : case Encoding::SOMEIP_ENCODING_UTF8:
246 : {
247 13 : return UTF8::TERMINATION_LENGTH;
248 : }
249 10 : case Encoding::SOMEIP_ENCODING_UTF16LE:
250 : {
251 10 : return UTF16LE::TERMINATION_LENGTH;
252 : }
253 4 : case Encoding::SOMEIP_ENCODING_UTF16BE:
254 : {
255 4 : return UTF16BE::TERMINATION_LENGTH;
256 : }
257 2 : case Encoding::SOMEIP_ENCODING_UTF8_NO_ZERO:
258 : {
259 2 : return UTF8NoZero::TERMINATION_LENGTH;
260 : }
261 2 : case Encoding::SOMEIP_ENCODING_NO_BOM_NO_ZERO:
262 : {
263 2 : return NoBomNoZero::TERMINATION_LENGTH;
264 : }
265 2 : case Encoding::SOMEIP_ENCODING_NO_BOM:
266 : {
267 2 : return NoBom::TERMINATION_LENGTH;
268 : }
269 1 : default:
270 : {
271 1 : return 0U;
272 : }
273 : }
274 : }
275 :
276 32 : static char const* bom(Encoding const e)
277 : {
278 32 : switch (e)
279 : {
280 11 : case Encoding::SOMEIP_ENCODING_UTF8:
281 : {
282 11 : return UTF8::BOM();
283 : }
284 10 : case Encoding::SOMEIP_ENCODING_UTF16LE:
285 : {
286 10 : return UTF16LE::BOM();
287 : }
288 4 : case Encoding::SOMEIP_ENCODING_UTF16BE:
289 : {
290 4 : return UTF16BE::BOM();
291 : }
292 2 : case Encoding::SOMEIP_ENCODING_UTF8_NO_ZERO:
293 : {
294 2 : return UTF8NoZero::BOM();
295 : }
296 2 : case Encoding::SOMEIP_ENCODING_NO_BOM_NO_ZERO:
297 : {
298 2 : return NoBomNoZero::BOM();
299 : }
300 2 : case Encoding::SOMEIP_ENCODING_NO_BOM:
301 : {
302 2 : return NoBom::BOM();
303 : }
304 1 : default:
305 : {
306 1 : return nullptr;
307 : }
308 : }
309 : }
310 : };
311 :
312 : } // namespace internal
313 : } // namespace someip
|
