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 "value_object.h" 17 18 #include "rdb_errno.h" 19 #include "sqlite_utils.h" 20 21 namespace OHOS { 22 namespace NativeRdb { ValueObject()23ValueObject::ValueObject() : type(ValueObjectType::TYPE_NULL) 24 { 25 } 26 ValueObject(ValueObject && valueObject)27ValueObject::ValueObject(ValueObject &&valueObject) noexcept 28 { 29 if (this == &valueObject) { 30 return; 31 } 32 type = valueObject.type; 33 value = std::move(valueObject.value); 34 valueObject.type = ValueObjectType::TYPE_NULL; 35 } 36 ValueObject(const ValueObject & valueObject)37ValueObject::ValueObject(const ValueObject &valueObject) 38 { 39 if (this == &valueObject) { 40 return; 41 } 42 type = valueObject.type; 43 value = valueObject.value; 44 } 45 ~ValueObject()46ValueObject::~ValueObject() 47 { 48 } 49 ValueObject(int val)50ValueObject::ValueObject(int val) : type(ValueObjectType::TYPE_INT) 51 { 52 value = static_cast<int64_t>(val); 53 } 54 ValueObject(int64_t val)55ValueObject::ValueObject(int64_t val) : type(ValueObjectType::TYPE_INT64) 56 { 57 value = val; 58 } ValueObject(double val)59ValueObject::ValueObject(double val) : type(ValueObjectType::TYPE_DOUBLE) 60 { 61 value = val; 62 } ValueObject(bool val)63ValueObject::ValueObject(bool val) : type(ValueObjectType::TYPE_BOOL) 64 { 65 value = val; 66 } ValueObject(const std::string & val)67ValueObject::ValueObject(const std::string &val) : type(ValueObjectType::TYPE_STRING) 68 { 69 value = val; 70 } ValueObject(const std::vector<uint8_t> & val)71ValueObject::ValueObject(const std::vector<uint8_t> &val) : type(ValueObjectType::TYPE_BLOB) 72 { 73 std::vector<uint8_t> blob = val; 74 value = blob; 75 } 76 operator =(ValueObject && valueObject)77ValueObject &ValueObject::operator=(ValueObject &&valueObject) noexcept 78 { 79 if (this == &valueObject) { 80 return *this; 81 } 82 type = valueObject.type; 83 value = std::move(valueObject.value); 84 valueObject.type = ValueObjectType::TYPE_NULL; 85 return *this; 86 } 87 operator =(const ValueObject & valueObject)88ValueObject &ValueObject::operator=(const ValueObject &valueObject) 89 { 90 if (this == &valueObject) { 91 return *this; 92 } 93 type = valueObject.type; 94 value = valueObject.value; 95 return *this; 96 } 97 GetType() const98ValueObjectType ValueObject::GetType() const 99 { 100 return type; 101 } 102 GetInt(int & val) const103int ValueObject::GetInt(int &val) const 104 { 105 if (type != ValueObjectType::TYPE_INT) { 106 return E_INVALID_OBJECT_TYPE; 107 } 108 109 int64_t v = std::get<int64_t>(value); 110 val = static_cast<int>(v); 111 return E_OK; 112 } 113 GetLong(int64_t & val) const114int ValueObject::GetLong(int64_t &val) const 115 { 116 if (type != ValueObjectType::TYPE_INT64 && type != ValueObjectType::TYPE_INT) { 117 return E_INVALID_OBJECT_TYPE; 118 } 119 120 val = std::get<int64_t>(value); 121 return E_OK; 122 } 123 GetDouble(double & val) const124int ValueObject::GetDouble(double &val) const 125 { 126 if (type != ValueObjectType::TYPE_DOUBLE) { 127 return E_INVALID_OBJECT_TYPE; 128 } 129 130 val = std::get<double>(value); 131 return E_OK; 132 } 133 GetBool(bool & val) const134int ValueObject::GetBool(bool &val) const 135 { 136 if (type != ValueObjectType::TYPE_BOOL) { 137 return E_INVALID_OBJECT_TYPE; 138 } 139 140 val = std::get<bool>(value); 141 return E_OK; 142 } 143 GetString(std::string & val) const144int ValueObject::GetString(std::string &val) const 145 { 146 if (type != ValueObjectType::TYPE_STRING) { 147 return E_INVALID_OBJECT_TYPE; 148 } 149 150 val = std::get<std::string>(value); 151 return E_OK; 152 } 153 GetBlob(std::vector<uint8_t> & val) const154int ValueObject::GetBlob(std::vector<uint8_t> &val) const 155 { 156 if (type != ValueObjectType::TYPE_BLOB) { 157 return E_INVALID_OBJECT_TYPE; 158 } 159 160 val = std::get<std::vector<uint8_t>>(value); 161 return E_OK; 162 } 163 164 #if !defined(WINDOWS_PLATFORM) && !defined(MAC_PLATFORM) Marshalling(Parcel & parcel) const165bool ValueObject::Marshalling(Parcel &parcel) const 166 { 167 switch (this->type) { 168 case ValueObjectType::TYPE_NULL: { 169 parcel.WriteInt16((int16_t) ValueObjectType::TYPE_NULL); 170 break; 171 } 172 case ValueObjectType::TYPE_INT: { 173 parcel.WriteInt16((int16_t) ValueObjectType::TYPE_INT); 174 parcel.WriteInt64(std::get<int64_t>(value)); 175 break; 176 } 177 case ValueObjectType::TYPE_INT64: { 178 parcel.WriteInt16((int16_t) ValueObjectType::TYPE_INT64); 179 parcel.WriteInt64(std::get<int64_t>(value)); 180 break; 181 } 182 case ValueObjectType::TYPE_DOUBLE: { 183 parcel.WriteInt16((int16_t) ValueObjectType::TYPE_DOUBLE); 184 parcel.WriteDouble(std::get<double>(value)); 185 break; 186 } 187 case ValueObjectType::TYPE_STRING: { 188 parcel.WriteInt16((int16_t) ValueObjectType::TYPE_STRING); 189 parcel.WriteString(std::get<std::string>(value)); 190 break; 191 } 192 case ValueObjectType::TYPE_BLOB: { 193 parcel.WriteInt16((int16_t) ValueObjectType::TYPE_BLOB); 194 parcel.WriteUInt8Vector(std::get<std::vector<uint8_t>>(value)); 195 break; 196 } 197 case ValueObjectType::TYPE_BOOL: { 198 parcel.WriteInt16((int16_t) ValueObjectType::TYPE_BOOL); 199 parcel.WriteBool(std::get<bool>(value)); 200 break; 201 } 202 default: 203 break; 204 } 205 return true; 206 } 207 Unmarshalling(Parcel & parcel)208ValueObject *ValueObject::Unmarshalling(Parcel &parcel) 209 { 210 auto *pValueObject = new ValueObject(); 211 switch (parcel.ReadInt16()) { 212 case (int16_t)ValueObjectType::TYPE_NULL: { 213 pValueObject->type = ValueObjectType::TYPE_NULL; 214 break; 215 } 216 case (int16_t)ValueObjectType::TYPE_INT: { 217 pValueObject->type = ValueObjectType::TYPE_INT; 218 pValueObject->value = parcel.ReadInt64(); 219 break; 220 } 221 case (int16_t)ValueObjectType::TYPE_INT64: { 222 pValueObject->type = ValueObjectType::TYPE_INT64; 223 pValueObject->value = parcel.ReadInt64(); 224 break; 225 } 226 case (int16_t)ValueObjectType::TYPE_DOUBLE: { 227 pValueObject->type = ValueObjectType::TYPE_DOUBLE; 228 pValueObject->value = parcel.ReadDouble(); 229 break; 230 } 231 case (int16_t)ValueObjectType::TYPE_STRING: { 232 pValueObject->type = ValueObjectType::TYPE_STRING; 233 pValueObject->value = parcel.ReadString(); 234 break; 235 } 236 case (int16_t)ValueObjectType::TYPE_BLOB: { 237 pValueObject->type = ValueObjectType::TYPE_BLOB; 238 std::vector<uint8_t> val; 239 parcel.ReadUInt8Vector(&val); 240 pValueObject->value = val; 241 break; 242 } 243 case (int16_t)ValueObjectType::TYPE_BOOL: { 244 pValueObject->type = ValueObjectType::TYPE_BOOL; 245 pValueObject->value = parcel.ReadBool(); 246 break; 247 } 248 default: 249 break; 250 } 251 return pValueObject; 252 } 253 #endif 254 } // namespace NativeRdb 255 } // namespace OHOS 256