• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2022 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 
18 namespace OHOS {
19 namespace Idl {
Serialize()20 void MetadataSerializer::Serialize()
21 {
22     SerializeMetaComponent(metaComponent_);
23 }
24 
SerializeMetaComponent(MetaComponent * mc)25 void 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 
SerializeMetaNamespace(MetaNamespace * mn)63 void 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 
SerializeMetaSequenceable(MetaSequenceable * mp)80 void 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 
SerializeMetaInterface(MetaInterface * mi)89 void 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 
SerializeMetaMethod(MetaMethod * mm)106 void 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 
SerializeMetaParameter(MetaParameter * mp)122 void MetadataSerializer::SerializeMetaParameter(MetaParameter* mp)
123 {
124     if (mp == nullptr) {
125         return;
126     }
127     mp->name_ = reinterpret_cast<char*>(SerializeAdjust(mp->name_));
128 }
129 
SerializeMetaType(MetaType * mt)130 void MetadataSerializer::SerializeMetaType(MetaType* mt)
131 {
132     if (mt == nullptr) {
133         return;
134     }
135     mt->nestedTypeIndexes_ = reinterpret_cast<int*>(SerializeAdjust(mt->nestedTypeIndexes_));
136 }
137 
SerializeAdjust(const void * addr)138 ptrdiff_t MetadataSerializer::SerializeAdjust(const void* addr)
139 {
140     return reinterpret_cast<uintptr_t>(addr) - baseAddr_;
141 }
142 
Deserialize()143 void MetadataSerializer::Deserialize()
144 {
145     DeserializeMetaComponent(metaComponent_);
146 }
147 
DeserializeMetaComponent(MetaComponent * mc)148 void 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 
DeserializeMetaNamespace(MetaNamespace * mn)186 void 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 
DeserializeMetaSequenceable(MetaSequenceable * mp)203 void 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 
DeserializeMetaInterface(MetaInterface * mi)212 void 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 
DeserializeMetaMethod(MetaMethod * mm)229 void 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 
DeserializeMetaParameter(MetaParameter * mp)245 void MetadataSerializer::DeserializeMetaParameter(MetaParameter* mp)
246 {
247     if (mp == nullptr) {
248         return;
249     }
250     mp->name_ = reinterpret_cast<char*>(DeserializeAdjust(mp->name_));
251 }
252 
DeserializeMetaType(MetaType * mt)253 void MetadataSerializer::DeserializeMetaType(MetaType* mt)
254 {
255     if (mt == nullptr) {
256         return;
257     }
258     mt->nestedTypeIndexes_ = reinterpret_cast<int*>(DeserializeAdjust(mt->nestedTypeIndexes_));
259 }
260 
DeserializeAdjust(const void * addr)261 uintptr_t MetadataSerializer::DeserializeAdjust(const void* addr)
262 {
263     return reinterpret_cast<ptrdiff_t>(addr) + baseAddr_;
264 }
265 } // namespace Idl
266 } // namespace OHOS
267