1 /*
2  * Copyright (c) 2021-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 "data_ability_operation.h"
17 
18 #include "data_ability_predicates.h"
19 #include "hilog_tag_wrapper.h"
20 #include "values_bucket.h"
21 
22 namespace OHOS {
23 namespace AppExecFwk {
DataAbilityOperation(const std::shared_ptr<DataAbilityOperation> & dataAbilityOperation,const std::shared_ptr<Uri> & withUri)24 DataAbilityOperation::DataAbilityOperation(
25     const std::shared_ptr<DataAbilityOperation> &dataAbilityOperation, const std::shared_ptr<Uri> &withUri)
26 {
27     uri_ = withUri;
28     if (dataAbilityOperation != nullptr) {
29         type_ = dataAbilityOperation->type_;
30         valuesBucket_ = dataAbilityOperation->valuesBucket_;
31         expectedCount_ = dataAbilityOperation->expectedCount_;
32         dataAbilityPredicates_ = dataAbilityOperation->dataAbilityPredicates_;
33         valuesBucketReferences_ = dataAbilityOperation->valuesBucketReferences_;
34         dataAbilityPredicatesBackReferences_ = dataAbilityOperation->dataAbilityPredicatesBackReferences_;
35         interrupted_ = dataAbilityOperation->interrupted_;
36     } else {
37         type_ = 0;
38         expectedCount_ = 0;
39         valuesBucket_ = std::make_shared<NativeRdb::ValuesBucket>();
40         dataAbilityPredicates_ = std::make_shared<NativeRdb::DataAbilityPredicates>();
41         valuesBucketReferences_ = std::make_shared<NativeRdb::ValuesBucket>();
42         dataAbilityPredicatesBackReferences_.clear();
43         interrupted_ = false;
44     }
45 }
DataAbilityOperation(Parcel & in)46 DataAbilityOperation::DataAbilityOperation(Parcel &in)
47 {
48     ReadFromParcel(in);
49 }
DataAbilityOperation(const std::shared_ptr<DataAbilityOperationBuilder> & builder)50 DataAbilityOperation::DataAbilityOperation(const std::shared_ptr<DataAbilityOperationBuilder> &builder)
51 {
52     if (builder != nullptr) {
53         type_ = builder->type_;
54         uri_ = builder->uri_;
55         valuesBucket_ = builder->valuesBucket_;
56         expectedCount_ = builder->expectedCount_;
57         dataAbilityPredicates_ = builder->dataAbilityPredicates_;
58         valuesBucketReferences_ = builder->valuesBucketReferences_;
59         dataAbilityPredicatesBackReferences_ = builder->dataAbilityPredicatesBackReferences_;
60         interrupted_ = builder->interrupted_;
61     }
62 }
63 
DataAbilityOperation()64 DataAbilityOperation::DataAbilityOperation()
65 {
66     type_ = 0;
67     uri_ = nullptr;
68     expectedCount_ = 0;
69     valuesBucket_ = std::make_shared<NativeRdb::ValuesBucket>();
70     dataAbilityPredicates_ = std::make_shared<NativeRdb::DataAbilityPredicates>();
71     valuesBucketReferences_ = std::make_shared<NativeRdb::ValuesBucket>();
72     dataAbilityPredicatesBackReferences_.clear();
73     interrupted_ = false;
74 }
75 
~DataAbilityOperation()76 DataAbilityOperation::~DataAbilityOperation()
77 {
78     dataAbilityPredicatesBackReferences_.clear();
79 }
80 
operator ==(const DataAbilityOperation & other) const81 bool DataAbilityOperation::operator==(const DataAbilityOperation &other) const
82 {
83     if (type_ != other.type_) {
84         return false;
85     }
86     if ((uri_ != nullptr) && (other.uri_ != nullptr) && (uri_->ToString() != other.uri_->ToString())) {
87         return false;
88     }
89     if (expectedCount_ != other.expectedCount_) {
90         return false;
91     }
92     if (valuesBucket_ != other.valuesBucket_) {
93         return false;
94     }
95     if (dataAbilityPredicates_ != other.dataAbilityPredicates_) {
96         return false;
97     }
98     if (valuesBucketReferences_ != other.valuesBucketReferences_) {
99         return false;
100     }
101     size_t backReferencesCount = dataAbilityPredicatesBackReferences_.size();
102     size_t otherBackReferencesCount = other.dataAbilityPredicatesBackReferences_.size();
103     if (backReferencesCount != otherBackReferencesCount) {
104         return false;
105     }
106 
107     std::map<int, int>::const_iterator it = dataAbilityPredicatesBackReferences_.begin();
108     while (it != dataAbilityPredicatesBackReferences_.end()) {
109         std::map<int, int>::const_iterator otherIt = other.dataAbilityPredicatesBackReferences_.find(it->first);
110         if (otherIt != other.dataAbilityPredicatesBackReferences_.end()) {
111             if (otherIt->second != it->second) {
112                 return false;
113             }
114         } else {
115             return false;
116         }
117         it++;
118     }
119 
120     if (interrupted_ != other.interrupted_) {
121         return false;
122     }
123     return true;
124 }
125 
operator =(const DataAbilityOperation & other)126 DataAbilityOperation &DataAbilityOperation::operator=(const DataAbilityOperation &other)
127 {
128     if (this != &other) {
129         type_ = other.type_;
130         uri_ = other.uri_;
131         expectedCount_ = other.expectedCount_;
132         valuesBucket_ = other.valuesBucket_;
133         dataAbilityPredicates_ = other.dataAbilityPredicates_;
134         valuesBucketReferences_ = other.valuesBucketReferences_;
135         dataAbilityPredicatesBackReferences_ = other.dataAbilityPredicatesBackReferences_;
136         interrupted_ = other.interrupted_;
137     }
138     return *this;
139 }
140 
NewInsertBuilder(const std::shared_ptr<Uri> & uri)141 std::shared_ptr<DataAbilityOperationBuilder> DataAbilityOperation::NewInsertBuilder(const std::shared_ptr<Uri> &uri)
142 {
143     TAG_LOGD(AAFwkTag::DATA_ABILITY, "start");
144     if (uri == nullptr) {
145         TAG_LOGE(AAFwkTag::DATA_ABILITY, "null uri");
146         return nullptr;
147     }
148     std::shared_ptr<DataAbilityOperationBuilder> builder =
149         std::make_shared<DataAbilityOperationBuilder>(TYPE_INSERT, uri);
150     TAG_LOGD(AAFwkTag::DATA_ABILITY, "end");
151     return builder;
152 }
153 
NewUpdateBuilder(const std::shared_ptr<Uri> & uri)154 std::shared_ptr<DataAbilityOperationBuilder> DataAbilityOperation::NewUpdateBuilder(const std::shared_ptr<Uri> &uri)
155 {
156     TAG_LOGD(AAFwkTag::DATA_ABILITY, "start");
157     if (uri == nullptr) {
158         TAG_LOGE(AAFwkTag::DATA_ABILITY, "null uri");
159         return nullptr;
160     }
161     std::shared_ptr<DataAbilityOperationBuilder> builder =
162         std::make_shared<DataAbilityOperationBuilder>(TYPE_UPDATE, uri);
163     TAG_LOGD(AAFwkTag::DATA_ABILITY, "end");
164     return builder;
165 }
166 
NewDeleteBuilder(const std::shared_ptr<Uri> & uri)167 std::shared_ptr<DataAbilityOperationBuilder> DataAbilityOperation::NewDeleteBuilder(const std::shared_ptr<Uri> &uri)
168 {
169     TAG_LOGD(AAFwkTag::DATA_ABILITY, "start");
170     if (uri == nullptr) {
171         TAG_LOGE(AAFwkTag::DATA_ABILITY, "null uri");
172         return nullptr;
173     }
174     std::shared_ptr<DataAbilityOperationBuilder> builder =
175         std::make_shared<DataAbilityOperationBuilder>(TYPE_DELETE, uri);
176     TAG_LOGD(AAFwkTag::DATA_ABILITY, "end");
177     return builder;
178 }
179 
NewAssertBuilder(const std::shared_ptr<Uri> & uri)180 std::shared_ptr<DataAbilityOperationBuilder> DataAbilityOperation::NewAssertBuilder(const std::shared_ptr<Uri> &uri)
181 {
182     TAG_LOGD(AAFwkTag::DATA_ABILITY, "start");
183     if (uri == nullptr) {
184         TAG_LOGE(AAFwkTag::DATA_ABILITY, "null uri");
185         return nullptr;
186     }
187     std::shared_ptr<DataAbilityOperationBuilder> builder =
188         std::make_shared<DataAbilityOperationBuilder>(TYPE_ASSERT, uri);
189     TAG_LOGD(AAFwkTag::DATA_ABILITY, "end");
190     return builder;
191 }
192 
GetType() const193 int DataAbilityOperation::GetType() const
194 {
195     TAG_LOGD(AAFwkTag::DATA_ABILITY, "called");
196     return type_;
197 }
198 
GetUri() const199 std::shared_ptr<Uri> DataAbilityOperation::GetUri() const
200 {
201     TAG_LOGD(AAFwkTag::DATA_ABILITY, "called");
202     return uri_;
203 }
204 
GetValuesBucket() const205 std::shared_ptr<NativeRdb::ValuesBucket> DataAbilityOperation::GetValuesBucket() const
206 {
207     TAG_LOGD(AAFwkTag::DATA_ABILITY, "called");
208     return valuesBucket_;
209 }
210 
GetExpectedCount() const211 int DataAbilityOperation::GetExpectedCount() const
212 {
213     TAG_LOGD(AAFwkTag::DATA_ABILITY, "called");
214     return expectedCount_;
215 }
216 
GetDataAbilityPredicates() const217 std::shared_ptr<NativeRdb::DataAbilityPredicates> DataAbilityOperation::GetDataAbilityPredicates() const
218 {
219     TAG_LOGD(AAFwkTag::DATA_ABILITY, "called");
220     return dataAbilityPredicates_;
221 }
222 
GetValuesBucketReferences() const223 std::shared_ptr<NativeRdb::ValuesBucket> DataAbilityOperation::GetValuesBucketReferences() const
224 {
225     TAG_LOGD(AAFwkTag::DATA_ABILITY, "called");
226     return valuesBucketReferences_;
227 }
GetDataAbilityPredicatesBackReferences() const228 std::map<int, int> DataAbilityOperation::GetDataAbilityPredicatesBackReferences() const
229 {
230     TAG_LOGD(AAFwkTag::DATA_ABILITY, "called");
231     return dataAbilityPredicatesBackReferences_;
232 }
IsValidOperation() const233 bool DataAbilityOperation::IsValidOperation() const
234 {
235     TAG_LOGD(AAFwkTag::DATA_ABILITY, "type: %{public}d", type_);
236     return (type_ == TYPE_INSERT || type_ == TYPE_UPDATE || type_ == TYPE_DELETE || type_ == TYPE_ASSERT);
237 }
IsInsertOperation() const238 bool DataAbilityOperation::IsInsertOperation() const
239 {
240     TAG_LOGD(AAFwkTag::DATA_ABILITY, "TYPE_INSERT?: %{public}d", type_ == TYPE_INSERT);
241     return type_ == TYPE_INSERT;
242 }
IsUpdateOperation() const243 bool DataAbilityOperation::IsUpdateOperation() const
244 {
245     TAG_LOGD(AAFwkTag::DATA_ABILITY, "TYPE_UPDATE?: %{public}d", type_ == TYPE_UPDATE);
246     return type_ == TYPE_UPDATE;
247 }
IsDeleteOperation() const248 bool DataAbilityOperation::IsDeleteOperation() const
249 {
250     TAG_LOGD(AAFwkTag::DATA_ABILITY, "TYPE_DELETE?: %{public}d", type_ == TYPE_DELETE);
251     return type_ == TYPE_DELETE;
252 }
IsAssertOperation() const253 bool DataAbilityOperation::IsAssertOperation() const
254 {
255     TAG_LOGD(AAFwkTag::DATA_ABILITY, "TYPE_ASSERT?: %{public}d", type_ == TYPE_ASSERT);
256     return type_ == TYPE_ASSERT;
257 }
IsInterruptionAllowed() const258 bool DataAbilityOperation::IsInterruptionAllowed() const
259 {
260     TAG_LOGD(AAFwkTag::DATA_ABILITY, "interrupted_: %{public}d", interrupted_);
261     return interrupted_;
262 }
263 
WriteUri(Parcel & out) const264 bool DataAbilityOperation::WriteUri(Parcel &out) const
265 {
266     if (uri_ == nullptr) {
267         TAG_LOGD(AAFwkTag::DATA_ABILITY, "null uri_");
268         return out.WriteInt32(VALUE_NULL);
269     }
270     if (!out.WriteInt32(VALUE_OBJECT)) {
271         TAG_LOGE(AAFwkTag::DATA_ABILITY, "Write VALUE_OBJECT error");
272         return false;
273     }
274     if (!out.WriteParcelable(uri_.get())) {
275         TAG_LOGE(AAFwkTag::DATA_ABILITY, "Write Uri error");
276         return false;
277     }
278     return true;
279 }
280 
WriteValuesBucket(Parcel & out) const281 bool DataAbilityOperation::WriteValuesBucket(Parcel &out) const
282 {
283     if (valuesBucket_ == nullptr) {
284         TAG_LOGD(AAFwkTag::DATA_ABILITY, "null valuesBucket_");
285         return out.WriteInt32(VALUE_NULL);
286     }
287     if (!out.WriteInt32(VALUE_OBJECT)) {
288         TAG_LOGE(AAFwkTag::DATA_ABILITY, "Write VALUE_OBJECT error");
289         return false;
290     }
291     if (!valuesBucket_->Marshalling(out)) {
292         TAG_LOGE(AAFwkTag::DATA_ABILITY, "Write ValuesBucket error");
293         return false;
294     }
295     return true;
296 }
297 
WritePredicates(Parcel & out) const298 bool DataAbilityOperation::WritePredicates(Parcel &out) const
299 {
300     if (dataAbilityPredicates_ == nullptr) {
301         TAG_LOGD(AAFwkTag::DATA_ABILITY, "null dataAbilityPredicates_");
302         return out.WriteInt32(VALUE_NULL);
303     }
304     if (!out.WriteInt32(VALUE_OBJECT)) {
305         TAG_LOGE(AAFwkTag::DATA_ABILITY, "Write VALUE_OBJECT error");
306         return false;
307     }
308     if (!out.WriteParcelable(dataAbilityPredicates_.get())) {
309         TAG_LOGE(AAFwkTag::DATA_ABILITY, "Write DataAbilityPredicates error");
310         return false;
311     }
312     return true;
313 }
314 
WriteValuesBucketReferences(Parcel & out) const315 bool DataAbilityOperation::WriteValuesBucketReferences(Parcel &out) const
316 {
317     if (valuesBucketReferences_ == nullptr) {
318         TAG_LOGD(AAFwkTag::DATA_ABILITY, "null valuesBucketReferences_");
319         return out.WriteInt32(VALUE_NULL);
320     }
321     if (!out.WriteInt32(VALUE_OBJECT)) {
322         TAG_LOGE(AAFwkTag::DATA_ABILITY, "Write VALUE_OBJECT error");
323         return false;
324     }
325     if (!valuesBucketReferences_->Marshalling(out)) {
326         TAG_LOGE(AAFwkTag::DATA_ABILITY, "Marshalling error");
327         return false;
328     }
329     return true;
330 }
331 
Marshalling(Parcel & out) const332 bool DataAbilityOperation::Marshalling(Parcel &out) const
333 {
334     TAG_LOGD(AAFwkTag::DATA_ABILITY, "start");
335     if (!out.WriteInt32(type_)) {
336         TAG_LOGE(AAFwkTag::DATA_ABILITY, "WriteInt32(type) error");
337         return false;
338     }
339     if (!out.WriteInt32(expectedCount_)) {
340         TAG_LOGE(AAFwkTag::DATA_ABILITY, "WriteInt32(expectedCount) error");
341         return false;
342     }
343     if (!out.WriteBool(interrupted_)) {
344         TAG_LOGE(AAFwkTag::DATA_ABILITY, "WriteInt32(interrupted) error");
345         return false;
346     }
347     if (!WriteUri(out) || !WriteValuesBucket(out) || !WritePredicates(out) || !WriteValuesBucketReferences(out)) {
348         TAG_LOGE(AAFwkTag::DATA_ABILITY, "Marshalling error");
349         return false;
350     }
351     int referenceSize = (int)dataAbilityPredicatesBackReferences_.size();
352     if (dataAbilityPredicatesBackReferences_.empty()) {
353         TAG_LOGD(AAFwkTag::DATA_ABILITY, "dataAbilityPredicatesBackReferences_:null");
354         if (!out.WriteInt32(referenceSize)) {
355             TAG_LOGE(AAFwkTag::DATA_ABILITY, "WriteInt32(VALUE_OBJECT) error");
356             return false;
357         }
358         TAG_LOGD(AAFwkTag::DATA_ABILITY, "end");
359         return true;
360     }
361     if (!out.WriteInt32(referenceSize)) {
362         TAG_LOGE(AAFwkTag::DATA_ABILITY, "WriteInt32(VALUE_OBJECT) error");
363         return false;
364     }
365     if (referenceSize >= REFERENCE_THRESHOLD) {
366         TAG_LOGI(AAFwkTag::DATA_ABILITY, "referenceSize >= REFERENCE_THRESHOLD");
367         return true;
368     }
369     for (auto it = dataAbilityPredicatesBackReferences_.begin(); it != dataAbilityPredicatesBackReferences_.end();
370         it++) {
371         if (!out.WriteInt32(it->first)) {
372             TAG_LOGE(AAFwkTag::DATA_ABILITY, "WriteInt32(VALUE_OBJECT) error");
373             return false;
374         }
375         if (!out.WriteInt32(it->second)) {
376             TAG_LOGE(AAFwkTag::DATA_ABILITY, "WriteInt32(VALUE_OBJECT) error");
377             return false;
378         }
379     }
380     TAG_LOGD(AAFwkTag::DATA_ABILITY, "end");
381     return true;
382 }
Unmarshalling(Parcel & in)383 DataAbilityOperation *DataAbilityOperation::Unmarshalling(Parcel &in)
384 {
385     TAG_LOGD(AAFwkTag::DATA_ABILITY, "start");
386     DataAbilityOperation *dataAbilityOperation = new (std::nothrow) DataAbilityOperation();
387     if (dataAbilityOperation != nullptr && !dataAbilityOperation->ReadFromParcel(in)) {
388         TAG_LOGE(AAFwkTag::DATA_ABILITY, "dataAbilityOperation error");
389         delete dataAbilityOperation;
390         dataAbilityOperation = nullptr;
391     }
392     TAG_LOGD(AAFwkTag::DATA_ABILITY, "end");
393     return dataAbilityOperation;
394 }
395 
ReadUriFromParcel(Parcel & in)396 bool DataAbilityOperation::ReadUriFromParcel(Parcel &in)
397 {
398     int empty = VALUE_NULL;
399     if (!in.ReadInt32(empty)) {
400         TAG_LOGE(AAFwkTag::DATA_ABILITY, "ReadInt32(empty) error");
401         return false;
402     }
403     if (empty == VALUE_OBJECT) {
404         TAG_LOGD(AAFwkTag::DATA_ABILITY, "empty is VALUE_OBJECT");
405         uri_.reset(in.ReadParcelable<Uri>());
406         return true;
407     }
408     uri_.reset();
409     return true;
410 }
411 
ReadValuesBucketFromParcel(Parcel & in)412 bool DataAbilityOperation::ReadValuesBucketFromParcel(Parcel &in)
413 {
414     int empty = VALUE_NULL;
415     if (!in.ReadInt32(empty)) {
416         TAG_LOGE(AAFwkTag::DATA_ABILITY, "ReadInt32(empty) error");
417         return false;
418     }
419     if (empty == VALUE_OBJECT) {
420         TAG_LOGD(AAFwkTag::DATA_ABILITY, "empty is VALUE_OBJECT");
421         valuesBucket_ = std::make_shared<NativeRdb::ValuesBucket>(NativeRdb::ValuesBucket::Unmarshalling(in));
422         return true;
423     }
424     valuesBucket_.reset();
425     return true;
426 }
427 
ReadDataAbilityPredicatesFromParcel(Parcel & in)428 bool DataAbilityOperation::ReadDataAbilityPredicatesFromParcel(Parcel &in)
429 {
430     int empty = VALUE_NULL;
431     if (!in.ReadInt32(empty)) {
432         TAG_LOGE(AAFwkTag::DATA_ABILITY, "ReadInt32(empty) error");
433         return false;
434     }
435     if (empty == VALUE_OBJECT) {
436         TAG_LOGD(AAFwkTag::DATA_ABILITY, "empty is VALUE_OBJECT");
437         dataAbilityPredicates_.reset(in.ReadParcelable<NativeRdb::DataAbilityPredicates>());
438         return true;
439     }
440     dataAbilityPredicates_.reset();
441     return true;
442 }
443 
ReadValuesBucketReferencesFromParcel(Parcel & in)444 bool DataAbilityOperation::ReadValuesBucketReferencesFromParcel(Parcel &in)
445 {
446     int empty = VALUE_NULL;
447     if (!in.ReadInt32(empty)) {
448         TAG_LOGE(AAFwkTag::DATA_ABILITY, "ReadInt32(empty) error");
449         return false;
450     }
451     if (empty == VALUE_OBJECT) {
452         TAG_LOGD(AAFwkTag::DATA_ABILITY, "empty is VALUE_OBJECT");
453         valuesBucketReferences_ = std::make_shared<NativeRdb::ValuesBucket>(
454             NativeRdb::ValuesBucket::Unmarshalling(in));
455         return true;
456     }
457     valuesBucketReferences_.reset();
458     return true;
459 }
460 
ReadFromParcel(Parcel & in)461 bool DataAbilityOperation::ReadFromParcel(Parcel &in)
462 {
463     TAG_LOGD(AAFwkTag::DATA_ABILITY, "start");
464     if (!in.ReadInt32(type_)) {
465         TAG_LOGE(AAFwkTag::DATA_ABILITY, "ReadInt32(type) error");
466         return false;
467     }
468     if (!in.ReadInt32(expectedCount_)) {
469         TAG_LOGE(AAFwkTag::DATA_ABILITY, "ReadInt32(expectedCount) error");
470         return false;
471     }
472     interrupted_ = in.ReadBool();
473     if (!ReadUriFromParcel(in) || !ReadValuesBucketFromParcel(in) || !ReadDataAbilityPredicatesFromParcel(in) ||
474         !ReadValuesBucketReferencesFromParcel(in)) {
475         TAG_LOGE(AAFwkTag::DATA_ABILITY, "error");
476         return false;
477     }
478     int referenceSize = 0;
479     if (!in.ReadInt32(referenceSize)) {
480         TAG_LOGE(AAFwkTag::DATA_ABILITY, "end");
481         return false;
482     }
483     if (referenceSize >= REFERENCE_THRESHOLD) {
484         TAG_LOGI(AAFwkTag::DATA_ABILITY, "referenceSize:%{public}d >= REFERENCE_THRESHOLD:%{public}d",
485             referenceSize, REFERENCE_THRESHOLD);
486         return true;
487     }
488 
489     for (int i = 0; i < REFERENCE_THRESHOLD && i < referenceSize; ++i) {
490         int first = 0;
491         int second = 0;
492         if (!in.ReadInt32(first)) {
493             TAG_LOGE(AAFwkTag::DATA_ABILITY, "end");
494             return false;
495         }
496         if (!in.ReadInt32(second)) {
497             TAG_LOGE(AAFwkTag::DATA_ABILITY, "end");
498             return false;
499         }
500         dataAbilityPredicatesBackReferences_.insert(std::make_pair(first, second));
501     }
502 
503     TAG_LOGD(AAFwkTag::DATA_ABILITY, "end");
504     return true;
505 }
CreateFromParcel(Parcel & in)506 std::shared_ptr<DataAbilityOperation> DataAbilityOperation::CreateFromParcel(Parcel &in)
507 {
508     TAG_LOGD(AAFwkTag::DATA_ABILITY, "start");
509     std::shared_ptr<DataAbilityOperation> operation = std::make_shared<DataAbilityOperation>(in);
510     TAG_LOGD(AAFwkTag::DATA_ABILITY, "end");
511     return operation;
512 }
PutMap(Parcel & in)513 void DataAbilityOperation::PutMap(Parcel &in)
514 {
515     TAG_LOGD(AAFwkTag::DATA_ABILITY, "start");
516     int count = in.ReadInt32();
517     if (count > 0 && count < REFERENCE_THRESHOLD) {
518         for (int i = 0; i < count; ++i) {
519             dataAbilityPredicatesBackReferences_.insert(std::make_pair(in.ReadInt32(), in.ReadInt32()));
520         }
521     }
522     TAG_LOGD(AAFwkTag::DATA_ABILITY, "end");
523 }
524 }  // namespace AppExecFwk
525 }  // namespace OHOS
526