1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #ifndef ARK_WEB_TYPES_H_
17 #define ARK_WEB_TYPES_H_
18 #pragma once
19
20 #include <list>
21 #include <map>
22 #include <string>
23 #include <vector>
24
25 #include "base/include/ark_web_macros.h"
26 #include "base/include/ark_web_memory.h"
27 #include "base/include/ark_web_scoped_refptr.h"
28
29 template<class T>
30 using ArkWebRefPtr = ark_web_scoped_refptr<T>;
31
32 typedef struct {
33 int size;
34 char* value;
35
36 ArkWebMemFreeFunc ark_web_mem_free_func;
37 } ArkWebCharVector;
38
39 const ArkWebCharVector ark_web_char_vector_default = {
40 0,
41 };
42
43 typedef struct {
44 int size;
45 uint8_t* value;
46
47 ArkWebMemFreeFunc ark_web_mem_free_func;
48 } ArkWebUint8Vector;
49
50 const ArkWebUint8Vector ark_web_uint8_vector_default = {
51 0,
52 };
53
54 typedef struct {
55 int size;
56 uint16_t* value;
57
58 ArkWebMemFreeFunc ark_web_mem_free_func;
59 } ArkWebUint16Vector;
60
61 const ArkWebUint16Vector ark_web_uint16_vector_default = {
62 0,
63 };
64
65 typedef struct {
66 int size;
67 int32_t* value;
68
69 ArkWebMemFreeFunc ark_web_mem_free_func;
70 } ArkWebInt32Vector;
71
72 const ArkWebInt32Vector ark_web_int32_vector_default = {
73 0,
74 };
75
76 typedef struct {
77 int size;
78 int64_t* value;
79
80 ArkWebMemFreeFunc ark_web_mem_free_func;
81 } ArkWebInt64Vector;
82
83 const ArkWebInt64Vector ark_web_int64_vector_default = {
84 0,
85 };
86
87 typedef struct {
88 int size;
89 uint32_t* value;
90
91 ArkWebMemFreeFunc ark_web_mem_free_func;
92 } ArkWebUint32Vector;
93
94 const ArkWebUint32Vector ark_web_uint32_vector_default = {
95 0,
96 };
97
98 typedef struct {
99 int size;
100 double* value;
101
102 ArkWebMemFreeFunc ark_web_mem_free_func;
103 } ArkWebDoubleVector;
104
105 const ArkWebDoubleVector ark_web_double_vector_default = {
106 0,
107 };
108
109 typedef struct {
110 int size;
111 bool* value;
112
113 ArkWebMemFreeFunc ark_web_mem_free_func;
114 } ArkWebBooleanVector;
115
116 const ArkWebBooleanVector ark_web_boolean_vector_default = {
117 0,
118 };
119
120 typedef struct {
121 int size;
122 int32_t* value;
123
124 ArkWebMemFreeFunc ark_web_mem_free_func;
125 } ArkWebInt32List;
126
127 const ArkWebInt32List ark_web_int32_list_default = {
128 0,
129 };
130
131 typedef struct {
132 int size;
133 char* value;
134
135 ArkWebMemFreeFunc ark_web_mem_free_func;
136 } ArkWebString;
137
138 const ArkWebString ark_web_string_default = {
139 0,
140 };
141
142 typedef struct {
143 int size;
144 char16_t* value;
145
146 ArkWebMemFreeFunc ark_web_mem_free_func;
147 } ArkWebU16String;
148
149 const ArkWebU16String ark_web_u16string_default = {
150 0,
151 };
152
153 typedef struct {
154 int size;
155 ArkWebString* key;
156 ArkWebString* value;
157
158 ArkWebMemFreeFunc ark_web_mem_free_func;
159 } ArkWebStringMap;
160
161 const ArkWebStringMap ark_web_string_map_default = {
162 0,
163 };
164
165 typedef struct {
166 int size;
167 ArkWebString* value;
168
169 ArkWebMemFreeFunc ark_web_mem_free_func;
170 } ArkWebStringList;
171
172 const ArkWebStringList ark_web_string_list_default = {
173 0,
174 };
175
176 typedef struct {
177 int size;
178 ArkWebString* value;
179
180 ArkWebMemFreeFunc ark_web_mem_free_func;
181 } ArkWebStringVector;
182
183 const ArkWebStringVector ark_web_string_vector_default = {
184 0,
185 };
186
187 typedef struct {
188 int size;
189 ArkWebString* key;
190 ArkWebStringVector* value;
191
192 ArkWebMemFreeFunc ark_web_mem_free_func;
193 } ArkWebStringVectorMap;
194
195 const ArkWebStringVectorMap ark_web_string_vector_map_default = {
196 0,
197 };
198
199 template<typename T1, typename T2, typename R>
ArkWebBasicMapClassToStruct(const std::map<T1,T2> & class_value)200 R ArkWebBasicMapClassToStruct(const std::map<T1, T2>& class_value)
201 {
202 R struct_value = { .size = class_value.size(), .ark_web_mem_free_func = ArkWebMemFree };
203 if (struct_value.size > 0) {
204 struct_value.key = (T1*)ArkWebMemMalloc(sizeof(T1) * struct_value.size);
205 struct_value.value = (T2*)ArkWebMemMalloc(sizeof(T2) * struct_value.size);
206 if (struct_value.key == nullptr || struct_value.value == nullptr) {
207 ArkWebMemFree(struct_value.key);
208 ArkWebMemFree(struct_value.value);
209 struct_value.size = 0;
210 return struct_value;
211 }
212
213 int count = 0;
214 for (auto it = class_value.begin(); it != class_value.end(); it++) {
215 struct_value.key[count] = it->first;
216 struct_value.value[count] = it->second;
217 count++;
218 }
219 }
220
221 return struct_value;
222 }
223
224 template<typename T1, typename T2, typename P>
ArkWebBasicMapStructToClass(const P & struct_value)225 std::map<T1, T2> ArkWebBasicMapStructToClass(const P& struct_value)
226 {
227 std::map<T1, T2> class_value;
228 if (struct_value.size > 0) {
229 for (int count = 0; count < struct_value.size; count++) {
230 class_value.insert(std::map<T1, T2>::value_type(struct_value.key[count], struct_value.value[count]));
231 }
232 }
233
234 return class_value;
235 }
236
237 template<typename P>
ArkWebBasicMapStructRelease(P & struct_value)238 void ArkWebBasicMapStructRelease(P& struct_value)
239 {
240 struct_value.size = 0;
241 SAFE_FREE(struct_value.key, struct_value.ark_web_mem_free_func);
242 SAFE_FREE(struct_value.value, struct_value.ark_web_mem_free_func);
243 }
244
245 template<typename T, typename R>
ArkWebBasicListClassToStruct(const std::list<T> & class_value)246 R ArkWebBasicListClassToStruct(const std::list<T>& class_value)
247 {
248 R struct_value = { .size = class_value.size(), .ark_web_mem_free_func = ArkWebMemFree };
249 if (struct_value.size > 0) {
250 struct_value.value = (T*)ArkWebMemMalloc(sizeof(T) * struct_value.size);
251 if (struct_value.value == nullptr) {
252 struct_value.size = 0;
253 return struct_value;
254 }
255
256 int count = 0;
257 for (auto it = class_value.begin(); it != class_value.end(); it++) {
258 struct_value.value[count] = *it;
259 count++;
260 }
261 }
262
263 return struct_value;
264 }
265
266 template<typename T, typename P>
ArkWebBasicListStructToClass(const P & struct_value)267 std::list<T> ArkWebBasicListStructToClass(const P& struct_value)
268 {
269 std::list<T> class_value;
270 if (struct_value.size > 0) {
271 for (int count = 0; count < struct_value.size; count++) {
272 class_value.push_back(struct_value.value[count]);
273 }
274 }
275
276 return class_value;
277 }
278
279 template<typename P>
ArkWebBasicListStructRelease(P & struct_value)280 void ArkWebBasicListStructRelease(P& struct_value)
281 {
282 struct_value.size = 0;
283 SAFE_FREE(struct_value.value, struct_value.ark_web_mem_free_func);
284 }
285
286 template<typename T, typename R>
ArkWebBasicVectorClassToStruct(const std::vector<T> & class_value)287 R ArkWebBasicVectorClassToStruct(const std::vector<T>& class_value)
288 {
289 R struct_value = { .size = class_value.size(), .ark_web_mem_free_func = ArkWebMemFree };
290 if (struct_value.size > 0) {
291 struct_value.value = (T*)ArkWebMemMalloc(sizeof(T) * struct_value.size);
292 if (struct_value.value == nullptr) {
293 struct_value.size = 0;
294 return struct_value;
295 }
296
297 int count = 0;
298 for (auto it = class_value.begin(); it != class_value.end(); it++) {
299 struct_value.value[count] = *it;
300 count++;
301 }
302 }
303
304 return struct_value;
305 }
306
307 template<typename T, typename P>
ArkWebBasicVectorStructToClass(const P & struct_value)308 std::vector<T> ArkWebBasicVectorStructToClass(const P& struct_value)
309 {
310 std::vector<T> class_value;
311 if (struct_value.size > 0) {
312 for (int count = 0; count < struct_value.size; count++) {
313 class_value.push_back(struct_value.value[count]);
314 }
315 }
316
317 return class_value;
318 }
319
320 template<typename P>
ArkWebBasicVectorStructRelease(P & struct_value)321 void ArkWebBasicVectorStructRelease(P& struct_value)
322 {
323 struct_value.size = 0;
324 SAFE_FREE(struct_value.value, struct_value.ark_web_mem_free_func);
325 }
326
327 ArkWebString ArkWebStringClassToStruct(const std::string& class_value);
328
329 std::string ArkWebStringStructToClass(const ArkWebString& struct_value);
330
331 ArkWebU16String ArkWebU16StringClassToStruct(const std::u16string& class_value);
332
333 std::u16string ArkWebU16StringStructToClass(const ArkWebU16String& struct_value);
334
335 void ArkWebStringStructRelease(ArkWebString& struct_value);
336
337 void ArkWebU16StringStructRelease(ArkWebU16String& struct_value);
338
339 ArkWebStringMap ArkWebStringMapClassToStruct(const std::map<std::string, std::string>& class_value);
340
341 std::map<std::string, std::string> ArkWebStringMapStructToClass(const ArkWebStringMap& struct_value);
342
343 void ArkWebStringMapStructRelease(ArkWebStringMap& struct_value);
344
345 ArkWebStringList ArkWebStringListClassToStruct(const std::list<std::string>& class_value);
346
347 std::list<std::string> ArkWebStringListStructToClass(const ArkWebStringList& struct_value);
348
349 void ArkWebStringListStructRelease(ArkWebStringList& struct_value);
350
351 ArkWebStringVector ArkWebStringVectorClassToStruct(const std::vector<std::string>& class_value);
352
353 std::vector<std::string> ArkWebStringVectorStructToClass(const ArkWebStringVector& struct_value);
354
355 void ArkWebStringVectorStructRelease(ArkWebStringVector& struct_value);
356
357 ArkWebStringVectorMap ArkWebStringVectorMapClassToStruct(
358 const std::map<std::string, std::vector<std::string>>& class_value);
359
360 std::map<std::string, std::vector<std::string>> ArkWebStringVectorMapStructToClass(
361 const ArkWebStringVectorMap& struct_value);
362
363 void ArkWebStringVectorMapStructRelease(ArkWebStringVectorMap& struct_value);
364
365 #endif // ARK_WEB_TYPES_H_
366