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