1 /* 2 * Copyright (c) 2023 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 #ifndef BASE_EVENT_RAW_ENCODE_INCLUDE_ENCODED_PARAM_H 17 #define BASE_EVENT_RAW_ENCODE_INCLUDE_ENCODED_PARAM_H 18 19 #include <cstdarg> 20 #include <cstddef> 21 #include <cstdint> 22 #include <string> 23 #include <vector> 24 25 #include "base/raw_data_base_def.h" 26 #include "base/value_param.h" 27 #include "encoded/raw_data_encoder.h" 28 #include "base/raw_data.h" 29 30 namespace OHOS { 31 namespace HiviewDFX { 32 namespace EventRaw { 33 class EncodedParam : public ValueParam { 34 public: 35 EncodedParam(const std::string& key); 36 virtual ~EncodedParam(); 37 38 public: 39 virtual std::string& GetKey(); 40 virtual RawData& GetRawData(); 41 virtual bool Encode(); 42 43 public: 44 virtual bool AsUint64(uint64_t& dest) override; 45 virtual bool AsInt64(int64_t& dest) override; 46 virtual bool AsDouble(double& dest) override; 47 virtual bool AsString(std::string& dest) override; 48 virtual bool AsUint64Vec(std::vector<uint64_t>& dest) override; 49 virtual bool AsInt64Vec(std::vector<int64_t>& dest) override; 50 virtual bool AsDoubleVec(std::vector<double>& dest) override; 51 virtual bool AsStringVec(std::vector<std::string>& dest) override; 52 53 protected: 54 virtual bool EncodeKey(); 55 virtual bool EncodeValueType() = 0; 56 virtual bool EncodeValue() = 0; 57 58 protected: 59 std::string key_; 60 RawData rawData_; 61 bool hasEncoded_ = false; 62 }; 63 64 template<typename T, 65 std::enable_if_t<std::is_same_v<std::decay_t<T>, uint8_t> || std::is_same_v<std::decay_t<T>, uint16_t> || 66 std::is_same_v<std::decay_t<T>, uint32_t> || std::is_same_v<std::decay_t<T>, uint64_t>>* = nullptr> 67 class UnsignedVarintEncodedParam : public EncodedParam { 68 public: UnsignedVarintEncodedParam(const std::string & key,T val)69 UnsignedVarintEncodedParam(const std::string& key, T val): EncodedParam(key) 70 { 71 val_ = val; 72 } 73 EncodeValueType()74 virtual bool EncodeValueType() override 75 { 76 return RawDataEncoder::ValueTypeEncoded(rawData_, false, ValueType::UINT64, 0); 77 } 78 EncodeValue()79 virtual bool EncodeValue() override 80 { 81 return RawDataEncoder::UnsignedVarintEncoded(rawData_, EncodeType::VARINT, val_); 82 } 83 AsString(std::string & ret)84 virtual bool AsString(std::string& ret) override 85 { 86 ret = std::to_string(val_); 87 return true; 88 } 89 AsUint64(uint64_t & dest)90 virtual bool AsUint64(uint64_t& dest) override 91 { 92 dest = static_cast<uint64_t>(val_); 93 return true; 94 } 95 GetDataCodedType()96 virtual DataCodedType GetDataCodedType() override 97 { 98 return DataCodedType::UNSIGNED_VARINT; 99 } 100 101 private: 102 T val_; 103 }; 104 105 template<typename T, 106 std::enable_if_t<std::is_same_v<std::decay_t<T>, uint8_t> || std::is_same_v<std::decay_t<T>, uint16_t> || 107 std::is_same_v<std::decay_t<T>, uint32_t> || std::is_same_v<std::decay_t<T>, uint64_t>>* = nullptr> 108 class UnsignedVarintEncodedArrayParam : public EncodedParam { 109 public: UnsignedVarintEncodedArrayParam(const std::string & key,const std::vector<T> & vals)110 UnsignedVarintEncodedArrayParam(const std::string& key, const std::vector<T>& vals): EncodedParam(key) 111 { 112 unsigned int index = 0; 113 for (auto item = vals.begin(); item != vals.end(); item++) { 114 index++; 115 if (index > MAX_ARRAY_SIZE) { 116 break; 117 } 118 vals_.emplace_back(*item); 119 } 120 } 121 EncodeValueType()122 virtual bool EncodeValueType() override 123 { 124 return RawDataEncoder::ValueTypeEncoded(rawData_, true, ValueType::UINT64, 0); 125 } 126 EncodeValue()127 virtual bool EncodeValue() override 128 { 129 bool ret = RawDataEncoder::UnsignedVarintEncoded(rawData_, EncodeType::LENGTH_DELIMITED, vals_.size()); 130 for (auto item : vals_) { 131 ret = ret && RawDataEncoder::UnsignedVarintEncoded(rawData_, EncodeType::VARINT, item); 132 } 133 return ret; 134 } 135 AsUint64Vec(std::vector<uint64_t> & dest)136 virtual bool AsUint64Vec(std::vector<uint64_t>& dest) override 137 { 138 for (auto item : vals_) { 139 dest.emplace_back(static_cast<uint64_t>(item)); 140 } 141 return true; 142 } 143 GetDataCodedType()144 virtual DataCodedType GetDataCodedType() override 145 { 146 return DataCodedType::UNSIGNED_VARINT_ARRAY; 147 } 148 149 private: 150 std::vector<T> vals_; 151 }; 152 153 template<typename T, 154 std::enable_if_t<std::is_same_v<std::decay_t<T>, bool> || std::is_same_v<std::decay_t<T>, int8_t> || 155 std::is_same_v<std::decay_t<T>, int16_t> || std::is_same_v<std::decay_t<T>, int32_t> || 156 std::is_same_v<std::decay_t<T>, int64_t>>* = nullptr> 157 class SignedVarintEncodedParam : public EncodedParam { 158 public: SignedVarintEncodedParam(const std::string & key,T val)159 SignedVarintEncodedParam(const std::string& key, T val): EncodedParam(key) 160 { 161 val_ = val; 162 } 163 EncodeValueType()164 virtual bool EncodeValueType() override 165 { 166 return RawDataEncoder::ValueTypeEncoded(rawData_, false, ValueType::INT64, 0); 167 } 168 EncodeValue()169 virtual bool EncodeValue() override 170 { 171 return RawDataEncoder::SignedVarintEncoded(rawData_, EncodeType::VARINT, val_); 172 } 173 AsString(std::string & ret)174 virtual bool AsString(std::string& ret) override 175 { 176 ret = std::to_string(val_); 177 return true; 178 } 179 AsInt64(int64_t & dest)180 virtual bool AsInt64(int64_t& dest) override 181 { 182 dest = static_cast<int64_t>(val_); 183 return true; 184 } 185 GetDataCodedType()186 virtual DataCodedType GetDataCodedType() override 187 { 188 return DataCodedType::SIGNED_VARINT; 189 } 190 191 private: 192 T val_; 193 }; 194 195 template<typename T, 196 std::enable_if_t<std::is_same_v<std::decay_t<T>, bool> || std::is_same_v<std::decay_t<T>, int8_t> || 197 std::is_same_v<std::decay_t<T>, int16_t> || std::is_same_v<std::decay_t<T>, int32_t> || 198 std::is_same_v<std::decay_t<T>, int64_t>>* = nullptr> 199 class SignedVarintEncodedArrayParam : public EncodedParam { 200 public: SignedVarintEncodedArrayParam(const std::string & key,const std::vector<T> & vals)201 SignedVarintEncodedArrayParam(const std::string& key, const std::vector<T>& vals): EncodedParam(key) 202 { 203 unsigned int index = 0; 204 for (auto item = vals.begin(); item != vals.end(); item++) { 205 index++; 206 if (index > MAX_ARRAY_SIZE) { 207 break; 208 } 209 vals_.emplace_back(*item); 210 } 211 } 212 EncodeValueType()213 virtual bool EncodeValueType() override 214 { 215 return RawDataEncoder::ValueTypeEncoded(rawData_, true, ValueType::INT64, 0); 216 } 217 EncodeValue()218 virtual bool EncodeValue() override 219 { 220 bool ret = RawDataEncoder::UnsignedVarintEncoded(rawData_, EncodeType::LENGTH_DELIMITED, vals_.size()); 221 for (auto item : vals_) { 222 ret = ret && RawDataEncoder::SignedVarintEncoded(rawData_, EncodeType::VARINT, item); 223 } 224 return ret; 225 } 226 AsInt64Vec(std::vector<int64_t> & dest)227 virtual bool AsInt64Vec(std::vector<int64_t>& dest) override 228 { 229 for (auto item : vals_) { 230 dest.emplace_back(static_cast<int64_t>(item)); 231 } 232 return true; 233 } 234 GetDataCodedType()235 virtual DataCodedType GetDataCodedType() override 236 { 237 return DataCodedType::SIGNED_VARINT_ARRAY; 238 } 239 240 private: 241 std::vector<T> vals_; 242 }; 243 244 template<typename T, 245 std::enable_if_t<std::is_same_v<std::decay_t<T>, float> || std::is_same_v<std::decay_t<T>, double>>* = nullptr> 246 class FloatingNumberEncodedParam : public EncodedParam { 247 public: FloatingNumberEncodedParam(const std::string & key,T val)248 FloatingNumberEncodedParam(const std::string& key, T val): EncodedParam(key) 249 { 250 val_ = val; 251 } 252 EncodeValueType()253 virtual bool EncodeValueType() override 254 { 255 auto valueType = ValueType::UNKNOWN; 256 if (std::is_same_v<std::decay_t<T>, float>) { 257 valueType = ValueType::FLOAT; 258 } 259 if (std::is_same_v<std::decay_t<T>, double>) { 260 valueType = ValueType::DOUBLE; 261 } 262 return RawDataEncoder::ValueTypeEncoded(rawData_, false, valueType, 0); 263 } 264 EncodeValue()265 virtual bool EncodeValue() override 266 { 267 return RawDataEncoder::FloatingNumberEncoded(rawData_, val_); 268 } 269 AsString(std::string & ret)270 virtual bool AsString(std::string& ret) override 271 { 272 ret = std::to_string(val_); 273 return true; 274 } 275 AsDouble(double & ret)276 virtual bool AsDouble(double& ret) override 277 { 278 ret = static_cast<double>(val_); 279 return true; 280 } 281 GetDataCodedType()282 virtual DataCodedType GetDataCodedType() override 283 { 284 return DataCodedType::FLOATING; 285 } 286 287 private: 288 T val_; 289 }; 290 291 template<typename T, 292 std::enable_if_t<std::is_same_v<std::decay_t<T>, float> || std::is_same_v<std::decay_t<T>, double>>* = nullptr> 293 class FloatingNumberEncodedArrayParam : public EncodedParam { 294 public: FloatingNumberEncodedArrayParam(const std::string & key,const std::vector<T> & vals)295 FloatingNumberEncodedArrayParam(const std::string& key, const std::vector<T>& vals): EncodedParam(key) 296 { 297 unsigned int index = 0; 298 for (auto item = vals.begin(); item != vals.end(); item++) { 299 index++; 300 if (index > MAX_ARRAY_SIZE) { 301 break; 302 } 303 vals_.emplace_back(*item); 304 } 305 } 306 EncodeValueType()307 virtual bool EncodeValueType() override 308 { 309 auto valueType = ValueType::UNKNOWN; 310 if (std::is_same_v<std::decay_t<T>, float>) { 311 valueType = ValueType::FLOAT; 312 } 313 if (std::is_same_v<std::decay_t<T>, double>) { 314 valueType = ValueType::DOUBLE; 315 } 316 return RawDataEncoder::ValueTypeEncoded(rawData_, true, valueType, 0); 317 } 318 EncodeValue()319 virtual bool EncodeValue() override 320 { 321 bool ret = RawDataEncoder::UnsignedVarintEncoded(rawData_, EncodeType::LENGTH_DELIMITED, vals_.size()); 322 for (auto item : vals_) { 323 ret = ret && RawDataEncoder::FloatingNumberEncoded(rawData_, item); 324 } 325 return ret; 326 } 327 AsDoubleVec(std::vector<double> & dest)328 virtual bool AsDoubleVec(std::vector<double>& dest) override 329 { 330 for (auto item : vals_) { 331 dest.emplace_back(static_cast<double>(item)); 332 } 333 return true; 334 } 335 GetDataCodedType()336 virtual DataCodedType GetDataCodedType() override 337 { 338 return DataCodedType::FLOATING_ARRAY; 339 } 340 341 private: 342 std::vector<T> vals_; 343 }; 344 345 class StringEncodedParam : public EncodedParam { 346 public: StringEncodedParam(const std::string & key,const std::string & val)347 StringEncodedParam(const std::string& key, const std::string& val): EncodedParam(key) 348 { 349 val_ = val; 350 } 351 EncodeValueType()352 virtual bool EncodeValueType() override 353 { 354 return RawDataEncoder::ValueTypeEncoded(rawData_, false, ValueType::STRING, 0); 355 } 356 EncodeValue()357 virtual bool EncodeValue() override 358 { 359 return RawDataEncoder::StringValueEncoded(rawData_, val_); 360 } 361 AsString(std::string & ret)362 bool AsString(std::string& ret) override 363 { 364 ret = val_; 365 return true; 366 } 367 GetDataCodedType()368 DataCodedType GetDataCodedType() override 369 { 370 return DataCodedType::DSTRING; 371 } 372 373 private: 374 std::string val_; 375 }; 376 377 class StringEncodedArrayParam : public EncodedParam { 378 public: StringEncodedArrayParam(const std::string & key,const std::vector<std::string> & vals)379 StringEncodedArrayParam(const std::string& key, const std::vector<std::string>& vals): EncodedParam(key) 380 { 381 unsigned int index = 0; 382 for (auto item = vals.begin(); item != vals.end(); item++) { 383 index++; 384 if (index > MAX_ARRAY_SIZE) { 385 break; 386 } 387 vals_.emplace_back(*item); 388 } 389 } 390 EncodeValueType()391 virtual bool EncodeValueType() override 392 { 393 return RawDataEncoder::ValueTypeEncoded(rawData_, true, ValueType::STRING, 0); 394 } 395 EncodeValue()396 virtual bool EncodeValue() override 397 { 398 bool ret = RawDataEncoder::UnsignedVarintEncoded(rawData_, EncodeType::LENGTH_DELIMITED, vals_.size()); 399 for (auto item : vals_) { 400 ret = ret && RawDataEncoder::StringValueEncoded(rawData_, item); 401 } 402 return ret; 403 } 404 AsStringVec(std::vector<std::string> & dest)405 bool AsStringVec(std::vector<std::string>& dest) override 406 { 407 dest.assign(vals_.begin(), vals_.end()); 408 return true; 409 } 410 GetDataCodedType()411 DataCodedType GetDataCodedType() override 412 { 413 return DataCodedType::DSTRING_ARRAY; 414 } 415 416 private: 417 std::vector<std::string> vals_; 418 }; 419 } // namespace EventRaw 420 } // namespace HiviewDFX 421 } // namespace OHOS 422 423 #endif // BASE_EVENT_RAW_ENCODE_INCLUDE_ENCODED_PARAM_H