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 "someip/LengthHelper.h"
14 : #include "someip/PrimitiveTypes.h"
15 : #include "someip/SomeIpParser.h"
16 : #include "someip/SomeIpSerializer.h"
17 : #include "someip/StringEncoding.h"
18 :
19 : #include <etl/string.h>
20 :
21 : namespace someip
22 : {
23 : namespace internal
24 : {
25 : /// \cond INTERNAL
26 : template<size_t S>
27 : struct GetSizeHelper<::etl::string<S>>
28 : {
29 : static uint32_t
30 2 : getSize(::etl::string<S> const& t, size_t const lengthSize, Encoding const encoding)
31 : {
32 2 : uint32_t const bomLength = EncodingHelper::encodingLength(encoding);
33 2 : uint32_t const termLength = EncodingHelper::terminationLength(encoding);
34 :
35 : // static string
36 2 : if (lengthSize == 0U)
37 : {
38 : return static_cast<uint32_t>(
39 1 : (t.max_size() * sizeof(char)) - 1U + bomLength + termLength);
40 : }
41 :
42 : // dynamic string
43 : return static_cast<uint32_t>(
44 1 : (lengthSize + (t.size() * sizeof(char))) + bomLength + termLength);
45 : }
46 : };
47 :
48 : /// \endcond
49 :
50 : } // namespace internal
51 : } // namespace someip
52 :
53 : namespace someip
54 : {
55 : /*
56 : * Base class string parser for both static and dynamic strings
57 : */
58 : class StringParser
59 : {
60 : protected:
61 : static bool parseBom(SomeIpParser& parser, char const* bom, uint32_t bomLength);
62 :
63 : static void readAndSkipNulls(SomeIpParser& parser, ::etl::istring& str, uint32_t nulls);
64 : };
65 :
66 : /*
67 : * Base class string serializer for both static and dynamic strings
68 : */
69 : class StringSerializer
70 : {
71 : protected:
72 : static void writeStringBytes(
73 : SomeIpSerializer& serializer, ::etl::istring const& str, Encoding encoding, uint32_t nulls);
74 : };
75 :
76 : /**
77 : * StaticStringParser is a helper class used for reading a SOME/IP fixed-length string from
78 : * an array of bytes. This class is used by the SOME/IP code generator.
79 : */
80 : class StaticStringParser : public StringParser
81 : {
82 : public:
83 : /**
84 : * A helper friend function for reading in a fixed-length string.
85 : *
86 : * \param parser The SOME/IP parser.
87 : * \param str The container object that holds the string to be parsed.
88 : */
89 : static void readString(SomeIpParser& parser, ::etl::istring& str, Encoding encoding);
90 :
91 : private:
92 : static void
93 : readUtf8Bytes(SomeIpParser& parser, ::etl::istring& str, uint32_t terminationLength);
94 :
95 : static void
96 : readUtf16Bytes(SomeIpParser& parser, ::etl::istring& str, uint32_t terminationLength);
97 : };
98 :
99 : class StaticStringSerializer : public StringSerializer
100 : {
101 : public:
102 : static void
103 : writeString(SomeIpSerializer& serializer, ::etl::istring const& str, Encoding encoding);
104 : };
105 :
106 : template<class LENGTH_TYPE>
107 : class DynamicStringSerializer : public StringSerializer
108 : {
109 : public:
110 : static void
111 : writeString(SomeIpSerializer& serializer, ::etl::istring const& str, Encoding encoding);
112 : };
113 :
114 : class DynamicStringParserBase : public StringParser
115 : {
116 : protected:
117 : static void parseStringBytes(
118 : SomeIpParser& parser, ::etl::istring& str, Encoding encoding, uint32_t numBytes);
119 : };
120 :
121 : template<class LENGTH_TYPE>
122 : class DynamicStringParser : public DynamicStringParserBase
123 : {
124 : public:
125 : static void readString(SomeIpParser& parser, ::etl::istring& str, Encoding encoding);
126 : };
127 :
128 : /*
129 : * inline implementation
130 : */
131 :
132 : /*
133 : * DynamicStringSerializer
134 : */
135 : // static
136 : template<class LENGTH_TYPE>
137 3 : void DynamicStringSerializer<LENGTH_TYPE>::writeString(
138 : SomeIpSerializer& serializer, ::etl::istring const& str, Encoding const encoding)
139 : {
140 3 : if (!serializer.isGood())
141 : {
142 1 : return;
143 : }
144 :
145 2 : LengthSerializerHelper<LENGTH_TYPE> const helper(serializer);
146 :
147 2 : uint32_t const nulls = internal::EncodingHelper::terminationLength(encoding);
148 :
149 2 : writeStringBytes(serializer, str, encoding, nulls);
150 2 : }
151 :
152 : /*
153 : * DynamicStringParser
154 : */
155 : template<class LENGTH_TYPE>
156 10 : void DynamicStringParser<LENGTH_TYPE>::readString(
157 : SomeIpParser& parser, ::etl::istring& str, Encoding const encoding)
158 : {
159 10 : if (!parser.isGood())
160 : {
161 1 : return;
162 : }
163 :
164 9 : str.clear();
165 :
166 9 : uint32_t const numBytes = LengthParserHelper<LENGTH_TYPE>::parseLength(parser);
167 9 : if (numBytes == 0U)
168 : {
169 2 : return;
170 : }
171 :
172 7 : parseStringBytes(parser, str, encoding, numBytes);
173 : }
174 :
175 : } // namespace someip
|
