1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
|
#pragma once
#include <android/binder_to_string.h>
#include <binder/Parcel.h>
#include <binder/Status.h>
#include <cassert>
#include <cstdint>
#include <string>
#include <type_traits>
#include <utility>
#include <utils/String16.h>
#include <variant>
#ifndef __BIONIC__
#define __assert2(a,b,c,d) ((void)0)
#endif
namespace android {
namespace aidl {
namespace loggable {
class Union : public ::android::Parcelable {
public:
inline bool operator!=(const Union& rhs) const {
return _value != rhs._value;
}
inline bool operator<(const Union& rhs) const {
return _value < rhs._value;
}
inline bool operator<=(const Union& rhs) const {
return _value <= rhs._value;
}
inline bool operator==(const Union& rhs) const {
return _value == rhs._value;
}
inline bool operator>(const Union& rhs) const {
return _value > rhs._value;
}
inline bool operator>=(const Union& rhs) const {
return _value >= rhs._value;
}
enum Tag : int32_t {
num = 0, // int num;
str, // String str;
};
template<typename _Tp>
static constexpr bool _not_self = !std::is_same_v<std::remove_cv_t<std::remove_reference_t<_Tp>>, Union>;
Union() : _value(std::in_place_index<num>, int32_t(43)) { }
Union(const Union&) = default;
Union(Union&&) = default;
Union& operator=(const Union&) = default;
Union& operator=(Union&&) = default;
template <typename _Tp, typename = std::enable_if_t<_not_self<_Tp>>>
// NOLINTNEXTLINE(google-explicit-constructor)
constexpr Union(_Tp&& _arg)
: _value(std::forward<_Tp>(_arg)) {}
template <size_t _Np, typename... _Tp>
constexpr explicit Union(std::in_place_index_t<_Np>, _Tp&&... _args)
: _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {}
template <Tag _tag, typename... _Tp>
static Union make(_Tp&&... _args) {
return Union(std::in_place_index<_tag>, std::forward<_Tp>(_args)...);
}
template <Tag _tag, typename _Tp, typename... _Up>
static Union make(std::initializer_list<_Tp> _il, _Up&&... _args) {
return Union(std::in_place_index<_tag>, std::move(_il), std::forward<_Up>(_args)...);
}
Tag getTag() const {
return static_cast<Tag>(_value.index());
}
template <Tag _tag>
const auto& get() const {
if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); }
return std::get<_tag>(_value);
}
template <Tag _tag>
auto& get() {
if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); }
return std::get<_tag>(_value);
}
template <Tag _tag, typename... _Tp>
void set(_Tp&&... _args) {
_value.emplace<_tag>(std::forward<_Tp>(_args)...);
}
::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final;
::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final;
static const ::android::String16& getParcelableDescriptor() {
static const ::android::StaticString16 DESCIPTOR (u"android.aidl.loggable.Union");
return DESCIPTOR;
}
inline std::string toString() const {
std::ostringstream os;
os << "Union{";
switch (getTag()) {
case num: os << "num: " << ::android::internal::ToString(get<num>()); break;
case str: os << "str: " << ::android::internal::ToString(get<str>()); break;
}
os << "}";
return os.str();
}
private:
std::variant<int32_t, ::std::string> _value;
}; // class Union
} // namespace loggable
} // namespace aidl
} // namespace android
|
