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 #include "base/include/ark_web_types.h"
17 
18 #include "base/include/ark_web_log_utils.h"
19 
ArkWebU16StringClassToStruct(const std::u16string & class_value)20 ArkWebU16String ArkWebU16StringClassToStruct(const std::u16string& class_value)
21 {
22     ArkWebU16String struct_value = { .size = class_value.size(), .ark_web_mem_free_func = ArkWebMemFree };
23     if (struct_value.size > 0) {
24         struct_value.value = (char16_t*)ArkWebMemMalloc((struct_value.size + 1) * sizeof(char16_t));
25         if (struct_value.value == nullptr) {
26             struct_value.size = 0;
27             return struct_value;
28         }
29 
30         memcpy((char*)struct_value.value, (char*)class_value.c_str(), struct_value.size * sizeof(char16_t));
31         struct_value.value[struct_value.size] = 0;
32     }
33 
34     ARK_WEB_BASE_DV_LOG("length is %{public}d", struct_value.size);
35 
36     return struct_value;
37 }
38 
ArkWebU16StringStructToClass(const ArkWebU16String & struct_value)39 std::u16string ArkWebU16StringStructToClass(const ArkWebU16String& struct_value)
40 {
41     std::u16string class_value;
42     if (struct_value.size > 0) {
43         class_value = struct_value.value;
44     }
45 
46     ARK_WEB_BASE_DV_LOG("length is %{public}d", struct_value.size);
47 
48     return class_value;
49 }
50 
ArkWebStringClassToStruct(const std::string & class_value)51 ArkWebString ArkWebStringClassToStruct(const std::string& class_value)
52 {
53     ArkWebString struct_value = { .size = class_value.size(), .ark_web_mem_free_func = ArkWebMemFree };
54     if (struct_value.size > 0) {
55         struct_value.value = (char*)ArkWebMemMalloc(struct_value.size + 1);
56         if (struct_value.value == nullptr) {
57             struct_value.size = 0;
58             return struct_value;
59         }
60 
61         memcpy(struct_value.value, class_value.c_str(), struct_value.size);
62         struct_value.value[struct_value.size] = 0;
63     }
64 
65     ARK_WEB_BASE_DV_LOG("string is %{public}s,length is %{public}d", class_value.c_str(), struct_value.size);
66 
67     return struct_value;
68 }
69 
ArkWebStringStructToClass(const ArkWebString & struct_value)70 std::string ArkWebStringStructToClass(const ArkWebString& struct_value)
71 {
72     std::string class_value;
73     if (struct_value.size > 0) {
74         class_value.assign(struct_value.value, struct_value.size);
75     }
76 
77     ARK_WEB_BASE_DV_LOG("string is %{public}s,length is %{public}d", class_value.c_str(), struct_value.size);
78 
79     return class_value;
80 }
81 
ArkWebStringStructRelease(ArkWebString & struct_value)82 void ArkWebStringStructRelease(ArkWebString& struct_value)
83 {
84     struct_value.size = 0;
85     SAFE_FREE(struct_value.value, struct_value.ark_web_mem_free_func);
86 }
87 
ArkWebU16StringStructRelease(ArkWebU16String & struct_value)88 void ArkWebU16StringStructRelease(ArkWebU16String& struct_value)
89 {
90     struct_value.size = 0;
91     SAFE_FREE(struct_value.value, struct_value.ark_web_mem_free_func);
92 }
93 
ArkWebStringMapClassToStruct(const std::map<std::string,std::string> & class_value)94 ArkWebStringMap ArkWebStringMapClassToStruct(const std::map<std::string, std::string>& class_value)
95 {
96     ArkWebStringMap struct_value = { .size = class_value.size(), .ark_web_mem_free_func = ArkWebMemFree };
97     if (struct_value.size > 0) {
98         struct_value.key = (ArkWebString*)ArkWebMemMalloc(sizeof(ArkWebString) * struct_value.size);
99         struct_value.value = (ArkWebString*)ArkWebMemMalloc(sizeof(ArkWebString) * struct_value.size);
100         if (struct_value.key == nullptr || struct_value.value == nullptr) {
101             ArkWebMemFree(struct_value.key);
102             ArkWebMemFree(struct_value.value);
103             struct_value.size = 0;
104             return struct_value;
105         }
106 
107         int count = 0;
108         for (auto it = class_value.begin(); it != class_value.end(); it++) {
109             struct_value.key[count] = ArkWebStringClassToStruct(it->first);
110             struct_value.value[count] = ArkWebStringClassToStruct(it->second);
111             count++;
112         }
113     }
114 
115     return struct_value;
116 }
117 
ArkWebStringMapStructToClass(const ArkWebStringMap & struct_value)118 std::map<std::string, std::string> ArkWebStringMapStructToClass(const ArkWebStringMap& struct_value)
119 {
120     std::map<std::string, std::string> class_value;
121     for (int count = 0; count < struct_value.size; count++) {
122         class_value.insert(std::map<std::string, std::string>::value_type(
123             ArkWebStringStructToClass(struct_value.key[count]), ArkWebStringStructToClass(struct_value.value[count])));
124     }
125 
126     return class_value;
127 }
128 
ArkWebStringMapStructRelease(ArkWebStringMap & struct_value)129 void ArkWebStringMapStructRelease(ArkWebStringMap& struct_value)
130 {
131     for (int count = 0; count < struct_value.size; count++) {
132         ArkWebStringStructRelease(struct_value.key[count]);
133         ArkWebStringStructRelease(struct_value.value[count]);
134     }
135 
136     struct_value.size = 0;
137     SAFE_FREE(struct_value.key, struct_value.ark_web_mem_free_func);
138     SAFE_FREE(struct_value.value, struct_value.ark_web_mem_free_func);
139 }
140 
ArkWebStringListClassToStruct(const std::list<std::string> & class_value)141 ArkWebStringList ArkWebStringListClassToStruct(const std::list<std::string>& class_value)
142 {
143     ArkWebStringList struct_value = { .size = class_value.size(), .ark_web_mem_free_func = ArkWebMemFree };
144     if (struct_value.size > 0) {
145         struct_value.value = (ArkWebString*)ArkWebMemMalloc(sizeof(ArkWebString) * struct_value.size);
146         if (struct_value.value == nullptr) {
147             struct_value.size = 0;
148             return struct_value;
149         }
150 
151         int count = 0;
152         for (auto it = class_value.begin(); it != class_value.end(); it++) {
153             struct_value.value[count] = ArkWebStringClassToStruct(*it);
154             count++;
155         }
156     }
157 
158     return struct_value;
159 }
160 
ArkWebStringListStructToClass(const ArkWebStringList & struct_value)161 std::list<std::string> ArkWebStringListStructToClass(const ArkWebStringList& struct_value)
162 {
163     std::list<std::string> class_value;
164     for (int count = 0; count < struct_value.size; count++) {
165         class_value.push_back(ArkWebStringStructToClass(struct_value.value[count]));
166     }
167 
168     return class_value;
169 }
170 
ArkWebStringListStructRelease(ArkWebStringList & struct_value)171 void ArkWebStringListStructRelease(ArkWebStringList& struct_value)
172 {
173     for (int count = 0; count < struct_value.size; count++) {
174         ArkWebStringStructRelease(struct_value.value[count]);
175     }
176 
177     struct_value.size = 0;
178     SAFE_FREE(struct_value.value, struct_value.ark_web_mem_free_func);
179 }
180 
ArkWebStringVectorClassToStruct(const std::vector<std::string> & class_value)181 ArkWebStringVector ArkWebStringVectorClassToStruct(const std::vector<std::string>& class_value)
182 {
183     ArkWebStringVector struct_value = { .size = class_value.size(), .ark_web_mem_free_func = ArkWebMemFree };
184     if (struct_value.size > 0) {
185         struct_value.value = (ArkWebString*)ArkWebMemMalloc(sizeof(ArkWebString) * struct_value.size);
186         if (struct_value.value == nullptr) {
187             struct_value.size = 0;
188             return struct_value;
189         }
190 
191         int count = 0;
192         for (auto it = class_value.begin(); it != class_value.end(); it++) {
193             struct_value.value[count] = ArkWebStringClassToStruct(*it);
194             count++;
195         }
196     }
197 
198     return struct_value;
199 }
200 
ArkWebStringVectorStructToClass(const ArkWebStringVector & struct_value)201 std::vector<std::string> ArkWebStringVectorStructToClass(const ArkWebStringVector& struct_value)
202 {
203     std::vector<std::string> class_value;
204     for (int count = 0; count < struct_value.size; count++) {
205         class_value.push_back(ArkWebStringStructToClass(struct_value.value[count]));
206     }
207 
208     return class_value;
209 }
210 
ArkWebStringVectorStructRelease(ArkWebStringVector & struct_value)211 void ArkWebStringVectorStructRelease(ArkWebStringVector& struct_value)
212 {
213     for (int count = 0; count < struct_value.size; count++) {
214         ArkWebStringStructRelease(struct_value.value[count]);
215     }
216 
217     struct_value.size = 0;
218     SAFE_FREE(struct_value.value, struct_value.ark_web_mem_free_func);
219 }
220 
ArkWebStringVectorMapClassToStruct(const std::map<std::string,std::vector<std::string>> & class_value)221 ArkWebStringVectorMap ArkWebStringVectorMapClassToStruct(
222     const std::map<std::string, std::vector<std::string>>& class_value)
223 {
224     ArkWebStringVectorMap struct_value = { .size = class_value.size(), .ark_web_mem_free_func = ArkWebMemFree };
225     if (struct_value.size > 0) {
226         struct_value.key = (ArkWebString*)ArkWebMemMalloc(sizeof(ArkWebString) * struct_value.size);
227         struct_value.value = (ArkWebStringVector*)ArkWebMemMalloc(sizeof(ArkWebStringVector) * struct_value.size);
228         if (struct_value.key == nullptr || struct_value.value == nullptr) {
229             ArkWebMemFree(struct_value.key);
230             ArkWebMemFree(struct_value.value);
231             struct_value.size = 0;
232             return struct_value;
233         }
234 
235         int count = 0;
236         for (auto it = class_value.begin(); it != class_value.end(); it++) {
237             struct_value.key[count] = ArkWebStringClassToStruct(it->first);
238             struct_value.value[count] = ArkWebStringVectorClassToStruct(it->second);
239             count++;
240         }
241     }
242 
243     return struct_value;
244 }
245 
ArkWebStringVectorMapStructToClass(const ArkWebStringVectorMap & struct_value)246 std::map<std::string, std::vector<std::string>> ArkWebStringVectorMapStructToClass(
247     const ArkWebStringVectorMap& struct_value)
248 {
249     std::map<std::string, std::vector<std::string>> class_value;
250     for (int count = 0; count < struct_value.size; count++) {
251         class_value.insert(std::map<std::string, std::vector<std::string>>::value_type(
252             ArkWebStringStructToClass(struct_value.key[count]),
253             ArkWebStringVectorStructToClass(struct_value.value[count])));
254     }
255 
256     return class_value;
257 }
258 
ArkWebStringVectorMapStructRelease(ArkWebStringVectorMap & struct_value)259 void ArkWebStringVectorMapStructRelease(ArkWebStringVectorMap& struct_value)
260 {
261     for (int count = 0; count < struct_value.size; count++) {
262         ArkWebStringStructRelease(struct_value.key[count]);
263         ArkWebStringVectorStructRelease(struct_value.value[count]);
264     }
265 
266     struct_value.size = 0;
267     SAFE_FREE(struct_value.key, struct_value.ark_web_mem_free_func);
268     SAFE_FREE(struct_value.value, struct_value.ark_web_mem_free_func);
269 }
270