-
Notifications
You must be signed in to change notification settings - Fork 73
Expand file tree
/
Copy pathvalue.h
More file actions
214 lines (178 loc) · 7.37 KB
/
Copy pathvalue.h
File metadata and controls
214 lines (178 loc) · 7.37 KB
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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
// Copyright 2022 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// IWYU pragma: private, include "base/value.h"
#ifndef THIRD_PARTY_CEL_CPP_BASE_INTERNAL_VALUE_H_
#define THIRD_PARTY_CEL_CPP_BASE_INTERNAL_VALUE_H_
#include <cstdint>
#include <functional>
#include <memory>
#include <type_traits>
#include "absl/status/status.h"
#include "absl/strings/cord.h"
#include "absl/strings/string_view.h"
#include "absl/time/time.h"
#include "absl/types/variant.h"
#include "base/handle.h"
#include "base/internal/data.h"
#include "base/internal/type.h"
#include "internal/rtti.h"
namespace cel {
class Type;
class BytesValue;
class StringValue;
class StructValue;
class ListValue;
class MapValue;
class UnknownValue;
namespace base_internal {
template <typename T, typename U>
class SimpleValue;
class ValueHandle;
internal::TypeInfo GetStructValueTypeId(const StructValue& struct_value);
internal::TypeInfo GetListValueTypeId(const ListValue& list_value);
internal::TypeInfo GetMapValueTypeId(const MapValue& map_value);
static_assert(std::is_trivially_copyable_v<absl::Duration>,
"absl::Duration must be trivially copyable.");
static_assert(std::is_trivially_destructible_v<absl::Duration>,
"absl::Duration must be trivially destructible.");
static_assert(std::is_trivially_copyable_v<absl::Time>,
"absl::Time must be trivially copyable.");
static_assert(std::is_trivially_destructible_v<absl::Time>,
"absl::Time must be trivially destructible.");
static_assert(std::is_trivially_copyable_v<absl::string_view>,
"absl::string_view must be trivially copyable.");
static_assert(std::is_trivially_destructible_v<absl::string_view>,
"absl::string_view must be trivially destructible.");
struct InlineValue final {
uintptr_t vptr;
union {
bool bool_value;
int64_t int64_value;
uint64_t uint64_value;
double double_value;
uintptr_t pointer_value;
absl::Duration duration_value;
absl::Time time_value;
absl::Status status_value;
absl::Cord cord_value;
struct {
absl::string_view string_value;
uintptr_t owner;
} string_value;
AnyType type_value;
struct {
AnyType type;
int64_t number;
} enum_value;
};
};
inline constexpr size_t kValueInlineSize = sizeof(InlineValue);
inline constexpr size_t kValueInlineAlign = alignof(InlineValue);
static_assert(kValueInlineSize <= 32,
"Size of an inline value should be less than 32 bytes.");
static_assert(kValueInlineAlign <= alignof(std::max_align_t),
"Alignment of an inline value should not be overaligned.");
using AnyValue = AnyData<kValueInlineSize, kValueInlineAlign>;
// Metaprogramming utility for interacting with Value.
//
// ValueTraits<T>::type is an alias for T.
// ValueTraits<T>::type_type is the corresponding Type for T.
// ValueTraits<T>::underlying_type is the underlying C++ primitive for T if it
// exists, otherwise void. ValueTraits<T>::DebugString accepts type or
// underlying_type and returns the debug string.
template <typename T>
struct ValueTraits;
class InlinedCordBytesValue;
class InlinedStringViewBytesValue;
class StringBytesValue;
class InlinedCordStringValue;
class InlinedStringViewStringValue;
class StringStringValue;
class LegacyStructValue;
class AbstractStructValue;
class LegacyListValue;
class AbstractListValue;
class LegacyMapValue;
class AbstractMapValue;
class LegacyTypeValue;
class ModernTypeValue;
using StringValueRep =
absl::variant<absl::string_view, std::reference_wrapper<const absl::Cord>>;
using BytesValueRep =
absl::variant<absl::string_view, std::reference_wrapper<const absl::Cord>>;
struct UnknownSetImpl;
// Enumeration used to differentiate between BytesValue's multiple inline
// non-trivial implementations.
enum class InlinedBytesValueVariant {
kCord = 0,
kStringView,
};
// Enumeration used to differentiate between StringValue's multiple inline
// non-trivial implementations.
enum class InlinedStringValueVariant {
kCord = 0,
kStringView,
};
// Enumeration used to differentiate between TypeValue's multiple inline
// non-trivial implementations.
enum class InlinedTypeValueVariant {
kLegacy = 0,
kModern,
};
} // namespace base_internal
namespace interop_internal {
base_internal::StringValueRep GetStringValueRep(
const Handle<StringValue>& value);
base_internal::BytesValueRep GetBytesValueRep(const Handle<BytesValue>& value);
std::shared_ptr<base_internal::UnknownSetImpl> GetUnknownValueImpl(
const Handle<UnknownValue>& value);
void SetUnknownValueImpl(Handle<UnknownValue>& value,
std::shared_ptr<base_internal::UnknownSetImpl> impl);
struct ErrorValueAccess;
struct UnknownValueAccess;
} // namespace interop_internal
} // namespace cel
#define CEL_INTERNAL_VALUE_DECL(name) extern template class Handle<name>
#define CEL_INTERNAL_VALUE_IMPL(name) template class Handle<name>
#define CEL_INTERNAL_DECLARE_VALUE(base, derived) \
public: \
static bool Is(const ::cel::Value& value); \
\
using ::cel::base##Value::Is; \
\
static const derived& Cast(const cel::Value& value) { \
ABSL_ASSERT(Is(value)); \
return static_cast<const derived&>(value); \
} \
\
private: \
friend class ::cel::base_internal::ValueHandle; \
\
::cel::internal::TypeInfo TypeId() const override;
#define CEL_INTERNAL_IMPLEMENT_VALUE(base, derived) \
static_assert(::std::is_base_of_v<::cel::base##Value, derived>, \
#derived " must inherit from cel::" #base "Value"); \
static_assert(!::std::is_abstract_v<derived>, "this must not be abstract"); \
\
bool derived::Is(const ::cel::Value& value) { \
return value.kind() == ::cel::Kind::k##base && \
::cel::base_internal::Get##base##ValueTypeId( \
static_cast<const ::cel::base##Value&>(value)) == \
::cel::internal::TypeId<derived>(); \
} \
\
::cel::internal::TypeInfo derived::TypeId() const { \
return ::cel::internal::TypeId<derived>(); \
}
#endif // THIRD_PARTY_CEL_CPP_BASE_INTERNAL_VALUE_H_