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) ? 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 if (dstBuf.size() == 0) {
84 LOGE("[DbAbility][DeSerialize] buf length get failed.");
85 return -E_LENGTH_ERROR;
86 }
87 std::vector<bool> targetBuff(SyncConfig::ABILITYBITS.back().first + SyncConfig::ABILITYBITS.back().second);
88 uint32_t buffOffset = 0;
89 uint32_t innerBuffOffset = 0;
90 for (uint32_t pos = 0; pos < targetBuff.size() && pos < SERIALIZE_BIT_SIZE * dstBuf.size(); pos++) {
91 if (innerBuffOffset >= SERIALIZE_BIT_SIZE) {
92 innerBuffOffset = 0;
93 buffOffset++;
94 }
95 targetBuff[pos] = (dstBuf[buffOffset] >> innerBuffOffset) & 0x1;
96 innerBuffOffset++;
97 }
98 curAbility.SetDbAbilityBuff(targetBuff);
99 return E_OK;
100 }
101
CalculateLen(const DbAbility & curAbility)102 uint32_t DbAbility::CalculateLen(const DbAbility &curAbility)
103 {
104 uint32_t div = curAbility.GetAbilityBitsLen() / SERIALIZE_BIT_SIZE;
105 uint32_t buffLen = (curAbility.GetAbilityBitsLen() % SERIALIZE_BIT_SIZE) ? div + 1 : div;
106 return Parcel::GetVectorLen<uint64_t>(std::vector<uint64_t>(buffLen, 0));
107 }
108
SetDbAbilityBuff(const std::vector<bool> & buff)109 void DbAbility::SetDbAbilityBuff(const std::vector<bool> &buff)
110 {
111 dbAbility_ = buff;
112 }
113
GetDbAbilityBuff() const114 const std::vector<bool> &DbAbility::GetDbAbilityBuff() const
115 {
116 return dbAbility_;
117 }
118
GetAbilityBitsLen() const119 uint32_t DbAbility::GetAbilityBitsLen() const
120 {
121 return dbAbility_.size();
122 }
123
GetAbilityItem(const AbilityItem & abilityType) const124 uint8_t DbAbility::GetAbilityItem(const AbilityItem &abilityType) const
125 {
126 uint8_t data = 0;
127 auto iter = dbAbilityItemSet_.find(abilityType);
128 if (iter != dbAbilityItemSet_.end()) {
129 if ((iter->first + iter->second) > dbAbility_.size()) {
130 LOGE("[DbAbility] abilityType is error, start=%" PRIu32 ", use_bit=%" PRIu32 ", totalLen=%zu",
131 iter->first, iter->second, dbAbility_.size());
132 return 0;
133 }
134 uint32_t skip = 0;
135 // dbAbility_ bit[0..len] : low-->high, skip range 0..7
136 for (uint32_t pos = iter->first; pos < (iter->first + iter->second); pos++, skip++) {
137 if (dbAbility_[pos]) {
138 data += (static_cast<uint8_t>(dbAbility_[pos])) << skip;
139 }
140 }
141 }
142 return data;
143 }
144
SetAbilityItem(const AbilityItem & abilityType,uint8_t data)145 int DbAbility::SetAbilityItem(const AbilityItem &abilityType, uint8_t data)
146 {
147 auto iter = dbAbilityItemSet_.find(abilityType);
148 if (iter != dbAbilityItemSet_.end()) {
149 if (data >= pow(2, iter->second)) { // 2: means binary
150 LOGE("[DbAbility] value is invalid, data=%d, use_bit=%d", data, iter->second);
151 return -E_INTERNAL_ERROR;
152 }
153 if ((iter->first + iter->second) > dbAbility_.size()) {
154 dbAbility_.resize(iter->first + iter->second);
155 }
156 int pos = iter->first;
157 while (data) {
158 dbAbility_[pos] = data % 2; // 2: means binary
159 data = (data >> 1);
160 pos++;
161 }
162 }
163 return E_OK;
164 }
165 } // namespace DistributedDB