1 /*
2 * Copyright (c) 2021 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 "db_ability.h"
17
18 #include <cmath>
19 #include "db_errno.h"
20 #include "types_export.h"
21
22 namespace DistributedDB {
DbAbility()23 DbAbility::DbAbility()
24 {
25 for (const auto &item : SyncConfig::ABILITYBITS) {
26 dbAbilityItemSet_.insert(item);
27 }
28 dbAbility_.resize(SyncConfig::ABILITYBITS.back().first + SyncConfig::ABILITYBITS.back().second);
29 }
30
DbAbility(const DbAbility & other)31 DbAbility::DbAbility(const DbAbility &other)
32 {
33 if (&other != this) {
34 dbAbility_ = other.dbAbility_;
35 dbAbilityItemSet_ = other.dbAbilityItemSet_;
36 }
37 }
38
operator =(const DbAbility & other)39 DbAbility& DbAbility::operator=(const DbAbility &other)
40 {
41 if (&other != this) {
42 dbAbility_ = other.dbAbility_;
43 dbAbilityItemSet_ = other.dbAbilityItemSet_;
44 }
45 return *this;
46 }
47
operator ==(const DbAbility & other) const48 bool DbAbility::operator==(const DbAbility &other) const
49 {
50 return (dbAbility_ == other.dbAbility_) && (dbAbilityItemSet_ == other.dbAbilityItemSet_);
51 }
52
Serialize(Parcel & parcel,const DbAbility & curAbility)53 int DbAbility::Serialize(Parcel &parcel, const DbAbility &curAbility)
54 {
55 uint32_t div = curAbility.GetAbilityBitsLen() / SERIALIZE_BIT_SIZE;
56 uint32_t buffLen = (curAbility.GetAbilityBitsLen() % SERIALIZE_BIT_SIZE != 0) ? div + 1 : div;
57 std::vector<uint64_t> dstBuf(buffLen, 0);
58 uint32_t buffOffset = 0;
59 uint32_t innerBuffOffset = 0;
60 const std::vector<bool> &abilityBuff = curAbility.GetDbAbilityBuff();
61 for (uint32_t pos = 0; pos < curAbility.GetAbilityBitsLen(); pos++, innerBuffOffset++) {
62 if (innerBuffOffset >= SERIALIZE_BIT_SIZE) {
63 innerBuffOffset = 0;
64 buffOffset++;
65 }
66 uint64_t value = static_cast<uint64_t>(abilityBuff[pos]) << innerBuffOffset;
67 dstBuf[buffOffset] = dstBuf[buffOffset] | value;
68 }
69 return parcel.WriteVector<uint64_t>(dstBuf);
70 }
71
DeSerialize(Parcel & parcel,DbAbility & curAbility)72 int DbAbility::DeSerialize(Parcel &parcel, DbAbility &curAbility)
73 {
74 if (!parcel.IsContinueRead()) {
75 return E_OK;
76 }
77 std::vector<uint64_t> dstBuf;
78 parcel.ReadVector<uint64_t>(dstBuf);
79 if (parcel.IsError()) {
80 LOGE("[DbAbility][DeSerialize] deserialize failed.");
81 return -E_LENGTH_ERROR;
82 }
83 std::vector<bool> targetBuff(SyncConfig::ABILITYBITS.back().first + SyncConfig::ABILITYBITS.back().second);
84 uint32_t buffOffset = 0;
85 uint32_t innerBuffOffset = 0;
86 for (uint32_t pos = 0; pos < targetBuff.size() && pos < SERIALIZE_BIT_SIZE * dstBuf.size(); pos++) {
87 if (innerBuffOffset >= SERIALIZE_BIT_SIZE) {
88 innerBuffOffset = 0;
89 buffOffset++;
90 }
91 targetBuff[pos] = (dstBuf[buffOffset] >> innerBuffOffset) & 0x1;
92 innerBuffOffset++;
93 }
94 curAbility.SetDbAbilityBuff(targetBuff);
95 return E_OK;
96 }
97
CalculateLen(const DbAbility & curAbility)98 uint32_t DbAbility::CalculateLen(const DbAbility &curAbility)
99 {
100 uint32_t div = curAbility.GetAbilityBitsLen() / SERIALIZE_BIT_SIZE;
101 uint32_t buffLen = (curAbility.GetAbilityBitsLen() % SERIALIZE_BIT_SIZE != 0) ? div + 1 : div;
102 return Parcel::GetVectorLen<uint64_t>(std::vector<uint64_t>(buffLen, 0));
103 }
104
SetDbAbilityBuff(const std::vector<bool> & buff)105 void DbAbility::SetDbAbilityBuff(const std::vector<bool> &buff)
106 {
107 dbAbility_ = buff;
108 }
109
GetDbAbilityBuff() const110 const std::vector<bool> &DbAbility::GetDbAbilityBuff() const
111 {
112 return dbAbility_;
113 }
114
GetAbilityBitsLen() const115 uint32_t DbAbility::GetAbilityBitsLen() const
116 {
117 return dbAbility_.size();
118 }
119
GetAbilityItem(const AbilityItem & abilityType) const120 uint8_t DbAbility::GetAbilityItem(const AbilityItem &abilityType) const
121 {
122 uint8_t data = 0;
123 auto iter = dbAbilityItemSet_.find(abilityType);
124 if (iter != dbAbilityItemSet_.end()) {
125 if ((iter->first + iter->second) > dbAbility_.size()) {
126 LOGE("[DbAbility] abilityType is error, start=%" PRIu32 ", use_bit=%" PRIu32 ", totalLen=%zu",
127 iter->first, iter->second, dbAbility_.size());
128 return 0;
129 }
130 uint32_t skip = 0;
131 // dbAbility_ bit[0..len] : low-->high, skip range 0..7
132 for (uint32_t pos = iter->first; pos < (iter->first + iter->second); pos++, skip++) {
133 if (dbAbility_[pos]) {
134 data += (static_cast<uint8_t>(dbAbility_[pos])) << skip;
135 }
136 }
137 }
138 return data;
139 }
140
SetAbilityItem(const AbilityItem & abilityType,uint8_t data)141 int DbAbility::SetAbilityItem(const AbilityItem &abilityType, uint8_t data)
142 {
143 auto iter = dbAbilityItemSet_.find(abilityType);
144 if (iter != dbAbilityItemSet_.end()) {
145 if (data >= pow(2, iter->second)) { // 2: means binary
146 LOGE("[DbAbility] value is invalid, data=%d, use_bit=%d", data, iter->second);
147 return -E_INTERNAL_ERROR;
148 }
149 if ((iter->first + iter->second) > dbAbility_.size()) {
150 dbAbility_.resize(iter->first + iter->second);
151 }
152 int pos = iter->first;
153 while (data) {
154 dbAbility_[pos] = data % 2; // 2: means binary
155 data = (data >> 1);
156 pos++;
157 }
158 }
159 return E_OK;
160 }
161 } // namespace DistributedDB