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 "metadata/metadata_serializer.h"
17
18namespace OHOS {
19namespace Idl {
20void MetadataSerializer::Serialize()
21{
22    SerializeMetaComponent(metaComponent_);
23}
24
25void MetadataSerializer::SerializeMetaComponent(MetaComponent* mc)
26{
27    if (mc == nullptr) {
28        return;
29    }
30    mc->name_ = reinterpret_cast<char*>(SerializeAdjust(mc->name_));
31
32    for (int i = 0; i < mc->namespaceNumber_; i++) {
33        MetaNamespace* mn = mc->namespaces_[i];
34        SerializeMetaNamespace(mn);
35        mc->namespaces_[i] = reinterpret_cast<MetaNamespace*>(SerializeAdjust(mn));
36    }
37    mc->namespaces_ = reinterpret_cast<MetaNamespace**>(SerializeAdjust(mc->namespaces_));
38
39    for (int i = 0; i < mc->sequenceableNumber_; i++) {
40        MetaSequenceable* mp = mc->sequenceables_[i];
41        SerializeMetaSequenceable(mp);
42        mc->sequenceables_[i] = reinterpret_cast<MetaSequenceable*>(SerializeAdjust(mp));
43    }
44    mc->sequenceables_ = reinterpret_cast<MetaSequenceable**>(SerializeAdjust(mc->sequenceables_));
45
46    for (int i = 0; i < mc->interfaceNumber_; i++) {
47        MetaInterface* mi = mc->interfaces_[i];
48        SerializeMetaInterface(mi);
49        mc->interfaces_[i] = reinterpret_cast<MetaInterface*>(SerializeAdjust(mi));
50    }
51    mc->interfaces_ = reinterpret_cast<MetaInterface**>(SerializeAdjust(mc->interfaces_));
52
53    for (int i = 0; i < mc->typeNumber_; i++) {
54        MetaType* mt = mc->types_[i];
55        SerializeMetaType(mt);
56        mc->types_[i] = reinterpret_cast<MetaType*>(SerializeAdjust(mt));
57    }
58    mc->types_ = reinterpret_cast<MetaType**>(SerializeAdjust(mc->types_));
59
60    mc->stringPool_ = reinterpret_cast<char*>(SerializeAdjust(mc->stringPool_));
61}
62
63void MetadataSerializer::SerializeMetaNamespace(MetaNamespace* mn)
64{
65    if (mn == nullptr) {
66        return;
67    }
68    mn->name_ = reinterpret_cast<char*>(SerializeAdjust(mn->name_));
69    mn->sequenceableIndexes_ = reinterpret_cast<int*>(SerializeAdjust(mn->sequenceableIndexes_));
70    mn->interfaceIndexes_ = reinterpret_cast<int*>(SerializeAdjust(mn->interfaceIndexes_));
71
72    for (int i = 0; i < mn->namespaceNumber_; i++) {
73        MetaNamespace* innermn = mn->namespaces_[i];
74        SerializeMetaNamespace(innermn);
75        mn->namespaces_[i] = reinterpret_cast<MetaNamespace*>(SerializeAdjust(innermn));
76    }
77    mn->namespaces_ = reinterpret_cast<MetaNamespace**>(SerializeAdjust(mn->namespaces_));
78}
79
80void MetadataSerializer::SerializeMetaSequenceable(MetaSequenceable* mp)
81{
82    if (mp == nullptr) {
83        return;
84    }
85    mp->name_ = reinterpret_cast<char*>(SerializeAdjust(mp->name_));
86    mp->namespace_ = reinterpret_cast<char*>(SerializeAdjust(mp->namespace_));
87}
88
89void MetadataSerializer::SerializeMetaInterface(MetaInterface* mi)
90{
91    if (mi == nullptr) {
92        return;
93    }
94    mi->license_ = reinterpret_cast<char*>(SerializeAdjust(mi->license_));
95    mi->name_ = reinterpret_cast<char*>(SerializeAdjust(mi->name_));
96    mi->namespace_ = reinterpret_cast<char*>(SerializeAdjust(mi->namespace_));
97
98    for (int i = 0; i < mi->methodNumber_; i++) {
99        MetaMethod* mm = mi->methods_[i];
100        SerializeMetaMethod(mm);
101        mi->methods_[i] = reinterpret_cast<MetaMethod*>(SerializeAdjust(mm));
102    }
103    mi->methods_ = reinterpret_cast<MetaMethod**>(SerializeAdjust(mi->methods_));
104}
105
106void MetadataSerializer::SerializeMetaMethod(MetaMethod* mm)
107{
108    if (mm == nullptr) {
109        return;
110    }
111    mm->name_ = reinterpret_cast<char*>(SerializeAdjust(mm->name_));
112    mm->signature_ = reinterpret_cast<char*>(SerializeAdjust(mm->signature_));
113
114    for (int i = 0; i < mm->parameterNumber_; i++) {
115        MetaParameter* mp = mm->parameters_[i];
116        SerializeMetaParameter(mp);
117        mm->parameters_[i] = reinterpret_cast<MetaParameter*>(SerializeAdjust(mp));
118    }
119    mm->parameters_ = reinterpret_cast<MetaParameter**>(SerializeAdjust(mm->parameters_));
120}
121
122void MetadataSerializer::SerializeMetaParameter(MetaParameter* mp)
123{
124    if (mp == nullptr) {
125        return;
126    }
127    mp->name_ = reinterpret_cast<char*>(SerializeAdjust(mp->name_));
128}
129
130void MetadataSerializer::SerializeMetaType(MetaType* mt)
131{
132    if (mt == nullptr) {
133        return;
134    }
135    mt->nestedTypeIndexes_ = reinterpret_cast<int*>(SerializeAdjust(mt->nestedTypeIndexes_));
136}
137
138ptrdiff_t MetadataSerializer::SerializeAdjust(const void* addr)
139{
140    return reinterpret_cast<uintptr_t>(addr) - baseAddr_;
141}
142
143void MetadataSerializer::Deserialize()
144{
145    DeserializeMetaComponent(metaComponent_);
146}
147
148void MetadataSerializer::DeserializeMetaComponent(MetaComponent* mc)
149{
150    if (mc == nullptr) {
151        return;
152    }
153    mc->name_ = reinterpret_cast<char*>(DeserializeAdjust(mc->name_));
154
155    mc->namespaces_ = reinterpret_cast<MetaNamespace**>(DeserializeAdjust(mc->namespaces_));
156    for (int i = 0; i < mc->namespaceNumber_; i++) {
157        mc->namespaces_[i] = reinterpret_cast<MetaNamespace*>(DeserializeAdjust(mc->namespaces_[i]));
158        MetaNamespace* mn = mc->namespaces_[i];
159        DeserializeMetaNamespace(mn);
160    }
161
162    mc->sequenceables_ = reinterpret_cast<MetaSequenceable**>(DeserializeAdjust(mc->sequenceables_));
163    for (int i = 0; i < mc->sequenceableNumber_; i++) {
164        mc->sequenceables_[i] = reinterpret_cast<MetaSequenceable*>(DeserializeAdjust(mc->sequenceables_[i]));
165        MetaSequenceable* mp = mc->sequenceables_[i];
166        DeserializeMetaSequenceable(mp);
167    }
168
169    mc->interfaces_ = reinterpret_cast<MetaInterface**>(DeserializeAdjust(mc->interfaces_));
170    for (int i = 0; i < mc->interfaceNumber_; i++) {
171        mc->interfaces_[i] = reinterpret_cast<MetaInterface*>(DeserializeAdjust(mc->interfaces_[i]));
172        MetaInterface* mi = mc->interfaces_[i];
173        DeserializeMetaInterface(mi);
174    }
175
176    mc->types_ = reinterpret_cast<MetaType**>(DeserializeAdjust(mc->types_));
177    for (int i = 0; i < mc->typeNumber_; i++) {
178        mc->types_[i] = reinterpret_cast<MetaType*>(DeserializeAdjust(mc->types_[i]));
179        MetaType* mt = mc->types_[i];
180        DeserializeMetaType(mt);
181    }
182
183    mc->stringPool_ = reinterpret_cast<char*>(DeserializeAdjust(mc->stringPool_));
184}
185
186void MetadataSerializer::DeserializeMetaNamespace(MetaNamespace* mn)
187{
188    if (mn == nullptr) {
189        return;
190    }
191    mn->name_ = reinterpret_cast<char*>(DeserializeAdjust(mn->name_));
192    mn->sequenceableIndexes_ = reinterpret_cast<int*>(DeserializeAdjust(mn->sequenceableIndexes_));
193    mn->interfaceIndexes_ = reinterpret_cast<int*>(DeserializeAdjust(mn->interfaceIndexes_));
194
195    mn->namespaces_ = reinterpret_cast<MetaNamespace**>(DeserializeAdjust(mn->namespaces_));
196    for (int i = 0; i < mn->namespaceNumber_; i++) {
197        mn->namespaces_[i] = reinterpret_cast<MetaNamespace*>(DeserializeAdjust(mn->namespaces_[i]));
198        MetaNamespace* innermn = mn->namespaces_[i];
199        DeserializeMetaNamespace(innermn);
200    }
201}
202
203void MetadataSerializer::DeserializeMetaSequenceable(MetaSequenceable* mp)
204{
205    if (mp == nullptr) {
206        return;
207    }
208    mp->name_ = reinterpret_cast<char*>(DeserializeAdjust(mp->name_));
209    mp->namespace_ = reinterpret_cast<char*>(DeserializeAdjust(mp->namespace_));
210}
211
212void MetadataSerializer::DeserializeMetaInterface(MetaInterface* mi)
213{
214    if (mi == nullptr) {
215        return;
216    }
217    mi->license_ = reinterpret_cast<char*>(DeserializeAdjust(mi->license_));
218    mi->name_ = reinterpret_cast<char*>(DeserializeAdjust(mi->name_));
219    mi->namespace_ = reinterpret_cast<char*>(DeserializeAdjust(mi->namespace_));
220
221    mi->methods_ = reinterpret_cast<MetaMethod**>(DeserializeAdjust(mi->methods_));
222    for (int i = 0; i < mi->methodNumber_; i++) {
223        mi->methods_[i] = reinterpret_cast<MetaMethod*>(DeserializeAdjust(mi->methods_[i]));
224        MetaMethod* mm = mi->methods_[i];
225        DeserializeMetaMethod(mm);
226    }
227}
228
229void MetadataSerializer::DeserializeMetaMethod(MetaMethod* mm)
230{
231    if (mm == nullptr) {
232        return;
233    }
234    mm->name_ = reinterpret_cast<char*>(DeserializeAdjust(mm->name_));
235    mm->signature_ = reinterpret_cast<char*>(DeserializeAdjust(mm->signature_));
236
237    mm->parameters_ = reinterpret_cast<MetaParameter**>(DeserializeAdjust(mm->parameters_));
238    for (int i = 0; i < mm->parameterNumber_; i++) {
239        mm->parameters_[i] = reinterpret_cast<MetaParameter*>(DeserializeAdjust(mm->parameters_[i]));
240        MetaParameter* mp = mm->parameters_[i];
241        DeserializeMetaParameter(mp);
242    }
243}
244
245void MetadataSerializer::DeserializeMetaParameter(MetaParameter* mp)
246{
247    if (mp == nullptr) {
248        return;
249    }
250    mp->name_ = reinterpret_cast<char*>(DeserializeAdjust(mp->name_));
251}
252
253void MetadataSerializer::DeserializeMetaType(MetaType* mt)
254{
255    if (mt == nullptr) {
256        return;
257    }
258    mt->nestedTypeIndexes_ = reinterpret_cast<int*>(DeserializeAdjust(mt->nestedTypeIndexes_));
259}
260
261uintptr_t MetadataSerializer::DeserializeAdjust(const void* addr)
262{
263    return reinterpret_cast<ptrdiff_t>(addr) + baseAddr_;
264}
265} // namespace Idl
266} // namespace OHOS
267