1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: icing/proto/schema.proto
3
4 #include "icing/proto/schema.pb.h"
5
6 #include <algorithm>
7 #include <cstdint>
8
9 #include <google/protobuf/io/coded_stream.h>
10 #include <google/protobuf/extension_set.h>
11 #include <google/protobuf/wire_format_lite.h>
12 #include <google/protobuf/io/zero_copy_stream_impl_lite.h>
13 // @@protoc_insertion_point(includes)
14 #include <google/protobuf/port_def.inc>
15
16 PROTOBUF_PRAGMA_INIT_SEG
17
18 namespace _pb = ::PROTOBUF_NAMESPACE_ID;
19 namespace _pbi = _pb::internal;
20
21 namespace icing {
22 namespace lib {
SchemaTypeConfigProto(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR SchemaTypeConfigProto::SchemaTypeConfigProto(
24 ::_pbi::ConstantInitialized): _impl_{
25 /*decltype(_impl_._has_bits_)*/{}
26 , /*decltype(_impl_._cached_size_)*/{}
27 , /*decltype(_impl_.properties_)*/{}
28 , /*decltype(_impl_.parent_types_)*/{}
29 , /*decltype(_impl_.schema_type_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
30 , /*decltype(_impl_.description_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
31 , /*decltype(_impl_.database_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
32 , /*decltype(_impl_.version_)*/0} {}
33 struct SchemaTypeConfigProtoDefaultTypeInternal {
SchemaTypeConfigProtoDefaultTypeInternalicing::lib::SchemaTypeConfigProtoDefaultTypeInternal34 PROTOBUF_CONSTEXPR SchemaTypeConfigProtoDefaultTypeInternal()
35 : _instance(::_pbi::ConstantInitialized{}) {}
~SchemaTypeConfigProtoDefaultTypeInternalicing::lib::SchemaTypeConfigProtoDefaultTypeInternal36 ~SchemaTypeConfigProtoDefaultTypeInternal() {}
37 union { // NOLINT(misc-non-private-member-variables-in-classes)
38 SchemaTypeConfigProto _instance;
39 };
40 };
41 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SchemaTypeConfigProtoDefaultTypeInternal _SchemaTypeConfigProto_default_instance_;
StringIndexingConfig_TokenizerType(::_pbi::ConstantInitialized)42 PROTOBUF_CONSTEXPR StringIndexingConfig_TokenizerType::StringIndexingConfig_TokenizerType(
43 ::_pbi::ConstantInitialized): _impl_{
44 /*decltype(_impl_._cached_size_)*/{}} {}
45 struct StringIndexingConfig_TokenizerTypeDefaultTypeInternal {
StringIndexingConfig_TokenizerTypeDefaultTypeInternalicing::lib::StringIndexingConfig_TokenizerTypeDefaultTypeInternal46 PROTOBUF_CONSTEXPR StringIndexingConfig_TokenizerTypeDefaultTypeInternal()
47 : _instance(::_pbi::ConstantInitialized{}) {}
~StringIndexingConfig_TokenizerTypeDefaultTypeInternalicing::lib::StringIndexingConfig_TokenizerTypeDefaultTypeInternal48 ~StringIndexingConfig_TokenizerTypeDefaultTypeInternal() {}
49 union { // NOLINT(misc-non-private-member-variables-in-classes)
50 StringIndexingConfig_TokenizerType _instance;
51 };
52 };
53 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StringIndexingConfig_TokenizerTypeDefaultTypeInternal _StringIndexingConfig_TokenizerType_default_instance_;
StringIndexingConfig(::_pbi::ConstantInitialized)54 PROTOBUF_CONSTEXPR StringIndexingConfig::StringIndexingConfig(
55 ::_pbi::ConstantInitialized): _impl_{
56 /*decltype(_impl_._has_bits_)*/{}
57 , /*decltype(_impl_._cached_size_)*/{}
58 , /*decltype(_impl_.term_match_type_)*/0
59 , /*decltype(_impl_.tokenizer_type_)*/0} {}
60 struct StringIndexingConfigDefaultTypeInternal {
StringIndexingConfigDefaultTypeInternalicing::lib::StringIndexingConfigDefaultTypeInternal61 PROTOBUF_CONSTEXPR StringIndexingConfigDefaultTypeInternal()
62 : _instance(::_pbi::ConstantInitialized{}) {}
~StringIndexingConfigDefaultTypeInternalicing::lib::StringIndexingConfigDefaultTypeInternal63 ~StringIndexingConfigDefaultTypeInternal() {}
64 union { // NOLINT(misc-non-private-member-variables-in-classes)
65 StringIndexingConfig _instance;
66 };
67 };
68 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StringIndexingConfigDefaultTypeInternal _StringIndexingConfig_default_instance_;
DocumentIndexingConfig(::_pbi::ConstantInitialized)69 PROTOBUF_CONSTEXPR DocumentIndexingConfig::DocumentIndexingConfig(
70 ::_pbi::ConstantInitialized): _impl_{
71 /*decltype(_impl_._has_bits_)*/{}
72 , /*decltype(_impl_._cached_size_)*/{}
73 , /*decltype(_impl_.indexable_nested_properties_list_)*/{}
74 , /*decltype(_impl_.index_nested_properties_)*/false} {}
75 struct DocumentIndexingConfigDefaultTypeInternal {
DocumentIndexingConfigDefaultTypeInternalicing::lib::DocumentIndexingConfigDefaultTypeInternal76 PROTOBUF_CONSTEXPR DocumentIndexingConfigDefaultTypeInternal()
77 : _instance(::_pbi::ConstantInitialized{}) {}
~DocumentIndexingConfigDefaultTypeInternalicing::lib::DocumentIndexingConfigDefaultTypeInternal78 ~DocumentIndexingConfigDefaultTypeInternal() {}
79 union { // NOLINT(misc-non-private-member-variables-in-classes)
80 DocumentIndexingConfig _instance;
81 };
82 };
83 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DocumentIndexingConfigDefaultTypeInternal _DocumentIndexingConfig_default_instance_;
IntegerIndexingConfig_NumericMatchType(::_pbi::ConstantInitialized)84 PROTOBUF_CONSTEXPR IntegerIndexingConfig_NumericMatchType::IntegerIndexingConfig_NumericMatchType(
85 ::_pbi::ConstantInitialized): _impl_{
86 /*decltype(_impl_._cached_size_)*/{}} {}
87 struct IntegerIndexingConfig_NumericMatchTypeDefaultTypeInternal {
IntegerIndexingConfig_NumericMatchTypeDefaultTypeInternalicing::lib::IntegerIndexingConfig_NumericMatchTypeDefaultTypeInternal88 PROTOBUF_CONSTEXPR IntegerIndexingConfig_NumericMatchTypeDefaultTypeInternal()
89 : _instance(::_pbi::ConstantInitialized{}) {}
~IntegerIndexingConfig_NumericMatchTypeDefaultTypeInternalicing::lib::IntegerIndexingConfig_NumericMatchTypeDefaultTypeInternal90 ~IntegerIndexingConfig_NumericMatchTypeDefaultTypeInternal() {}
91 union { // NOLINT(misc-non-private-member-variables-in-classes)
92 IntegerIndexingConfig_NumericMatchType _instance;
93 };
94 };
95 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 IntegerIndexingConfig_NumericMatchTypeDefaultTypeInternal _IntegerIndexingConfig_NumericMatchType_default_instance_;
IntegerIndexingConfig(::_pbi::ConstantInitialized)96 PROTOBUF_CONSTEXPR IntegerIndexingConfig::IntegerIndexingConfig(
97 ::_pbi::ConstantInitialized): _impl_{
98 /*decltype(_impl_._has_bits_)*/{}
99 , /*decltype(_impl_._cached_size_)*/{}
100 , /*decltype(_impl_.numeric_match_type_)*/0} {}
101 struct IntegerIndexingConfigDefaultTypeInternal {
IntegerIndexingConfigDefaultTypeInternalicing::lib::IntegerIndexingConfigDefaultTypeInternal102 PROTOBUF_CONSTEXPR IntegerIndexingConfigDefaultTypeInternal()
103 : _instance(::_pbi::ConstantInitialized{}) {}
~IntegerIndexingConfigDefaultTypeInternalicing::lib::IntegerIndexingConfigDefaultTypeInternal104 ~IntegerIndexingConfigDefaultTypeInternal() {}
105 union { // NOLINT(misc-non-private-member-variables-in-classes)
106 IntegerIndexingConfig _instance;
107 };
108 };
109 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 IntegerIndexingConfigDefaultTypeInternal _IntegerIndexingConfig_default_instance_;
EmbeddingIndexingConfig_EmbeddingIndexingType(::_pbi::ConstantInitialized)110 PROTOBUF_CONSTEXPR EmbeddingIndexingConfig_EmbeddingIndexingType::EmbeddingIndexingConfig_EmbeddingIndexingType(
111 ::_pbi::ConstantInitialized): _impl_{
112 /*decltype(_impl_._cached_size_)*/{}} {}
113 struct EmbeddingIndexingConfig_EmbeddingIndexingTypeDefaultTypeInternal {
EmbeddingIndexingConfig_EmbeddingIndexingTypeDefaultTypeInternalicing::lib::EmbeddingIndexingConfig_EmbeddingIndexingTypeDefaultTypeInternal114 PROTOBUF_CONSTEXPR EmbeddingIndexingConfig_EmbeddingIndexingTypeDefaultTypeInternal()
115 : _instance(::_pbi::ConstantInitialized{}) {}
~EmbeddingIndexingConfig_EmbeddingIndexingTypeDefaultTypeInternalicing::lib::EmbeddingIndexingConfig_EmbeddingIndexingTypeDefaultTypeInternal116 ~EmbeddingIndexingConfig_EmbeddingIndexingTypeDefaultTypeInternal() {}
117 union { // NOLINT(misc-non-private-member-variables-in-classes)
118 EmbeddingIndexingConfig_EmbeddingIndexingType _instance;
119 };
120 };
121 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EmbeddingIndexingConfig_EmbeddingIndexingTypeDefaultTypeInternal _EmbeddingIndexingConfig_EmbeddingIndexingType_default_instance_;
EmbeddingIndexingConfig_QuantizationType(::_pbi::ConstantInitialized)122 PROTOBUF_CONSTEXPR EmbeddingIndexingConfig_QuantizationType::EmbeddingIndexingConfig_QuantizationType(
123 ::_pbi::ConstantInitialized): _impl_{
124 /*decltype(_impl_._cached_size_)*/{}} {}
125 struct EmbeddingIndexingConfig_QuantizationTypeDefaultTypeInternal {
EmbeddingIndexingConfig_QuantizationTypeDefaultTypeInternalicing::lib::EmbeddingIndexingConfig_QuantizationTypeDefaultTypeInternal126 PROTOBUF_CONSTEXPR EmbeddingIndexingConfig_QuantizationTypeDefaultTypeInternal()
127 : _instance(::_pbi::ConstantInitialized{}) {}
~EmbeddingIndexingConfig_QuantizationTypeDefaultTypeInternalicing::lib::EmbeddingIndexingConfig_QuantizationTypeDefaultTypeInternal128 ~EmbeddingIndexingConfig_QuantizationTypeDefaultTypeInternal() {}
129 union { // NOLINT(misc-non-private-member-variables-in-classes)
130 EmbeddingIndexingConfig_QuantizationType _instance;
131 };
132 };
133 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EmbeddingIndexingConfig_QuantizationTypeDefaultTypeInternal _EmbeddingIndexingConfig_QuantizationType_default_instance_;
EmbeddingIndexingConfig(::_pbi::ConstantInitialized)134 PROTOBUF_CONSTEXPR EmbeddingIndexingConfig::EmbeddingIndexingConfig(
135 ::_pbi::ConstantInitialized): _impl_{
136 /*decltype(_impl_._has_bits_)*/{}
137 , /*decltype(_impl_._cached_size_)*/{}
138 , /*decltype(_impl_.embedding_indexing_type_)*/0
139 , /*decltype(_impl_.quantization_type_)*/0} {}
140 struct EmbeddingIndexingConfigDefaultTypeInternal {
EmbeddingIndexingConfigDefaultTypeInternalicing::lib::EmbeddingIndexingConfigDefaultTypeInternal141 PROTOBUF_CONSTEXPR EmbeddingIndexingConfigDefaultTypeInternal()
142 : _instance(::_pbi::ConstantInitialized{}) {}
~EmbeddingIndexingConfigDefaultTypeInternalicing::lib::EmbeddingIndexingConfigDefaultTypeInternal143 ~EmbeddingIndexingConfigDefaultTypeInternal() {}
144 union { // NOLINT(misc-non-private-member-variables-in-classes)
145 EmbeddingIndexingConfig _instance;
146 };
147 };
148 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EmbeddingIndexingConfigDefaultTypeInternal _EmbeddingIndexingConfig_default_instance_;
JoinableConfig_ValueType(::_pbi::ConstantInitialized)149 PROTOBUF_CONSTEXPR JoinableConfig_ValueType::JoinableConfig_ValueType(
150 ::_pbi::ConstantInitialized): _impl_{
151 /*decltype(_impl_._cached_size_)*/{}} {}
152 struct JoinableConfig_ValueTypeDefaultTypeInternal {
JoinableConfig_ValueTypeDefaultTypeInternalicing::lib::JoinableConfig_ValueTypeDefaultTypeInternal153 PROTOBUF_CONSTEXPR JoinableConfig_ValueTypeDefaultTypeInternal()
154 : _instance(::_pbi::ConstantInitialized{}) {}
~JoinableConfig_ValueTypeDefaultTypeInternalicing::lib::JoinableConfig_ValueTypeDefaultTypeInternal155 ~JoinableConfig_ValueTypeDefaultTypeInternal() {}
156 union { // NOLINT(misc-non-private-member-variables-in-classes)
157 JoinableConfig_ValueType _instance;
158 };
159 };
160 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 JoinableConfig_ValueTypeDefaultTypeInternal _JoinableConfig_ValueType_default_instance_;
JoinableConfig_DeletePropagationType(::_pbi::ConstantInitialized)161 PROTOBUF_CONSTEXPR JoinableConfig_DeletePropagationType::JoinableConfig_DeletePropagationType(
162 ::_pbi::ConstantInitialized): _impl_{
163 /*decltype(_impl_._cached_size_)*/{}} {}
164 struct JoinableConfig_DeletePropagationTypeDefaultTypeInternal {
JoinableConfig_DeletePropagationTypeDefaultTypeInternalicing::lib::JoinableConfig_DeletePropagationTypeDefaultTypeInternal165 PROTOBUF_CONSTEXPR JoinableConfig_DeletePropagationTypeDefaultTypeInternal()
166 : _instance(::_pbi::ConstantInitialized{}) {}
~JoinableConfig_DeletePropagationTypeDefaultTypeInternalicing::lib::JoinableConfig_DeletePropagationTypeDefaultTypeInternal167 ~JoinableConfig_DeletePropagationTypeDefaultTypeInternal() {}
168 union { // NOLINT(misc-non-private-member-variables-in-classes)
169 JoinableConfig_DeletePropagationType _instance;
170 };
171 };
172 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 JoinableConfig_DeletePropagationTypeDefaultTypeInternal _JoinableConfig_DeletePropagationType_default_instance_;
JoinableConfig(::_pbi::ConstantInitialized)173 PROTOBUF_CONSTEXPR JoinableConfig::JoinableConfig(
174 ::_pbi::ConstantInitialized): _impl_{
175 /*decltype(_impl_._has_bits_)*/{}
176 , /*decltype(_impl_._cached_size_)*/{}
177 , /*decltype(_impl_.value_type_)*/0
178 , /*decltype(_impl_.delete_propagation_type_)*/0} {}
179 struct JoinableConfigDefaultTypeInternal {
JoinableConfigDefaultTypeInternalicing::lib::JoinableConfigDefaultTypeInternal180 PROTOBUF_CONSTEXPR JoinableConfigDefaultTypeInternal()
181 : _instance(::_pbi::ConstantInitialized{}) {}
~JoinableConfigDefaultTypeInternalicing::lib::JoinableConfigDefaultTypeInternal182 ~JoinableConfigDefaultTypeInternal() {}
183 union { // NOLINT(misc-non-private-member-variables-in-classes)
184 JoinableConfig _instance;
185 };
186 };
187 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 JoinableConfigDefaultTypeInternal _JoinableConfig_default_instance_;
PropertyConfigProto_DataType(::_pbi::ConstantInitialized)188 PROTOBUF_CONSTEXPR PropertyConfigProto_DataType::PropertyConfigProto_DataType(
189 ::_pbi::ConstantInitialized): _impl_{
190 /*decltype(_impl_._cached_size_)*/{}} {}
191 struct PropertyConfigProto_DataTypeDefaultTypeInternal {
PropertyConfigProto_DataTypeDefaultTypeInternalicing::lib::PropertyConfigProto_DataTypeDefaultTypeInternal192 PROTOBUF_CONSTEXPR PropertyConfigProto_DataTypeDefaultTypeInternal()
193 : _instance(::_pbi::ConstantInitialized{}) {}
~PropertyConfigProto_DataTypeDefaultTypeInternalicing::lib::PropertyConfigProto_DataTypeDefaultTypeInternal194 ~PropertyConfigProto_DataTypeDefaultTypeInternal() {}
195 union { // NOLINT(misc-non-private-member-variables-in-classes)
196 PropertyConfigProto_DataType _instance;
197 };
198 };
199 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PropertyConfigProto_DataTypeDefaultTypeInternal _PropertyConfigProto_DataType_default_instance_;
PropertyConfigProto_Cardinality(::_pbi::ConstantInitialized)200 PROTOBUF_CONSTEXPR PropertyConfigProto_Cardinality::PropertyConfigProto_Cardinality(
201 ::_pbi::ConstantInitialized): _impl_{
202 /*decltype(_impl_._cached_size_)*/{}} {}
203 struct PropertyConfigProto_CardinalityDefaultTypeInternal {
PropertyConfigProto_CardinalityDefaultTypeInternalicing::lib::PropertyConfigProto_CardinalityDefaultTypeInternal204 PROTOBUF_CONSTEXPR PropertyConfigProto_CardinalityDefaultTypeInternal()
205 : _instance(::_pbi::ConstantInitialized{}) {}
~PropertyConfigProto_CardinalityDefaultTypeInternalicing::lib::PropertyConfigProto_CardinalityDefaultTypeInternal206 ~PropertyConfigProto_CardinalityDefaultTypeInternal() {}
207 union { // NOLINT(misc-non-private-member-variables-in-classes)
208 PropertyConfigProto_Cardinality _instance;
209 };
210 };
211 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PropertyConfigProto_CardinalityDefaultTypeInternal _PropertyConfigProto_Cardinality_default_instance_;
PropertyConfigProto_ScorableType(::_pbi::ConstantInitialized)212 PROTOBUF_CONSTEXPR PropertyConfigProto_ScorableType::PropertyConfigProto_ScorableType(
213 ::_pbi::ConstantInitialized): _impl_{
214 /*decltype(_impl_._cached_size_)*/{}} {}
215 struct PropertyConfigProto_ScorableTypeDefaultTypeInternal {
PropertyConfigProto_ScorableTypeDefaultTypeInternalicing::lib::PropertyConfigProto_ScorableTypeDefaultTypeInternal216 PROTOBUF_CONSTEXPR PropertyConfigProto_ScorableTypeDefaultTypeInternal()
217 : _instance(::_pbi::ConstantInitialized{}) {}
~PropertyConfigProto_ScorableTypeDefaultTypeInternalicing::lib::PropertyConfigProto_ScorableTypeDefaultTypeInternal218 ~PropertyConfigProto_ScorableTypeDefaultTypeInternal() {}
219 union { // NOLINT(misc-non-private-member-variables-in-classes)
220 PropertyConfigProto_ScorableType _instance;
221 };
222 };
223 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PropertyConfigProto_ScorableTypeDefaultTypeInternal _PropertyConfigProto_ScorableType_default_instance_;
PropertyConfigProto(::_pbi::ConstantInitialized)224 PROTOBUF_CONSTEXPR PropertyConfigProto::PropertyConfigProto(
225 ::_pbi::ConstantInitialized): _impl_{
226 /*decltype(_impl_._has_bits_)*/{}
227 , /*decltype(_impl_._cached_size_)*/{}
228 , /*decltype(_impl_.property_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
229 , /*decltype(_impl_.schema_type_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
230 , /*decltype(_impl_.description_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
231 , /*decltype(_impl_.string_indexing_config_)*/nullptr
232 , /*decltype(_impl_.document_indexing_config_)*/nullptr
233 , /*decltype(_impl_.integer_indexing_config_)*/nullptr
234 , /*decltype(_impl_.joinable_config_)*/nullptr
235 , /*decltype(_impl_.embedding_indexing_config_)*/nullptr
236 , /*decltype(_impl_.data_type_)*/0
237 , /*decltype(_impl_.cardinality_)*/0
238 , /*decltype(_impl_.scorable_type_)*/0} {}
239 struct PropertyConfigProtoDefaultTypeInternal {
PropertyConfigProtoDefaultTypeInternalicing::lib::PropertyConfigProtoDefaultTypeInternal240 PROTOBUF_CONSTEXPR PropertyConfigProtoDefaultTypeInternal()
241 : _instance(::_pbi::ConstantInitialized{}) {}
~PropertyConfigProtoDefaultTypeInternalicing::lib::PropertyConfigProtoDefaultTypeInternal242 ~PropertyConfigProtoDefaultTypeInternal() {}
243 union { // NOLINT(misc-non-private-member-variables-in-classes)
244 PropertyConfigProto _instance;
245 };
246 };
247 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PropertyConfigProtoDefaultTypeInternal _PropertyConfigProto_default_instance_;
SchemaProto(::_pbi::ConstantInitialized)248 PROTOBUF_CONSTEXPR SchemaProto::SchemaProto(
249 ::_pbi::ConstantInitialized): _impl_{
250 /*decltype(_impl_.types_)*/{}
251 , /*decltype(_impl_._cached_size_)*/{}} {}
252 struct SchemaProtoDefaultTypeInternal {
SchemaProtoDefaultTypeInternalicing::lib::SchemaProtoDefaultTypeInternal253 PROTOBUF_CONSTEXPR SchemaProtoDefaultTypeInternal()
254 : _instance(::_pbi::ConstantInitialized{}) {}
~SchemaProtoDefaultTypeInternalicing::lib::SchemaProtoDefaultTypeInternal255 ~SchemaProtoDefaultTypeInternal() {}
256 union { // NOLINT(misc-non-private-member-variables-in-classes)
257 SchemaProto _instance;
258 };
259 };
260 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SchemaProtoDefaultTypeInternal _SchemaProto_default_instance_;
SetSchemaResultProto(::_pbi::ConstantInitialized)261 PROTOBUF_CONSTEXPR SetSchemaResultProto::SetSchemaResultProto(
262 ::_pbi::ConstantInitialized): _impl_{
263 /*decltype(_impl_._has_bits_)*/{}
264 , /*decltype(_impl_._cached_size_)*/{}
265 , /*decltype(_impl_.deleted_schema_types_)*/{}
266 , /*decltype(_impl_.incompatible_schema_types_)*/{}
267 , /*decltype(_impl_.new_schema_types_)*/{}
268 , /*decltype(_impl_.fully_compatible_changed_schema_types_)*/{}
269 , /*decltype(_impl_.index_incompatible_changed_schema_types_)*/{}
270 , /*decltype(_impl_.join_incompatible_changed_schema_types_)*/{}
271 , /*decltype(_impl_.status_)*/nullptr
272 , /*decltype(_impl_.latency_ms_)*/0} {}
273 struct SetSchemaResultProtoDefaultTypeInternal {
SetSchemaResultProtoDefaultTypeInternalicing::lib::SetSchemaResultProtoDefaultTypeInternal274 PROTOBUF_CONSTEXPR SetSchemaResultProtoDefaultTypeInternal()
275 : _instance(::_pbi::ConstantInitialized{}) {}
~SetSchemaResultProtoDefaultTypeInternalicing::lib::SetSchemaResultProtoDefaultTypeInternal276 ~SetSchemaResultProtoDefaultTypeInternal() {}
277 union { // NOLINT(misc-non-private-member-variables-in-classes)
278 SetSchemaResultProto _instance;
279 };
280 };
281 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SetSchemaResultProtoDefaultTypeInternal _SetSchemaResultProto_default_instance_;
GetSchemaResultProto(::_pbi::ConstantInitialized)282 PROTOBUF_CONSTEXPR GetSchemaResultProto::GetSchemaResultProto(
283 ::_pbi::ConstantInitialized): _impl_{
284 /*decltype(_impl_._has_bits_)*/{}
285 , /*decltype(_impl_._cached_size_)*/{}
286 , /*decltype(_impl_.status_)*/nullptr
287 , /*decltype(_impl_.schema_)*/nullptr} {}
288 struct GetSchemaResultProtoDefaultTypeInternal {
GetSchemaResultProtoDefaultTypeInternalicing::lib::GetSchemaResultProtoDefaultTypeInternal289 PROTOBUF_CONSTEXPR GetSchemaResultProtoDefaultTypeInternal()
290 : _instance(::_pbi::ConstantInitialized{}) {}
~GetSchemaResultProtoDefaultTypeInternalicing::lib::GetSchemaResultProtoDefaultTypeInternal291 ~GetSchemaResultProtoDefaultTypeInternal() {}
292 union { // NOLINT(misc-non-private-member-variables-in-classes)
293 GetSchemaResultProto _instance;
294 };
295 };
296 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetSchemaResultProtoDefaultTypeInternal _GetSchemaResultProto_default_instance_;
GetSchemaTypeResultProto(::_pbi::ConstantInitialized)297 PROTOBUF_CONSTEXPR GetSchemaTypeResultProto::GetSchemaTypeResultProto(
298 ::_pbi::ConstantInitialized): _impl_{
299 /*decltype(_impl_._has_bits_)*/{}
300 , /*decltype(_impl_._cached_size_)*/{}
301 , /*decltype(_impl_.status_)*/nullptr
302 , /*decltype(_impl_.schema_type_config_)*/nullptr} {}
303 struct GetSchemaTypeResultProtoDefaultTypeInternal {
GetSchemaTypeResultProtoDefaultTypeInternalicing::lib::GetSchemaTypeResultProtoDefaultTypeInternal304 PROTOBUF_CONSTEXPR GetSchemaTypeResultProtoDefaultTypeInternal()
305 : _instance(::_pbi::ConstantInitialized{}) {}
~GetSchemaTypeResultProtoDefaultTypeInternalicing::lib::GetSchemaTypeResultProtoDefaultTypeInternal306 ~GetSchemaTypeResultProtoDefaultTypeInternal() {}
307 union { // NOLINT(misc-non-private-member-variables-in-classes)
308 GetSchemaTypeResultProto _instance;
309 };
310 };
311 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetSchemaTypeResultProtoDefaultTypeInternal _GetSchemaTypeResultProto_default_instance_;
312 } // namespace lib
313 } // namespace icing
314 namespace icing {
315 namespace lib {
StringIndexingConfig_TokenizerType_Code_IsValid(int value)316 bool StringIndexingConfig_TokenizerType_Code_IsValid(int value) {
317 switch (value) {
318 case 0:
319 case 1:
320 case 2:
321 case 3:
322 case 4:
323 return true;
324 default:
325 return false;
326 }
327 }
328
329 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> StringIndexingConfig_TokenizerType_Code_strings[5] = {};
330
331 static const char StringIndexingConfig_TokenizerType_Code_names[] =
332 "NONE"
333 "PLAIN"
334 "RFC822"
335 "URL"
336 "VERBATIM";
337
338 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry StringIndexingConfig_TokenizerType_Code_entries[] = {
339 { {StringIndexingConfig_TokenizerType_Code_names + 0, 4}, 0 },
340 { {StringIndexingConfig_TokenizerType_Code_names + 4, 5}, 1 },
341 { {StringIndexingConfig_TokenizerType_Code_names + 9, 6}, 3 },
342 { {StringIndexingConfig_TokenizerType_Code_names + 15, 3}, 4 },
343 { {StringIndexingConfig_TokenizerType_Code_names + 18, 8}, 2 },
344 };
345
346 static const int StringIndexingConfig_TokenizerType_Code_entries_by_number[] = {
347 0, // 0 -> NONE
348 1, // 1 -> PLAIN
349 4, // 2 -> VERBATIM
350 2, // 3 -> RFC822
351 3, // 4 -> URL
352 };
353
StringIndexingConfig_TokenizerType_Code_Name(StringIndexingConfig_TokenizerType_Code value)354 const std::string& StringIndexingConfig_TokenizerType_Code_Name(
355 StringIndexingConfig_TokenizerType_Code value) {
356 static const bool dummy =
357 ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
358 StringIndexingConfig_TokenizerType_Code_entries,
359 StringIndexingConfig_TokenizerType_Code_entries_by_number,
360 5, StringIndexingConfig_TokenizerType_Code_strings);
361 (void) dummy;
362 int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
363 StringIndexingConfig_TokenizerType_Code_entries,
364 StringIndexingConfig_TokenizerType_Code_entries_by_number,
365 5, value);
366 return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
367 StringIndexingConfig_TokenizerType_Code_strings[idx].get();
368 }
StringIndexingConfig_TokenizerType_Code_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,StringIndexingConfig_TokenizerType_Code * value)369 bool StringIndexingConfig_TokenizerType_Code_Parse(
370 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StringIndexingConfig_TokenizerType_Code* value) {
371 int int_value;
372 bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
373 StringIndexingConfig_TokenizerType_Code_entries, 5, name, &int_value);
374 if (success) {
375 *value = static_cast<StringIndexingConfig_TokenizerType_Code>(int_value);
376 }
377 return success;
378 }
379 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
380 constexpr StringIndexingConfig_TokenizerType_Code StringIndexingConfig_TokenizerType::NONE;
381 constexpr StringIndexingConfig_TokenizerType_Code StringIndexingConfig_TokenizerType::PLAIN;
382 constexpr StringIndexingConfig_TokenizerType_Code StringIndexingConfig_TokenizerType::VERBATIM;
383 constexpr StringIndexingConfig_TokenizerType_Code StringIndexingConfig_TokenizerType::RFC822;
384 constexpr StringIndexingConfig_TokenizerType_Code StringIndexingConfig_TokenizerType::URL;
385 constexpr StringIndexingConfig_TokenizerType_Code StringIndexingConfig_TokenizerType::Code_MIN;
386 constexpr StringIndexingConfig_TokenizerType_Code StringIndexingConfig_TokenizerType::Code_MAX;
387 constexpr int StringIndexingConfig_TokenizerType::Code_ARRAYSIZE;
388 #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
IntegerIndexingConfig_NumericMatchType_Code_IsValid(int value)389 bool IntegerIndexingConfig_NumericMatchType_Code_IsValid(int value) {
390 switch (value) {
391 case 0:
392 case 1:
393 return true;
394 default:
395 return false;
396 }
397 }
398
399 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> IntegerIndexingConfig_NumericMatchType_Code_strings[2] = {};
400
401 static const char IntegerIndexingConfig_NumericMatchType_Code_names[] =
402 "RANGE"
403 "UNKNOWN";
404
405 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry IntegerIndexingConfig_NumericMatchType_Code_entries[] = {
406 { {IntegerIndexingConfig_NumericMatchType_Code_names + 0, 5}, 1 },
407 { {IntegerIndexingConfig_NumericMatchType_Code_names + 5, 7}, 0 },
408 };
409
410 static const int IntegerIndexingConfig_NumericMatchType_Code_entries_by_number[] = {
411 1, // 0 -> UNKNOWN
412 0, // 1 -> RANGE
413 };
414
IntegerIndexingConfig_NumericMatchType_Code_Name(IntegerIndexingConfig_NumericMatchType_Code value)415 const std::string& IntegerIndexingConfig_NumericMatchType_Code_Name(
416 IntegerIndexingConfig_NumericMatchType_Code value) {
417 static const bool dummy =
418 ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
419 IntegerIndexingConfig_NumericMatchType_Code_entries,
420 IntegerIndexingConfig_NumericMatchType_Code_entries_by_number,
421 2, IntegerIndexingConfig_NumericMatchType_Code_strings);
422 (void) dummy;
423 int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
424 IntegerIndexingConfig_NumericMatchType_Code_entries,
425 IntegerIndexingConfig_NumericMatchType_Code_entries_by_number,
426 2, value);
427 return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
428 IntegerIndexingConfig_NumericMatchType_Code_strings[idx].get();
429 }
IntegerIndexingConfig_NumericMatchType_Code_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,IntegerIndexingConfig_NumericMatchType_Code * value)430 bool IntegerIndexingConfig_NumericMatchType_Code_Parse(
431 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, IntegerIndexingConfig_NumericMatchType_Code* value) {
432 int int_value;
433 bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
434 IntegerIndexingConfig_NumericMatchType_Code_entries, 2, name, &int_value);
435 if (success) {
436 *value = static_cast<IntegerIndexingConfig_NumericMatchType_Code>(int_value);
437 }
438 return success;
439 }
440 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
441 constexpr IntegerIndexingConfig_NumericMatchType_Code IntegerIndexingConfig_NumericMatchType::UNKNOWN;
442 constexpr IntegerIndexingConfig_NumericMatchType_Code IntegerIndexingConfig_NumericMatchType::RANGE;
443 constexpr IntegerIndexingConfig_NumericMatchType_Code IntegerIndexingConfig_NumericMatchType::Code_MIN;
444 constexpr IntegerIndexingConfig_NumericMatchType_Code IntegerIndexingConfig_NumericMatchType::Code_MAX;
445 constexpr int IntegerIndexingConfig_NumericMatchType::Code_ARRAYSIZE;
446 #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
EmbeddingIndexingConfig_EmbeddingIndexingType_Code_IsValid(int value)447 bool EmbeddingIndexingConfig_EmbeddingIndexingType_Code_IsValid(int value) {
448 switch (value) {
449 case 0:
450 case 1:
451 return true;
452 default:
453 return false;
454 }
455 }
456
457 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> EmbeddingIndexingConfig_EmbeddingIndexingType_Code_strings[2] = {};
458
459 static const char EmbeddingIndexingConfig_EmbeddingIndexingType_Code_names[] =
460 "LINEAR_SEARCH"
461 "UNKNOWN";
462
463 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry EmbeddingIndexingConfig_EmbeddingIndexingType_Code_entries[] = {
464 { {EmbeddingIndexingConfig_EmbeddingIndexingType_Code_names + 0, 13}, 1 },
465 { {EmbeddingIndexingConfig_EmbeddingIndexingType_Code_names + 13, 7}, 0 },
466 };
467
468 static const int EmbeddingIndexingConfig_EmbeddingIndexingType_Code_entries_by_number[] = {
469 1, // 0 -> UNKNOWN
470 0, // 1 -> LINEAR_SEARCH
471 };
472
EmbeddingIndexingConfig_EmbeddingIndexingType_Code_Name(EmbeddingIndexingConfig_EmbeddingIndexingType_Code value)473 const std::string& EmbeddingIndexingConfig_EmbeddingIndexingType_Code_Name(
474 EmbeddingIndexingConfig_EmbeddingIndexingType_Code value) {
475 static const bool dummy =
476 ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
477 EmbeddingIndexingConfig_EmbeddingIndexingType_Code_entries,
478 EmbeddingIndexingConfig_EmbeddingIndexingType_Code_entries_by_number,
479 2, EmbeddingIndexingConfig_EmbeddingIndexingType_Code_strings);
480 (void) dummy;
481 int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
482 EmbeddingIndexingConfig_EmbeddingIndexingType_Code_entries,
483 EmbeddingIndexingConfig_EmbeddingIndexingType_Code_entries_by_number,
484 2, value);
485 return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
486 EmbeddingIndexingConfig_EmbeddingIndexingType_Code_strings[idx].get();
487 }
EmbeddingIndexingConfig_EmbeddingIndexingType_Code_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,EmbeddingIndexingConfig_EmbeddingIndexingType_Code * value)488 bool EmbeddingIndexingConfig_EmbeddingIndexingType_Code_Parse(
489 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, EmbeddingIndexingConfig_EmbeddingIndexingType_Code* value) {
490 int int_value;
491 bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
492 EmbeddingIndexingConfig_EmbeddingIndexingType_Code_entries, 2, name, &int_value);
493 if (success) {
494 *value = static_cast<EmbeddingIndexingConfig_EmbeddingIndexingType_Code>(int_value);
495 }
496 return success;
497 }
498 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
499 constexpr EmbeddingIndexingConfig_EmbeddingIndexingType_Code EmbeddingIndexingConfig_EmbeddingIndexingType::UNKNOWN;
500 constexpr EmbeddingIndexingConfig_EmbeddingIndexingType_Code EmbeddingIndexingConfig_EmbeddingIndexingType::LINEAR_SEARCH;
501 constexpr EmbeddingIndexingConfig_EmbeddingIndexingType_Code EmbeddingIndexingConfig_EmbeddingIndexingType::Code_MIN;
502 constexpr EmbeddingIndexingConfig_EmbeddingIndexingType_Code EmbeddingIndexingConfig_EmbeddingIndexingType::Code_MAX;
503 constexpr int EmbeddingIndexingConfig_EmbeddingIndexingType::Code_ARRAYSIZE;
504 #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
EmbeddingIndexingConfig_QuantizationType_Code_IsValid(int value)505 bool EmbeddingIndexingConfig_QuantizationType_Code_IsValid(int value) {
506 switch (value) {
507 case 0:
508 case 1:
509 return true;
510 default:
511 return false;
512 }
513 }
514
515 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> EmbeddingIndexingConfig_QuantizationType_Code_strings[2] = {};
516
517 static const char EmbeddingIndexingConfig_QuantizationType_Code_names[] =
518 "NONE"
519 "QUANTIZE_8_BIT";
520
521 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry EmbeddingIndexingConfig_QuantizationType_Code_entries[] = {
522 { {EmbeddingIndexingConfig_QuantizationType_Code_names + 0, 4}, 0 },
523 { {EmbeddingIndexingConfig_QuantizationType_Code_names + 4, 14}, 1 },
524 };
525
526 static const int EmbeddingIndexingConfig_QuantizationType_Code_entries_by_number[] = {
527 0, // 0 -> NONE
528 1, // 1 -> QUANTIZE_8_BIT
529 };
530
EmbeddingIndexingConfig_QuantizationType_Code_Name(EmbeddingIndexingConfig_QuantizationType_Code value)531 const std::string& EmbeddingIndexingConfig_QuantizationType_Code_Name(
532 EmbeddingIndexingConfig_QuantizationType_Code value) {
533 static const bool dummy =
534 ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
535 EmbeddingIndexingConfig_QuantizationType_Code_entries,
536 EmbeddingIndexingConfig_QuantizationType_Code_entries_by_number,
537 2, EmbeddingIndexingConfig_QuantizationType_Code_strings);
538 (void) dummy;
539 int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
540 EmbeddingIndexingConfig_QuantizationType_Code_entries,
541 EmbeddingIndexingConfig_QuantizationType_Code_entries_by_number,
542 2, value);
543 return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
544 EmbeddingIndexingConfig_QuantizationType_Code_strings[idx].get();
545 }
EmbeddingIndexingConfig_QuantizationType_Code_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,EmbeddingIndexingConfig_QuantizationType_Code * value)546 bool EmbeddingIndexingConfig_QuantizationType_Code_Parse(
547 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, EmbeddingIndexingConfig_QuantizationType_Code* value) {
548 int int_value;
549 bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
550 EmbeddingIndexingConfig_QuantizationType_Code_entries, 2, name, &int_value);
551 if (success) {
552 *value = static_cast<EmbeddingIndexingConfig_QuantizationType_Code>(int_value);
553 }
554 return success;
555 }
556 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
557 constexpr EmbeddingIndexingConfig_QuantizationType_Code EmbeddingIndexingConfig_QuantizationType::NONE;
558 constexpr EmbeddingIndexingConfig_QuantizationType_Code EmbeddingIndexingConfig_QuantizationType::QUANTIZE_8_BIT;
559 constexpr EmbeddingIndexingConfig_QuantizationType_Code EmbeddingIndexingConfig_QuantizationType::Code_MIN;
560 constexpr EmbeddingIndexingConfig_QuantizationType_Code EmbeddingIndexingConfig_QuantizationType::Code_MAX;
561 constexpr int EmbeddingIndexingConfig_QuantizationType::Code_ARRAYSIZE;
562 #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
JoinableConfig_ValueType_Code_IsValid(int value)563 bool JoinableConfig_ValueType_Code_IsValid(int value) {
564 switch (value) {
565 case 0:
566 case 1:
567 return true;
568 default:
569 return false;
570 }
571 }
572
573 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> JoinableConfig_ValueType_Code_strings[2] = {};
574
575 static const char JoinableConfig_ValueType_Code_names[] =
576 "NONE"
577 "QUALIFIED_ID";
578
579 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry JoinableConfig_ValueType_Code_entries[] = {
580 { {JoinableConfig_ValueType_Code_names + 0, 4}, 0 },
581 { {JoinableConfig_ValueType_Code_names + 4, 12}, 1 },
582 };
583
584 static const int JoinableConfig_ValueType_Code_entries_by_number[] = {
585 0, // 0 -> NONE
586 1, // 1 -> QUALIFIED_ID
587 };
588
JoinableConfig_ValueType_Code_Name(JoinableConfig_ValueType_Code value)589 const std::string& JoinableConfig_ValueType_Code_Name(
590 JoinableConfig_ValueType_Code value) {
591 static const bool dummy =
592 ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
593 JoinableConfig_ValueType_Code_entries,
594 JoinableConfig_ValueType_Code_entries_by_number,
595 2, JoinableConfig_ValueType_Code_strings);
596 (void) dummy;
597 int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
598 JoinableConfig_ValueType_Code_entries,
599 JoinableConfig_ValueType_Code_entries_by_number,
600 2, value);
601 return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
602 JoinableConfig_ValueType_Code_strings[idx].get();
603 }
JoinableConfig_ValueType_Code_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,JoinableConfig_ValueType_Code * value)604 bool JoinableConfig_ValueType_Code_Parse(
605 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, JoinableConfig_ValueType_Code* value) {
606 int int_value;
607 bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
608 JoinableConfig_ValueType_Code_entries, 2, name, &int_value);
609 if (success) {
610 *value = static_cast<JoinableConfig_ValueType_Code>(int_value);
611 }
612 return success;
613 }
614 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
615 constexpr JoinableConfig_ValueType_Code JoinableConfig_ValueType::NONE;
616 constexpr JoinableConfig_ValueType_Code JoinableConfig_ValueType::QUALIFIED_ID;
617 constexpr JoinableConfig_ValueType_Code JoinableConfig_ValueType::Code_MIN;
618 constexpr JoinableConfig_ValueType_Code JoinableConfig_ValueType::Code_MAX;
619 constexpr int JoinableConfig_ValueType::Code_ARRAYSIZE;
620 #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
JoinableConfig_DeletePropagationType_Code_IsValid(int value)621 bool JoinableConfig_DeletePropagationType_Code_IsValid(int value) {
622 switch (value) {
623 case 0:
624 case 1:
625 return true;
626 default:
627 return false;
628 }
629 }
630
631 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> JoinableConfig_DeletePropagationType_Code_strings[2] = {};
632
633 static const char JoinableConfig_DeletePropagationType_Code_names[] =
634 "NONE"
635 "PROPAGATE_FROM";
636
637 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry JoinableConfig_DeletePropagationType_Code_entries[] = {
638 { {JoinableConfig_DeletePropagationType_Code_names + 0, 4}, 0 },
639 { {JoinableConfig_DeletePropagationType_Code_names + 4, 14}, 1 },
640 };
641
642 static const int JoinableConfig_DeletePropagationType_Code_entries_by_number[] = {
643 0, // 0 -> NONE
644 1, // 1 -> PROPAGATE_FROM
645 };
646
JoinableConfig_DeletePropagationType_Code_Name(JoinableConfig_DeletePropagationType_Code value)647 const std::string& JoinableConfig_DeletePropagationType_Code_Name(
648 JoinableConfig_DeletePropagationType_Code value) {
649 static const bool dummy =
650 ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
651 JoinableConfig_DeletePropagationType_Code_entries,
652 JoinableConfig_DeletePropagationType_Code_entries_by_number,
653 2, JoinableConfig_DeletePropagationType_Code_strings);
654 (void) dummy;
655 int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
656 JoinableConfig_DeletePropagationType_Code_entries,
657 JoinableConfig_DeletePropagationType_Code_entries_by_number,
658 2, value);
659 return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
660 JoinableConfig_DeletePropagationType_Code_strings[idx].get();
661 }
JoinableConfig_DeletePropagationType_Code_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,JoinableConfig_DeletePropagationType_Code * value)662 bool JoinableConfig_DeletePropagationType_Code_Parse(
663 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, JoinableConfig_DeletePropagationType_Code* value) {
664 int int_value;
665 bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
666 JoinableConfig_DeletePropagationType_Code_entries, 2, name, &int_value);
667 if (success) {
668 *value = static_cast<JoinableConfig_DeletePropagationType_Code>(int_value);
669 }
670 return success;
671 }
672 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
673 constexpr JoinableConfig_DeletePropagationType_Code JoinableConfig_DeletePropagationType::NONE;
674 constexpr JoinableConfig_DeletePropagationType_Code JoinableConfig_DeletePropagationType::PROPAGATE_FROM;
675 constexpr JoinableConfig_DeletePropagationType_Code JoinableConfig_DeletePropagationType::Code_MIN;
676 constexpr JoinableConfig_DeletePropagationType_Code JoinableConfig_DeletePropagationType::Code_MAX;
677 constexpr int JoinableConfig_DeletePropagationType::Code_ARRAYSIZE;
678 #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
PropertyConfigProto_DataType_Code_IsValid(int value)679 bool PropertyConfigProto_DataType_Code_IsValid(int value) {
680 switch (value) {
681 case 0:
682 case 1:
683 case 2:
684 case 3:
685 case 4:
686 case 5:
687 case 6:
688 case 7:
689 case 8:
690 return true;
691 default:
692 return false;
693 }
694 }
695
696 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> PropertyConfigProto_DataType_Code_strings[9] = {};
697
698 static const char PropertyConfigProto_DataType_Code_names[] =
699 "BLOB_HANDLE"
700 "BOOLEAN"
701 "BYTES"
702 "DOCUMENT"
703 "DOUBLE"
704 "INT64"
705 "STRING"
706 "UNKNOWN"
707 "VECTOR";
708
709 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry PropertyConfigProto_DataType_Code_entries[] = {
710 { {PropertyConfigProto_DataType_Code_names + 0, 11}, 8 },
711 { {PropertyConfigProto_DataType_Code_names + 11, 7}, 4 },
712 { {PropertyConfigProto_DataType_Code_names + 18, 5}, 5 },
713 { {PropertyConfigProto_DataType_Code_names + 23, 8}, 6 },
714 { {PropertyConfigProto_DataType_Code_names + 31, 6}, 3 },
715 { {PropertyConfigProto_DataType_Code_names + 37, 5}, 2 },
716 { {PropertyConfigProto_DataType_Code_names + 42, 6}, 1 },
717 { {PropertyConfigProto_DataType_Code_names + 48, 7}, 0 },
718 { {PropertyConfigProto_DataType_Code_names + 55, 6}, 7 },
719 };
720
721 static const int PropertyConfigProto_DataType_Code_entries_by_number[] = {
722 7, // 0 -> UNKNOWN
723 6, // 1 -> STRING
724 5, // 2 -> INT64
725 4, // 3 -> DOUBLE
726 1, // 4 -> BOOLEAN
727 2, // 5 -> BYTES
728 3, // 6 -> DOCUMENT
729 8, // 7 -> VECTOR
730 0, // 8 -> BLOB_HANDLE
731 };
732
PropertyConfigProto_DataType_Code_Name(PropertyConfigProto_DataType_Code value)733 const std::string& PropertyConfigProto_DataType_Code_Name(
734 PropertyConfigProto_DataType_Code value) {
735 static const bool dummy =
736 ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
737 PropertyConfigProto_DataType_Code_entries,
738 PropertyConfigProto_DataType_Code_entries_by_number,
739 9, PropertyConfigProto_DataType_Code_strings);
740 (void) dummy;
741 int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
742 PropertyConfigProto_DataType_Code_entries,
743 PropertyConfigProto_DataType_Code_entries_by_number,
744 9, value);
745 return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
746 PropertyConfigProto_DataType_Code_strings[idx].get();
747 }
PropertyConfigProto_DataType_Code_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,PropertyConfigProto_DataType_Code * value)748 bool PropertyConfigProto_DataType_Code_Parse(
749 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PropertyConfigProto_DataType_Code* value) {
750 int int_value;
751 bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
752 PropertyConfigProto_DataType_Code_entries, 9, name, &int_value);
753 if (success) {
754 *value = static_cast<PropertyConfigProto_DataType_Code>(int_value);
755 }
756 return success;
757 }
758 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
759 constexpr PropertyConfigProto_DataType_Code PropertyConfigProto_DataType::UNKNOWN;
760 constexpr PropertyConfigProto_DataType_Code PropertyConfigProto_DataType::STRING;
761 constexpr PropertyConfigProto_DataType_Code PropertyConfigProto_DataType::INT64;
762 constexpr PropertyConfigProto_DataType_Code PropertyConfigProto_DataType::DOUBLE;
763 constexpr PropertyConfigProto_DataType_Code PropertyConfigProto_DataType::BOOLEAN;
764 constexpr PropertyConfigProto_DataType_Code PropertyConfigProto_DataType::BYTES;
765 constexpr PropertyConfigProto_DataType_Code PropertyConfigProto_DataType::DOCUMENT;
766 constexpr PropertyConfigProto_DataType_Code PropertyConfigProto_DataType::VECTOR;
767 constexpr PropertyConfigProto_DataType_Code PropertyConfigProto_DataType::BLOB_HANDLE;
768 constexpr PropertyConfigProto_DataType_Code PropertyConfigProto_DataType::Code_MIN;
769 constexpr PropertyConfigProto_DataType_Code PropertyConfigProto_DataType::Code_MAX;
770 constexpr int PropertyConfigProto_DataType::Code_ARRAYSIZE;
771 #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
PropertyConfigProto_Cardinality_Code_IsValid(int value)772 bool PropertyConfigProto_Cardinality_Code_IsValid(int value) {
773 switch (value) {
774 case 0:
775 case 1:
776 case 2:
777 case 3:
778 return true;
779 default:
780 return false;
781 }
782 }
783
784 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> PropertyConfigProto_Cardinality_Code_strings[4] = {};
785
786 static const char PropertyConfigProto_Cardinality_Code_names[] =
787 "OPTIONAL"
788 "REPEATED"
789 "REQUIRED"
790 "UNKNOWN";
791
792 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry PropertyConfigProto_Cardinality_Code_entries[] = {
793 { {PropertyConfigProto_Cardinality_Code_names + 0, 8}, 2 },
794 { {PropertyConfigProto_Cardinality_Code_names + 8, 8}, 1 },
795 { {PropertyConfigProto_Cardinality_Code_names + 16, 8}, 3 },
796 { {PropertyConfigProto_Cardinality_Code_names + 24, 7}, 0 },
797 };
798
799 static const int PropertyConfigProto_Cardinality_Code_entries_by_number[] = {
800 3, // 0 -> UNKNOWN
801 1, // 1 -> REPEATED
802 0, // 2 -> OPTIONAL
803 2, // 3 -> REQUIRED
804 };
805
PropertyConfigProto_Cardinality_Code_Name(PropertyConfigProto_Cardinality_Code value)806 const std::string& PropertyConfigProto_Cardinality_Code_Name(
807 PropertyConfigProto_Cardinality_Code value) {
808 static const bool dummy =
809 ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
810 PropertyConfigProto_Cardinality_Code_entries,
811 PropertyConfigProto_Cardinality_Code_entries_by_number,
812 4, PropertyConfigProto_Cardinality_Code_strings);
813 (void) dummy;
814 int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
815 PropertyConfigProto_Cardinality_Code_entries,
816 PropertyConfigProto_Cardinality_Code_entries_by_number,
817 4, value);
818 return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
819 PropertyConfigProto_Cardinality_Code_strings[idx].get();
820 }
PropertyConfigProto_Cardinality_Code_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,PropertyConfigProto_Cardinality_Code * value)821 bool PropertyConfigProto_Cardinality_Code_Parse(
822 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PropertyConfigProto_Cardinality_Code* value) {
823 int int_value;
824 bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
825 PropertyConfigProto_Cardinality_Code_entries, 4, name, &int_value);
826 if (success) {
827 *value = static_cast<PropertyConfigProto_Cardinality_Code>(int_value);
828 }
829 return success;
830 }
831 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
832 constexpr PropertyConfigProto_Cardinality_Code PropertyConfigProto_Cardinality::UNKNOWN;
833 constexpr PropertyConfigProto_Cardinality_Code PropertyConfigProto_Cardinality::REPEATED;
834 constexpr PropertyConfigProto_Cardinality_Code PropertyConfigProto_Cardinality::OPTIONAL;
835 constexpr PropertyConfigProto_Cardinality_Code PropertyConfigProto_Cardinality::REQUIRED;
836 constexpr PropertyConfigProto_Cardinality_Code PropertyConfigProto_Cardinality::Code_MIN;
837 constexpr PropertyConfigProto_Cardinality_Code PropertyConfigProto_Cardinality::Code_MAX;
838 constexpr int PropertyConfigProto_Cardinality::Code_ARRAYSIZE;
839 #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
PropertyConfigProto_ScorableType_Code_IsValid(int value)840 bool PropertyConfigProto_ScorableType_Code_IsValid(int value) {
841 switch (value) {
842 case 0:
843 case 1:
844 case 2:
845 return true;
846 default:
847 return false;
848 }
849 }
850
851 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> PropertyConfigProto_ScorableType_Code_strings[3] = {};
852
853 static const char PropertyConfigProto_ScorableType_Code_names[] =
854 "DISABLED"
855 "ENABLED"
856 "UNKNOWN";
857
858 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry PropertyConfigProto_ScorableType_Code_entries[] = {
859 { {PropertyConfigProto_ScorableType_Code_names + 0, 8}, 1 },
860 { {PropertyConfigProto_ScorableType_Code_names + 8, 7}, 2 },
861 { {PropertyConfigProto_ScorableType_Code_names + 15, 7}, 0 },
862 };
863
864 static const int PropertyConfigProto_ScorableType_Code_entries_by_number[] = {
865 2, // 0 -> UNKNOWN
866 0, // 1 -> DISABLED
867 1, // 2 -> ENABLED
868 };
869
PropertyConfigProto_ScorableType_Code_Name(PropertyConfigProto_ScorableType_Code value)870 const std::string& PropertyConfigProto_ScorableType_Code_Name(
871 PropertyConfigProto_ScorableType_Code value) {
872 static const bool dummy =
873 ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
874 PropertyConfigProto_ScorableType_Code_entries,
875 PropertyConfigProto_ScorableType_Code_entries_by_number,
876 3, PropertyConfigProto_ScorableType_Code_strings);
877 (void) dummy;
878 int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
879 PropertyConfigProto_ScorableType_Code_entries,
880 PropertyConfigProto_ScorableType_Code_entries_by_number,
881 3, value);
882 return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
883 PropertyConfigProto_ScorableType_Code_strings[idx].get();
884 }
PropertyConfigProto_ScorableType_Code_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,PropertyConfigProto_ScorableType_Code * value)885 bool PropertyConfigProto_ScorableType_Code_Parse(
886 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PropertyConfigProto_ScorableType_Code* value) {
887 int int_value;
888 bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
889 PropertyConfigProto_ScorableType_Code_entries, 3, name, &int_value);
890 if (success) {
891 *value = static_cast<PropertyConfigProto_ScorableType_Code>(int_value);
892 }
893 return success;
894 }
895 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
896 constexpr PropertyConfigProto_ScorableType_Code PropertyConfigProto_ScorableType::UNKNOWN;
897 constexpr PropertyConfigProto_ScorableType_Code PropertyConfigProto_ScorableType::DISABLED;
898 constexpr PropertyConfigProto_ScorableType_Code PropertyConfigProto_ScorableType::ENABLED;
899 constexpr PropertyConfigProto_ScorableType_Code PropertyConfigProto_ScorableType::Code_MIN;
900 constexpr PropertyConfigProto_ScorableType_Code PropertyConfigProto_ScorableType::Code_MAX;
901 constexpr int PropertyConfigProto_ScorableType::Code_ARRAYSIZE;
902 #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
903
904 // ===================================================================
905
906 class SchemaTypeConfigProto::_Internal {
907 public:
908 using HasBits = decltype(std::declval<SchemaTypeConfigProto>()._impl_._has_bits_);
set_has_schema_type(HasBits * has_bits)909 static void set_has_schema_type(HasBits* has_bits) {
910 (*has_bits)[0] |= 1u;
911 }
set_has_description(HasBits * has_bits)912 static void set_has_description(HasBits* has_bits) {
913 (*has_bits)[0] |= 2u;
914 }
set_has_database(HasBits * has_bits)915 static void set_has_database(HasBits* has_bits) {
916 (*has_bits)[0] |= 4u;
917 }
set_has_version(HasBits * has_bits)918 static void set_has_version(HasBits* has_bits) {
919 (*has_bits)[0] |= 8u;
920 }
921 };
922
SchemaTypeConfigProto(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)923 SchemaTypeConfigProto::SchemaTypeConfigProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
924 bool is_message_owned)
925 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
926 SharedCtor(arena, is_message_owned);
927 // @@protoc_insertion_point(arena_constructor:icing.lib.SchemaTypeConfigProto)
928 }
SchemaTypeConfigProto(const SchemaTypeConfigProto & from)929 SchemaTypeConfigProto::SchemaTypeConfigProto(const SchemaTypeConfigProto& from)
930 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
931 SchemaTypeConfigProto* const _this = this; (void)_this;
932 new (&_impl_) Impl_{
933 decltype(_impl_._has_bits_){from._impl_._has_bits_}
934 , /*decltype(_impl_._cached_size_)*/{}
935 , decltype(_impl_.properties_){from._impl_.properties_}
936 , decltype(_impl_.parent_types_){from._impl_.parent_types_}
937 , decltype(_impl_.schema_type_){}
938 , decltype(_impl_.description_){}
939 , decltype(_impl_.database_){}
940 , decltype(_impl_.version_){}};
941
942 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
943 _impl_.schema_type_.InitDefault();
944 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
945 _impl_.schema_type_.Set("", GetArenaForAllocation());
946 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
947 if (from._internal_has_schema_type()) {
948 _this->_impl_.schema_type_.Set(from._internal_schema_type(),
949 _this->GetArenaForAllocation());
950 }
951 _impl_.description_.InitDefault();
952 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
953 _impl_.description_.Set("", GetArenaForAllocation());
954 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
955 if (from._internal_has_description()) {
956 _this->_impl_.description_.Set(from._internal_description(),
957 _this->GetArenaForAllocation());
958 }
959 _impl_.database_.InitDefault();
960 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
961 _impl_.database_.Set("", GetArenaForAllocation());
962 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
963 if (from._internal_has_database()) {
964 _this->_impl_.database_.Set(from._internal_database(),
965 _this->GetArenaForAllocation());
966 }
967 _this->_impl_.version_ = from._impl_.version_;
968 // @@protoc_insertion_point(copy_constructor:icing.lib.SchemaTypeConfigProto)
969 }
970
SharedCtor(::_pb::Arena * arena,bool is_message_owned)971 inline void SchemaTypeConfigProto::SharedCtor(
972 ::_pb::Arena* arena, bool is_message_owned) {
973 (void)arena;
974 (void)is_message_owned;
975 new (&_impl_) Impl_{
976 decltype(_impl_._has_bits_){}
977 , /*decltype(_impl_._cached_size_)*/{}
978 , decltype(_impl_.properties_){arena}
979 , decltype(_impl_.parent_types_){arena}
980 , decltype(_impl_.schema_type_){}
981 , decltype(_impl_.description_){}
982 , decltype(_impl_.database_){}
983 , decltype(_impl_.version_){0}
984 };
985 _impl_.schema_type_.InitDefault();
986 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
987 _impl_.schema_type_.Set("", GetArenaForAllocation());
988 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
989 _impl_.description_.InitDefault();
990 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
991 _impl_.description_.Set("", GetArenaForAllocation());
992 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
993 _impl_.database_.InitDefault();
994 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
995 _impl_.database_.Set("", GetArenaForAllocation());
996 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
997 }
998
~SchemaTypeConfigProto()999 SchemaTypeConfigProto::~SchemaTypeConfigProto() {
1000 // @@protoc_insertion_point(destructor:icing.lib.SchemaTypeConfigProto)
1001 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1002 (void)arena;
1003 return;
1004 }
1005 SharedDtor();
1006 }
1007
SharedDtor()1008 inline void SchemaTypeConfigProto::SharedDtor() {
1009 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1010 _impl_.properties_.~RepeatedPtrField();
1011 _impl_.parent_types_.~RepeatedPtrField();
1012 _impl_.schema_type_.Destroy();
1013 _impl_.description_.Destroy();
1014 _impl_.database_.Destroy();
1015 }
1016
SetCachedSize(int size) const1017 void SchemaTypeConfigProto::SetCachedSize(int size) const {
1018 _impl_._cached_size_.Set(size);
1019 }
1020
Clear()1021 void SchemaTypeConfigProto::Clear() {
1022 // @@protoc_insertion_point(message_clear_start:icing.lib.SchemaTypeConfigProto)
1023 ::uint32_t cached_has_bits = 0;
1024 // Prevent compiler warnings about cached_has_bits being unused
1025 (void) cached_has_bits;
1026
1027 _impl_.properties_.Clear();
1028 _impl_.parent_types_.Clear();
1029 cached_has_bits = _impl_._has_bits_[0];
1030 if (cached_has_bits & 0x00000007u) {
1031 if (cached_has_bits & 0x00000001u) {
1032 _impl_.schema_type_.ClearNonDefaultToEmpty();
1033 }
1034 if (cached_has_bits & 0x00000002u) {
1035 _impl_.description_.ClearNonDefaultToEmpty();
1036 }
1037 if (cached_has_bits & 0x00000004u) {
1038 _impl_.database_.ClearNonDefaultToEmpty();
1039 }
1040 }
1041 _impl_.version_ = 0;
1042 _impl_._has_bits_.Clear();
1043 _internal_metadata_.Clear<std::string>();
1044 }
1045
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1046 const char* SchemaTypeConfigProto::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1047 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1048 _Internal::HasBits has_bits{};
1049 while (!ctx->Done(&ptr)) {
1050 ::uint32_t tag;
1051 ptr = ::_pbi::ReadTag(ptr, &tag);
1052 switch (tag >> 3) {
1053 // optional string schema_type = 1;
1054 case 1:
1055 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1056 auto str = _internal_mutable_schema_type();
1057 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1058 CHK_(ptr);
1059 } else {
1060 goto handle_unusual;
1061 }
1062 continue;
1063 // repeated .icing.lib.PropertyConfigProto properties = 4;
1064 case 4:
1065 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
1066 ptr -= 1;
1067 do {
1068 ptr += 1;
1069 ptr = ctx->ParseMessage(_internal_add_properties(), ptr);
1070 CHK_(ptr);
1071 if (!ctx->DataAvailable(ptr)) break;
1072 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
1073 } else {
1074 goto handle_unusual;
1075 }
1076 continue;
1077 // optional int32 version = 5;
1078 case 5:
1079 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
1080 _Internal::set_has_version(&has_bits);
1081 _impl_.version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1082 CHK_(ptr);
1083 } else {
1084 goto handle_unusual;
1085 }
1086 continue;
1087 // repeated string parent_types = 6;
1088 case 6:
1089 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
1090 ptr -= 1;
1091 do {
1092 ptr += 1;
1093 auto str = _internal_add_parent_types();
1094 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1095 CHK_(ptr);
1096 if (!ctx->DataAvailable(ptr)) break;
1097 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr));
1098 } else {
1099 goto handle_unusual;
1100 }
1101 continue;
1102 // optional string description = 7;
1103 case 7:
1104 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 58)) {
1105 auto str = _internal_mutable_description();
1106 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1107 CHK_(ptr);
1108 } else {
1109 goto handle_unusual;
1110 }
1111 continue;
1112 // optional string database = 8;
1113 case 8:
1114 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 66)) {
1115 auto str = _internal_mutable_database();
1116 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1117 CHK_(ptr);
1118 } else {
1119 goto handle_unusual;
1120 }
1121 continue;
1122 default:
1123 goto handle_unusual;
1124 } // switch
1125 handle_unusual:
1126 if ((tag == 0) || ((tag & 7) == 4)) {
1127 CHK_(ptr);
1128 ctx->SetLastTag(tag);
1129 goto message_done;
1130 }
1131 ptr = UnknownFieldParse(
1132 tag,
1133 _internal_metadata_.mutable_unknown_fields<std::string>(),
1134 ptr, ctx);
1135 CHK_(ptr != nullptr);
1136 } // while
1137 message_done:
1138 _impl_._has_bits_.Or(has_bits);
1139 return ptr;
1140 failure:
1141 ptr = nullptr;
1142 goto message_done;
1143 #undef CHK_
1144 }
1145
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1146 ::uint8_t* SchemaTypeConfigProto::_InternalSerialize(
1147 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1148 // @@protoc_insertion_point(serialize_to_array_start:icing.lib.SchemaTypeConfigProto)
1149 ::uint32_t cached_has_bits = 0;
1150 (void) cached_has_bits;
1151
1152 cached_has_bits = _impl_._has_bits_[0];
1153 // optional string schema_type = 1;
1154 if (cached_has_bits & 0x00000001u) {
1155 target = stream->WriteStringMaybeAliased(
1156 1, this->_internal_schema_type(), target);
1157 }
1158
1159 // repeated .icing.lib.PropertyConfigProto properties = 4;
1160 for (unsigned i = 0,
1161 n = static_cast<unsigned>(this->_internal_properties_size()); i < n; i++) {
1162 const auto& repfield = this->_internal_properties(i);
1163 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1164 InternalWriteMessage(4, repfield, repfield.GetCachedSize(), target, stream);
1165 }
1166
1167 // optional int32 version = 5;
1168 if (cached_has_bits & 0x00000008u) {
1169 target = stream->EnsureSpace(target);
1170 target = ::_pbi::WireFormatLite::WriteInt32ToArray(5, this->_internal_version(), target);
1171 }
1172
1173 // repeated string parent_types = 6;
1174 for (int i = 0, n = this->_internal_parent_types_size(); i < n; i++) {
1175 const auto& s = this->_internal_parent_types(i);
1176 target = stream->WriteString(6, s, target);
1177 }
1178
1179 // optional string description = 7;
1180 if (cached_has_bits & 0x00000002u) {
1181 target = stream->WriteStringMaybeAliased(
1182 7, this->_internal_description(), target);
1183 }
1184
1185 // optional string database = 8;
1186 if (cached_has_bits & 0x00000004u) {
1187 target = stream->WriteStringMaybeAliased(
1188 8, this->_internal_database(), target);
1189 }
1190
1191 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1192 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1193 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1194 }
1195 // @@protoc_insertion_point(serialize_to_array_end:icing.lib.SchemaTypeConfigProto)
1196 return target;
1197 }
1198
ByteSizeLong() const1199 size_t SchemaTypeConfigProto::ByteSizeLong() const {
1200 // @@protoc_insertion_point(message_byte_size_start:icing.lib.SchemaTypeConfigProto)
1201 size_t total_size = 0;
1202
1203 ::uint32_t cached_has_bits = 0;
1204 // Prevent compiler warnings about cached_has_bits being unused
1205 (void) cached_has_bits;
1206
1207 // repeated .icing.lib.PropertyConfigProto properties = 4;
1208 total_size += 1UL * this->_internal_properties_size();
1209 for (const auto& msg : this->_impl_.properties_) {
1210 total_size +=
1211 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
1212 }
1213
1214 // repeated string parent_types = 6;
1215 total_size += 1 *
1216 ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.parent_types_.size());
1217 for (int i = 0, n = _impl_.parent_types_.size(); i < n; i++) {
1218 total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1219 _impl_.parent_types_.Get(i));
1220 }
1221
1222 cached_has_bits = _impl_._has_bits_[0];
1223 if (cached_has_bits & 0x0000000fu) {
1224 // optional string schema_type = 1;
1225 if (cached_has_bits & 0x00000001u) {
1226 total_size += 1 +
1227 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1228 this->_internal_schema_type());
1229 }
1230
1231 // optional string description = 7;
1232 if (cached_has_bits & 0x00000002u) {
1233 total_size += 1 +
1234 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1235 this->_internal_description());
1236 }
1237
1238 // optional string database = 8;
1239 if (cached_has_bits & 0x00000004u) {
1240 total_size += 1 +
1241 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1242 this->_internal_database());
1243 }
1244
1245 // optional int32 version = 5;
1246 if (cached_has_bits & 0x00000008u) {
1247 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_version());
1248 }
1249
1250 }
1251 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1252 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1253 }
1254 int cached_size = ::_pbi::ToCachedSize(total_size);
1255 SetCachedSize(cached_size);
1256 return total_size;
1257 }
1258
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1259 void SchemaTypeConfigProto::CheckTypeAndMergeFrom(
1260 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1261 MergeFrom(*::_pbi::DownCast<const SchemaTypeConfigProto*>(
1262 &from));
1263 }
1264
MergeFrom(const SchemaTypeConfigProto & from)1265 void SchemaTypeConfigProto::MergeFrom(const SchemaTypeConfigProto& from) {
1266 SchemaTypeConfigProto* const _this = this;
1267 // @@protoc_insertion_point(class_specific_merge_from_start:icing.lib.SchemaTypeConfigProto)
1268 GOOGLE_DCHECK_NE(&from, _this);
1269 ::uint32_t cached_has_bits = 0;
1270 (void) cached_has_bits;
1271
1272 _this->_impl_.properties_.MergeFrom(from._impl_.properties_);
1273 _this->_impl_.parent_types_.MergeFrom(from._impl_.parent_types_);
1274 cached_has_bits = from._impl_._has_bits_[0];
1275 if (cached_has_bits & 0x0000000fu) {
1276 if (cached_has_bits & 0x00000001u) {
1277 _this->_internal_set_schema_type(from._internal_schema_type());
1278 }
1279 if (cached_has_bits & 0x00000002u) {
1280 _this->_internal_set_description(from._internal_description());
1281 }
1282 if (cached_has_bits & 0x00000004u) {
1283 _this->_internal_set_database(from._internal_database());
1284 }
1285 if (cached_has_bits & 0x00000008u) {
1286 _this->_impl_.version_ = from._impl_.version_;
1287 }
1288 _this->_impl_._has_bits_[0] |= cached_has_bits;
1289 }
1290 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1291 }
1292
CopyFrom(const SchemaTypeConfigProto & from)1293 void SchemaTypeConfigProto::CopyFrom(const SchemaTypeConfigProto& from) {
1294 // @@protoc_insertion_point(class_specific_copy_from_start:icing.lib.SchemaTypeConfigProto)
1295 if (&from == this) return;
1296 Clear();
1297 MergeFrom(from);
1298 }
1299
IsInitialized() const1300 bool SchemaTypeConfigProto::IsInitialized() const {
1301 return true;
1302 }
1303
InternalSwap(SchemaTypeConfigProto * other)1304 void SchemaTypeConfigProto::InternalSwap(SchemaTypeConfigProto* other) {
1305 using std::swap;
1306 auto* lhs_arena = GetArenaForAllocation();
1307 auto* rhs_arena = other->GetArenaForAllocation();
1308 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1309 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1310 _impl_.properties_.InternalSwap(&other->_impl_.properties_);
1311 _impl_.parent_types_.InternalSwap(&other->_impl_.parent_types_);
1312 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1313 &_impl_.schema_type_, lhs_arena,
1314 &other->_impl_.schema_type_, rhs_arena
1315 );
1316 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1317 &_impl_.description_, lhs_arena,
1318 &other->_impl_.description_, rhs_arena
1319 );
1320 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1321 &_impl_.database_, lhs_arena,
1322 &other->_impl_.database_, rhs_arena
1323 );
1324 swap(_impl_.version_, other->_impl_.version_);
1325 }
1326
GetTypeName() const1327 std::string SchemaTypeConfigProto::GetTypeName() const {
1328 return "icing.lib.SchemaTypeConfigProto";
1329 }
1330
1331
1332 // ===================================================================
1333
1334 class StringIndexingConfig_TokenizerType::_Internal {
1335 public:
1336 };
1337
StringIndexingConfig_TokenizerType(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1338 StringIndexingConfig_TokenizerType::StringIndexingConfig_TokenizerType(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1339 bool is_message_owned)
1340 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1341 SharedCtor(arena, is_message_owned);
1342 // @@protoc_insertion_point(arena_constructor:icing.lib.StringIndexingConfig.TokenizerType)
1343 }
StringIndexingConfig_TokenizerType(const StringIndexingConfig_TokenizerType & from)1344 StringIndexingConfig_TokenizerType::StringIndexingConfig_TokenizerType(const StringIndexingConfig_TokenizerType& from)
1345 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1346 StringIndexingConfig_TokenizerType* const _this = this; (void)_this;
1347 new (&_impl_) Impl_{
1348 /*decltype(_impl_._cached_size_)*/{}};
1349
1350 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1351 // @@protoc_insertion_point(copy_constructor:icing.lib.StringIndexingConfig.TokenizerType)
1352 }
1353
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1354 inline void StringIndexingConfig_TokenizerType::SharedCtor(
1355 ::_pb::Arena* arena, bool is_message_owned) {
1356 (void)arena;
1357 (void)is_message_owned;
1358 new (&_impl_) Impl_{
1359 /*decltype(_impl_._cached_size_)*/{}
1360 };
1361 }
1362
~StringIndexingConfig_TokenizerType()1363 StringIndexingConfig_TokenizerType::~StringIndexingConfig_TokenizerType() {
1364 // @@protoc_insertion_point(destructor:icing.lib.StringIndexingConfig.TokenizerType)
1365 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1366 (void)arena;
1367 return;
1368 }
1369 SharedDtor();
1370 }
1371
SharedDtor()1372 inline void StringIndexingConfig_TokenizerType::SharedDtor() {
1373 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1374 }
1375
SetCachedSize(int size) const1376 void StringIndexingConfig_TokenizerType::SetCachedSize(int size) const {
1377 _impl_._cached_size_.Set(size);
1378 }
1379
Clear()1380 void StringIndexingConfig_TokenizerType::Clear() {
1381 // @@protoc_insertion_point(message_clear_start:icing.lib.StringIndexingConfig.TokenizerType)
1382 ::uint32_t cached_has_bits = 0;
1383 // Prevent compiler warnings about cached_has_bits being unused
1384 (void) cached_has_bits;
1385
1386 _internal_metadata_.Clear<std::string>();
1387 }
1388
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1389 const char* StringIndexingConfig_TokenizerType::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1390 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1391 while (!ctx->Done(&ptr)) {
1392 ::uint32_t tag;
1393 ptr = ::_pbi::ReadTag(ptr, &tag);
1394 if ((tag == 0) || ((tag & 7) == 4)) {
1395 CHK_(ptr);
1396 ctx->SetLastTag(tag);
1397 goto message_done;
1398 }
1399 ptr = UnknownFieldParse(
1400 tag,
1401 _internal_metadata_.mutable_unknown_fields<std::string>(),
1402 ptr, ctx);
1403 CHK_(ptr != nullptr);
1404 } // while
1405 message_done:
1406 return ptr;
1407 failure:
1408 ptr = nullptr;
1409 goto message_done;
1410 #undef CHK_
1411 }
1412
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1413 ::uint8_t* StringIndexingConfig_TokenizerType::_InternalSerialize(
1414 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1415 // @@protoc_insertion_point(serialize_to_array_start:icing.lib.StringIndexingConfig.TokenizerType)
1416 ::uint32_t cached_has_bits = 0;
1417 (void) cached_has_bits;
1418
1419 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1420 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1421 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1422 }
1423 // @@protoc_insertion_point(serialize_to_array_end:icing.lib.StringIndexingConfig.TokenizerType)
1424 return target;
1425 }
1426
ByteSizeLong() const1427 size_t StringIndexingConfig_TokenizerType::ByteSizeLong() const {
1428 // @@protoc_insertion_point(message_byte_size_start:icing.lib.StringIndexingConfig.TokenizerType)
1429 size_t total_size = 0;
1430
1431 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1432 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1433 }
1434 int cached_size = ::_pbi::ToCachedSize(total_size);
1435 SetCachedSize(cached_size);
1436 return total_size;
1437 }
1438
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1439 void StringIndexingConfig_TokenizerType::CheckTypeAndMergeFrom(
1440 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1441 MergeFrom(*::_pbi::DownCast<const StringIndexingConfig_TokenizerType*>(
1442 &from));
1443 }
1444
MergeFrom(const StringIndexingConfig_TokenizerType & from)1445 void StringIndexingConfig_TokenizerType::MergeFrom(const StringIndexingConfig_TokenizerType& from) {
1446 StringIndexingConfig_TokenizerType* const _this = this;
1447 // @@protoc_insertion_point(class_specific_merge_from_start:icing.lib.StringIndexingConfig.TokenizerType)
1448 GOOGLE_DCHECK_NE(&from, _this);
1449 ::uint32_t cached_has_bits = 0;
1450 (void) cached_has_bits;
1451
1452 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1453 }
1454
CopyFrom(const StringIndexingConfig_TokenizerType & from)1455 void StringIndexingConfig_TokenizerType::CopyFrom(const StringIndexingConfig_TokenizerType& from) {
1456 // @@protoc_insertion_point(class_specific_copy_from_start:icing.lib.StringIndexingConfig.TokenizerType)
1457 if (&from == this) return;
1458 Clear();
1459 MergeFrom(from);
1460 }
1461
IsInitialized() const1462 bool StringIndexingConfig_TokenizerType::IsInitialized() const {
1463 return true;
1464 }
1465
InternalSwap(StringIndexingConfig_TokenizerType * other)1466 void StringIndexingConfig_TokenizerType::InternalSwap(StringIndexingConfig_TokenizerType* other) {
1467 using std::swap;
1468 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1469 }
1470
GetTypeName() const1471 std::string StringIndexingConfig_TokenizerType::GetTypeName() const {
1472 return "icing.lib.StringIndexingConfig.TokenizerType";
1473 }
1474
1475
1476 // ===================================================================
1477
1478 class StringIndexingConfig::_Internal {
1479 public:
1480 using HasBits = decltype(std::declval<StringIndexingConfig>()._impl_._has_bits_);
set_has_term_match_type(HasBits * has_bits)1481 static void set_has_term_match_type(HasBits* has_bits) {
1482 (*has_bits)[0] |= 1u;
1483 }
set_has_tokenizer_type(HasBits * has_bits)1484 static void set_has_tokenizer_type(HasBits* has_bits) {
1485 (*has_bits)[0] |= 2u;
1486 }
1487 };
1488
StringIndexingConfig(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1489 StringIndexingConfig::StringIndexingConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1490 bool is_message_owned)
1491 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1492 SharedCtor(arena, is_message_owned);
1493 // @@protoc_insertion_point(arena_constructor:icing.lib.StringIndexingConfig)
1494 }
StringIndexingConfig(const StringIndexingConfig & from)1495 StringIndexingConfig::StringIndexingConfig(const StringIndexingConfig& from)
1496 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1497 StringIndexingConfig* const _this = this; (void)_this;
1498 new (&_impl_) Impl_{
1499 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1500 , /*decltype(_impl_._cached_size_)*/{}
1501 , decltype(_impl_.term_match_type_){}
1502 , decltype(_impl_.tokenizer_type_){}};
1503
1504 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1505 ::memcpy(&_impl_.term_match_type_, &from._impl_.term_match_type_,
1506 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.tokenizer_type_) -
1507 reinterpret_cast<char*>(&_impl_.term_match_type_)) + sizeof(_impl_.tokenizer_type_));
1508 // @@protoc_insertion_point(copy_constructor:icing.lib.StringIndexingConfig)
1509 }
1510
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1511 inline void StringIndexingConfig::SharedCtor(
1512 ::_pb::Arena* arena, bool is_message_owned) {
1513 (void)arena;
1514 (void)is_message_owned;
1515 new (&_impl_) Impl_{
1516 decltype(_impl_._has_bits_){}
1517 , /*decltype(_impl_._cached_size_)*/{}
1518 , decltype(_impl_.term_match_type_){0}
1519 , decltype(_impl_.tokenizer_type_){0}
1520 };
1521 }
1522
~StringIndexingConfig()1523 StringIndexingConfig::~StringIndexingConfig() {
1524 // @@protoc_insertion_point(destructor:icing.lib.StringIndexingConfig)
1525 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1526 (void)arena;
1527 return;
1528 }
1529 SharedDtor();
1530 }
1531
SharedDtor()1532 inline void StringIndexingConfig::SharedDtor() {
1533 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1534 }
1535
SetCachedSize(int size) const1536 void StringIndexingConfig::SetCachedSize(int size) const {
1537 _impl_._cached_size_.Set(size);
1538 }
1539
Clear()1540 void StringIndexingConfig::Clear() {
1541 // @@protoc_insertion_point(message_clear_start:icing.lib.StringIndexingConfig)
1542 ::uint32_t cached_has_bits = 0;
1543 // Prevent compiler warnings about cached_has_bits being unused
1544 (void) cached_has_bits;
1545
1546 cached_has_bits = _impl_._has_bits_[0];
1547 if (cached_has_bits & 0x00000003u) {
1548 ::memset(&_impl_.term_match_type_, 0, static_cast<size_t>(
1549 reinterpret_cast<char*>(&_impl_.tokenizer_type_) -
1550 reinterpret_cast<char*>(&_impl_.term_match_type_)) + sizeof(_impl_.tokenizer_type_));
1551 }
1552 _impl_._has_bits_.Clear();
1553 _internal_metadata_.Clear<std::string>();
1554 }
1555
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1556 const char* StringIndexingConfig::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1557 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1558 _Internal::HasBits has_bits{};
1559 while (!ctx->Done(&ptr)) {
1560 ::uint32_t tag;
1561 ptr = ::_pbi::ReadTag(ptr, &tag);
1562 switch (tag >> 3) {
1563 // optional .icing.lib.TermMatchType.Code term_match_type = 1;
1564 case 1:
1565 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1566 ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1567 CHK_(ptr);
1568 if (PROTOBUF_PREDICT_TRUE(::icing::lib::TermMatchType_Code_IsValid(val))) {
1569 _internal_set_term_match_type(static_cast<::icing::lib::TermMatchType_Code>(val));
1570 } else {
1571 ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
1572 }
1573 } else {
1574 goto handle_unusual;
1575 }
1576 continue;
1577 // optional .icing.lib.StringIndexingConfig.TokenizerType.Code tokenizer_type = 2;
1578 case 2:
1579 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1580 ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1581 CHK_(ptr);
1582 if (PROTOBUF_PREDICT_TRUE(::icing::lib::StringIndexingConfig_TokenizerType_Code_IsValid(val))) {
1583 _internal_set_tokenizer_type(static_cast<::icing::lib::StringIndexingConfig_TokenizerType_Code>(val));
1584 } else {
1585 ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
1586 }
1587 } else {
1588 goto handle_unusual;
1589 }
1590 continue;
1591 default:
1592 goto handle_unusual;
1593 } // switch
1594 handle_unusual:
1595 if ((tag == 0) || ((tag & 7) == 4)) {
1596 CHK_(ptr);
1597 ctx->SetLastTag(tag);
1598 goto message_done;
1599 }
1600 ptr = UnknownFieldParse(
1601 tag,
1602 _internal_metadata_.mutable_unknown_fields<std::string>(),
1603 ptr, ctx);
1604 CHK_(ptr != nullptr);
1605 } // while
1606 message_done:
1607 _impl_._has_bits_.Or(has_bits);
1608 return ptr;
1609 failure:
1610 ptr = nullptr;
1611 goto message_done;
1612 #undef CHK_
1613 }
1614
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1615 ::uint8_t* StringIndexingConfig::_InternalSerialize(
1616 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1617 // @@protoc_insertion_point(serialize_to_array_start:icing.lib.StringIndexingConfig)
1618 ::uint32_t cached_has_bits = 0;
1619 (void) cached_has_bits;
1620
1621 cached_has_bits = _impl_._has_bits_[0];
1622 // optional .icing.lib.TermMatchType.Code term_match_type = 1;
1623 if (cached_has_bits & 0x00000001u) {
1624 target = stream->EnsureSpace(target);
1625 target = ::_pbi::WireFormatLite::WriteEnumToArray(
1626 1, this->_internal_term_match_type(), target);
1627 }
1628
1629 // optional .icing.lib.StringIndexingConfig.TokenizerType.Code tokenizer_type = 2;
1630 if (cached_has_bits & 0x00000002u) {
1631 target = stream->EnsureSpace(target);
1632 target = ::_pbi::WireFormatLite::WriteEnumToArray(
1633 2, this->_internal_tokenizer_type(), target);
1634 }
1635
1636 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1637 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1638 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1639 }
1640 // @@protoc_insertion_point(serialize_to_array_end:icing.lib.StringIndexingConfig)
1641 return target;
1642 }
1643
ByteSizeLong() const1644 size_t StringIndexingConfig::ByteSizeLong() const {
1645 // @@protoc_insertion_point(message_byte_size_start:icing.lib.StringIndexingConfig)
1646 size_t total_size = 0;
1647
1648 ::uint32_t cached_has_bits = 0;
1649 // Prevent compiler warnings about cached_has_bits being unused
1650 (void) cached_has_bits;
1651
1652 cached_has_bits = _impl_._has_bits_[0];
1653 if (cached_has_bits & 0x00000003u) {
1654 // optional .icing.lib.TermMatchType.Code term_match_type = 1;
1655 if (cached_has_bits & 0x00000001u) {
1656 total_size += 1 +
1657 ::_pbi::WireFormatLite::EnumSize(this->_internal_term_match_type());
1658 }
1659
1660 // optional .icing.lib.StringIndexingConfig.TokenizerType.Code tokenizer_type = 2;
1661 if (cached_has_bits & 0x00000002u) {
1662 total_size += 1 +
1663 ::_pbi::WireFormatLite::EnumSize(this->_internal_tokenizer_type());
1664 }
1665
1666 }
1667 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1668 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1669 }
1670 int cached_size = ::_pbi::ToCachedSize(total_size);
1671 SetCachedSize(cached_size);
1672 return total_size;
1673 }
1674
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1675 void StringIndexingConfig::CheckTypeAndMergeFrom(
1676 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1677 MergeFrom(*::_pbi::DownCast<const StringIndexingConfig*>(
1678 &from));
1679 }
1680
MergeFrom(const StringIndexingConfig & from)1681 void StringIndexingConfig::MergeFrom(const StringIndexingConfig& from) {
1682 StringIndexingConfig* const _this = this;
1683 // @@protoc_insertion_point(class_specific_merge_from_start:icing.lib.StringIndexingConfig)
1684 GOOGLE_DCHECK_NE(&from, _this);
1685 ::uint32_t cached_has_bits = 0;
1686 (void) cached_has_bits;
1687
1688 cached_has_bits = from._impl_._has_bits_[0];
1689 if (cached_has_bits & 0x00000003u) {
1690 if (cached_has_bits & 0x00000001u) {
1691 _this->_impl_.term_match_type_ = from._impl_.term_match_type_;
1692 }
1693 if (cached_has_bits & 0x00000002u) {
1694 _this->_impl_.tokenizer_type_ = from._impl_.tokenizer_type_;
1695 }
1696 _this->_impl_._has_bits_[0] |= cached_has_bits;
1697 }
1698 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1699 }
1700
CopyFrom(const StringIndexingConfig & from)1701 void StringIndexingConfig::CopyFrom(const StringIndexingConfig& from) {
1702 // @@protoc_insertion_point(class_specific_copy_from_start:icing.lib.StringIndexingConfig)
1703 if (&from == this) return;
1704 Clear();
1705 MergeFrom(from);
1706 }
1707
IsInitialized() const1708 bool StringIndexingConfig::IsInitialized() const {
1709 return true;
1710 }
1711
InternalSwap(StringIndexingConfig * other)1712 void StringIndexingConfig::InternalSwap(StringIndexingConfig* other) {
1713 using std::swap;
1714 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1715 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1716 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1717 PROTOBUF_FIELD_OFFSET(StringIndexingConfig, _impl_.tokenizer_type_)
1718 + sizeof(StringIndexingConfig::_impl_.tokenizer_type_) // NOLINT
1719 - PROTOBUF_FIELD_OFFSET(StringIndexingConfig, _impl_.term_match_type_)>(
1720 reinterpret_cast<char*>(&_impl_.term_match_type_),
1721 reinterpret_cast<char*>(&other->_impl_.term_match_type_));
1722 }
1723
GetTypeName() const1724 std::string StringIndexingConfig::GetTypeName() const {
1725 return "icing.lib.StringIndexingConfig";
1726 }
1727
1728
1729 // ===================================================================
1730
1731 class DocumentIndexingConfig::_Internal {
1732 public:
1733 using HasBits = decltype(std::declval<DocumentIndexingConfig>()._impl_._has_bits_);
set_has_index_nested_properties(HasBits * has_bits)1734 static void set_has_index_nested_properties(HasBits* has_bits) {
1735 (*has_bits)[0] |= 1u;
1736 }
1737 };
1738
DocumentIndexingConfig(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1739 DocumentIndexingConfig::DocumentIndexingConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1740 bool is_message_owned)
1741 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1742 SharedCtor(arena, is_message_owned);
1743 // @@protoc_insertion_point(arena_constructor:icing.lib.DocumentIndexingConfig)
1744 }
DocumentIndexingConfig(const DocumentIndexingConfig & from)1745 DocumentIndexingConfig::DocumentIndexingConfig(const DocumentIndexingConfig& from)
1746 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1747 DocumentIndexingConfig* const _this = this; (void)_this;
1748 new (&_impl_) Impl_{
1749 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1750 , /*decltype(_impl_._cached_size_)*/{}
1751 , decltype(_impl_.indexable_nested_properties_list_){from._impl_.indexable_nested_properties_list_}
1752 , decltype(_impl_.index_nested_properties_){}};
1753
1754 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1755 _this->_impl_.index_nested_properties_ = from._impl_.index_nested_properties_;
1756 // @@protoc_insertion_point(copy_constructor:icing.lib.DocumentIndexingConfig)
1757 }
1758
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1759 inline void DocumentIndexingConfig::SharedCtor(
1760 ::_pb::Arena* arena, bool is_message_owned) {
1761 (void)arena;
1762 (void)is_message_owned;
1763 new (&_impl_) Impl_{
1764 decltype(_impl_._has_bits_){}
1765 , /*decltype(_impl_._cached_size_)*/{}
1766 , decltype(_impl_.indexable_nested_properties_list_){arena}
1767 , decltype(_impl_.index_nested_properties_){false}
1768 };
1769 }
1770
~DocumentIndexingConfig()1771 DocumentIndexingConfig::~DocumentIndexingConfig() {
1772 // @@protoc_insertion_point(destructor:icing.lib.DocumentIndexingConfig)
1773 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1774 (void)arena;
1775 return;
1776 }
1777 SharedDtor();
1778 }
1779
SharedDtor()1780 inline void DocumentIndexingConfig::SharedDtor() {
1781 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1782 _impl_.indexable_nested_properties_list_.~RepeatedPtrField();
1783 }
1784
SetCachedSize(int size) const1785 void DocumentIndexingConfig::SetCachedSize(int size) const {
1786 _impl_._cached_size_.Set(size);
1787 }
1788
Clear()1789 void DocumentIndexingConfig::Clear() {
1790 // @@protoc_insertion_point(message_clear_start:icing.lib.DocumentIndexingConfig)
1791 ::uint32_t cached_has_bits = 0;
1792 // Prevent compiler warnings about cached_has_bits being unused
1793 (void) cached_has_bits;
1794
1795 _impl_.indexable_nested_properties_list_.Clear();
1796 _impl_.index_nested_properties_ = false;
1797 _impl_._has_bits_.Clear();
1798 _internal_metadata_.Clear<std::string>();
1799 }
1800
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1801 const char* DocumentIndexingConfig::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1802 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1803 _Internal::HasBits has_bits{};
1804 while (!ctx->Done(&ptr)) {
1805 ::uint32_t tag;
1806 ptr = ::_pbi::ReadTag(ptr, &tag);
1807 switch (tag >> 3) {
1808 // optional bool index_nested_properties = 1;
1809 case 1:
1810 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1811 _Internal::set_has_index_nested_properties(&has_bits);
1812 _impl_.index_nested_properties_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1813 CHK_(ptr);
1814 } else {
1815 goto handle_unusual;
1816 }
1817 continue;
1818 // repeated string indexable_nested_properties_list = 2;
1819 case 2:
1820 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
1821 ptr -= 1;
1822 do {
1823 ptr += 1;
1824 auto str = _internal_add_indexable_nested_properties_list();
1825 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1826 CHK_(ptr);
1827 if (!ctx->DataAvailable(ptr)) break;
1828 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
1829 } else {
1830 goto handle_unusual;
1831 }
1832 continue;
1833 default:
1834 goto handle_unusual;
1835 } // switch
1836 handle_unusual:
1837 if ((tag == 0) || ((tag & 7) == 4)) {
1838 CHK_(ptr);
1839 ctx->SetLastTag(tag);
1840 goto message_done;
1841 }
1842 ptr = UnknownFieldParse(
1843 tag,
1844 _internal_metadata_.mutable_unknown_fields<std::string>(),
1845 ptr, ctx);
1846 CHK_(ptr != nullptr);
1847 } // while
1848 message_done:
1849 _impl_._has_bits_.Or(has_bits);
1850 return ptr;
1851 failure:
1852 ptr = nullptr;
1853 goto message_done;
1854 #undef CHK_
1855 }
1856
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1857 ::uint8_t* DocumentIndexingConfig::_InternalSerialize(
1858 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1859 // @@protoc_insertion_point(serialize_to_array_start:icing.lib.DocumentIndexingConfig)
1860 ::uint32_t cached_has_bits = 0;
1861 (void) cached_has_bits;
1862
1863 cached_has_bits = _impl_._has_bits_[0];
1864 // optional bool index_nested_properties = 1;
1865 if (cached_has_bits & 0x00000001u) {
1866 target = stream->EnsureSpace(target);
1867 target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_index_nested_properties(), target);
1868 }
1869
1870 // repeated string indexable_nested_properties_list = 2;
1871 for (int i = 0, n = this->_internal_indexable_nested_properties_list_size(); i < n; i++) {
1872 const auto& s = this->_internal_indexable_nested_properties_list(i);
1873 target = stream->WriteString(2, s, target);
1874 }
1875
1876 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1877 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1878 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1879 }
1880 // @@protoc_insertion_point(serialize_to_array_end:icing.lib.DocumentIndexingConfig)
1881 return target;
1882 }
1883
ByteSizeLong() const1884 size_t DocumentIndexingConfig::ByteSizeLong() const {
1885 // @@protoc_insertion_point(message_byte_size_start:icing.lib.DocumentIndexingConfig)
1886 size_t total_size = 0;
1887
1888 ::uint32_t cached_has_bits = 0;
1889 // Prevent compiler warnings about cached_has_bits being unused
1890 (void) cached_has_bits;
1891
1892 // repeated string indexable_nested_properties_list = 2;
1893 total_size += 1 *
1894 ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.indexable_nested_properties_list_.size());
1895 for (int i = 0, n = _impl_.indexable_nested_properties_list_.size(); i < n; i++) {
1896 total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1897 _impl_.indexable_nested_properties_list_.Get(i));
1898 }
1899
1900 // optional bool index_nested_properties = 1;
1901 cached_has_bits = _impl_._has_bits_[0];
1902 if (cached_has_bits & 0x00000001u) {
1903 total_size += 1 + 1;
1904 }
1905
1906 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1907 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1908 }
1909 int cached_size = ::_pbi::ToCachedSize(total_size);
1910 SetCachedSize(cached_size);
1911 return total_size;
1912 }
1913
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1914 void DocumentIndexingConfig::CheckTypeAndMergeFrom(
1915 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1916 MergeFrom(*::_pbi::DownCast<const DocumentIndexingConfig*>(
1917 &from));
1918 }
1919
MergeFrom(const DocumentIndexingConfig & from)1920 void DocumentIndexingConfig::MergeFrom(const DocumentIndexingConfig& from) {
1921 DocumentIndexingConfig* const _this = this;
1922 // @@protoc_insertion_point(class_specific_merge_from_start:icing.lib.DocumentIndexingConfig)
1923 GOOGLE_DCHECK_NE(&from, _this);
1924 ::uint32_t cached_has_bits = 0;
1925 (void) cached_has_bits;
1926
1927 _this->_impl_.indexable_nested_properties_list_.MergeFrom(from._impl_.indexable_nested_properties_list_);
1928 if (from._internal_has_index_nested_properties()) {
1929 _this->_internal_set_index_nested_properties(from._internal_index_nested_properties());
1930 }
1931 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1932 }
1933
CopyFrom(const DocumentIndexingConfig & from)1934 void DocumentIndexingConfig::CopyFrom(const DocumentIndexingConfig& from) {
1935 // @@protoc_insertion_point(class_specific_copy_from_start:icing.lib.DocumentIndexingConfig)
1936 if (&from == this) return;
1937 Clear();
1938 MergeFrom(from);
1939 }
1940
IsInitialized() const1941 bool DocumentIndexingConfig::IsInitialized() const {
1942 return true;
1943 }
1944
InternalSwap(DocumentIndexingConfig * other)1945 void DocumentIndexingConfig::InternalSwap(DocumentIndexingConfig* other) {
1946 using std::swap;
1947 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1948 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1949 _impl_.indexable_nested_properties_list_.InternalSwap(&other->_impl_.indexable_nested_properties_list_);
1950 swap(_impl_.index_nested_properties_, other->_impl_.index_nested_properties_);
1951 }
1952
GetTypeName() const1953 std::string DocumentIndexingConfig::GetTypeName() const {
1954 return "icing.lib.DocumentIndexingConfig";
1955 }
1956
1957
1958 // ===================================================================
1959
1960 class IntegerIndexingConfig_NumericMatchType::_Internal {
1961 public:
1962 };
1963
IntegerIndexingConfig_NumericMatchType(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1964 IntegerIndexingConfig_NumericMatchType::IntegerIndexingConfig_NumericMatchType(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1965 bool is_message_owned)
1966 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1967 SharedCtor(arena, is_message_owned);
1968 // @@protoc_insertion_point(arena_constructor:icing.lib.IntegerIndexingConfig.NumericMatchType)
1969 }
IntegerIndexingConfig_NumericMatchType(const IntegerIndexingConfig_NumericMatchType & from)1970 IntegerIndexingConfig_NumericMatchType::IntegerIndexingConfig_NumericMatchType(const IntegerIndexingConfig_NumericMatchType& from)
1971 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1972 IntegerIndexingConfig_NumericMatchType* const _this = this; (void)_this;
1973 new (&_impl_) Impl_{
1974 /*decltype(_impl_._cached_size_)*/{}};
1975
1976 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1977 // @@protoc_insertion_point(copy_constructor:icing.lib.IntegerIndexingConfig.NumericMatchType)
1978 }
1979
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1980 inline void IntegerIndexingConfig_NumericMatchType::SharedCtor(
1981 ::_pb::Arena* arena, bool is_message_owned) {
1982 (void)arena;
1983 (void)is_message_owned;
1984 new (&_impl_) Impl_{
1985 /*decltype(_impl_._cached_size_)*/{}
1986 };
1987 }
1988
~IntegerIndexingConfig_NumericMatchType()1989 IntegerIndexingConfig_NumericMatchType::~IntegerIndexingConfig_NumericMatchType() {
1990 // @@protoc_insertion_point(destructor:icing.lib.IntegerIndexingConfig.NumericMatchType)
1991 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1992 (void)arena;
1993 return;
1994 }
1995 SharedDtor();
1996 }
1997
SharedDtor()1998 inline void IntegerIndexingConfig_NumericMatchType::SharedDtor() {
1999 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2000 }
2001
SetCachedSize(int size) const2002 void IntegerIndexingConfig_NumericMatchType::SetCachedSize(int size) const {
2003 _impl_._cached_size_.Set(size);
2004 }
2005
Clear()2006 void IntegerIndexingConfig_NumericMatchType::Clear() {
2007 // @@protoc_insertion_point(message_clear_start:icing.lib.IntegerIndexingConfig.NumericMatchType)
2008 ::uint32_t cached_has_bits = 0;
2009 // Prevent compiler warnings about cached_has_bits being unused
2010 (void) cached_has_bits;
2011
2012 _internal_metadata_.Clear<std::string>();
2013 }
2014
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2015 const char* IntegerIndexingConfig_NumericMatchType::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2016 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2017 while (!ctx->Done(&ptr)) {
2018 ::uint32_t tag;
2019 ptr = ::_pbi::ReadTag(ptr, &tag);
2020 if ((tag == 0) || ((tag & 7) == 4)) {
2021 CHK_(ptr);
2022 ctx->SetLastTag(tag);
2023 goto message_done;
2024 }
2025 ptr = UnknownFieldParse(
2026 tag,
2027 _internal_metadata_.mutable_unknown_fields<std::string>(),
2028 ptr, ctx);
2029 CHK_(ptr != nullptr);
2030 } // while
2031 message_done:
2032 return ptr;
2033 failure:
2034 ptr = nullptr;
2035 goto message_done;
2036 #undef CHK_
2037 }
2038
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2039 ::uint8_t* IntegerIndexingConfig_NumericMatchType::_InternalSerialize(
2040 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2041 // @@protoc_insertion_point(serialize_to_array_start:icing.lib.IntegerIndexingConfig.NumericMatchType)
2042 ::uint32_t cached_has_bits = 0;
2043 (void) cached_has_bits;
2044
2045 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2046 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2047 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2048 }
2049 // @@protoc_insertion_point(serialize_to_array_end:icing.lib.IntegerIndexingConfig.NumericMatchType)
2050 return target;
2051 }
2052
ByteSizeLong() const2053 size_t IntegerIndexingConfig_NumericMatchType::ByteSizeLong() const {
2054 // @@protoc_insertion_point(message_byte_size_start:icing.lib.IntegerIndexingConfig.NumericMatchType)
2055 size_t total_size = 0;
2056
2057 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2058 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2059 }
2060 int cached_size = ::_pbi::ToCachedSize(total_size);
2061 SetCachedSize(cached_size);
2062 return total_size;
2063 }
2064
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2065 void IntegerIndexingConfig_NumericMatchType::CheckTypeAndMergeFrom(
2066 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2067 MergeFrom(*::_pbi::DownCast<const IntegerIndexingConfig_NumericMatchType*>(
2068 &from));
2069 }
2070
MergeFrom(const IntegerIndexingConfig_NumericMatchType & from)2071 void IntegerIndexingConfig_NumericMatchType::MergeFrom(const IntegerIndexingConfig_NumericMatchType& from) {
2072 IntegerIndexingConfig_NumericMatchType* const _this = this;
2073 // @@protoc_insertion_point(class_specific_merge_from_start:icing.lib.IntegerIndexingConfig.NumericMatchType)
2074 GOOGLE_DCHECK_NE(&from, _this);
2075 ::uint32_t cached_has_bits = 0;
2076 (void) cached_has_bits;
2077
2078 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2079 }
2080
CopyFrom(const IntegerIndexingConfig_NumericMatchType & from)2081 void IntegerIndexingConfig_NumericMatchType::CopyFrom(const IntegerIndexingConfig_NumericMatchType& from) {
2082 // @@protoc_insertion_point(class_specific_copy_from_start:icing.lib.IntegerIndexingConfig.NumericMatchType)
2083 if (&from == this) return;
2084 Clear();
2085 MergeFrom(from);
2086 }
2087
IsInitialized() const2088 bool IntegerIndexingConfig_NumericMatchType::IsInitialized() const {
2089 return true;
2090 }
2091
InternalSwap(IntegerIndexingConfig_NumericMatchType * other)2092 void IntegerIndexingConfig_NumericMatchType::InternalSwap(IntegerIndexingConfig_NumericMatchType* other) {
2093 using std::swap;
2094 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2095 }
2096
GetTypeName() const2097 std::string IntegerIndexingConfig_NumericMatchType::GetTypeName() const {
2098 return "icing.lib.IntegerIndexingConfig.NumericMatchType";
2099 }
2100
2101
2102 // ===================================================================
2103
2104 class IntegerIndexingConfig::_Internal {
2105 public:
2106 using HasBits = decltype(std::declval<IntegerIndexingConfig>()._impl_._has_bits_);
set_has_numeric_match_type(HasBits * has_bits)2107 static void set_has_numeric_match_type(HasBits* has_bits) {
2108 (*has_bits)[0] |= 1u;
2109 }
2110 };
2111
IntegerIndexingConfig(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2112 IntegerIndexingConfig::IntegerIndexingConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2113 bool is_message_owned)
2114 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2115 SharedCtor(arena, is_message_owned);
2116 // @@protoc_insertion_point(arena_constructor:icing.lib.IntegerIndexingConfig)
2117 }
IntegerIndexingConfig(const IntegerIndexingConfig & from)2118 IntegerIndexingConfig::IntegerIndexingConfig(const IntegerIndexingConfig& from)
2119 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2120 IntegerIndexingConfig* const _this = this; (void)_this;
2121 new (&_impl_) Impl_{
2122 decltype(_impl_._has_bits_){from._impl_._has_bits_}
2123 , /*decltype(_impl_._cached_size_)*/{}
2124 , decltype(_impl_.numeric_match_type_){}};
2125
2126 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2127 _this->_impl_.numeric_match_type_ = from._impl_.numeric_match_type_;
2128 // @@protoc_insertion_point(copy_constructor:icing.lib.IntegerIndexingConfig)
2129 }
2130
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2131 inline void IntegerIndexingConfig::SharedCtor(
2132 ::_pb::Arena* arena, bool is_message_owned) {
2133 (void)arena;
2134 (void)is_message_owned;
2135 new (&_impl_) Impl_{
2136 decltype(_impl_._has_bits_){}
2137 , /*decltype(_impl_._cached_size_)*/{}
2138 , decltype(_impl_.numeric_match_type_){0}
2139 };
2140 }
2141
~IntegerIndexingConfig()2142 IntegerIndexingConfig::~IntegerIndexingConfig() {
2143 // @@protoc_insertion_point(destructor:icing.lib.IntegerIndexingConfig)
2144 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2145 (void)arena;
2146 return;
2147 }
2148 SharedDtor();
2149 }
2150
SharedDtor()2151 inline void IntegerIndexingConfig::SharedDtor() {
2152 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2153 }
2154
SetCachedSize(int size) const2155 void IntegerIndexingConfig::SetCachedSize(int size) const {
2156 _impl_._cached_size_.Set(size);
2157 }
2158
Clear()2159 void IntegerIndexingConfig::Clear() {
2160 // @@protoc_insertion_point(message_clear_start:icing.lib.IntegerIndexingConfig)
2161 ::uint32_t cached_has_bits = 0;
2162 // Prevent compiler warnings about cached_has_bits being unused
2163 (void) cached_has_bits;
2164
2165 _impl_.numeric_match_type_ = 0;
2166 _impl_._has_bits_.Clear();
2167 _internal_metadata_.Clear<std::string>();
2168 }
2169
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2170 const char* IntegerIndexingConfig::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2171 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2172 _Internal::HasBits has_bits{};
2173 while (!ctx->Done(&ptr)) {
2174 ::uint32_t tag;
2175 ptr = ::_pbi::ReadTag(ptr, &tag);
2176 switch (tag >> 3) {
2177 // optional .icing.lib.IntegerIndexingConfig.NumericMatchType.Code numeric_match_type = 1;
2178 case 1:
2179 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
2180 ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2181 CHK_(ptr);
2182 if (PROTOBUF_PREDICT_TRUE(::icing::lib::IntegerIndexingConfig_NumericMatchType_Code_IsValid(val))) {
2183 _internal_set_numeric_match_type(static_cast<::icing::lib::IntegerIndexingConfig_NumericMatchType_Code>(val));
2184 } else {
2185 ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
2186 }
2187 } else {
2188 goto handle_unusual;
2189 }
2190 continue;
2191 default:
2192 goto handle_unusual;
2193 } // switch
2194 handle_unusual:
2195 if ((tag == 0) || ((tag & 7) == 4)) {
2196 CHK_(ptr);
2197 ctx->SetLastTag(tag);
2198 goto message_done;
2199 }
2200 ptr = UnknownFieldParse(
2201 tag,
2202 _internal_metadata_.mutable_unknown_fields<std::string>(),
2203 ptr, ctx);
2204 CHK_(ptr != nullptr);
2205 } // while
2206 message_done:
2207 _impl_._has_bits_.Or(has_bits);
2208 return ptr;
2209 failure:
2210 ptr = nullptr;
2211 goto message_done;
2212 #undef CHK_
2213 }
2214
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2215 ::uint8_t* IntegerIndexingConfig::_InternalSerialize(
2216 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2217 // @@protoc_insertion_point(serialize_to_array_start:icing.lib.IntegerIndexingConfig)
2218 ::uint32_t cached_has_bits = 0;
2219 (void) cached_has_bits;
2220
2221 cached_has_bits = _impl_._has_bits_[0];
2222 // optional .icing.lib.IntegerIndexingConfig.NumericMatchType.Code numeric_match_type = 1;
2223 if (cached_has_bits & 0x00000001u) {
2224 target = stream->EnsureSpace(target);
2225 target = ::_pbi::WireFormatLite::WriteEnumToArray(
2226 1, this->_internal_numeric_match_type(), target);
2227 }
2228
2229 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2230 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2231 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2232 }
2233 // @@protoc_insertion_point(serialize_to_array_end:icing.lib.IntegerIndexingConfig)
2234 return target;
2235 }
2236
ByteSizeLong() const2237 size_t IntegerIndexingConfig::ByteSizeLong() const {
2238 // @@protoc_insertion_point(message_byte_size_start:icing.lib.IntegerIndexingConfig)
2239 size_t total_size = 0;
2240
2241 ::uint32_t cached_has_bits = 0;
2242 // Prevent compiler warnings about cached_has_bits being unused
2243 (void) cached_has_bits;
2244
2245 // optional .icing.lib.IntegerIndexingConfig.NumericMatchType.Code numeric_match_type = 1;
2246 cached_has_bits = _impl_._has_bits_[0];
2247 if (cached_has_bits & 0x00000001u) {
2248 total_size += 1 +
2249 ::_pbi::WireFormatLite::EnumSize(this->_internal_numeric_match_type());
2250 }
2251
2252 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2253 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2254 }
2255 int cached_size = ::_pbi::ToCachedSize(total_size);
2256 SetCachedSize(cached_size);
2257 return total_size;
2258 }
2259
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2260 void IntegerIndexingConfig::CheckTypeAndMergeFrom(
2261 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2262 MergeFrom(*::_pbi::DownCast<const IntegerIndexingConfig*>(
2263 &from));
2264 }
2265
MergeFrom(const IntegerIndexingConfig & from)2266 void IntegerIndexingConfig::MergeFrom(const IntegerIndexingConfig& from) {
2267 IntegerIndexingConfig* const _this = this;
2268 // @@protoc_insertion_point(class_specific_merge_from_start:icing.lib.IntegerIndexingConfig)
2269 GOOGLE_DCHECK_NE(&from, _this);
2270 ::uint32_t cached_has_bits = 0;
2271 (void) cached_has_bits;
2272
2273 if (from._internal_has_numeric_match_type()) {
2274 _this->_internal_set_numeric_match_type(from._internal_numeric_match_type());
2275 }
2276 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2277 }
2278
CopyFrom(const IntegerIndexingConfig & from)2279 void IntegerIndexingConfig::CopyFrom(const IntegerIndexingConfig& from) {
2280 // @@protoc_insertion_point(class_specific_copy_from_start:icing.lib.IntegerIndexingConfig)
2281 if (&from == this) return;
2282 Clear();
2283 MergeFrom(from);
2284 }
2285
IsInitialized() const2286 bool IntegerIndexingConfig::IsInitialized() const {
2287 return true;
2288 }
2289
InternalSwap(IntegerIndexingConfig * other)2290 void IntegerIndexingConfig::InternalSwap(IntegerIndexingConfig* other) {
2291 using std::swap;
2292 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2293 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2294 swap(_impl_.numeric_match_type_, other->_impl_.numeric_match_type_);
2295 }
2296
GetTypeName() const2297 std::string IntegerIndexingConfig::GetTypeName() const {
2298 return "icing.lib.IntegerIndexingConfig";
2299 }
2300
2301
2302 // ===================================================================
2303
2304 class EmbeddingIndexingConfig_EmbeddingIndexingType::_Internal {
2305 public:
2306 };
2307
EmbeddingIndexingConfig_EmbeddingIndexingType(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2308 EmbeddingIndexingConfig_EmbeddingIndexingType::EmbeddingIndexingConfig_EmbeddingIndexingType(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2309 bool is_message_owned)
2310 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2311 SharedCtor(arena, is_message_owned);
2312 // @@protoc_insertion_point(arena_constructor:icing.lib.EmbeddingIndexingConfig.EmbeddingIndexingType)
2313 }
EmbeddingIndexingConfig_EmbeddingIndexingType(const EmbeddingIndexingConfig_EmbeddingIndexingType & from)2314 EmbeddingIndexingConfig_EmbeddingIndexingType::EmbeddingIndexingConfig_EmbeddingIndexingType(const EmbeddingIndexingConfig_EmbeddingIndexingType& from)
2315 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2316 EmbeddingIndexingConfig_EmbeddingIndexingType* const _this = this; (void)_this;
2317 new (&_impl_) Impl_{
2318 /*decltype(_impl_._cached_size_)*/{}};
2319
2320 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2321 // @@protoc_insertion_point(copy_constructor:icing.lib.EmbeddingIndexingConfig.EmbeddingIndexingType)
2322 }
2323
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2324 inline void EmbeddingIndexingConfig_EmbeddingIndexingType::SharedCtor(
2325 ::_pb::Arena* arena, bool is_message_owned) {
2326 (void)arena;
2327 (void)is_message_owned;
2328 new (&_impl_) Impl_{
2329 /*decltype(_impl_._cached_size_)*/{}
2330 };
2331 }
2332
~EmbeddingIndexingConfig_EmbeddingIndexingType()2333 EmbeddingIndexingConfig_EmbeddingIndexingType::~EmbeddingIndexingConfig_EmbeddingIndexingType() {
2334 // @@protoc_insertion_point(destructor:icing.lib.EmbeddingIndexingConfig.EmbeddingIndexingType)
2335 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2336 (void)arena;
2337 return;
2338 }
2339 SharedDtor();
2340 }
2341
SharedDtor()2342 inline void EmbeddingIndexingConfig_EmbeddingIndexingType::SharedDtor() {
2343 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2344 }
2345
SetCachedSize(int size) const2346 void EmbeddingIndexingConfig_EmbeddingIndexingType::SetCachedSize(int size) const {
2347 _impl_._cached_size_.Set(size);
2348 }
2349
Clear()2350 void EmbeddingIndexingConfig_EmbeddingIndexingType::Clear() {
2351 // @@protoc_insertion_point(message_clear_start:icing.lib.EmbeddingIndexingConfig.EmbeddingIndexingType)
2352 ::uint32_t cached_has_bits = 0;
2353 // Prevent compiler warnings about cached_has_bits being unused
2354 (void) cached_has_bits;
2355
2356 _internal_metadata_.Clear<std::string>();
2357 }
2358
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2359 const char* EmbeddingIndexingConfig_EmbeddingIndexingType::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2360 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2361 while (!ctx->Done(&ptr)) {
2362 ::uint32_t tag;
2363 ptr = ::_pbi::ReadTag(ptr, &tag);
2364 if ((tag == 0) || ((tag & 7) == 4)) {
2365 CHK_(ptr);
2366 ctx->SetLastTag(tag);
2367 goto message_done;
2368 }
2369 ptr = UnknownFieldParse(
2370 tag,
2371 _internal_metadata_.mutable_unknown_fields<std::string>(),
2372 ptr, ctx);
2373 CHK_(ptr != nullptr);
2374 } // while
2375 message_done:
2376 return ptr;
2377 failure:
2378 ptr = nullptr;
2379 goto message_done;
2380 #undef CHK_
2381 }
2382
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2383 ::uint8_t* EmbeddingIndexingConfig_EmbeddingIndexingType::_InternalSerialize(
2384 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2385 // @@protoc_insertion_point(serialize_to_array_start:icing.lib.EmbeddingIndexingConfig.EmbeddingIndexingType)
2386 ::uint32_t cached_has_bits = 0;
2387 (void) cached_has_bits;
2388
2389 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2390 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2391 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2392 }
2393 // @@protoc_insertion_point(serialize_to_array_end:icing.lib.EmbeddingIndexingConfig.EmbeddingIndexingType)
2394 return target;
2395 }
2396
ByteSizeLong() const2397 size_t EmbeddingIndexingConfig_EmbeddingIndexingType::ByteSizeLong() const {
2398 // @@protoc_insertion_point(message_byte_size_start:icing.lib.EmbeddingIndexingConfig.EmbeddingIndexingType)
2399 size_t total_size = 0;
2400
2401 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2402 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2403 }
2404 int cached_size = ::_pbi::ToCachedSize(total_size);
2405 SetCachedSize(cached_size);
2406 return total_size;
2407 }
2408
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2409 void EmbeddingIndexingConfig_EmbeddingIndexingType::CheckTypeAndMergeFrom(
2410 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2411 MergeFrom(*::_pbi::DownCast<const EmbeddingIndexingConfig_EmbeddingIndexingType*>(
2412 &from));
2413 }
2414
MergeFrom(const EmbeddingIndexingConfig_EmbeddingIndexingType & from)2415 void EmbeddingIndexingConfig_EmbeddingIndexingType::MergeFrom(const EmbeddingIndexingConfig_EmbeddingIndexingType& from) {
2416 EmbeddingIndexingConfig_EmbeddingIndexingType* const _this = this;
2417 // @@protoc_insertion_point(class_specific_merge_from_start:icing.lib.EmbeddingIndexingConfig.EmbeddingIndexingType)
2418 GOOGLE_DCHECK_NE(&from, _this);
2419 ::uint32_t cached_has_bits = 0;
2420 (void) cached_has_bits;
2421
2422 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2423 }
2424
CopyFrom(const EmbeddingIndexingConfig_EmbeddingIndexingType & from)2425 void EmbeddingIndexingConfig_EmbeddingIndexingType::CopyFrom(const EmbeddingIndexingConfig_EmbeddingIndexingType& from) {
2426 // @@protoc_insertion_point(class_specific_copy_from_start:icing.lib.EmbeddingIndexingConfig.EmbeddingIndexingType)
2427 if (&from == this) return;
2428 Clear();
2429 MergeFrom(from);
2430 }
2431
IsInitialized() const2432 bool EmbeddingIndexingConfig_EmbeddingIndexingType::IsInitialized() const {
2433 return true;
2434 }
2435
InternalSwap(EmbeddingIndexingConfig_EmbeddingIndexingType * other)2436 void EmbeddingIndexingConfig_EmbeddingIndexingType::InternalSwap(EmbeddingIndexingConfig_EmbeddingIndexingType* other) {
2437 using std::swap;
2438 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2439 }
2440
GetTypeName() const2441 std::string EmbeddingIndexingConfig_EmbeddingIndexingType::GetTypeName() const {
2442 return "icing.lib.EmbeddingIndexingConfig.EmbeddingIndexingType";
2443 }
2444
2445
2446 // ===================================================================
2447
2448 class EmbeddingIndexingConfig_QuantizationType::_Internal {
2449 public:
2450 };
2451
EmbeddingIndexingConfig_QuantizationType(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2452 EmbeddingIndexingConfig_QuantizationType::EmbeddingIndexingConfig_QuantizationType(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2453 bool is_message_owned)
2454 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2455 SharedCtor(arena, is_message_owned);
2456 // @@protoc_insertion_point(arena_constructor:icing.lib.EmbeddingIndexingConfig.QuantizationType)
2457 }
EmbeddingIndexingConfig_QuantizationType(const EmbeddingIndexingConfig_QuantizationType & from)2458 EmbeddingIndexingConfig_QuantizationType::EmbeddingIndexingConfig_QuantizationType(const EmbeddingIndexingConfig_QuantizationType& from)
2459 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2460 EmbeddingIndexingConfig_QuantizationType* const _this = this; (void)_this;
2461 new (&_impl_) Impl_{
2462 /*decltype(_impl_._cached_size_)*/{}};
2463
2464 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2465 // @@protoc_insertion_point(copy_constructor:icing.lib.EmbeddingIndexingConfig.QuantizationType)
2466 }
2467
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2468 inline void EmbeddingIndexingConfig_QuantizationType::SharedCtor(
2469 ::_pb::Arena* arena, bool is_message_owned) {
2470 (void)arena;
2471 (void)is_message_owned;
2472 new (&_impl_) Impl_{
2473 /*decltype(_impl_._cached_size_)*/{}
2474 };
2475 }
2476
~EmbeddingIndexingConfig_QuantizationType()2477 EmbeddingIndexingConfig_QuantizationType::~EmbeddingIndexingConfig_QuantizationType() {
2478 // @@protoc_insertion_point(destructor:icing.lib.EmbeddingIndexingConfig.QuantizationType)
2479 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2480 (void)arena;
2481 return;
2482 }
2483 SharedDtor();
2484 }
2485
SharedDtor()2486 inline void EmbeddingIndexingConfig_QuantizationType::SharedDtor() {
2487 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2488 }
2489
SetCachedSize(int size) const2490 void EmbeddingIndexingConfig_QuantizationType::SetCachedSize(int size) const {
2491 _impl_._cached_size_.Set(size);
2492 }
2493
Clear()2494 void EmbeddingIndexingConfig_QuantizationType::Clear() {
2495 // @@protoc_insertion_point(message_clear_start:icing.lib.EmbeddingIndexingConfig.QuantizationType)
2496 ::uint32_t cached_has_bits = 0;
2497 // Prevent compiler warnings about cached_has_bits being unused
2498 (void) cached_has_bits;
2499
2500 _internal_metadata_.Clear<std::string>();
2501 }
2502
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2503 const char* EmbeddingIndexingConfig_QuantizationType::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2504 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2505 while (!ctx->Done(&ptr)) {
2506 ::uint32_t tag;
2507 ptr = ::_pbi::ReadTag(ptr, &tag);
2508 if ((tag == 0) || ((tag & 7) == 4)) {
2509 CHK_(ptr);
2510 ctx->SetLastTag(tag);
2511 goto message_done;
2512 }
2513 ptr = UnknownFieldParse(
2514 tag,
2515 _internal_metadata_.mutable_unknown_fields<std::string>(),
2516 ptr, ctx);
2517 CHK_(ptr != nullptr);
2518 } // while
2519 message_done:
2520 return ptr;
2521 failure:
2522 ptr = nullptr;
2523 goto message_done;
2524 #undef CHK_
2525 }
2526
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2527 ::uint8_t* EmbeddingIndexingConfig_QuantizationType::_InternalSerialize(
2528 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2529 // @@protoc_insertion_point(serialize_to_array_start:icing.lib.EmbeddingIndexingConfig.QuantizationType)
2530 ::uint32_t cached_has_bits = 0;
2531 (void) cached_has_bits;
2532
2533 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2534 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2535 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2536 }
2537 // @@protoc_insertion_point(serialize_to_array_end:icing.lib.EmbeddingIndexingConfig.QuantizationType)
2538 return target;
2539 }
2540
ByteSizeLong() const2541 size_t EmbeddingIndexingConfig_QuantizationType::ByteSizeLong() const {
2542 // @@protoc_insertion_point(message_byte_size_start:icing.lib.EmbeddingIndexingConfig.QuantizationType)
2543 size_t total_size = 0;
2544
2545 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2546 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2547 }
2548 int cached_size = ::_pbi::ToCachedSize(total_size);
2549 SetCachedSize(cached_size);
2550 return total_size;
2551 }
2552
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2553 void EmbeddingIndexingConfig_QuantizationType::CheckTypeAndMergeFrom(
2554 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2555 MergeFrom(*::_pbi::DownCast<const EmbeddingIndexingConfig_QuantizationType*>(
2556 &from));
2557 }
2558
MergeFrom(const EmbeddingIndexingConfig_QuantizationType & from)2559 void EmbeddingIndexingConfig_QuantizationType::MergeFrom(const EmbeddingIndexingConfig_QuantizationType& from) {
2560 EmbeddingIndexingConfig_QuantizationType* const _this = this;
2561 // @@protoc_insertion_point(class_specific_merge_from_start:icing.lib.EmbeddingIndexingConfig.QuantizationType)
2562 GOOGLE_DCHECK_NE(&from, _this);
2563 ::uint32_t cached_has_bits = 0;
2564 (void) cached_has_bits;
2565
2566 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2567 }
2568
CopyFrom(const EmbeddingIndexingConfig_QuantizationType & from)2569 void EmbeddingIndexingConfig_QuantizationType::CopyFrom(const EmbeddingIndexingConfig_QuantizationType& from) {
2570 // @@protoc_insertion_point(class_specific_copy_from_start:icing.lib.EmbeddingIndexingConfig.QuantizationType)
2571 if (&from == this) return;
2572 Clear();
2573 MergeFrom(from);
2574 }
2575
IsInitialized() const2576 bool EmbeddingIndexingConfig_QuantizationType::IsInitialized() const {
2577 return true;
2578 }
2579
InternalSwap(EmbeddingIndexingConfig_QuantizationType * other)2580 void EmbeddingIndexingConfig_QuantizationType::InternalSwap(EmbeddingIndexingConfig_QuantizationType* other) {
2581 using std::swap;
2582 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2583 }
2584
GetTypeName() const2585 std::string EmbeddingIndexingConfig_QuantizationType::GetTypeName() const {
2586 return "icing.lib.EmbeddingIndexingConfig.QuantizationType";
2587 }
2588
2589
2590 // ===================================================================
2591
2592 class EmbeddingIndexingConfig::_Internal {
2593 public:
2594 using HasBits = decltype(std::declval<EmbeddingIndexingConfig>()._impl_._has_bits_);
set_has_embedding_indexing_type(HasBits * has_bits)2595 static void set_has_embedding_indexing_type(HasBits* has_bits) {
2596 (*has_bits)[0] |= 1u;
2597 }
set_has_quantization_type(HasBits * has_bits)2598 static void set_has_quantization_type(HasBits* has_bits) {
2599 (*has_bits)[0] |= 2u;
2600 }
2601 };
2602
EmbeddingIndexingConfig(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2603 EmbeddingIndexingConfig::EmbeddingIndexingConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2604 bool is_message_owned)
2605 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2606 SharedCtor(arena, is_message_owned);
2607 // @@protoc_insertion_point(arena_constructor:icing.lib.EmbeddingIndexingConfig)
2608 }
EmbeddingIndexingConfig(const EmbeddingIndexingConfig & from)2609 EmbeddingIndexingConfig::EmbeddingIndexingConfig(const EmbeddingIndexingConfig& from)
2610 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2611 EmbeddingIndexingConfig* const _this = this; (void)_this;
2612 new (&_impl_) Impl_{
2613 decltype(_impl_._has_bits_){from._impl_._has_bits_}
2614 , /*decltype(_impl_._cached_size_)*/{}
2615 , decltype(_impl_.embedding_indexing_type_){}
2616 , decltype(_impl_.quantization_type_){}};
2617
2618 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2619 ::memcpy(&_impl_.embedding_indexing_type_, &from._impl_.embedding_indexing_type_,
2620 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.quantization_type_) -
2621 reinterpret_cast<char*>(&_impl_.embedding_indexing_type_)) + sizeof(_impl_.quantization_type_));
2622 // @@protoc_insertion_point(copy_constructor:icing.lib.EmbeddingIndexingConfig)
2623 }
2624
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2625 inline void EmbeddingIndexingConfig::SharedCtor(
2626 ::_pb::Arena* arena, bool is_message_owned) {
2627 (void)arena;
2628 (void)is_message_owned;
2629 new (&_impl_) Impl_{
2630 decltype(_impl_._has_bits_){}
2631 , /*decltype(_impl_._cached_size_)*/{}
2632 , decltype(_impl_.embedding_indexing_type_){0}
2633 , decltype(_impl_.quantization_type_){0}
2634 };
2635 }
2636
~EmbeddingIndexingConfig()2637 EmbeddingIndexingConfig::~EmbeddingIndexingConfig() {
2638 // @@protoc_insertion_point(destructor:icing.lib.EmbeddingIndexingConfig)
2639 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2640 (void)arena;
2641 return;
2642 }
2643 SharedDtor();
2644 }
2645
SharedDtor()2646 inline void EmbeddingIndexingConfig::SharedDtor() {
2647 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2648 }
2649
SetCachedSize(int size) const2650 void EmbeddingIndexingConfig::SetCachedSize(int size) const {
2651 _impl_._cached_size_.Set(size);
2652 }
2653
Clear()2654 void EmbeddingIndexingConfig::Clear() {
2655 // @@protoc_insertion_point(message_clear_start:icing.lib.EmbeddingIndexingConfig)
2656 ::uint32_t cached_has_bits = 0;
2657 // Prevent compiler warnings about cached_has_bits being unused
2658 (void) cached_has_bits;
2659
2660 cached_has_bits = _impl_._has_bits_[0];
2661 if (cached_has_bits & 0x00000003u) {
2662 ::memset(&_impl_.embedding_indexing_type_, 0, static_cast<size_t>(
2663 reinterpret_cast<char*>(&_impl_.quantization_type_) -
2664 reinterpret_cast<char*>(&_impl_.embedding_indexing_type_)) + sizeof(_impl_.quantization_type_));
2665 }
2666 _impl_._has_bits_.Clear();
2667 _internal_metadata_.Clear<std::string>();
2668 }
2669
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2670 const char* EmbeddingIndexingConfig::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2671 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2672 _Internal::HasBits has_bits{};
2673 while (!ctx->Done(&ptr)) {
2674 ::uint32_t tag;
2675 ptr = ::_pbi::ReadTag(ptr, &tag);
2676 switch (tag >> 3) {
2677 // optional .icing.lib.EmbeddingIndexingConfig.EmbeddingIndexingType.Code embedding_indexing_type = 1;
2678 case 1:
2679 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
2680 ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2681 CHK_(ptr);
2682 if (PROTOBUF_PREDICT_TRUE(::icing::lib::EmbeddingIndexingConfig_EmbeddingIndexingType_Code_IsValid(val))) {
2683 _internal_set_embedding_indexing_type(static_cast<::icing::lib::EmbeddingIndexingConfig_EmbeddingIndexingType_Code>(val));
2684 } else {
2685 ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
2686 }
2687 } else {
2688 goto handle_unusual;
2689 }
2690 continue;
2691 // optional .icing.lib.EmbeddingIndexingConfig.QuantizationType.Code quantization_type = 2;
2692 case 2:
2693 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
2694 ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2695 CHK_(ptr);
2696 if (PROTOBUF_PREDICT_TRUE(::icing::lib::EmbeddingIndexingConfig_QuantizationType_Code_IsValid(val))) {
2697 _internal_set_quantization_type(static_cast<::icing::lib::EmbeddingIndexingConfig_QuantizationType_Code>(val));
2698 } else {
2699 ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
2700 }
2701 } else {
2702 goto handle_unusual;
2703 }
2704 continue;
2705 default:
2706 goto handle_unusual;
2707 } // switch
2708 handle_unusual:
2709 if ((tag == 0) || ((tag & 7) == 4)) {
2710 CHK_(ptr);
2711 ctx->SetLastTag(tag);
2712 goto message_done;
2713 }
2714 ptr = UnknownFieldParse(
2715 tag,
2716 _internal_metadata_.mutable_unknown_fields<std::string>(),
2717 ptr, ctx);
2718 CHK_(ptr != nullptr);
2719 } // while
2720 message_done:
2721 _impl_._has_bits_.Or(has_bits);
2722 return ptr;
2723 failure:
2724 ptr = nullptr;
2725 goto message_done;
2726 #undef CHK_
2727 }
2728
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2729 ::uint8_t* EmbeddingIndexingConfig::_InternalSerialize(
2730 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2731 // @@protoc_insertion_point(serialize_to_array_start:icing.lib.EmbeddingIndexingConfig)
2732 ::uint32_t cached_has_bits = 0;
2733 (void) cached_has_bits;
2734
2735 cached_has_bits = _impl_._has_bits_[0];
2736 // optional .icing.lib.EmbeddingIndexingConfig.EmbeddingIndexingType.Code embedding_indexing_type = 1;
2737 if (cached_has_bits & 0x00000001u) {
2738 target = stream->EnsureSpace(target);
2739 target = ::_pbi::WireFormatLite::WriteEnumToArray(
2740 1, this->_internal_embedding_indexing_type(), target);
2741 }
2742
2743 // optional .icing.lib.EmbeddingIndexingConfig.QuantizationType.Code quantization_type = 2;
2744 if (cached_has_bits & 0x00000002u) {
2745 target = stream->EnsureSpace(target);
2746 target = ::_pbi::WireFormatLite::WriteEnumToArray(
2747 2, this->_internal_quantization_type(), target);
2748 }
2749
2750 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2751 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2752 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2753 }
2754 // @@protoc_insertion_point(serialize_to_array_end:icing.lib.EmbeddingIndexingConfig)
2755 return target;
2756 }
2757
ByteSizeLong() const2758 size_t EmbeddingIndexingConfig::ByteSizeLong() const {
2759 // @@protoc_insertion_point(message_byte_size_start:icing.lib.EmbeddingIndexingConfig)
2760 size_t total_size = 0;
2761
2762 ::uint32_t cached_has_bits = 0;
2763 // Prevent compiler warnings about cached_has_bits being unused
2764 (void) cached_has_bits;
2765
2766 cached_has_bits = _impl_._has_bits_[0];
2767 if (cached_has_bits & 0x00000003u) {
2768 // optional .icing.lib.EmbeddingIndexingConfig.EmbeddingIndexingType.Code embedding_indexing_type = 1;
2769 if (cached_has_bits & 0x00000001u) {
2770 total_size += 1 +
2771 ::_pbi::WireFormatLite::EnumSize(this->_internal_embedding_indexing_type());
2772 }
2773
2774 // optional .icing.lib.EmbeddingIndexingConfig.QuantizationType.Code quantization_type = 2;
2775 if (cached_has_bits & 0x00000002u) {
2776 total_size += 1 +
2777 ::_pbi::WireFormatLite::EnumSize(this->_internal_quantization_type());
2778 }
2779
2780 }
2781 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2782 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2783 }
2784 int cached_size = ::_pbi::ToCachedSize(total_size);
2785 SetCachedSize(cached_size);
2786 return total_size;
2787 }
2788
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2789 void EmbeddingIndexingConfig::CheckTypeAndMergeFrom(
2790 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2791 MergeFrom(*::_pbi::DownCast<const EmbeddingIndexingConfig*>(
2792 &from));
2793 }
2794
MergeFrom(const EmbeddingIndexingConfig & from)2795 void EmbeddingIndexingConfig::MergeFrom(const EmbeddingIndexingConfig& from) {
2796 EmbeddingIndexingConfig* const _this = this;
2797 // @@protoc_insertion_point(class_specific_merge_from_start:icing.lib.EmbeddingIndexingConfig)
2798 GOOGLE_DCHECK_NE(&from, _this);
2799 ::uint32_t cached_has_bits = 0;
2800 (void) cached_has_bits;
2801
2802 cached_has_bits = from._impl_._has_bits_[0];
2803 if (cached_has_bits & 0x00000003u) {
2804 if (cached_has_bits & 0x00000001u) {
2805 _this->_impl_.embedding_indexing_type_ = from._impl_.embedding_indexing_type_;
2806 }
2807 if (cached_has_bits & 0x00000002u) {
2808 _this->_impl_.quantization_type_ = from._impl_.quantization_type_;
2809 }
2810 _this->_impl_._has_bits_[0] |= cached_has_bits;
2811 }
2812 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2813 }
2814
CopyFrom(const EmbeddingIndexingConfig & from)2815 void EmbeddingIndexingConfig::CopyFrom(const EmbeddingIndexingConfig& from) {
2816 // @@protoc_insertion_point(class_specific_copy_from_start:icing.lib.EmbeddingIndexingConfig)
2817 if (&from == this) return;
2818 Clear();
2819 MergeFrom(from);
2820 }
2821
IsInitialized() const2822 bool EmbeddingIndexingConfig::IsInitialized() const {
2823 return true;
2824 }
2825
InternalSwap(EmbeddingIndexingConfig * other)2826 void EmbeddingIndexingConfig::InternalSwap(EmbeddingIndexingConfig* other) {
2827 using std::swap;
2828 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2829 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2830 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2831 PROTOBUF_FIELD_OFFSET(EmbeddingIndexingConfig, _impl_.quantization_type_)
2832 + sizeof(EmbeddingIndexingConfig::_impl_.quantization_type_) // NOLINT
2833 - PROTOBUF_FIELD_OFFSET(EmbeddingIndexingConfig, _impl_.embedding_indexing_type_)>(
2834 reinterpret_cast<char*>(&_impl_.embedding_indexing_type_),
2835 reinterpret_cast<char*>(&other->_impl_.embedding_indexing_type_));
2836 }
2837
GetTypeName() const2838 std::string EmbeddingIndexingConfig::GetTypeName() const {
2839 return "icing.lib.EmbeddingIndexingConfig";
2840 }
2841
2842
2843 // ===================================================================
2844
2845 class JoinableConfig_ValueType::_Internal {
2846 public:
2847 };
2848
JoinableConfig_ValueType(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2849 JoinableConfig_ValueType::JoinableConfig_ValueType(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2850 bool is_message_owned)
2851 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2852 SharedCtor(arena, is_message_owned);
2853 // @@protoc_insertion_point(arena_constructor:icing.lib.JoinableConfig.ValueType)
2854 }
JoinableConfig_ValueType(const JoinableConfig_ValueType & from)2855 JoinableConfig_ValueType::JoinableConfig_ValueType(const JoinableConfig_ValueType& from)
2856 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2857 JoinableConfig_ValueType* const _this = this; (void)_this;
2858 new (&_impl_) Impl_{
2859 /*decltype(_impl_._cached_size_)*/{}};
2860
2861 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2862 // @@protoc_insertion_point(copy_constructor:icing.lib.JoinableConfig.ValueType)
2863 }
2864
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2865 inline void JoinableConfig_ValueType::SharedCtor(
2866 ::_pb::Arena* arena, bool is_message_owned) {
2867 (void)arena;
2868 (void)is_message_owned;
2869 new (&_impl_) Impl_{
2870 /*decltype(_impl_._cached_size_)*/{}
2871 };
2872 }
2873
~JoinableConfig_ValueType()2874 JoinableConfig_ValueType::~JoinableConfig_ValueType() {
2875 // @@protoc_insertion_point(destructor:icing.lib.JoinableConfig.ValueType)
2876 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2877 (void)arena;
2878 return;
2879 }
2880 SharedDtor();
2881 }
2882
SharedDtor()2883 inline void JoinableConfig_ValueType::SharedDtor() {
2884 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2885 }
2886
SetCachedSize(int size) const2887 void JoinableConfig_ValueType::SetCachedSize(int size) const {
2888 _impl_._cached_size_.Set(size);
2889 }
2890
Clear()2891 void JoinableConfig_ValueType::Clear() {
2892 // @@protoc_insertion_point(message_clear_start:icing.lib.JoinableConfig.ValueType)
2893 ::uint32_t cached_has_bits = 0;
2894 // Prevent compiler warnings about cached_has_bits being unused
2895 (void) cached_has_bits;
2896
2897 _internal_metadata_.Clear<std::string>();
2898 }
2899
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2900 const char* JoinableConfig_ValueType::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2901 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2902 while (!ctx->Done(&ptr)) {
2903 ::uint32_t tag;
2904 ptr = ::_pbi::ReadTag(ptr, &tag);
2905 if ((tag == 0) || ((tag & 7) == 4)) {
2906 CHK_(ptr);
2907 ctx->SetLastTag(tag);
2908 goto message_done;
2909 }
2910 ptr = UnknownFieldParse(
2911 tag,
2912 _internal_metadata_.mutable_unknown_fields<std::string>(),
2913 ptr, ctx);
2914 CHK_(ptr != nullptr);
2915 } // while
2916 message_done:
2917 return ptr;
2918 failure:
2919 ptr = nullptr;
2920 goto message_done;
2921 #undef CHK_
2922 }
2923
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2924 ::uint8_t* JoinableConfig_ValueType::_InternalSerialize(
2925 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2926 // @@protoc_insertion_point(serialize_to_array_start:icing.lib.JoinableConfig.ValueType)
2927 ::uint32_t cached_has_bits = 0;
2928 (void) cached_has_bits;
2929
2930 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2931 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2932 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2933 }
2934 // @@protoc_insertion_point(serialize_to_array_end:icing.lib.JoinableConfig.ValueType)
2935 return target;
2936 }
2937
ByteSizeLong() const2938 size_t JoinableConfig_ValueType::ByteSizeLong() const {
2939 // @@protoc_insertion_point(message_byte_size_start:icing.lib.JoinableConfig.ValueType)
2940 size_t total_size = 0;
2941
2942 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2943 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2944 }
2945 int cached_size = ::_pbi::ToCachedSize(total_size);
2946 SetCachedSize(cached_size);
2947 return total_size;
2948 }
2949
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2950 void JoinableConfig_ValueType::CheckTypeAndMergeFrom(
2951 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2952 MergeFrom(*::_pbi::DownCast<const JoinableConfig_ValueType*>(
2953 &from));
2954 }
2955
MergeFrom(const JoinableConfig_ValueType & from)2956 void JoinableConfig_ValueType::MergeFrom(const JoinableConfig_ValueType& from) {
2957 JoinableConfig_ValueType* const _this = this;
2958 // @@protoc_insertion_point(class_specific_merge_from_start:icing.lib.JoinableConfig.ValueType)
2959 GOOGLE_DCHECK_NE(&from, _this);
2960 ::uint32_t cached_has_bits = 0;
2961 (void) cached_has_bits;
2962
2963 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2964 }
2965
CopyFrom(const JoinableConfig_ValueType & from)2966 void JoinableConfig_ValueType::CopyFrom(const JoinableConfig_ValueType& from) {
2967 // @@protoc_insertion_point(class_specific_copy_from_start:icing.lib.JoinableConfig.ValueType)
2968 if (&from == this) return;
2969 Clear();
2970 MergeFrom(from);
2971 }
2972
IsInitialized() const2973 bool JoinableConfig_ValueType::IsInitialized() const {
2974 return true;
2975 }
2976
InternalSwap(JoinableConfig_ValueType * other)2977 void JoinableConfig_ValueType::InternalSwap(JoinableConfig_ValueType* other) {
2978 using std::swap;
2979 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2980 }
2981
GetTypeName() const2982 std::string JoinableConfig_ValueType::GetTypeName() const {
2983 return "icing.lib.JoinableConfig.ValueType";
2984 }
2985
2986
2987 // ===================================================================
2988
2989 class JoinableConfig_DeletePropagationType::_Internal {
2990 public:
2991 };
2992
JoinableConfig_DeletePropagationType(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2993 JoinableConfig_DeletePropagationType::JoinableConfig_DeletePropagationType(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2994 bool is_message_owned)
2995 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2996 SharedCtor(arena, is_message_owned);
2997 // @@protoc_insertion_point(arena_constructor:icing.lib.JoinableConfig.DeletePropagationType)
2998 }
JoinableConfig_DeletePropagationType(const JoinableConfig_DeletePropagationType & from)2999 JoinableConfig_DeletePropagationType::JoinableConfig_DeletePropagationType(const JoinableConfig_DeletePropagationType& from)
3000 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
3001 JoinableConfig_DeletePropagationType* const _this = this; (void)_this;
3002 new (&_impl_) Impl_{
3003 /*decltype(_impl_._cached_size_)*/{}};
3004
3005 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3006 // @@protoc_insertion_point(copy_constructor:icing.lib.JoinableConfig.DeletePropagationType)
3007 }
3008
SharedCtor(::_pb::Arena * arena,bool is_message_owned)3009 inline void JoinableConfig_DeletePropagationType::SharedCtor(
3010 ::_pb::Arena* arena, bool is_message_owned) {
3011 (void)arena;
3012 (void)is_message_owned;
3013 new (&_impl_) Impl_{
3014 /*decltype(_impl_._cached_size_)*/{}
3015 };
3016 }
3017
~JoinableConfig_DeletePropagationType()3018 JoinableConfig_DeletePropagationType::~JoinableConfig_DeletePropagationType() {
3019 // @@protoc_insertion_point(destructor:icing.lib.JoinableConfig.DeletePropagationType)
3020 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
3021 (void)arena;
3022 return;
3023 }
3024 SharedDtor();
3025 }
3026
SharedDtor()3027 inline void JoinableConfig_DeletePropagationType::SharedDtor() {
3028 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
3029 }
3030
SetCachedSize(int size) const3031 void JoinableConfig_DeletePropagationType::SetCachedSize(int size) const {
3032 _impl_._cached_size_.Set(size);
3033 }
3034
Clear()3035 void JoinableConfig_DeletePropagationType::Clear() {
3036 // @@protoc_insertion_point(message_clear_start:icing.lib.JoinableConfig.DeletePropagationType)
3037 ::uint32_t cached_has_bits = 0;
3038 // Prevent compiler warnings about cached_has_bits being unused
3039 (void) cached_has_bits;
3040
3041 _internal_metadata_.Clear<std::string>();
3042 }
3043
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)3044 const char* JoinableConfig_DeletePropagationType::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
3045 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
3046 while (!ctx->Done(&ptr)) {
3047 ::uint32_t tag;
3048 ptr = ::_pbi::ReadTag(ptr, &tag);
3049 if ((tag == 0) || ((tag & 7) == 4)) {
3050 CHK_(ptr);
3051 ctx->SetLastTag(tag);
3052 goto message_done;
3053 }
3054 ptr = UnknownFieldParse(
3055 tag,
3056 _internal_metadata_.mutable_unknown_fields<std::string>(),
3057 ptr, ctx);
3058 CHK_(ptr != nullptr);
3059 } // while
3060 message_done:
3061 return ptr;
3062 failure:
3063 ptr = nullptr;
3064 goto message_done;
3065 #undef CHK_
3066 }
3067
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const3068 ::uint8_t* JoinableConfig_DeletePropagationType::_InternalSerialize(
3069 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
3070 // @@protoc_insertion_point(serialize_to_array_start:icing.lib.JoinableConfig.DeletePropagationType)
3071 ::uint32_t cached_has_bits = 0;
3072 (void) cached_has_bits;
3073
3074 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3075 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
3076 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
3077 }
3078 // @@protoc_insertion_point(serialize_to_array_end:icing.lib.JoinableConfig.DeletePropagationType)
3079 return target;
3080 }
3081
ByteSizeLong() const3082 size_t JoinableConfig_DeletePropagationType::ByteSizeLong() const {
3083 // @@protoc_insertion_point(message_byte_size_start:icing.lib.JoinableConfig.DeletePropagationType)
3084 size_t total_size = 0;
3085
3086 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3087 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3088 }
3089 int cached_size = ::_pbi::ToCachedSize(total_size);
3090 SetCachedSize(cached_size);
3091 return total_size;
3092 }
3093
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3094 void JoinableConfig_DeletePropagationType::CheckTypeAndMergeFrom(
3095 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3096 MergeFrom(*::_pbi::DownCast<const JoinableConfig_DeletePropagationType*>(
3097 &from));
3098 }
3099
MergeFrom(const JoinableConfig_DeletePropagationType & from)3100 void JoinableConfig_DeletePropagationType::MergeFrom(const JoinableConfig_DeletePropagationType& from) {
3101 JoinableConfig_DeletePropagationType* const _this = this;
3102 // @@protoc_insertion_point(class_specific_merge_from_start:icing.lib.JoinableConfig.DeletePropagationType)
3103 GOOGLE_DCHECK_NE(&from, _this);
3104 ::uint32_t cached_has_bits = 0;
3105 (void) cached_has_bits;
3106
3107 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3108 }
3109
CopyFrom(const JoinableConfig_DeletePropagationType & from)3110 void JoinableConfig_DeletePropagationType::CopyFrom(const JoinableConfig_DeletePropagationType& from) {
3111 // @@protoc_insertion_point(class_specific_copy_from_start:icing.lib.JoinableConfig.DeletePropagationType)
3112 if (&from == this) return;
3113 Clear();
3114 MergeFrom(from);
3115 }
3116
IsInitialized() const3117 bool JoinableConfig_DeletePropagationType::IsInitialized() const {
3118 return true;
3119 }
3120
InternalSwap(JoinableConfig_DeletePropagationType * other)3121 void JoinableConfig_DeletePropagationType::InternalSwap(JoinableConfig_DeletePropagationType* other) {
3122 using std::swap;
3123 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3124 }
3125
GetTypeName() const3126 std::string JoinableConfig_DeletePropagationType::GetTypeName() const {
3127 return "icing.lib.JoinableConfig.DeletePropagationType";
3128 }
3129
3130
3131 // ===================================================================
3132
3133 class JoinableConfig::_Internal {
3134 public:
3135 using HasBits = decltype(std::declval<JoinableConfig>()._impl_._has_bits_);
set_has_value_type(HasBits * has_bits)3136 static void set_has_value_type(HasBits* has_bits) {
3137 (*has_bits)[0] |= 1u;
3138 }
set_has_delete_propagation_type(HasBits * has_bits)3139 static void set_has_delete_propagation_type(HasBits* has_bits) {
3140 (*has_bits)[0] |= 2u;
3141 }
3142 };
3143
JoinableConfig(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)3144 JoinableConfig::JoinableConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3145 bool is_message_owned)
3146 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
3147 SharedCtor(arena, is_message_owned);
3148 // @@protoc_insertion_point(arena_constructor:icing.lib.JoinableConfig)
3149 }
JoinableConfig(const JoinableConfig & from)3150 JoinableConfig::JoinableConfig(const JoinableConfig& from)
3151 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
3152 JoinableConfig* const _this = this; (void)_this;
3153 new (&_impl_) Impl_{
3154 decltype(_impl_._has_bits_){from._impl_._has_bits_}
3155 , /*decltype(_impl_._cached_size_)*/{}
3156 , decltype(_impl_.value_type_){}
3157 , decltype(_impl_.delete_propagation_type_){}};
3158
3159 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3160 ::memcpy(&_impl_.value_type_, &from._impl_.value_type_,
3161 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.delete_propagation_type_) -
3162 reinterpret_cast<char*>(&_impl_.value_type_)) + sizeof(_impl_.delete_propagation_type_));
3163 // @@protoc_insertion_point(copy_constructor:icing.lib.JoinableConfig)
3164 }
3165
SharedCtor(::_pb::Arena * arena,bool is_message_owned)3166 inline void JoinableConfig::SharedCtor(
3167 ::_pb::Arena* arena, bool is_message_owned) {
3168 (void)arena;
3169 (void)is_message_owned;
3170 new (&_impl_) Impl_{
3171 decltype(_impl_._has_bits_){}
3172 , /*decltype(_impl_._cached_size_)*/{}
3173 , decltype(_impl_.value_type_){0}
3174 , decltype(_impl_.delete_propagation_type_){0}
3175 };
3176 }
3177
~JoinableConfig()3178 JoinableConfig::~JoinableConfig() {
3179 // @@protoc_insertion_point(destructor:icing.lib.JoinableConfig)
3180 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
3181 (void)arena;
3182 return;
3183 }
3184 SharedDtor();
3185 }
3186
SharedDtor()3187 inline void JoinableConfig::SharedDtor() {
3188 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
3189 }
3190
SetCachedSize(int size) const3191 void JoinableConfig::SetCachedSize(int size) const {
3192 _impl_._cached_size_.Set(size);
3193 }
3194
Clear()3195 void JoinableConfig::Clear() {
3196 // @@protoc_insertion_point(message_clear_start:icing.lib.JoinableConfig)
3197 ::uint32_t cached_has_bits = 0;
3198 // Prevent compiler warnings about cached_has_bits being unused
3199 (void) cached_has_bits;
3200
3201 cached_has_bits = _impl_._has_bits_[0];
3202 if (cached_has_bits & 0x00000003u) {
3203 ::memset(&_impl_.value_type_, 0, static_cast<size_t>(
3204 reinterpret_cast<char*>(&_impl_.delete_propagation_type_) -
3205 reinterpret_cast<char*>(&_impl_.value_type_)) + sizeof(_impl_.delete_propagation_type_));
3206 }
3207 _impl_._has_bits_.Clear();
3208 _internal_metadata_.Clear<std::string>();
3209 }
3210
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)3211 const char* JoinableConfig::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
3212 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
3213 _Internal::HasBits has_bits{};
3214 while (!ctx->Done(&ptr)) {
3215 ::uint32_t tag;
3216 ptr = ::_pbi::ReadTag(ptr, &tag);
3217 switch (tag >> 3) {
3218 // optional .icing.lib.JoinableConfig.ValueType.Code value_type = 1;
3219 case 1:
3220 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
3221 ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
3222 CHK_(ptr);
3223 if (PROTOBUF_PREDICT_TRUE(::icing::lib::JoinableConfig_ValueType_Code_IsValid(val))) {
3224 _internal_set_value_type(static_cast<::icing::lib::JoinableConfig_ValueType_Code>(val));
3225 } else {
3226 ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
3227 }
3228 } else {
3229 goto handle_unusual;
3230 }
3231 continue;
3232 // optional .icing.lib.JoinableConfig.DeletePropagationType.Code delete_propagation_type = 3;
3233 case 3:
3234 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
3235 ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
3236 CHK_(ptr);
3237 if (PROTOBUF_PREDICT_TRUE(::icing::lib::JoinableConfig_DeletePropagationType_Code_IsValid(val))) {
3238 _internal_set_delete_propagation_type(static_cast<::icing::lib::JoinableConfig_DeletePropagationType_Code>(val));
3239 } else {
3240 ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields());
3241 }
3242 } else {
3243 goto handle_unusual;
3244 }
3245 continue;
3246 default:
3247 goto handle_unusual;
3248 } // switch
3249 handle_unusual:
3250 if ((tag == 0) || ((tag & 7) == 4)) {
3251 CHK_(ptr);
3252 ctx->SetLastTag(tag);
3253 goto message_done;
3254 }
3255 ptr = UnknownFieldParse(
3256 tag,
3257 _internal_metadata_.mutable_unknown_fields<std::string>(),
3258 ptr, ctx);
3259 CHK_(ptr != nullptr);
3260 } // while
3261 message_done:
3262 _impl_._has_bits_.Or(has_bits);
3263 return ptr;
3264 failure:
3265 ptr = nullptr;
3266 goto message_done;
3267 #undef CHK_
3268 }
3269
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const3270 ::uint8_t* JoinableConfig::_InternalSerialize(
3271 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
3272 // @@protoc_insertion_point(serialize_to_array_start:icing.lib.JoinableConfig)
3273 ::uint32_t cached_has_bits = 0;
3274 (void) cached_has_bits;
3275
3276 cached_has_bits = _impl_._has_bits_[0];
3277 // optional .icing.lib.JoinableConfig.ValueType.Code value_type = 1;
3278 if (cached_has_bits & 0x00000001u) {
3279 target = stream->EnsureSpace(target);
3280 target = ::_pbi::WireFormatLite::WriteEnumToArray(
3281 1, this->_internal_value_type(), target);
3282 }
3283
3284 // optional .icing.lib.JoinableConfig.DeletePropagationType.Code delete_propagation_type = 3;
3285 if (cached_has_bits & 0x00000002u) {
3286 target = stream->EnsureSpace(target);
3287 target = ::_pbi::WireFormatLite::WriteEnumToArray(
3288 3, this->_internal_delete_propagation_type(), target);
3289 }
3290
3291 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3292 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
3293 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
3294 }
3295 // @@protoc_insertion_point(serialize_to_array_end:icing.lib.JoinableConfig)
3296 return target;
3297 }
3298
ByteSizeLong() const3299 size_t JoinableConfig::ByteSizeLong() const {
3300 // @@protoc_insertion_point(message_byte_size_start:icing.lib.JoinableConfig)
3301 size_t total_size = 0;
3302
3303 ::uint32_t cached_has_bits = 0;
3304 // Prevent compiler warnings about cached_has_bits being unused
3305 (void) cached_has_bits;
3306
3307 cached_has_bits = _impl_._has_bits_[0];
3308 if (cached_has_bits & 0x00000003u) {
3309 // optional .icing.lib.JoinableConfig.ValueType.Code value_type = 1;
3310 if (cached_has_bits & 0x00000001u) {
3311 total_size += 1 +
3312 ::_pbi::WireFormatLite::EnumSize(this->_internal_value_type());
3313 }
3314
3315 // optional .icing.lib.JoinableConfig.DeletePropagationType.Code delete_propagation_type = 3;
3316 if (cached_has_bits & 0x00000002u) {
3317 total_size += 1 +
3318 ::_pbi::WireFormatLite::EnumSize(this->_internal_delete_propagation_type());
3319 }
3320
3321 }
3322 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3323 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3324 }
3325 int cached_size = ::_pbi::ToCachedSize(total_size);
3326 SetCachedSize(cached_size);
3327 return total_size;
3328 }
3329
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3330 void JoinableConfig::CheckTypeAndMergeFrom(
3331 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3332 MergeFrom(*::_pbi::DownCast<const JoinableConfig*>(
3333 &from));
3334 }
3335
MergeFrom(const JoinableConfig & from)3336 void JoinableConfig::MergeFrom(const JoinableConfig& from) {
3337 JoinableConfig* const _this = this;
3338 // @@protoc_insertion_point(class_specific_merge_from_start:icing.lib.JoinableConfig)
3339 GOOGLE_DCHECK_NE(&from, _this);
3340 ::uint32_t cached_has_bits = 0;
3341 (void) cached_has_bits;
3342
3343 cached_has_bits = from._impl_._has_bits_[0];
3344 if (cached_has_bits & 0x00000003u) {
3345 if (cached_has_bits & 0x00000001u) {
3346 _this->_impl_.value_type_ = from._impl_.value_type_;
3347 }
3348 if (cached_has_bits & 0x00000002u) {
3349 _this->_impl_.delete_propagation_type_ = from._impl_.delete_propagation_type_;
3350 }
3351 _this->_impl_._has_bits_[0] |= cached_has_bits;
3352 }
3353 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3354 }
3355
CopyFrom(const JoinableConfig & from)3356 void JoinableConfig::CopyFrom(const JoinableConfig& from) {
3357 // @@protoc_insertion_point(class_specific_copy_from_start:icing.lib.JoinableConfig)
3358 if (&from == this) return;
3359 Clear();
3360 MergeFrom(from);
3361 }
3362
IsInitialized() const3363 bool JoinableConfig::IsInitialized() const {
3364 return true;
3365 }
3366
InternalSwap(JoinableConfig * other)3367 void JoinableConfig::InternalSwap(JoinableConfig* other) {
3368 using std::swap;
3369 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3370 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
3371 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
3372 PROTOBUF_FIELD_OFFSET(JoinableConfig, _impl_.delete_propagation_type_)
3373 + sizeof(JoinableConfig::_impl_.delete_propagation_type_) // NOLINT
3374 - PROTOBUF_FIELD_OFFSET(JoinableConfig, _impl_.value_type_)>(
3375 reinterpret_cast<char*>(&_impl_.value_type_),
3376 reinterpret_cast<char*>(&other->_impl_.value_type_));
3377 }
3378
GetTypeName() const3379 std::string JoinableConfig::GetTypeName() const {
3380 return "icing.lib.JoinableConfig";
3381 }
3382
3383
3384 // ===================================================================
3385
3386 class PropertyConfigProto_DataType::_Internal {
3387 public:
3388 };
3389
PropertyConfigProto_DataType(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)3390 PropertyConfigProto_DataType::PropertyConfigProto_DataType(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3391 bool is_message_owned)
3392 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
3393 SharedCtor(arena, is_message_owned);
3394 // @@protoc_insertion_point(arena_constructor:icing.lib.PropertyConfigProto.DataType)
3395 }
PropertyConfigProto_DataType(const PropertyConfigProto_DataType & from)3396 PropertyConfigProto_DataType::PropertyConfigProto_DataType(const PropertyConfigProto_DataType& from)
3397 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
3398 PropertyConfigProto_DataType* const _this = this; (void)_this;
3399 new (&_impl_) Impl_{
3400 /*decltype(_impl_._cached_size_)*/{}};
3401
3402 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3403 // @@protoc_insertion_point(copy_constructor:icing.lib.PropertyConfigProto.DataType)
3404 }
3405
SharedCtor(::_pb::Arena * arena,bool is_message_owned)3406 inline void PropertyConfigProto_DataType::SharedCtor(
3407 ::_pb::Arena* arena, bool is_message_owned) {
3408 (void)arena;
3409 (void)is_message_owned;
3410 new (&_impl_) Impl_{
3411 /*decltype(_impl_._cached_size_)*/{}
3412 };
3413 }
3414
~PropertyConfigProto_DataType()3415 PropertyConfigProto_DataType::~PropertyConfigProto_DataType() {
3416 // @@protoc_insertion_point(destructor:icing.lib.PropertyConfigProto.DataType)
3417 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
3418 (void)arena;
3419 return;
3420 }
3421 SharedDtor();
3422 }
3423
SharedDtor()3424 inline void PropertyConfigProto_DataType::SharedDtor() {
3425 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
3426 }
3427
SetCachedSize(int size) const3428 void PropertyConfigProto_DataType::SetCachedSize(int size) const {
3429 _impl_._cached_size_.Set(size);
3430 }
3431
Clear()3432 void PropertyConfigProto_DataType::Clear() {
3433 // @@protoc_insertion_point(message_clear_start:icing.lib.PropertyConfigProto.DataType)
3434 ::uint32_t cached_has_bits = 0;
3435 // Prevent compiler warnings about cached_has_bits being unused
3436 (void) cached_has_bits;
3437
3438 _internal_metadata_.Clear<std::string>();
3439 }
3440
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)3441 const char* PropertyConfigProto_DataType::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
3442 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
3443 while (!ctx->Done(&ptr)) {
3444 ::uint32_t tag;
3445 ptr = ::_pbi::ReadTag(ptr, &tag);
3446 if ((tag == 0) || ((tag & 7) == 4)) {
3447 CHK_(ptr);
3448 ctx->SetLastTag(tag);
3449 goto message_done;
3450 }
3451 ptr = UnknownFieldParse(
3452 tag,
3453 _internal_metadata_.mutable_unknown_fields<std::string>(),
3454 ptr, ctx);
3455 CHK_(ptr != nullptr);
3456 } // while
3457 message_done:
3458 return ptr;
3459 failure:
3460 ptr = nullptr;
3461 goto message_done;
3462 #undef CHK_
3463 }
3464
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const3465 ::uint8_t* PropertyConfigProto_DataType::_InternalSerialize(
3466 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
3467 // @@protoc_insertion_point(serialize_to_array_start:icing.lib.PropertyConfigProto.DataType)
3468 ::uint32_t cached_has_bits = 0;
3469 (void) cached_has_bits;
3470
3471 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3472 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
3473 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
3474 }
3475 // @@protoc_insertion_point(serialize_to_array_end:icing.lib.PropertyConfigProto.DataType)
3476 return target;
3477 }
3478
ByteSizeLong() const3479 size_t PropertyConfigProto_DataType::ByteSizeLong() const {
3480 // @@protoc_insertion_point(message_byte_size_start:icing.lib.PropertyConfigProto.DataType)
3481 size_t total_size = 0;
3482
3483 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3484 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3485 }
3486 int cached_size = ::_pbi::ToCachedSize(total_size);
3487 SetCachedSize(cached_size);
3488 return total_size;
3489 }
3490
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3491 void PropertyConfigProto_DataType::CheckTypeAndMergeFrom(
3492 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3493 MergeFrom(*::_pbi::DownCast<const PropertyConfigProto_DataType*>(
3494 &from));
3495 }
3496
MergeFrom(const PropertyConfigProto_DataType & from)3497 void PropertyConfigProto_DataType::MergeFrom(const PropertyConfigProto_DataType& from) {
3498 PropertyConfigProto_DataType* const _this = this;
3499 // @@protoc_insertion_point(class_specific_merge_from_start:icing.lib.PropertyConfigProto.DataType)
3500 GOOGLE_DCHECK_NE(&from, _this);
3501 ::uint32_t cached_has_bits = 0;
3502 (void) cached_has_bits;
3503
3504 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3505 }
3506
CopyFrom(const PropertyConfigProto_DataType & from)3507 void PropertyConfigProto_DataType::CopyFrom(const PropertyConfigProto_DataType& from) {
3508 // @@protoc_insertion_point(class_specific_copy_from_start:icing.lib.PropertyConfigProto.DataType)
3509 if (&from == this) return;
3510 Clear();
3511 MergeFrom(from);
3512 }
3513
IsInitialized() const3514 bool PropertyConfigProto_DataType::IsInitialized() const {
3515 return true;
3516 }
3517
InternalSwap(PropertyConfigProto_DataType * other)3518 void PropertyConfigProto_DataType::InternalSwap(PropertyConfigProto_DataType* other) {
3519 using std::swap;
3520 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3521 }
3522
GetTypeName() const3523 std::string PropertyConfigProto_DataType::GetTypeName() const {
3524 return "icing.lib.PropertyConfigProto.DataType";
3525 }
3526
3527
3528 // ===================================================================
3529
3530 class PropertyConfigProto_Cardinality::_Internal {
3531 public:
3532 };
3533
PropertyConfigProto_Cardinality(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)3534 PropertyConfigProto_Cardinality::PropertyConfigProto_Cardinality(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3535 bool is_message_owned)
3536 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
3537 SharedCtor(arena, is_message_owned);
3538 // @@protoc_insertion_point(arena_constructor:icing.lib.PropertyConfigProto.Cardinality)
3539 }
PropertyConfigProto_Cardinality(const PropertyConfigProto_Cardinality & from)3540 PropertyConfigProto_Cardinality::PropertyConfigProto_Cardinality(const PropertyConfigProto_Cardinality& from)
3541 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
3542 PropertyConfigProto_Cardinality* const _this = this; (void)_this;
3543 new (&_impl_) Impl_{
3544 /*decltype(_impl_._cached_size_)*/{}};
3545
3546 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3547 // @@protoc_insertion_point(copy_constructor:icing.lib.PropertyConfigProto.Cardinality)
3548 }
3549
SharedCtor(::_pb::Arena * arena,bool is_message_owned)3550 inline void PropertyConfigProto_Cardinality::SharedCtor(
3551 ::_pb::Arena* arena, bool is_message_owned) {
3552 (void)arena;
3553 (void)is_message_owned;
3554 new (&_impl_) Impl_{
3555 /*decltype(_impl_._cached_size_)*/{}
3556 };
3557 }
3558
~PropertyConfigProto_Cardinality()3559 PropertyConfigProto_Cardinality::~PropertyConfigProto_Cardinality() {
3560 // @@protoc_insertion_point(destructor:icing.lib.PropertyConfigProto.Cardinality)
3561 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
3562 (void)arena;
3563 return;
3564 }
3565 SharedDtor();
3566 }
3567
SharedDtor()3568 inline void PropertyConfigProto_Cardinality::SharedDtor() {
3569 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
3570 }
3571
SetCachedSize(int size) const3572 void PropertyConfigProto_Cardinality::SetCachedSize(int size) const {
3573 _impl_._cached_size_.Set(size);
3574 }
3575
Clear()3576 void PropertyConfigProto_Cardinality::Clear() {
3577 // @@protoc_insertion_point(message_clear_start:icing.lib.PropertyConfigProto.Cardinality)
3578 ::uint32_t cached_has_bits = 0;
3579 // Prevent compiler warnings about cached_has_bits being unused
3580 (void) cached_has_bits;
3581
3582 _internal_metadata_.Clear<std::string>();
3583 }
3584
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)3585 const char* PropertyConfigProto_Cardinality::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
3586 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
3587 while (!ctx->Done(&ptr)) {
3588 ::uint32_t tag;
3589 ptr = ::_pbi::ReadTag(ptr, &tag);
3590 if ((tag == 0) || ((tag & 7) == 4)) {
3591 CHK_(ptr);
3592 ctx->SetLastTag(tag);
3593 goto message_done;
3594 }
3595 ptr = UnknownFieldParse(
3596 tag,
3597 _internal_metadata_.mutable_unknown_fields<std::string>(),
3598 ptr, ctx);
3599 CHK_(ptr != nullptr);
3600 } // while
3601 message_done:
3602 return ptr;
3603 failure:
3604 ptr = nullptr;
3605 goto message_done;
3606 #undef CHK_
3607 }
3608
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const3609 ::uint8_t* PropertyConfigProto_Cardinality::_InternalSerialize(
3610 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
3611 // @@protoc_insertion_point(serialize_to_array_start:icing.lib.PropertyConfigProto.Cardinality)
3612 ::uint32_t cached_has_bits = 0;
3613 (void) cached_has_bits;
3614
3615 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3616 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
3617 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
3618 }
3619 // @@protoc_insertion_point(serialize_to_array_end:icing.lib.PropertyConfigProto.Cardinality)
3620 return target;
3621 }
3622
ByteSizeLong() const3623 size_t PropertyConfigProto_Cardinality::ByteSizeLong() const {
3624 // @@protoc_insertion_point(message_byte_size_start:icing.lib.PropertyConfigProto.Cardinality)
3625 size_t total_size = 0;
3626
3627 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3628 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3629 }
3630 int cached_size = ::_pbi::ToCachedSize(total_size);
3631 SetCachedSize(cached_size);
3632 return total_size;
3633 }
3634
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3635 void PropertyConfigProto_Cardinality::CheckTypeAndMergeFrom(
3636 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3637 MergeFrom(*::_pbi::DownCast<const PropertyConfigProto_Cardinality*>(
3638 &from));
3639 }
3640
MergeFrom(const PropertyConfigProto_Cardinality & from)3641 void PropertyConfigProto_Cardinality::MergeFrom(const PropertyConfigProto_Cardinality& from) {
3642 PropertyConfigProto_Cardinality* const _this = this;
3643 // @@protoc_insertion_point(class_specific_merge_from_start:icing.lib.PropertyConfigProto.Cardinality)
3644 GOOGLE_DCHECK_NE(&from, _this);
3645 ::uint32_t cached_has_bits = 0;
3646 (void) cached_has_bits;
3647
3648 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3649 }
3650
CopyFrom(const PropertyConfigProto_Cardinality & from)3651 void PropertyConfigProto_Cardinality::CopyFrom(const PropertyConfigProto_Cardinality& from) {
3652 // @@protoc_insertion_point(class_specific_copy_from_start:icing.lib.PropertyConfigProto.Cardinality)
3653 if (&from == this) return;
3654 Clear();
3655 MergeFrom(from);
3656 }
3657
IsInitialized() const3658 bool PropertyConfigProto_Cardinality::IsInitialized() const {
3659 return true;
3660 }
3661
InternalSwap(PropertyConfigProto_Cardinality * other)3662 void PropertyConfigProto_Cardinality::InternalSwap(PropertyConfigProto_Cardinality* other) {
3663 using std::swap;
3664 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3665 }
3666
GetTypeName() const3667 std::string PropertyConfigProto_Cardinality::GetTypeName() const {
3668 return "icing.lib.PropertyConfigProto.Cardinality";
3669 }
3670
3671
3672 // ===================================================================
3673
3674 class PropertyConfigProto_ScorableType::_Internal {
3675 public:
3676 };
3677
PropertyConfigProto_ScorableType(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)3678 PropertyConfigProto_ScorableType::PropertyConfigProto_ScorableType(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3679 bool is_message_owned)
3680 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
3681 SharedCtor(arena, is_message_owned);
3682 // @@protoc_insertion_point(arena_constructor:icing.lib.PropertyConfigProto.ScorableType)
3683 }
PropertyConfigProto_ScorableType(const PropertyConfigProto_ScorableType & from)3684 PropertyConfigProto_ScorableType::PropertyConfigProto_ScorableType(const PropertyConfigProto_ScorableType& from)
3685 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
3686 PropertyConfigProto_ScorableType* const _this = this; (void)_this;
3687 new (&_impl_) Impl_{
3688 /*decltype(_impl_._cached_size_)*/{}};
3689
3690 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3691 // @@protoc_insertion_point(copy_constructor:icing.lib.PropertyConfigProto.ScorableType)
3692 }
3693
SharedCtor(::_pb::Arena * arena,bool is_message_owned)3694 inline void PropertyConfigProto_ScorableType::SharedCtor(
3695 ::_pb::Arena* arena, bool is_message_owned) {
3696 (void)arena;
3697 (void)is_message_owned;
3698 new (&_impl_) Impl_{
3699 /*decltype(_impl_._cached_size_)*/{}
3700 };
3701 }
3702
~PropertyConfigProto_ScorableType()3703 PropertyConfigProto_ScorableType::~PropertyConfigProto_ScorableType() {
3704 // @@protoc_insertion_point(destructor:icing.lib.PropertyConfigProto.ScorableType)
3705 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
3706 (void)arena;
3707 return;
3708 }
3709 SharedDtor();
3710 }
3711
SharedDtor()3712 inline void PropertyConfigProto_ScorableType::SharedDtor() {
3713 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
3714 }
3715
SetCachedSize(int size) const3716 void PropertyConfigProto_ScorableType::SetCachedSize(int size) const {
3717 _impl_._cached_size_.Set(size);
3718 }
3719
Clear()3720 void PropertyConfigProto_ScorableType::Clear() {
3721 // @@protoc_insertion_point(message_clear_start:icing.lib.PropertyConfigProto.ScorableType)
3722 ::uint32_t cached_has_bits = 0;
3723 // Prevent compiler warnings about cached_has_bits being unused
3724 (void) cached_has_bits;
3725
3726 _internal_metadata_.Clear<std::string>();
3727 }
3728
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)3729 const char* PropertyConfigProto_ScorableType::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
3730 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
3731 while (!ctx->Done(&ptr)) {
3732 ::uint32_t tag;
3733 ptr = ::_pbi::ReadTag(ptr, &tag);
3734 if ((tag == 0) || ((tag & 7) == 4)) {
3735 CHK_(ptr);
3736 ctx->SetLastTag(tag);
3737 goto message_done;
3738 }
3739 ptr = UnknownFieldParse(
3740 tag,
3741 _internal_metadata_.mutable_unknown_fields<std::string>(),
3742 ptr, ctx);
3743 CHK_(ptr != nullptr);
3744 } // while
3745 message_done:
3746 return ptr;
3747 failure:
3748 ptr = nullptr;
3749 goto message_done;
3750 #undef CHK_
3751 }
3752
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const3753 ::uint8_t* PropertyConfigProto_ScorableType::_InternalSerialize(
3754 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
3755 // @@protoc_insertion_point(serialize_to_array_start:icing.lib.PropertyConfigProto.ScorableType)
3756 ::uint32_t cached_has_bits = 0;
3757 (void) cached_has_bits;
3758
3759 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3760 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
3761 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
3762 }
3763 // @@protoc_insertion_point(serialize_to_array_end:icing.lib.PropertyConfigProto.ScorableType)
3764 return target;
3765 }
3766
ByteSizeLong() const3767 size_t PropertyConfigProto_ScorableType::ByteSizeLong() const {
3768 // @@protoc_insertion_point(message_byte_size_start:icing.lib.PropertyConfigProto.ScorableType)
3769 size_t total_size = 0;
3770
3771 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3772 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3773 }
3774 int cached_size = ::_pbi::ToCachedSize(total_size);
3775 SetCachedSize(cached_size);
3776 return total_size;
3777 }
3778
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3779 void PropertyConfigProto_ScorableType::CheckTypeAndMergeFrom(
3780 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3781 MergeFrom(*::_pbi::DownCast<const PropertyConfigProto_ScorableType*>(
3782 &from));
3783 }
3784
MergeFrom(const PropertyConfigProto_ScorableType & from)3785 void PropertyConfigProto_ScorableType::MergeFrom(const PropertyConfigProto_ScorableType& from) {
3786 PropertyConfigProto_ScorableType* const _this = this;
3787 // @@protoc_insertion_point(class_specific_merge_from_start:icing.lib.PropertyConfigProto.ScorableType)
3788 GOOGLE_DCHECK_NE(&from, _this);
3789 ::uint32_t cached_has_bits = 0;
3790 (void) cached_has_bits;
3791
3792 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3793 }
3794
CopyFrom(const PropertyConfigProto_ScorableType & from)3795 void PropertyConfigProto_ScorableType::CopyFrom(const PropertyConfigProto_ScorableType& from) {
3796 // @@protoc_insertion_point(class_specific_copy_from_start:icing.lib.PropertyConfigProto.ScorableType)
3797 if (&from == this) return;
3798 Clear();
3799 MergeFrom(from);
3800 }
3801
IsInitialized() const3802 bool PropertyConfigProto_ScorableType::IsInitialized() const {
3803 return true;
3804 }
3805
InternalSwap(PropertyConfigProto_ScorableType * other)3806 void PropertyConfigProto_ScorableType::InternalSwap(PropertyConfigProto_ScorableType* other) {
3807 using std::swap;
3808 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3809 }
3810
GetTypeName() const3811 std::string PropertyConfigProto_ScorableType::GetTypeName() const {
3812 return "icing.lib.PropertyConfigProto.ScorableType";
3813 }
3814
3815
3816 // ===================================================================
3817
3818 class PropertyConfigProto::_Internal {
3819 public:
3820 using HasBits = decltype(std::declval<PropertyConfigProto>()._impl_._has_bits_);
set_has_property_name(HasBits * has_bits)3821 static void set_has_property_name(HasBits* has_bits) {
3822 (*has_bits)[0] |= 1u;
3823 }
set_has_description(HasBits * has_bits)3824 static void set_has_description(HasBits* has_bits) {
3825 (*has_bits)[0] |= 4u;
3826 }
set_has_data_type(HasBits * has_bits)3827 static void set_has_data_type(HasBits* has_bits) {
3828 (*has_bits)[0] |= 256u;
3829 }
set_has_schema_type(HasBits * has_bits)3830 static void set_has_schema_type(HasBits* has_bits) {
3831 (*has_bits)[0] |= 2u;
3832 }
set_has_cardinality(HasBits * has_bits)3833 static void set_has_cardinality(HasBits* has_bits) {
3834 (*has_bits)[0] |= 512u;
3835 }
3836 static const ::icing::lib::StringIndexingConfig& string_indexing_config(const PropertyConfigProto* msg);
set_has_string_indexing_config(HasBits * has_bits)3837 static void set_has_string_indexing_config(HasBits* has_bits) {
3838 (*has_bits)[0] |= 8u;
3839 }
3840 static const ::icing::lib::DocumentIndexingConfig& document_indexing_config(const PropertyConfigProto* msg);
set_has_document_indexing_config(HasBits * has_bits)3841 static void set_has_document_indexing_config(HasBits* has_bits) {
3842 (*has_bits)[0] |= 16u;
3843 }
3844 static const ::icing::lib::IntegerIndexingConfig& integer_indexing_config(const PropertyConfigProto* msg);
set_has_integer_indexing_config(HasBits * has_bits)3845 static void set_has_integer_indexing_config(HasBits* has_bits) {
3846 (*has_bits)[0] |= 32u;
3847 }
3848 static const ::icing::lib::JoinableConfig& joinable_config(const PropertyConfigProto* msg);
set_has_joinable_config(HasBits * has_bits)3849 static void set_has_joinable_config(HasBits* has_bits) {
3850 (*has_bits)[0] |= 64u;
3851 }
3852 static const ::icing::lib::EmbeddingIndexingConfig& embedding_indexing_config(const PropertyConfigProto* msg);
set_has_embedding_indexing_config(HasBits * has_bits)3853 static void set_has_embedding_indexing_config(HasBits* has_bits) {
3854 (*has_bits)[0] |= 128u;
3855 }
set_has_scorable_type(HasBits * has_bits)3856 static void set_has_scorable_type(HasBits* has_bits) {
3857 (*has_bits)[0] |= 1024u;
3858 }
3859 };
3860
3861 const ::icing::lib::StringIndexingConfig&
string_indexing_config(const PropertyConfigProto * msg)3862 PropertyConfigProto::_Internal::string_indexing_config(const PropertyConfigProto* msg) {
3863 return *msg->_impl_.string_indexing_config_;
3864 }
3865 const ::icing::lib::DocumentIndexingConfig&
document_indexing_config(const PropertyConfigProto * msg)3866 PropertyConfigProto::_Internal::document_indexing_config(const PropertyConfigProto* msg) {
3867 return *msg->_impl_.document_indexing_config_;
3868 }
3869 const ::icing::lib::IntegerIndexingConfig&
integer_indexing_config(const PropertyConfigProto * msg)3870 PropertyConfigProto::_Internal::integer_indexing_config(const PropertyConfigProto* msg) {
3871 return *msg->_impl_.integer_indexing_config_;
3872 }
3873 const ::icing::lib::JoinableConfig&
joinable_config(const PropertyConfigProto * msg)3874 PropertyConfigProto::_Internal::joinable_config(const PropertyConfigProto* msg) {
3875 return *msg->_impl_.joinable_config_;
3876 }
3877 const ::icing::lib::EmbeddingIndexingConfig&
embedding_indexing_config(const PropertyConfigProto * msg)3878 PropertyConfigProto::_Internal::embedding_indexing_config(const PropertyConfigProto* msg) {
3879 return *msg->_impl_.embedding_indexing_config_;
3880 }
PropertyConfigProto(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)3881 PropertyConfigProto::PropertyConfigProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3882 bool is_message_owned)
3883 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
3884 SharedCtor(arena, is_message_owned);
3885 // @@protoc_insertion_point(arena_constructor:icing.lib.PropertyConfigProto)
3886 }
PropertyConfigProto(const PropertyConfigProto & from)3887 PropertyConfigProto::PropertyConfigProto(const PropertyConfigProto& from)
3888 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
3889 PropertyConfigProto* const _this = this; (void)_this;
3890 new (&_impl_) Impl_{
3891 decltype(_impl_._has_bits_){from._impl_._has_bits_}
3892 , /*decltype(_impl_._cached_size_)*/{}
3893 , decltype(_impl_.property_name_){}
3894 , decltype(_impl_.schema_type_){}
3895 , decltype(_impl_.description_){}
3896 , decltype(_impl_.string_indexing_config_){nullptr}
3897 , decltype(_impl_.document_indexing_config_){nullptr}
3898 , decltype(_impl_.integer_indexing_config_){nullptr}
3899 , decltype(_impl_.joinable_config_){nullptr}
3900 , decltype(_impl_.embedding_indexing_config_){nullptr}
3901 , decltype(_impl_.data_type_){}
3902 , decltype(_impl_.cardinality_){}
3903 , decltype(_impl_.scorable_type_){}};
3904
3905 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3906 _impl_.property_name_.InitDefault();
3907 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3908 _impl_.property_name_.Set("", GetArenaForAllocation());
3909 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3910 if (from._internal_has_property_name()) {
3911 _this->_impl_.property_name_.Set(from._internal_property_name(),
3912 _this->GetArenaForAllocation());
3913 }
3914 _impl_.schema_type_.InitDefault();
3915 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3916 _impl_.schema_type_.Set("", GetArenaForAllocation());
3917 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3918 if (from._internal_has_schema_type()) {
3919 _this->_impl_.schema_type_.Set(from._internal_schema_type(),
3920 _this->GetArenaForAllocation());
3921 }
3922 _impl_.description_.InitDefault();
3923 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3924 _impl_.description_.Set("", GetArenaForAllocation());
3925 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3926 if (from._internal_has_description()) {
3927 _this->_impl_.description_.Set(from._internal_description(),
3928 _this->GetArenaForAllocation());
3929 }
3930 if (from._internal_has_string_indexing_config()) {
3931 _this->_impl_.string_indexing_config_ = new ::icing::lib::StringIndexingConfig(*from._impl_.string_indexing_config_);
3932 }
3933 if (from._internal_has_document_indexing_config()) {
3934 _this->_impl_.document_indexing_config_ = new ::icing::lib::DocumentIndexingConfig(*from._impl_.document_indexing_config_);
3935 }
3936 if (from._internal_has_integer_indexing_config()) {
3937 _this->_impl_.integer_indexing_config_ = new ::icing::lib::IntegerIndexingConfig(*from._impl_.integer_indexing_config_);
3938 }
3939 if (from._internal_has_joinable_config()) {
3940 _this->_impl_.joinable_config_ = new ::icing::lib::JoinableConfig(*from._impl_.joinable_config_);
3941 }
3942 if (from._internal_has_embedding_indexing_config()) {
3943 _this->_impl_.embedding_indexing_config_ = new ::icing::lib::EmbeddingIndexingConfig(*from._impl_.embedding_indexing_config_);
3944 }
3945 ::memcpy(&_impl_.data_type_, &from._impl_.data_type_,
3946 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.scorable_type_) -
3947 reinterpret_cast<char*>(&_impl_.data_type_)) + sizeof(_impl_.scorable_type_));
3948 // @@protoc_insertion_point(copy_constructor:icing.lib.PropertyConfigProto)
3949 }
3950
SharedCtor(::_pb::Arena * arena,bool is_message_owned)3951 inline void PropertyConfigProto::SharedCtor(
3952 ::_pb::Arena* arena, bool is_message_owned) {
3953 (void)arena;
3954 (void)is_message_owned;
3955 new (&_impl_) Impl_{
3956 decltype(_impl_._has_bits_){}
3957 , /*decltype(_impl_._cached_size_)*/{}
3958 , decltype(_impl_.property_name_){}
3959 , decltype(_impl_.schema_type_){}
3960 , decltype(_impl_.description_){}
3961 , decltype(_impl_.string_indexing_config_){nullptr}
3962 , decltype(_impl_.document_indexing_config_){nullptr}
3963 , decltype(_impl_.integer_indexing_config_){nullptr}
3964 , decltype(_impl_.joinable_config_){nullptr}
3965 , decltype(_impl_.embedding_indexing_config_){nullptr}
3966 , decltype(_impl_.data_type_){0}
3967 , decltype(_impl_.cardinality_){0}
3968 , decltype(_impl_.scorable_type_){0}
3969 };
3970 _impl_.property_name_.InitDefault();
3971 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3972 _impl_.property_name_.Set("", GetArenaForAllocation());
3973 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3974 _impl_.schema_type_.InitDefault();
3975 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3976 _impl_.schema_type_.Set("", GetArenaForAllocation());
3977 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3978 _impl_.description_.InitDefault();
3979 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3980 _impl_.description_.Set("", GetArenaForAllocation());
3981 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3982 }
3983
~PropertyConfigProto()3984 PropertyConfigProto::~PropertyConfigProto() {
3985 // @@protoc_insertion_point(destructor:icing.lib.PropertyConfigProto)
3986 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
3987 (void)arena;
3988 return;
3989 }
3990 SharedDtor();
3991 }
3992
SharedDtor()3993 inline void PropertyConfigProto::SharedDtor() {
3994 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
3995 _impl_.property_name_.Destroy();
3996 _impl_.schema_type_.Destroy();
3997 _impl_.description_.Destroy();
3998 if (this != internal_default_instance()) delete _impl_.string_indexing_config_;
3999 if (this != internal_default_instance()) delete _impl_.document_indexing_config_;
4000 if (this != internal_default_instance()) delete _impl_.integer_indexing_config_;
4001 if (this != internal_default_instance()) delete _impl_.joinable_config_;
4002 if (this != internal_default_instance()) delete _impl_.embedding_indexing_config_;
4003 }
4004
SetCachedSize(int size) const4005 void PropertyConfigProto::SetCachedSize(int size) const {
4006 _impl_._cached_size_.Set(size);
4007 }
4008
Clear()4009 void PropertyConfigProto::Clear() {
4010 // @@protoc_insertion_point(message_clear_start:icing.lib.PropertyConfigProto)
4011 ::uint32_t cached_has_bits = 0;
4012 // Prevent compiler warnings about cached_has_bits being unused
4013 (void) cached_has_bits;
4014
4015 cached_has_bits = _impl_._has_bits_[0];
4016 if (cached_has_bits & 0x000000ffu) {
4017 if (cached_has_bits & 0x00000001u) {
4018 _impl_.property_name_.ClearNonDefaultToEmpty();
4019 }
4020 if (cached_has_bits & 0x00000002u) {
4021 _impl_.schema_type_.ClearNonDefaultToEmpty();
4022 }
4023 if (cached_has_bits & 0x00000004u) {
4024 _impl_.description_.ClearNonDefaultToEmpty();
4025 }
4026 if (cached_has_bits & 0x00000008u) {
4027 GOOGLE_DCHECK(_impl_.string_indexing_config_ != nullptr);
4028 _impl_.string_indexing_config_->Clear();
4029 }
4030 if (cached_has_bits & 0x00000010u) {
4031 GOOGLE_DCHECK(_impl_.document_indexing_config_ != nullptr);
4032 _impl_.document_indexing_config_->Clear();
4033 }
4034 if (cached_has_bits & 0x00000020u) {
4035 GOOGLE_DCHECK(_impl_.integer_indexing_config_ != nullptr);
4036 _impl_.integer_indexing_config_->Clear();
4037 }
4038 if (cached_has_bits & 0x00000040u) {
4039 GOOGLE_DCHECK(_impl_.joinable_config_ != nullptr);
4040 _impl_.joinable_config_->Clear();
4041 }
4042 if (cached_has_bits & 0x00000080u) {
4043 GOOGLE_DCHECK(_impl_.embedding_indexing_config_ != nullptr);
4044 _impl_.embedding_indexing_config_->Clear();
4045 }
4046 }
4047 if (cached_has_bits & 0x00000700u) {
4048 ::memset(&_impl_.data_type_, 0, static_cast<size_t>(
4049 reinterpret_cast<char*>(&_impl_.scorable_type_) -
4050 reinterpret_cast<char*>(&_impl_.data_type_)) + sizeof(_impl_.scorable_type_));
4051 }
4052 _impl_._has_bits_.Clear();
4053 _internal_metadata_.Clear<std::string>();
4054 }
4055
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)4056 const char* PropertyConfigProto::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
4057 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
4058 _Internal::HasBits has_bits{};
4059 while (!ctx->Done(&ptr)) {
4060 ::uint32_t tag;
4061 ptr = ::_pbi::ReadTag(ptr, &tag);
4062 switch (tag >> 3) {
4063 // optional string property_name = 1;
4064 case 1:
4065 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
4066 auto str = _internal_mutable_property_name();
4067 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
4068 CHK_(ptr);
4069 } else {
4070 goto handle_unusual;
4071 }
4072 continue;
4073 // optional .icing.lib.PropertyConfigProto.DataType.Code data_type = 2;
4074 case 2:
4075 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
4076 ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
4077 CHK_(ptr);
4078 if (PROTOBUF_PREDICT_TRUE(::icing::lib::PropertyConfigProto_DataType_Code_IsValid(val))) {
4079 _internal_set_data_type(static_cast<::icing::lib::PropertyConfigProto_DataType_Code>(val));
4080 } else {
4081 ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
4082 }
4083 } else {
4084 goto handle_unusual;
4085 }
4086 continue;
4087 // optional string schema_type = 3;
4088 case 3:
4089 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
4090 auto str = _internal_mutable_schema_type();
4091 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
4092 CHK_(ptr);
4093 } else {
4094 goto handle_unusual;
4095 }
4096 continue;
4097 // optional .icing.lib.PropertyConfigProto.Cardinality.Code cardinality = 4;
4098 case 4:
4099 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
4100 ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
4101 CHK_(ptr);
4102 if (PROTOBUF_PREDICT_TRUE(::icing::lib::PropertyConfigProto_Cardinality_Code_IsValid(val))) {
4103 _internal_set_cardinality(static_cast<::icing::lib::PropertyConfigProto_Cardinality_Code>(val));
4104 } else {
4105 ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields());
4106 }
4107 } else {
4108 goto handle_unusual;
4109 }
4110 continue;
4111 // optional .icing.lib.StringIndexingConfig string_indexing_config = 5;
4112 case 5:
4113 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
4114 ptr = ctx->ParseMessage(_internal_mutable_string_indexing_config(), ptr);
4115 CHK_(ptr);
4116 } else {
4117 goto handle_unusual;
4118 }
4119 continue;
4120 // optional .icing.lib.DocumentIndexingConfig document_indexing_config = 6;
4121 case 6:
4122 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
4123 ptr = ctx->ParseMessage(_internal_mutable_document_indexing_config(), ptr);
4124 CHK_(ptr);
4125 } else {
4126 goto handle_unusual;
4127 }
4128 continue;
4129 // optional .icing.lib.IntegerIndexingConfig integer_indexing_config = 7;
4130 case 7:
4131 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 58)) {
4132 ptr = ctx->ParseMessage(_internal_mutable_integer_indexing_config(), ptr);
4133 CHK_(ptr);
4134 } else {
4135 goto handle_unusual;
4136 }
4137 continue;
4138 // optional .icing.lib.JoinableConfig joinable_config = 8;
4139 case 8:
4140 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 66)) {
4141 ptr = ctx->ParseMessage(_internal_mutable_joinable_config(), ptr);
4142 CHK_(ptr);
4143 } else {
4144 goto handle_unusual;
4145 }
4146 continue;
4147 // optional string description = 9;
4148 case 9:
4149 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 74)) {
4150 auto str = _internal_mutable_description();
4151 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
4152 CHK_(ptr);
4153 } else {
4154 goto handle_unusual;
4155 }
4156 continue;
4157 // optional .icing.lib.EmbeddingIndexingConfig embedding_indexing_config = 10;
4158 case 10:
4159 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 82)) {
4160 ptr = ctx->ParseMessage(_internal_mutable_embedding_indexing_config(), ptr);
4161 CHK_(ptr);
4162 } else {
4163 goto handle_unusual;
4164 }
4165 continue;
4166 // optional .icing.lib.PropertyConfigProto.ScorableType.Code scorable_type = 11;
4167 case 11:
4168 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 88)) {
4169 ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
4170 CHK_(ptr);
4171 if (PROTOBUF_PREDICT_TRUE(::icing::lib::PropertyConfigProto_ScorableType_Code_IsValid(val))) {
4172 _internal_set_scorable_type(static_cast<::icing::lib::PropertyConfigProto_ScorableType_Code>(val));
4173 } else {
4174 ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(11, val, mutable_unknown_fields());
4175 }
4176 } else {
4177 goto handle_unusual;
4178 }
4179 continue;
4180 default:
4181 goto handle_unusual;
4182 } // switch
4183 handle_unusual:
4184 if ((tag == 0) || ((tag & 7) == 4)) {
4185 CHK_(ptr);
4186 ctx->SetLastTag(tag);
4187 goto message_done;
4188 }
4189 ptr = UnknownFieldParse(
4190 tag,
4191 _internal_metadata_.mutable_unknown_fields<std::string>(),
4192 ptr, ctx);
4193 CHK_(ptr != nullptr);
4194 } // while
4195 message_done:
4196 _impl_._has_bits_.Or(has_bits);
4197 return ptr;
4198 failure:
4199 ptr = nullptr;
4200 goto message_done;
4201 #undef CHK_
4202 }
4203
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const4204 ::uint8_t* PropertyConfigProto::_InternalSerialize(
4205 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
4206 // @@protoc_insertion_point(serialize_to_array_start:icing.lib.PropertyConfigProto)
4207 ::uint32_t cached_has_bits = 0;
4208 (void) cached_has_bits;
4209
4210 cached_has_bits = _impl_._has_bits_[0];
4211 // optional string property_name = 1;
4212 if (cached_has_bits & 0x00000001u) {
4213 target = stream->WriteStringMaybeAliased(
4214 1, this->_internal_property_name(), target);
4215 }
4216
4217 // optional .icing.lib.PropertyConfigProto.DataType.Code data_type = 2;
4218 if (cached_has_bits & 0x00000100u) {
4219 target = stream->EnsureSpace(target);
4220 target = ::_pbi::WireFormatLite::WriteEnumToArray(
4221 2, this->_internal_data_type(), target);
4222 }
4223
4224 // optional string schema_type = 3;
4225 if (cached_has_bits & 0x00000002u) {
4226 target = stream->WriteStringMaybeAliased(
4227 3, this->_internal_schema_type(), target);
4228 }
4229
4230 // optional .icing.lib.PropertyConfigProto.Cardinality.Code cardinality = 4;
4231 if (cached_has_bits & 0x00000200u) {
4232 target = stream->EnsureSpace(target);
4233 target = ::_pbi::WireFormatLite::WriteEnumToArray(
4234 4, this->_internal_cardinality(), target);
4235 }
4236
4237 // optional .icing.lib.StringIndexingConfig string_indexing_config = 5;
4238 if (cached_has_bits & 0x00000008u) {
4239 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
4240 InternalWriteMessage(5, _Internal::string_indexing_config(this),
4241 _Internal::string_indexing_config(this).GetCachedSize(), target, stream);
4242 }
4243
4244 // optional .icing.lib.DocumentIndexingConfig document_indexing_config = 6;
4245 if (cached_has_bits & 0x00000010u) {
4246 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
4247 InternalWriteMessage(6, _Internal::document_indexing_config(this),
4248 _Internal::document_indexing_config(this).GetCachedSize(), target, stream);
4249 }
4250
4251 // optional .icing.lib.IntegerIndexingConfig integer_indexing_config = 7;
4252 if (cached_has_bits & 0x00000020u) {
4253 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
4254 InternalWriteMessage(7, _Internal::integer_indexing_config(this),
4255 _Internal::integer_indexing_config(this).GetCachedSize(), target, stream);
4256 }
4257
4258 // optional .icing.lib.JoinableConfig joinable_config = 8;
4259 if (cached_has_bits & 0x00000040u) {
4260 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
4261 InternalWriteMessage(8, _Internal::joinable_config(this),
4262 _Internal::joinable_config(this).GetCachedSize(), target, stream);
4263 }
4264
4265 // optional string description = 9;
4266 if (cached_has_bits & 0x00000004u) {
4267 target = stream->WriteStringMaybeAliased(
4268 9, this->_internal_description(), target);
4269 }
4270
4271 // optional .icing.lib.EmbeddingIndexingConfig embedding_indexing_config = 10;
4272 if (cached_has_bits & 0x00000080u) {
4273 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
4274 InternalWriteMessage(10, _Internal::embedding_indexing_config(this),
4275 _Internal::embedding_indexing_config(this).GetCachedSize(), target, stream);
4276 }
4277
4278 // optional .icing.lib.PropertyConfigProto.ScorableType.Code scorable_type = 11;
4279 if (cached_has_bits & 0x00000400u) {
4280 target = stream->EnsureSpace(target);
4281 target = ::_pbi::WireFormatLite::WriteEnumToArray(
4282 11, this->_internal_scorable_type(), target);
4283 }
4284
4285 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4286 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
4287 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
4288 }
4289 // @@protoc_insertion_point(serialize_to_array_end:icing.lib.PropertyConfigProto)
4290 return target;
4291 }
4292
ByteSizeLong() const4293 size_t PropertyConfigProto::ByteSizeLong() const {
4294 // @@protoc_insertion_point(message_byte_size_start:icing.lib.PropertyConfigProto)
4295 size_t total_size = 0;
4296
4297 ::uint32_t cached_has_bits = 0;
4298 // Prevent compiler warnings about cached_has_bits being unused
4299 (void) cached_has_bits;
4300
4301 cached_has_bits = _impl_._has_bits_[0];
4302 if (cached_has_bits & 0x000000ffu) {
4303 // optional string property_name = 1;
4304 if (cached_has_bits & 0x00000001u) {
4305 total_size += 1 +
4306 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
4307 this->_internal_property_name());
4308 }
4309
4310 // optional string schema_type = 3;
4311 if (cached_has_bits & 0x00000002u) {
4312 total_size += 1 +
4313 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
4314 this->_internal_schema_type());
4315 }
4316
4317 // optional string description = 9;
4318 if (cached_has_bits & 0x00000004u) {
4319 total_size += 1 +
4320 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
4321 this->_internal_description());
4322 }
4323
4324 // optional .icing.lib.StringIndexingConfig string_indexing_config = 5;
4325 if (cached_has_bits & 0x00000008u) {
4326 total_size += 1 +
4327 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
4328 *_impl_.string_indexing_config_);
4329 }
4330
4331 // optional .icing.lib.DocumentIndexingConfig document_indexing_config = 6;
4332 if (cached_has_bits & 0x00000010u) {
4333 total_size += 1 +
4334 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
4335 *_impl_.document_indexing_config_);
4336 }
4337
4338 // optional .icing.lib.IntegerIndexingConfig integer_indexing_config = 7;
4339 if (cached_has_bits & 0x00000020u) {
4340 total_size += 1 +
4341 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
4342 *_impl_.integer_indexing_config_);
4343 }
4344
4345 // optional .icing.lib.JoinableConfig joinable_config = 8;
4346 if (cached_has_bits & 0x00000040u) {
4347 total_size += 1 +
4348 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
4349 *_impl_.joinable_config_);
4350 }
4351
4352 // optional .icing.lib.EmbeddingIndexingConfig embedding_indexing_config = 10;
4353 if (cached_has_bits & 0x00000080u) {
4354 total_size += 1 +
4355 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
4356 *_impl_.embedding_indexing_config_);
4357 }
4358
4359 }
4360 if (cached_has_bits & 0x00000700u) {
4361 // optional .icing.lib.PropertyConfigProto.DataType.Code data_type = 2;
4362 if (cached_has_bits & 0x00000100u) {
4363 total_size += 1 +
4364 ::_pbi::WireFormatLite::EnumSize(this->_internal_data_type());
4365 }
4366
4367 // optional .icing.lib.PropertyConfigProto.Cardinality.Code cardinality = 4;
4368 if (cached_has_bits & 0x00000200u) {
4369 total_size += 1 +
4370 ::_pbi::WireFormatLite::EnumSize(this->_internal_cardinality());
4371 }
4372
4373 // optional .icing.lib.PropertyConfigProto.ScorableType.Code scorable_type = 11;
4374 if (cached_has_bits & 0x00000400u) {
4375 total_size += 1 +
4376 ::_pbi::WireFormatLite::EnumSize(this->_internal_scorable_type());
4377 }
4378
4379 }
4380 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4381 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
4382 }
4383 int cached_size = ::_pbi::ToCachedSize(total_size);
4384 SetCachedSize(cached_size);
4385 return total_size;
4386 }
4387
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)4388 void PropertyConfigProto::CheckTypeAndMergeFrom(
4389 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
4390 MergeFrom(*::_pbi::DownCast<const PropertyConfigProto*>(
4391 &from));
4392 }
4393
MergeFrom(const PropertyConfigProto & from)4394 void PropertyConfigProto::MergeFrom(const PropertyConfigProto& from) {
4395 PropertyConfigProto* const _this = this;
4396 // @@protoc_insertion_point(class_specific_merge_from_start:icing.lib.PropertyConfigProto)
4397 GOOGLE_DCHECK_NE(&from, _this);
4398 ::uint32_t cached_has_bits = 0;
4399 (void) cached_has_bits;
4400
4401 cached_has_bits = from._impl_._has_bits_[0];
4402 if (cached_has_bits & 0x000000ffu) {
4403 if (cached_has_bits & 0x00000001u) {
4404 _this->_internal_set_property_name(from._internal_property_name());
4405 }
4406 if (cached_has_bits & 0x00000002u) {
4407 _this->_internal_set_schema_type(from._internal_schema_type());
4408 }
4409 if (cached_has_bits & 0x00000004u) {
4410 _this->_internal_set_description(from._internal_description());
4411 }
4412 if (cached_has_bits & 0x00000008u) {
4413 _this->_internal_mutable_string_indexing_config()->::icing::lib::StringIndexingConfig::MergeFrom(
4414 from._internal_string_indexing_config());
4415 }
4416 if (cached_has_bits & 0x00000010u) {
4417 _this->_internal_mutable_document_indexing_config()->::icing::lib::DocumentIndexingConfig::MergeFrom(
4418 from._internal_document_indexing_config());
4419 }
4420 if (cached_has_bits & 0x00000020u) {
4421 _this->_internal_mutable_integer_indexing_config()->::icing::lib::IntegerIndexingConfig::MergeFrom(
4422 from._internal_integer_indexing_config());
4423 }
4424 if (cached_has_bits & 0x00000040u) {
4425 _this->_internal_mutable_joinable_config()->::icing::lib::JoinableConfig::MergeFrom(
4426 from._internal_joinable_config());
4427 }
4428 if (cached_has_bits & 0x00000080u) {
4429 _this->_internal_mutable_embedding_indexing_config()->::icing::lib::EmbeddingIndexingConfig::MergeFrom(
4430 from._internal_embedding_indexing_config());
4431 }
4432 }
4433 if (cached_has_bits & 0x00000700u) {
4434 if (cached_has_bits & 0x00000100u) {
4435 _this->_impl_.data_type_ = from._impl_.data_type_;
4436 }
4437 if (cached_has_bits & 0x00000200u) {
4438 _this->_impl_.cardinality_ = from._impl_.cardinality_;
4439 }
4440 if (cached_has_bits & 0x00000400u) {
4441 _this->_impl_.scorable_type_ = from._impl_.scorable_type_;
4442 }
4443 _this->_impl_._has_bits_[0] |= cached_has_bits;
4444 }
4445 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4446 }
4447
CopyFrom(const PropertyConfigProto & from)4448 void PropertyConfigProto::CopyFrom(const PropertyConfigProto& from) {
4449 // @@protoc_insertion_point(class_specific_copy_from_start:icing.lib.PropertyConfigProto)
4450 if (&from == this) return;
4451 Clear();
4452 MergeFrom(from);
4453 }
4454
IsInitialized() const4455 bool PropertyConfigProto::IsInitialized() const {
4456 return true;
4457 }
4458
InternalSwap(PropertyConfigProto * other)4459 void PropertyConfigProto::InternalSwap(PropertyConfigProto* other) {
4460 using std::swap;
4461 auto* lhs_arena = GetArenaForAllocation();
4462 auto* rhs_arena = other->GetArenaForAllocation();
4463 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
4464 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
4465 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
4466 &_impl_.property_name_, lhs_arena,
4467 &other->_impl_.property_name_, rhs_arena
4468 );
4469 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
4470 &_impl_.schema_type_, lhs_arena,
4471 &other->_impl_.schema_type_, rhs_arena
4472 );
4473 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
4474 &_impl_.description_, lhs_arena,
4475 &other->_impl_.description_, rhs_arena
4476 );
4477 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
4478 PROTOBUF_FIELD_OFFSET(PropertyConfigProto, _impl_.scorable_type_)
4479 + sizeof(PropertyConfigProto::_impl_.scorable_type_) // NOLINT
4480 - PROTOBUF_FIELD_OFFSET(PropertyConfigProto, _impl_.string_indexing_config_)>(
4481 reinterpret_cast<char*>(&_impl_.string_indexing_config_),
4482 reinterpret_cast<char*>(&other->_impl_.string_indexing_config_));
4483 }
4484
GetTypeName() const4485 std::string PropertyConfigProto::GetTypeName() const {
4486 return "icing.lib.PropertyConfigProto";
4487 }
4488
4489
4490 // ===================================================================
4491
4492 class SchemaProto::_Internal {
4493 public:
4494 };
4495
SchemaProto(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)4496 SchemaProto::SchemaProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
4497 bool is_message_owned)
4498 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
4499 SharedCtor(arena, is_message_owned);
4500 // @@protoc_insertion_point(arena_constructor:icing.lib.SchemaProto)
4501 }
SchemaProto(const SchemaProto & from)4502 SchemaProto::SchemaProto(const SchemaProto& from)
4503 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
4504 SchemaProto* const _this = this; (void)_this;
4505 new (&_impl_) Impl_{
4506 decltype(_impl_.types_){from._impl_.types_}
4507 , /*decltype(_impl_._cached_size_)*/{}};
4508
4509 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4510 // @@protoc_insertion_point(copy_constructor:icing.lib.SchemaProto)
4511 }
4512
SharedCtor(::_pb::Arena * arena,bool is_message_owned)4513 inline void SchemaProto::SharedCtor(
4514 ::_pb::Arena* arena, bool is_message_owned) {
4515 (void)arena;
4516 (void)is_message_owned;
4517 new (&_impl_) Impl_{
4518 decltype(_impl_.types_){arena}
4519 , /*decltype(_impl_._cached_size_)*/{}
4520 };
4521 }
4522
~SchemaProto()4523 SchemaProto::~SchemaProto() {
4524 // @@protoc_insertion_point(destructor:icing.lib.SchemaProto)
4525 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
4526 (void)arena;
4527 return;
4528 }
4529 SharedDtor();
4530 }
4531
SharedDtor()4532 inline void SchemaProto::SharedDtor() {
4533 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
4534 _impl_.types_.~RepeatedPtrField();
4535 }
4536
SetCachedSize(int size) const4537 void SchemaProto::SetCachedSize(int size) const {
4538 _impl_._cached_size_.Set(size);
4539 }
4540
Clear()4541 void SchemaProto::Clear() {
4542 // @@protoc_insertion_point(message_clear_start:icing.lib.SchemaProto)
4543 ::uint32_t cached_has_bits = 0;
4544 // Prevent compiler warnings about cached_has_bits being unused
4545 (void) cached_has_bits;
4546
4547 _impl_.types_.Clear();
4548 _internal_metadata_.Clear<std::string>();
4549 }
4550
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)4551 const char* SchemaProto::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
4552 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
4553 while (!ctx->Done(&ptr)) {
4554 ::uint32_t tag;
4555 ptr = ::_pbi::ReadTag(ptr, &tag);
4556 switch (tag >> 3) {
4557 // repeated .icing.lib.SchemaTypeConfigProto types = 1;
4558 case 1:
4559 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
4560 ptr -= 1;
4561 do {
4562 ptr += 1;
4563 ptr = ctx->ParseMessage(_internal_add_types(), ptr);
4564 CHK_(ptr);
4565 if (!ctx->DataAvailable(ptr)) break;
4566 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
4567 } else {
4568 goto handle_unusual;
4569 }
4570 continue;
4571 default:
4572 goto handle_unusual;
4573 } // switch
4574 handle_unusual:
4575 if ((tag == 0) || ((tag & 7) == 4)) {
4576 CHK_(ptr);
4577 ctx->SetLastTag(tag);
4578 goto message_done;
4579 }
4580 ptr = UnknownFieldParse(
4581 tag,
4582 _internal_metadata_.mutable_unknown_fields<std::string>(),
4583 ptr, ctx);
4584 CHK_(ptr != nullptr);
4585 } // while
4586 message_done:
4587 return ptr;
4588 failure:
4589 ptr = nullptr;
4590 goto message_done;
4591 #undef CHK_
4592 }
4593
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const4594 ::uint8_t* SchemaProto::_InternalSerialize(
4595 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
4596 // @@protoc_insertion_point(serialize_to_array_start:icing.lib.SchemaProto)
4597 ::uint32_t cached_has_bits = 0;
4598 (void) cached_has_bits;
4599
4600 // repeated .icing.lib.SchemaTypeConfigProto types = 1;
4601 for (unsigned i = 0,
4602 n = static_cast<unsigned>(this->_internal_types_size()); i < n; i++) {
4603 const auto& repfield = this->_internal_types(i);
4604 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
4605 InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
4606 }
4607
4608 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4609 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
4610 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
4611 }
4612 // @@protoc_insertion_point(serialize_to_array_end:icing.lib.SchemaProto)
4613 return target;
4614 }
4615
ByteSizeLong() const4616 size_t SchemaProto::ByteSizeLong() const {
4617 // @@protoc_insertion_point(message_byte_size_start:icing.lib.SchemaProto)
4618 size_t total_size = 0;
4619
4620 ::uint32_t cached_has_bits = 0;
4621 // Prevent compiler warnings about cached_has_bits being unused
4622 (void) cached_has_bits;
4623
4624 // repeated .icing.lib.SchemaTypeConfigProto types = 1;
4625 total_size += 1UL * this->_internal_types_size();
4626 for (const auto& msg : this->_impl_.types_) {
4627 total_size +=
4628 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
4629 }
4630
4631 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4632 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
4633 }
4634 int cached_size = ::_pbi::ToCachedSize(total_size);
4635 SetCachedSize(cached_size);
4636 return total_size;
4637 }
4638
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)4639 void SchemaProto::CheckTypeAndMergeFrom(
4640 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
4641 MergeFrom(*::_pbi::DownCast<const SchemaProto*>(
4642 &from));
4643 }
4644
MergeFrom(const SchemaProto & from)4645 void SchemaProto::MergeFrom(const SchemaProto& from) {
4646 SchemaProto* const _this = this;
4647 // @@protoc_insertion_point(class_specific_merge_from_start:icing.lib.SchemaProto)
4648 GOOGLE_DCHECK_NE(&from, _this);
4649 ::uint32_t cached_has_bits = 0;
4650 (void) cached_has_bits;
4651
4652 _this->_impl_.types_.MergeFrom(from._impl_.types_);
4653 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4654 }
4655
CopyFrom(const SchemaProto & from)4656 void SchemaProto::CopyFrom(const SchemaProto& from) {
4657 // @@protoc_insertion_point(class_specific_copy_from_start:icing.lib.SchemaProto)
4658 if (&from == this) return;
4659 Clear();
4660 MergeFrom(from);
4661 }
4662
IsInitialized() const4663 bool SchemaProto::IsInitialized() const {
4664 return true;
4665 }
4666
InternalSwap(SchemaProto * other)4667 void SchemaProto::InternalSwap(SchemaProto* other) {
4668 using std::swap;
4669 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
4670 _impl_.types_.InternalSwap(&other->_impl_.types_);
4671 }
4672
GetTypeName() const4673 std::string SchemaProto::GetTypeName() const {
4674 return "icing.lib.SchemaProto";
4675 }
4676
4677
4678 // ===================================================================
4679
4680 class SetSchemaResultProto::_Internal {
4681 public:
4682 using HasBits = decltype(std::declval<SetSchemaResultProto>()._impl_._has_bits_);
4683 static const ::icing::lib::StatusProto& status(const SetSchemaResultProto* msg);
set_has_status(HasBits * has_bits)4684 static void set_has_status(HasBits* has_bits) {
4685 (*has_bits)[0] |= 1u;
4686 }
set_has_latency_ms(HasBits * has_bits)4687 static void set_has_latency_ms(HasBits* has_bits) {
4688 (*has_bits)[0] |= 2u;
4689 }
4690 };
4691
4692 const ::icing::lib::StatusProto&
status(const SetSchemaResultProto * msg)4693 SetSchemaResultProto::_Internal::status(const SetSchemaResultProto* msg) {
4694 return *msg->_impl_.status_;
4695 }
clear_status()4696 void SetSchemaResultProto::clear_status() {
4697 if (_impl_.status_ != nullptr) _impl_.status_->Clear();
4698 _impl_._has_bits_[0] &= ~0x00000001u;
4699 }
SetSchemaResultProto(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)4700 SetSchemaResultProto::SetSchemaResultProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
4701 bool is_message_owned)
4702 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
4703 SharedCtor(arena, is_message_owned);
4704 // @@protoc_insertion_point(arena_constructor:icing.lib.SetSchemaResultProto)
4705 }
SetSchemaResultProto(const SetSchemaResultProto & from)4706 SetSchemaResultProto::SetSchemaResultProto(const SetSchemaResultProto& from)
4707 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
4708 SetSchemaResultProto* const _this = this; (void)_this;
4709 new (&_impl_) Impl_{
4710 decltype(_impl_._has_bits_){from._impl_._has_bits_}
4711 , /*decltype(_impl_._cached_size_)*/{}
4712 , decltype(_impl_.deleted_schema_types_){from._impl_.deleted_schema_types_}
4713 , decltype(_impl_.incompatible_schema_types_){from._impl_.incompatible_schema_types_}
4714 , decltype(_impl_.new_schema_types_){from._impl_.new_schema_types_}
4715 , decltype(_impl_.fully_compatible_changed_schema_types_){from._impl_.fully_compatible_changed_schema_types_}
4716 , decltype(_impl_.index_incompatible_changed_schema_types_){from._impl_.index_incompatible_changed_schema_types_}
4717 , decltype(_impl_.join_incompatible_changed_schema_types_){from._impl_.join_incompatible_changed_schema_types_}
4718 , decltype(_impl_.status_){nullptr}
4719 , decltype(_impl_.latency_ms_){}};
4720
4721 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4722 if (from._internal_has_status()) {
4723 _this->_impl_.status_ = new ::icing::lib::StatusProto(*from._impl_.status_);
4724 }
4725 _this->_impl_.latency_ms_ = from._impl_.latency_ms_;
4726 // @@protoc_insertion_point(copy_constructor:icing.lib.SetSchemaResultProto)
4727 }
4728
SharedCtor(::_pb::Arena * arena,bool is_message_owned)4729 inline void SetSchemaResultProto::SharedCtor(
4730 ::_pb::Arena* arena, bool is_message_owned) {
4731 (void)arena;
4732 (void)is_message_owned;
4733 new (&_impl_) Impl_{
4734 decltype(_impl_._has_bits_){}
4735 , /*decltype(_impl_._cached_size_)*/{}
4736 , decltype(_impl_.deleted_schema_types_){arena}
4737 , decltype(_impl_.incompatible_schema_types_){arena}
4738 , decltype(_impl_.new_schema_types_){arena}
4739 , decltype(_impl_.fully_compatible_changed_schema_types_){arena}
4740 , decltype(_impl_.index_incompatible_changed_schema_types_){arena}
4741 , decltype(_impl_.join_incompatible_changed_schema_types_){arena}
4742 , decltype(_impl_.status_){nullptr}
4743 , decltype(_impl_.latency_ms_){0}
4744 };
4745 }
4746
~SetSchemaResultProto()4747 SetSchemaResultProto::~SetSchemaResultProto() {
4748 // @@protoc_insertion_point(destructor:icing.lib.SetSchemaResultProto)
4749 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
4750 (void)arena;
4751 return;
4752 }
4753 SharedDtor();
4754 }
4755
SharedDtor()4756 inline void SetSchemaResultProto::SharedDtor() {
4757 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
4758 _impl_.deleted_schema_types_.~RepeatedPtrField();
4759 _impl_.incompatible_schema_types_.~RepeatedPtrField();
4760 _impl_.new_schema_types_.~RepeatedPtrField();
4761 _impl_.fully_compatible_changed_schema_types_.~RepeatedPtrField();
4762 _impl_.index_incompatible_changed_schema_types_.~RepeatedPtrField();
4763 _impl_.join_incompatible_changed_schema_types_.~RepeatedPtrField();
4764 if (this != internal_default_instance()) delete _impl_.status_;
4765 }
4766
SetCachedSize(int size) const4767 void SetSchemaResultProto::SetCachedSize(int size) const {
4768 _impl_._cached_size_.Set(size);
4769 }
4770
Clear()4771 void SetSchemaResultProto::Clear() {
4772 // @@protoc_insertion_point(message_clear_start:icing.lib.SetSchemaResultProto)
4773 ::uint32_t cached_has_bits = 0;
4774 // Prevent compiler warnings about cached_has_bits being unused
4775 (void) cached_has_bits;
4776
4777 _impl_.deleted_schema_types_.Clear();
4778 _impl_.incompatible_schema_types_.Clear();
4779 _impl_.new_schema_types_.Clear();
4780 _impl_.fully_compatible_changed_schema_types_.Clear();
4781 _impl_.index_incompatible_changed_schema_types_.Clear();
4782 _impl_.join_incompatible_changed_schema_types_.Clear();
4783 cached_has_bits = _impl_._has_bits_[0];
4784 if (cached_has_bits & 0x00000001u) {
4785 GOOGLE_DCHECK(_impl_.status_ != nullptr);
4786 _impl_.status_->Clear();
4787 }
4788 _impl_.latency_ms_ = 0;
4789 _impl_._has_bits_.Clear();
4790 _internal_metadata_.Clear<std::string>();
4791 }
4792
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)4793 const char* SetSchemaResultProto::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
4794 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
4795 _Internal::HasBits has_bits{};
4796 while (!ctx->Done(&ptr)) {
4797 ::uint32_t tag;
4798 ptr = ::_pbi::ReadTag(ptr, &tag);
4799 switch (tag >> 3) {
4800 // optional .icing.lib.StatusProto status = 1;
4801 case 1:
4802 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
4803 ptr = ctx->ParseMessage(_internal_mutable_status(), ptr);
4804 CHK_(ptr);
4805 } else {
4806 goto handle_unusual;
4807 }
4808 continue;
4809 // repeated string deleted_schema_types = 2;
4810 case 2:
4811 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
4812 ptr -= 1;
4813 do {
4814 ptr += 1;
4815 auto str = _internal_add_deleted_schema_types();
4816 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
4817 CHK_(ptr);
4818 if (!ctx->DataAvailable(ptr)) break;
4819 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
4820 } else {
4821 goto handle_unusual;
4822 }
4823 continue;
4824 // repeated string incompatible_schema_types = 3;
4825 case 3:
4826 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
4827 ptr -= 1;
4828 do {
4829 ptr += 1;
4830 auto str = _internal_add_incompatible_schema_types();
4831 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
4832 CHK_(ptr);
4833 if (!ctx->DataAvailable(ptr)) break;
4834 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
4835 } else {
4836 goto handle_unusual;
4837 }
4838 continue;
4839 // repeated string new_schema_types = 4;
4840 case 4:
4841 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
4842 ptr -= 1;
4843 do {
4844 ptr += 1;
4845 auto str = _internal_add_new_schema_types();
4846 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
4847 CHK_(ptr);
4848 if (!ctx->DataAvailable(ptr)) break;
4849 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
4850 } else {
4851 goto handle_unusual;
4852 }
4853 continue;
4854 // repeated string fully_compatible_changed_schema_types = 5;
4855 case 5:
4856 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
4857 ptr -= 1;
4858 do {
4859 ptr += 1;
4860 auto str = _internal_add_fully_compatible_changed_schema_types();
4861 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
4862 CHK_(ptr);
4863 if (!ctx->DataAvailable(ptr)) break;
4864 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
4865 } else {
4866 goto handle_unusual;
4867 }
4868 continue;
4869 // repeated string index_incompatible_changed_schema_types = 6;
4870 case 6:
4871 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
4872 ptr -= 1;
4873 do {
4874 ptr += 1;
4875 auto str = _internal_add_index_incompatible_changed_schema_types();
4876 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
4877 CHK_(ptr);
4878 if (!ctx->DataAvailable(ptr)) break;
4879 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr));
4880 } else {
4881 goto handle_unusual;
4882 }
4883 continue;
4884 // optional int32 latency_ms = 7;
4885 case 7:
4886 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
4887 _Internal::set_has_latency_ms(&has_bits);
4888 _impl_.latency_ms_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4889 CHK_(ptr);
4890 } else {
4891 goto handle_unusual;
4892 }
4893 continue;
4894 // repeated string join_incompatible_changed_schema_types = 8;
4895 case 8:
4896 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 66)) {
4897 ptr -= 1;
4898 do {
4899 ptr += 1;
4900 auto str = _internal_add_join_incompatible_changed_schema_types();
4901 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
4902 CHK_(ptr);
4903 if (!ctx->DataAvailable(ptr)) break;
4904 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<66>(ptr));
4905 } else {
4906 goto handle_unusual;
4907 }
4908 continue;
4909 default:
4910 goto handle_unusual;
4911 } // switch
4912 handle_unusual:
4913 if ((tag == 0) || ((tag & 7) == 4)) {
4914 CHK_(ptr);
4915 ctx->SetLastTag(tag);
4916 goto message_done;
4917 }
4918 ptr = UnknownFieldParse(
4919 tag,
4920 _internal_metadata_.mutable_unknown_fields<std::string>(),
4921 ptr, ctx);
4922 CHK_(ptr != nullptr);
4923 } // while
4924 message_done:
4925 _impl_._has_bits_.Or(has_bits);
4926 return ptr;
4927 failure:
4928 ptr = nullptr;
4929 goto message_done;
4930 #undef CHK_
4931 }
4932
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const4933 ::uint8_t* SetSchemaResultProto::_InternalSerialize(
4934 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
4935 // @@protoc_insertion_point(serialize_to_array_start:icing.lib.SetSchemaResultProto)
4936 ::uint32_t cached_has_bits = 0;
4937 (void) cached_has_bits;
4938
4939 cached_has_bits = _impl_._has_bits_[0];
4940 // optional .icing.lib.StatusProto status = 1;
4941 if (cached_has_bits & 0x00000001u) {
4942 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
4943 InternalWriteMessage(1, _Internal::status(this),
4944 _Internal::status(this).GetCachedSize(), target, stream);
4945 }
4946
4947 // repeated string deleted_schema_types = 2;
4948 for (int i = 0, n = this->_internal_deleted_schema_types_size(); i < n; i++) {
4949 const auto& s = this->_internal_deleted_schema_types(i);
4950 target = stream->WriteString(2, s, target);
4951 }
4952
4953 // repeated string incompatible_schema_types = 3;
4954 for (int i = 0, n = this->_internal_incompatible_schema_types_size(); i < n; i++) {
4955 const auto& s = this->_internal_incompatible_schema_types(i);
4956 target = stream->WriteString(3, s, target);
4957 }
4958
4959 // repeated string new_schema_types = 4;
4960 for (int i = 0, n = this->_internal_new_schema_types_size(); i < n; i++) {
4961 const auto& s = this->_internal_new_schema_types(i);
4962 target = stream->WriteString(4, s, target);
4963 }
4964
4965 // repeated string fully_compatible_changed_schema_types = 5;
4966 for (int i = 0, n = this->_internal_fully_compatible_changed_schema_types_size(); i < n; i++) {
4967 const auto& s = this->_internal_fully_compatible_changed_schema_types(i);
4968 target = stream->WriteString(5, s, target);
4969 }
4970
4971 // repeated string index_incompatible_changed_schema_types = 6;
4972 for (int i = 0, n = this->_internal_index_incompatible_changed_schema_types_size(); i < n; i++) {
4973 const auto& s = this->_internal_index_incompatible_changed_schema_types(i);
4974 target = stream->WriteString(6, s, target);
4975 }
4976
4977 // optional int32 latency_ms = 7;
4978 if (cached_has_bits & 0x00000002u) {
4979 target = stream->EnsureSpace(target);
4980 target = ::_pbi::WireFormatLite::WriteInt32ToArray(7, this->_internal_latency_ms(), target);
4981 }
4982
4983 // repeated string join_incompatible_changed_schema_types = 8;
4984 for (int i = 0, n = this->_internal_join_incompatible_changed_schema_types_size(); i < n; i++) {
4985 const auto& s = this->_internal_join_incompatible_changed_schema_types(i);
4986 target = stream->WriteString(8, s, target);
4987 }
4988
4989 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4990 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
4991 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
4992 }
4993 // @@protoc_insertion_point(serialize_to_array_end:icing.lib.SetSchemaResultProto)
4994 return target;
4995 }
4996
ByteSizeLong() const4997 size_t SetSchemaResultProto::ByteSizeLong() const {
4998 // @@protoc_insertion_point(message_byte_size_start:icing.lib.SetSchemaResultProto)
4999 size_t total_size = 0;
5000
5001 ::uint32_t cached_has_bits = 0;
5002 // Prevent compiler warnings about cached_has_bits being unused
5003 (void) cached_has_bits;
5004
5005 // repeated string deleted_schema_types = 2;
5006 total_size += 1 *
5007 ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.deleted_schema_types_.size());
5008 for (int i = 0, n = _impl_.deleted_schema_types_.size(); i < n; i++) {
5009 total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
5010 _impl_.deleted_schema_types_.Get(i));
5011 }
5012
5013 // repeated string incompatible_schema_types = 3;
5014 total_size += 1 *
5015 ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.incompatible_schema_types_.size());
5016 for (int i = 0, n = _impl_.incompatible_schema_types_.size(); i < n; i++) {
5017 total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
5018 _impl_.incompatible_schema_types_.Get(i));
5019 }
5020
5021 // repeated string new_schema_types = 4;
5022 total_size += 1 *
5023 ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.new_schema_types_.size());
5024 for (int i = 0, n = _impl_.new_schema_types_.size(); i < n; i++) {
5025 total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
5026 _impl_.new_schema_types_.Get(i));
5027 }
5028
5029 // repeated string fully_compatible_changed_schema_types = 5;
5030 total_size += 1 *
5031 ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.fully_compatible_changed_schema_types_.size());
5032 for (int i = 0, n = _impl_.fully_compatible_changed_schema_types_.size(); i < n; i++) {
5033 total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
5034 _impl_.fully_compatible_changed_schema_types_.Get(i));
5035 }
5036
5037 // repeated string index_incompatible_changed_schema_types = 6;
5038 total_size += 1 *
5039 ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.index_incompatible_changed_schema_types_.size());
5040 for (int i = 0, n = _impl_.index_incompatible_changed_schema_types_.size(); i < n; i++) {
5041 total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
5042 _impl_.index_incompatible_changed_schema_types_.Get(i));
5043 }
5044
5045 // repeated string join_incompatible_changed_schema_types = 8;
5046 total_size += 1 *
5047 ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.join_incompatible_changed_schema_types_.size());
5048 for (int i = 0, n = _impl_.join_incompatible_changed_schema_types_.size(); i < n; i++) {
5049 total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
5050 _impl_.join_incompatible_changed_schema_types_.Get(i));
5051 }
5052
5053 cached_has_bits = _impl_._has_bits_[0];
5054 if (cached_has_bits & 0x00000003u) {
5055 // optional .icing.lib.StatusProto status = 1;
5056 if (cached_has_bits & 0x00000001u) {
5057 total_size += 1 +
5058 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
5059 *_impl_.status_);
5060 }
5061
5062 // optional int32 latency_ms = 7;
5063 if (cached_has_bits & 0x00000002u) {
5064 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_latency_ms());
5065 }
5066
5067 }
5068 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
5069 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
5070 }
5071 int cached_size = ::_pbi::ToCachedSize(total_size);
5072 SetCachedSize(cached_size);
5073 return total_size;
5074 }
5075
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)5076 void SetSchemaResultProto::CheckTypeAndMergeFrom(
5077 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
5078 MergeFrom(*::_pbi::DownCast<const SetSchemaResultProto*>(
5079 &from));
5080 }
5081
MergeFrom(const SetSchemaResultProto & from)5082 void SetSchemaResultProto::MergeFrom(const SetSchemaResultProto& from) {
5083 SetSchemaResultProto* const _this = this;
5084 // @@protoc_insertion_point(class_specific_merge_from_start:icing.lib.SetSchemaResultProto)
5085 GOOGLE_DCHECK_NE(&from, _this);
5086 ::uint32_t cached_has_bits = 0;
5087 (void) cached_has_bits;
5088
5089 _this->_impl_.deleted_schema_types_.MergeFrom(from._impl_.deleted_schema_types_);
5090 _this->_impl_.incompatible_schema_types_.MergeFrom(from._impl_.incompatible_schema_types_);
5091 _this->_impl_.new_schema_types_.MergeFrom(from._impl_.new_schema_types_);
5092 _this->_impl_.fully_compatible_changed_schema_types_.MergeFrom(from._impl_.fully_compatible_changed_schema_types_);
5093 _this->_impl_.index_incompatible_changed_schema_types_.MergeFrom(from._impl_.index_incompatible_changed_schema_types_);
5094 _this->_impl_.join_incompatible_changed_schema_types_.MergeFrom(from._impl_.join_incompatible_changed_schema_types_);
5095 cached_has_bits = from._impl_._has_bits_[0];
5096 if (cached_has_bits & 0x00000003u) {
5097 if (cached_has_bits & 0x00000001u) {
5098 _this->_internal_mutable_status()->::icing::lib::StatusProto::MergeFrom(
5099 from._internal_status());
5100 }
5101 if (cached_has_bits & 0x00000002u) {
5102 _this->_impl_.latency_ms_ = from._impl_.latency_ms_;
5103 }
5104 _this->_impl_._has_bits_[0] |= cached_has_bits;
5105 }
5106 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
5107 }
5108
CopyFrom(const SetSchemaResultProto & from)5109 void SetSchemaResultProto::CopyFrom(const SetSchemaResultProto& from) {
5110 // @@protoc_insertion_point(class_specific_copy_from_start:icing.lib.SetSchemaResultProto)
5111 if (&from == this) return;
5112 Clear();
5113 MergeFrom(from);
5114 }
5115
IsInitialized() const5116 bool SetSchemaResultProto::IsInitialized() const {
5117 return true;
5118 }
5119
InternalSwap(SetSchemaResultProto * other)5120 void SetSchemaResultProto::InternalSwap(SetSchemaResultProto* other) {
5121 using std::swap;
5122 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
5123 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
5124 _impl_.deleted_schema_types_.InternalSwap(&other->_impl_.deleted_schema_types_);
5125 _impl_.incompatible_schema_types_.InternalSwap(&other->_impl_.incompatible_schema_types_);
5126 _impl_.new_schema_types_.InternalSwap(&other->_impl_.new_schema_types_);
5127 _impl_.fully_compatible_changed_schema_types_.InternalSwap(&other->_impl_.fully_compatible_changed_schema_types_);
5128 _impl_.index_incompatible_changed_schema_types_.InternalSwap(&other->_impl_.index_incompatible_changed_schema_types_);
5129 _impl_.join_incompatible_changed_schema_types_.InternalSwap(&other->_impl_.join_incompatible_changed_schema_types_);
5130 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
5131 PROTOBUF_FIELD_OFFSET(SetSchemaResultProto, _impl_.latency_ms_)
5132 + sizeof(SetSchemaResultProto::_impl_.latency_ms_) // NOLINT
5133 - PROTOBUF_FIELD_OFFSET(SetSchemaResultProto, _impl_.status_)>(
5134 reinterpret_cast<char*>(&_impl_.status_),
5135 reinterpret_cast<char*>(&other->_impl_.status_));
5136 }
5137
GetTypeName() const5138 std::string SetSchemaResultProto::GetTypeName() const {
5139 return "icing.lib.SetSchemaResultProto";
5140 }
5141
5142
5143 // ===================================================================
5144
5145 class GetSchemaResultProto::_Internal {
5146 public:
5147 using HasBits = decltype(std::declval<GetSchemaResultProto>()._impl_._has_bits_);
5148 static const ::icing::lib::StatusProto& status(const GetSchemaResultProto* msg);
set_has_status(HasBits * has_bits)5149 static void set_has_status(HasBits* has_bits) {
5150 (*has_bits)[0] |= 1u;
5151 }
5152 static const ::icing::lib::SchemaProto& schema(const GetSchemaResultProto* msg);
set_has_schema(HasBits * has_bits)5153 static void set_has_schema(HasBits* has_bits) {
5154 (*has_bits)[0] |= 2u;
5155 }
5156 };
5157
5158 const ::icing::lib::StatusProto&
status(const GetSchemaResultProto * msg)5159 GetSchemaResultProto::_Internal::status(const GetSchemaResultProto* msg) {
5160 return *msg->_impl_.status_;
5161 }
5162 const ::icing::lib::SchemaProto&
schema(const GetSchemaResultProto * msg)5163 GetSchemaResultProto::_Internal::schema(const GetSchemaResultProto* msg) {
5164 return *msg->_impl_.schema_;
5165 }
clear_status()5166 void GetSchemaResultProto::clear_status() {
5167 if (_impl_.status_ != nullptr) _impl_.status_->Clear();
5168 _impl_._has_bits_[0] &= ~0x00000001u;
5169 }
GetSchemaResultProto(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)5170 GetSchemaResultProto::GetSchemaResultProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
5171 bool is_message_owned)
5172 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
5173 SharedCtor(arena, is_message_owned);
5174 // @@protoc_insertion_point(arena_constructor:icing.lib.GetSchemaResultProto)
5175 }
GetSchemaResultProto(const GetSchemaResultProto & from)5176 GetSchemaResultProto::GetSchemaResultProto(const GetSchemaResultProto& from)
5177 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
5178 GetSchemaResultProto* const _this = this; (void)_this;
5179 new (&_impl_) Impl_{
5180 decltype(_impl_._has_bits_){from._impl_._has_bits_}
5181 , /*decltype(_impl_._cached_size_)*/{}
5182 , decltype(_impl_.status_){nullptr}
5183 , decltype(_impl_.schema_){nullptr}};
5184
5185 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
5186 if (from._internal_has_status()) {
5187 _this->_impl_.status_ = new ::icing::lib::StatusProto(*from._impl_.status_);
5188 }
5189 if (from._internal_has_schema()) {
5190 _this->_impl_.schema_ = new ::icing::lib::SchemaProto(*from._impl_.schema_);
5191 }
5192 // @@protoc_insertion_point(copy_constructor:icing.lib.GetSchemaResultProto)
5193 }
5194
SharedCtor(::_pb::Arena * arena,bool is_message_owned)5195 inline void GetSchemaResultProto::SharedCtor(
5196 ::_pb::Arena* arena, bool is_message_owned) {
5197 (void)arena;
5198 (void)is_message_owned;
5199 new (&_impl_) Impl_{
5200 decltype(_impl_._has_bits_){}
5201 , /*decltype(_impl_._cached_size_)*/{}
5202 , decltype(_impl_.status_){nullptr}
5203 , decltype(_impl_.schema_){nullptr}
5204 };
5205 }
5206
~GetSchemaResultProto()5207 GetSchemaResultProto::~GetSchemaResultProto() {
5208 // @@protoc_insertion_point(destructor:icing.lib.GetSchemaResultProto)
5209 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
5210 (void)arena;
5211 return;
5212 }
5213 SharedDtor();
5214 }
5215
SharedDtor()5216 inline void GetSchemaResultProto::SharedDtor() {
5217 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
5218 if (this != internal_default_instance()) delete _impl_.status_;
5219 if (this != internal_default_instance()) delete _impl_.schema_;
5220 }
5221
SetCachedSize(int size) const5222 void GetSchemaResultProto::SetCachedSize(int size) const {
5223 _impl_._cached_size_.Set(size);
5224 }
5225
Clear()5226 void GetSchemaResultProto::Clear() {
5227 // @@protoc_insertion_point(message_clear_start:icing.lib.GetSchemaResultProto)
5228 ::uint32_t cached_has_bits = 0;
5229 // Prevent compiler warnings about cached_has_bits being unused
5230 (void) cached_has_bits;
5231
5232 cached_has_bits = _impl_._has_bits_[0];
5233 if (cached_has_bits & 0x00000003u) {
5234 if (cached_has_bits & 0x00000001u) {
5235 GOOGLE_DCHECK(_impl_.status_ != nullptr);
5236 _impl_.status_->Clear();
5237 }
5238 if (cached_has_bits & 0x00000002u) {
5239 GOOGLE_DCHECK(_impl_.schema_ != nullptr);
5240 _impl_.schema_->Clear();
5241 }
5242 }
5243 _impl_._has_bits_.Clear();
5244 _internal_metadata_.Clear<std::string>();
5245 }
5246
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)5247 const char* GetSchemaResultProto::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
5248 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
5249 _Internal::HasBits has_bits{};
5250 while (!ctx->Done(&ptr)) {
5251 ::uint32_t tag;
5252 ptr = ::_pbi::ReadTag(ptr, &tag);
5253 switch (tag >> 3) {
5254 // optional .icing.lib.StatusProto status = 1;
5255 case 1:
5256 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
5257 ptr = ctx->ParseMessage(_internal_mutable_status(), ptr);
5258 CHK_(ptr);
5259 } else {
5260 goto handle_unusual;
5261 }
5262 continue;
5263 // optional .icing.lib.SchemaProto schema = 2;
5264 case 2:
5265 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
5266 ptr = ctx->ParseMessage(_internal_mutable_schema(), ptr);
5267 CHK_(ptr);
5268 } else {
5269 goto handle_unusual;
5270 }
5271 continue;
5272 default:
5273 goto handle_unusual;
5274 } // switch
5275 handle_unusual:
5276 if ((tag == 0) || ((tag & 7) == 4)) {
5277 CHK_(ptr);
5278 ctx->SetLastTag(tag);
5279 goto message_done;
5280 }
5281 ptr = UnknownFieldParse(
5282 tag,
5283 _internal_metadata_.mutable_unknown_fields<std::string>(),
5284 ptr, ctx);
5285 CHK_(ptr != nullptr);
5286 } // while
5287 message_done:
5288 _impl_._has_bits_.Or(has_bits);
5289 return ptr;
5290 failure:
5291 ptr = nullptr;
5292 goto message_done;
5293 #undef CHK_
5294 }
5295
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const5296 ::uint8_t* GetSchemaResultProto::_InternalSerialize(
5297 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
5298 // @@protoc_insertion_point(serialize_to_array_start:icing.lib.GetSchemaResultProto)
5299 ::uint32_t cached_has_bits = 0;
5300 (void) cached_has_bits;
5301
5302 cached_has_bits = _impl_._has_bits_[0];
5303 // optional .icing.lib.StatusProto status = 1;
5304 if (cached_has_bits & 0x00000001u) {
5305 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
5306 InternalWriteMessage(1, _Internal::status(this),
5307 _Internal::status(this).GetCachedSize(), target, stream);
5308 }
5309
5310 // optional .icing.lib.SchemaProto schema = 2;
5311 if (cached_has_bits & 0x00000002u) {
5312 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
5313 InternalWriteMessage(2, _Internal::schema(this),
5314 _Internal::schema(this).GetCachedSize(), target, stream);
5315 }
5316
5317 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
5318 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
5319 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
5320 }
5321 // @@protoc_insertion_point(serialize_to_array_end:icing.lib.GetSchemaResultProto)
5322 return target;
5323 }
5324
ByteSizeLong() const5325 size_t GetSchemaResultProto::ByteSizeLong() const {
5326 // @@protoc_insertion_point(message_byte_size_start:icing.lib.GetSchemaResultProto)
5327 size_t total_size = 0;
5328
5329 ::uint32_t cached_has_bits = 0;
5330 // Prevent compiler warnings about cached_has_bits being unused
5331 (void) cached_has_bits;
5332
5333 cached_has_bits = _impl_._has_bits_[0];
5334 if (cached_has_bits & 0x00000003u) {
5335 // optional .icing.lib.StatusProto status = 1;
5336 if (cached_has_bits & 0x00000001u) {
5337 total_size += 1 +
5338 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
5339 *_impl_.status_);
5340 }
5341
5342 // optional .icing.lib.SchemaProto schema = 2;
5343 if (cached_has_bits & 0x00000002u) {
5344 total_size += 1 +
5345 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
5346 *_impl_.schema_);
5347 }
5348
5349 }
5350 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
5351 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
5352 }
5353 int cached_size = ::_pbi::ToCachedSize(total_size);
5354 SetCachedSize(cached_size);
5355 return total_size;
5356 }
5357
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)5358 void GetSchemaResultProto::CheckTypeAndMergeFrom(
5359 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
5360 MergeFrom(*::_pbi::DownCast<const GetSchemaResultProto*>(
5361 &from));
5362 }
5363
MergeFrom(const GetSchemaResultProto & from)5364 void GetSchemaResultProto::MergeFrom(const GetSchemaResultProto& from) {
5365 GetSchemaResultProto* const _this = this;
5366 // @@protoc_insertion_point(class_specific_merge_from_start:icing.lib.GetSchemaResultProto)
5367 GOOGLE_DCHECK_NE(&from, _this);
5368 ::uint32_t cached_has_bits = 0;
5369 (void) cached_has_bits;
5370
5371 cached_has_bits = from._impl_._has_bits_[0];
5372 if (cached_has_bits & 0x00000003u) {
5373 if (cached_has_bits & 0x00000001u) {
5374 _this->_internal_mutable_status()->::icing::lib::StatusProto::MergeFrom(
5375 from._internal_status());
5376 }
5377 if (cached_has_bits & 0x00000002u) {
5378 _this->_internal_mutable_schema()->::icing::lib::SchemaProto::MergeFrom(
5379 from._internal_schema());
5380 }
5381 }
5382 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
5383 }
5384
CopyFrom(const GetSchemaResultProto & from)5385 void GetSchemaResultProto::CopyFrom(const GetSchemaResultProto& from) {
5386 // @@protoc_insertion_point(class_specific_copy_from_start:icing.lib.GetSchemaResultProto)
5387 if (&from == this) return;
5388 Clear();
5389 MergeFrom(from);
5390 }
5391
IsInitialized() const5392 bool GetSchemaResultProto::IsInitialized() const {
5393 return true;
5394 }
5395
InternalSwap(GetSchemaResultProto * other)5396 void GetSchemaResultProto::InternalSwap(GetSchemaResultProto* other) {
5397 using std::swap;
5398 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
5399 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
5400 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
5401 PROTOBUF_FIELD_OFFSET(GetSchemaResultProto, _impl_.schema_)
5402 + sizeof(GetSchemaResultProto::_impl_.schema_) // NOLINT
5403 - PROTOBUF_FIELD_OFFSET(GetSchemaResultProto, _impl_.status_)>(
5404 reinterpret_cast<char*>(&_impl_.status_),
5405 reinterpret_cast<char*>(&other->_impl_.status_));
5406 }
5407
GetTypeName() const5408 std::string GetSchemaResultProto::GetTypeName() const {
5409 return "icing.lib.GetSchemaResultProto";
5410 }
5411
5412
5413 // ===================================================================
5414
5415 class GetSchemaTypeResultProto::_Internal {
5416 public:
5417 using HasBits = decltype(std::declval<GetSchemaTypeResultProto>()._impl_._has_bits_);
5418 static const ::icing::lib::StatusProto& status(const GetSchemaTypeResultProto* msg);
set_has_status(HasBits * has_bits)5419 static void set_has_status(HasBits* has_bits) {
5420 (*has_bits)[0] |= 1u;
5421 }
5422 static const ::icing::lib::SchemaTypeConfigProto& schema_type_config(const GetSchemaTypeResultProto* msg);
set_has_schema_type_config(HasBits * has_bits)5423 static void set_has_schema_type_config(HasBits* has_bits) {
5424 (*has_bits)[0] |= 2u;
5425 }
5426 };
5427
5428 const ::icing::lib::StatusProto&
status(const GetSchemaTypeResultProto * msg)5429 GetSchemaTypeResultProto::_Internal::status(const GetSchemaTypeResultProto* msg) {
5430 return *msg->_impl_.status_;
5431 }
5432 const ::icing::lib::SchemaTypeConfigProto&
schema_type_config(const GetSchemaTypeResultProto * msg)5433 GetSchemaTypeResultProto::_Internal::schema_type_config(const GetSchemaTypeResultProto* msg) {
5434 return *msg->_impl_.schema_type_config_;
5435 }
clear_status()5436 void GetSchemaTypeResultProto::clear_status() {
5437 if (_impl_.status_ != nullptr) _impl_.status_->Clear();
5438 _impl_._has_bits_[0] &= ~0x00000001u;
5439 }
GetSchemaTypeResultProto(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)5440 GetSchemaTypeResultProto::GetSchemaTypeResultProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
5441 bool is_message_owned)
5442 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
5443 SharedCtor(arena, is_message_owned);
5444 // @@protoc_insertion_point(arena_constructor:icing.lib.GetSchemaTypeResultProto)
5445 }
GetSchemaTypeResultProto(const GetSchemaTypeResultProto & from)5446 GetSchemaTypeResultProto::GetSchemaTypeResultProto(const GetSchemaTypeResultProto& from)
5447 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
5448 GetSchemaTypeResultProto* const _this = this; (void)_this;
5449 new (&_impl_) Impl_{
5450 decltype(_impl_._has_bits_){from._impl_._has_bits_}
5451 , /*decltype(_impl_._cached_size_)*/{}
5452 , decltype(_impl_.status_){nullptr}
5453 , decltype(_impl_.schema_type_config_){nullptr}};
5454
5455 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
5456 if (from._internal_has_status()) {
5457 _this->_impl_.status_ = new ::icing::lib::StatusProto(*from._impl_.status_);
5458 }
5459 if (from._internal_has_schema_type_config()) {
5460 _this->_impl_.schema_type_config_ = new ::icing::lib::SchemaTypeConfigProto(*from._impl_.schema_type_config_);
5461 }
5462 // @@protoc_insertion_point(copy_constructor:icing.lib.GetSchemaTypeResultProto)
5463 }
5464
SharedCtor(::_pb::Arena * arena,bool is_message_owned)5465 inline void GetSchemaTypeResultProto::SharedCtor(
5466 ::_pb::Arena* arena, bool is_message_owned) {
5467 (void)arena;
5468 (void)is_message_owned;
5469 new (&_impl_) Impl_{
5470 decltype(_impl_._has_bits_){}
5471 , /*decltype(_impl_._cached_size_)*/{}
5472 , decltype(_impl_.status_){nullptr}
5473 , decltype(_impl_.schema_type_config_){nullptr}
5474 };
5475 }
5476
~GetSchemaTypeResultProto()5477 GetSchemaTypeResultProto::~GetSchemaTypeResultProto() {
5478 // @@protoc_insertion_point(destructor:icing.lib.GetSchemaTypeResultProto)
5479 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
5480 (void)arena;
5481 return;
5482 }
5483 SharedDtor();
5484 }
5485
SharedDtor()5486 inline void GetSchemaTypeResultProto::SharedDtor() {
5487 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
5488 if (this != internal_default_instance()) delete _impl_.status_;
5489 if (this != internal_default_instance()) delete _impl_.schema_type_config_;
5490 }
5491
SetCachedSize(int size) const5492 void GetSchemaTypeResultProto::SetCachedSize(int size) const {
5493 _impl_._cached_size_.Set(size);
5494 }
5495
Clear()5496 void GetSchemaTypeResultProto::Clear() {
5497 // @@protoc_insertion_point(message_clear_start:icing.lib.GetSchemaTypeResultProto)
5498 ::uint32_t cached_has_bits = 0;
5499 // Prevent compiler warnings about cached_has_bits being unused
5500 (void) cached_has_bits;
5501
5502 cached_has_bits = _impl_._has_bits_[0];
5503 if (cached_has_bits & 0x00000003u) {
5504 if (cached_has_bits & 0x00000001u) {
5505 GOOGLE_DCHECK(_impl_.status_ != nullptr);
5506 _impl_.status_->Clear();
5507 }
5508 if (cached_has_bits & 0x00000002u) {
5509 GOOGLE_DCHECK(_impl_.schema_type_config_ != nullptr);
5510 _impl_.schema_type_config_->Clear();
5511 }
5512 }
5513 _impl_._has_bits_.Clear();
5514 _internal_metadata_.Clear<std::string>();
5515 }
5516
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)5517 const char* GetSchemaTypeResultProto::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
5518 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
5519 _Internal::HasBits has_bits{};
5520 while (!ctx->Done(&ptr)) {
5521 ::uint32_t tag;
5522 ptr = ::_pbi::ReadTag(ptr, &tag);
5523 switch (tag >> 3) {
5524 // optional .icing.lib.StatusProto status = 1;
5525 case 1:
5526 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
5527 ptr = ctx->ParseMessage(_internal_mutable_status(), ptr);
5528 CHK_(ptr);
5529 } else {
5530 goto handle_unusual;
5531 }
5532 continue;
5533 // optional .icing.lib.SchemaTypeConfigProto schema_type_config = 2;
5534 case 2:
5535 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
5536 ptr = ctx->ParseMessage(_internal_mutable_schema_type_config(), ptr);
5537 CHK_(ptr);
5538 } else {
5539 goto handle_unusual;
5540 }
5541 continue;
5542 default:
5543 goto handle_unusual;
5544 } // switch
5545 handle_unusual:
5546 if ((tag == 0) || ((tag & 7) == 4)) {
5547 CHK_(ptr);
5548 ctx->SetLastTag(tag);
5549 goto message_done;
5550 }
5551 ptr = UnknownFieldParse(
5552 tag,
5553 _internal_metadata_.mutable_unknown_fields<std::string>(),
5554 ptr, ctx);
5555 CHK_(ptr != nullptr);
5556 } // while
5557 message_done:
5558 _impl_._has_bits_.Or(has_bits);
5559 return ptr;
5560 failure:
5561 ptr = nullptr;
5562 goto message_done;
5563 #undef CHK_
5564 }
5565
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const5566 ::uint8_t* GetSchemaTypeResultProto::_InternalSerialize(
5567 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
5568 // @@protoc_insertion_point(serialize_to_array_start:icing.lib.GetSchemaTypeResultProto)
5569 ::uint32_t cached_has_bits = 0;
5570 (void) cached_has_bits;
5571
5572 cached_has_bits = _impl_._has_bits_[0];
5573 // optional .icing.lib.StatusProto status = 1;
5574 if (cached_has_bits & 0x00000001u) {
5575 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
5576 InternalWriteMessage(1, _Internal::status(this),
5577 _Internal::status(this).GetCachedSize(), target, stream);
5578 }
5579
5580 // optional .icing.lib.SchemaTypeConfigProto schema_type_config = 2;
5581 if (cached_has_bits & 0x00000002u) {
5582 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
5583 InternalWriteMessage(2, _Internal::schema_type_config(this),
5584 _Internal::schema_type_config(this).GetCachedSize(), target, stream);
5585 }
5586
5587 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
5588 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
5589 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
5590 }
5591 // @@protoc_insertion_point(serialize_to_array_end:icing.lib.GetSchemaTypeResultProto)
5592 return target;
5593 }
5594
ByteSizeLong() const5595 size_t GetSchemaTypeResultProto::ByteSizeLong() const {
5596 // @@protoc_insertion_point(message_byte_size_start:icing.lib.GetSchemaTypeResultProto)
5597 size_t total_size = 0;
5598
5599 ::uint32_t cached_has_bits = 0;
5600 // Prevent compiler warnings about cached_has_bits being unused
5601 (void) cached_has_bits;
5602
5603 cached_has_bits = _impl_._has_bits_[0];
5604 if (cached_has_bits & 0x00000003u) {
5605 // optional .icing.lib.StatusProto status = 1;
5606 if (cached_has_bits & 0x00000001u) {
5607 total_size += 1 +
5608 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
5609 *_impl_.status_);
5610 }
5611
5612 // optional .icing.lib.SchemaTypeConfigProto schema_type_config = 2;
5613 if (cached_has_bits & 0x00000002u) {
5614 total_size += 1 +
5615 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
5616 *_impl_.schema_type_config_);
5617 }
5618
5619 }
5620 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
5621 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
5622 }
5623 int cached_size = ::_pbi::ToCachedSize(total_size);
5624 SetCachedSize(cached_size);
5625 return total_size;
5626 }
5627
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)5628 void GetSchemaTypeResultProto::CheckTypeAndMergeFrom(
5629 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
5630 MergeFrom(*::_pbi::DownCast<const GetSchemaTypeResultProto*>(
5631 &from));
5632 }
5633
MergeFrom(const GetSchemaTypeResultProto & from)5634 void GetSchemaTypeResultProto::MergeFrom(const GetSchemaTypeResultProto& from) {
5635 GetSchemaTypeResultProto* const _this = this;
5636 // @@protoc_insertion_point(class_specific_merge_from_start:icing.lib.GetSchemaTypeResultProto)
5637 GOOGLE_DCHECK_NE(&from, _this);
5638 ::uint32_t cached_has_bits = 0;
5639 (void) cached_has_bits;
5640
5641 cached_has_bits = from._impl_._has_bits_[0];
5642 if (cached_has_bits & 0x00000003u) {
5643 if (cached_has_bits & 0x00000001u) {
5644 _this->_internal_mutable_status()->::icing::lib::StatusProto::MergeFrom(
5645 from._internal_status());
5646 }
5647 if (cached_has_bits & 0x00000002u) {
5648 _this->_internal_mutable_schema_type_config()->::icing::lib::SchemaTypeConfigProto::MergeFrom(
5649 from._internal_schema_type_config());
5650 }
5651 }
5652 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
5653 }
5654
CopyFrom(const GetSchemaTypeResultProto & from)5655 void GetSchemaTypeResultProto::CopyFrom(const GetSchemaTypeResultProto& from) {
5656 // @@protoc_insertion_point(class_specific_copy_from_start:icing.lib.GetSchemaTypeResultProto)
5657 if (&from == this) return;
5658 Clear();
5659 MergeFrom(from);
5660 }
5661
IsInitialized() const5662 bool GetSchemaTypeResultProto::IsInitialized() const {
5663 return true;
5664 }
5665
InternalSwap(GetSchemaTypeResultProto * other)5666 void GetSchemaTypeResultProto::InternalSwap(GetSchemaTypeResultProto* other) {
5667 using std::swap;
5668 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
5669 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
5670 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
5671 PROTOBUF_FIELD_OFFSET(GetSchemaTypeResultProto, _impl_.schema_type_config_)
5672 + sizeof(GetSchemaTypeResultProto::_impl_.schema_type_config_) // NOLINT
5673 - PROTOBUF_FIELD_OFFSET(GetSchemaTypeResultProto, _impl_.status_)>(
5674 reinterpret_cast<char*>(&_impl_.status_),
5675 reinterpret_cast<char*>(&other->_impl_.status_));
5676 }
5677
GetTypeName() const5678 std::string GetSchemaTypeResultProto::GetTypeName() const {
5679 return "icing.lib.GetSchemaTypeResultProto";
5680 }
5681
5682
5683 // @@protoc_insertion_point(namespace_scope)
5684 } // namespace lib
5685 } // namespace icing
5686 PROTOBUF_NAMESPACE_OPEN
5687 template<> PROTOBUF_NOINLINE ::icing::lib::SchemaTypeConfigProto*
CreateMaybeMessage(Arena * arena)5688 Arena::CreateMaybeMessage< ::icing::lib::SchemaTypeConfigProto >(Arena* arena) {
5689 return Arena::CreateMessageInternal< ::icing::lib::SchemaTypeConfigProto >(arena);
5690 }
5691 template<> PROTOBUF_NOINLINE ::icing::lib::StringIndexingConfig_TokenizerType*
CreateMaybeMessage(Arena * arena)5692 Arena::CreateMaybeMessage< ::icing::lib::StringIndexingConfig_TokenizerType >(Arena* arena) {
5693 return Arena::CreateMessageInternal< ::icing::lib::StringIndexingConfig_TokenizerType >(arena);
5694 }
5695 template<> PROTOBUF_NOINLINE ::icing::lib::StringIndexingConfig*
CreateMaybeMessage(Arena * arena)5696 Arena::CreateMaybeMessage< ::icing::lib::StringIndexingConfig >(Arena* arena) {
5697 return Arena::CreateMessageInternal< ::icing::lib::StringIndexingConfig >(arena);
5698 }
5699 template<> PROTOBUF_NOINLINE ::icing::lib::DocumentIndexingConfig*
CreateMaybeMessage(Arena * arena)5700 Arena::CreateMaybeMessage< ::icing::lib::DocumentIndexingConfig >(Arena* arena) {
5701 return Arena::CreateMessageInternal< ::icing::lib::DocumentIndexingConfig >(arena);
5702 }
5703 template<> PROTOBUF_NOINLINE ::icing::lib::IntegerIndexingConfig_NumericMatchType*
CreateMaybeMessage(Arena * arena)5704 Arena::CreateMaybeMessage< ::icing::lib::IntegerIndexingConfig_NumericMatchType >(Arena* arena) {
5705 return Arena::CreateMessageInternal< ::icing::lib::IntegerIndexingConfig_NumericMatchType >(arena);
5706 }
5707 template<> PROTOBUF_NOINLINE ::icing::lib::IntegerIndexingConfig*
CreateMaybeMessage(Arena * arena)5708 Arena::CreateMaybeMessage< ::icing::lib::IntegerIndexingConfig >(Arena* arena) {
5709 return Arena::CreateMessageInternal< ::icing::lib::IntegerIndexingConfig >(arena);
5710 }
5711 template<> PROTOBUF_NOINLINE ::icing::lib::EmbeddingIndexingConfig_EmbeddingIndexingType*
CreateMaybeMessage(Arena * arena)5712 Arena::CreateMaybeMessage< ::icing::lib::EmbeddingIndexingConfig_EmbeddingIndexingType >(Arena* arena) {
5713 return Arena::CreateMessageInternal< ::icing::lib::EmbeddingIndexingConfig_EmbeddingIndexingType >(arena);
5714 }
5715 template<> PROTOBUF_NOINLINE ::icing::lib::EmbeddingIndexingConfig_QuantizationType*
CreateMaybeMessage(Arena * arena)5716 Arena::CreateMaybeMessage< ::icing::lib::EmbeddingIndexingConfig_QuantizationType >(Arena* arena) {
5717 return Arena::CreateMessageInternal< ::icing::lib::EmbeddingIndexingConfig_QuantizationType >(arena);
5718 }
5719 template<> PROTOBUF_NOINLINE ::icing::lib::EmbeddingIndexingConfig*
CreateMaybeMessage(Arena * arena)5720 Arena::CreateMaybeMessage< ::icing::lib::EmbeddingIndexingConfig >(Arena* arena) {
5721 return Arena::CreateMessageInternal< ::icing::lib::EmbeddingIndexingConfig >(arena);
5722 }
5723 template<> PROTOBUF_NOINLINE ::icing::lib::JoinableConfig_ValueType*
CreateMaybeMessage(Arena * arena)5724 Arena::CreateMaybeMessage< ::icing::lib::JoinableConfig_ValueType >(Arena* arena) {
5725 return Arena::CreateMessageInternal< ::icing::lib::JoinableConfig_ValueType >(arena);
5726 }
5727 template<> PROTOBUF_NOINLINE ::icing::lib::JoinableConfig_DeletePropagationType*
CreateMaybeMessage(Arena * arena)5728 Arena::CreateMaybeMessage< ::icing::lib::JoinableConfig_DeletePropagationType >(Arena* arena) {
5729 return Arena::CreateMessageInternal< ::icing::lib::JoinableConfig_DeletePropagationType >(arena);
5730 }
5731 template<> PROTOBUF_NOINLINE ::icing::lib::JoinableConfig*
CreateMaybeMessage(Arena * arena)5732 Arena::CreateMaybeMessage< ::icing::lib::JoinableConfig >(Arena* arena) {
5733 return Arena::CreateMessageInternal< ::icing::lib::JoinableConfig >(arena);
5734 }
5735 template<> PROTOBUF_NOINLINE ::icing::lib::PropertyConfigProto_DataType*
CreateMaybeMessage(Arena * arena)5736 Arena::CreateMaybeMessage< ::icing::lib::PropertyConfigProto_DataType >(Arena* arena) {
5737 return Arena::CreateMessageInternal< ::icing::lib::PropertyConfigProto_DataType >(arena);
5738 }
5739 template<> PROTOBUF_NOINLINE ::icing::lib::PropertyConfigProto_Cardinality*
CreateMaybeMessage(Arena * arena)5740 Arena::CreateMaybeMessage< ::icing::lib::PropertyConfigProto_Cardinality >(Arena* arena) {
5741 return Arena::CreateMessageInternal< ::icing::lib::PropertyConfigProto_Cardinality >(arena);
5742 }
5743 template<> PROTOBUF_NOINLINE ::icing::lib::PropertyConfigProto_ScorableType*
CreateMaybeMessage(Arena * arena)5744 Arena::CreateMaybeMessage< ::icing::lib::PropertyConfigProto_ScorableType >(Arena* arena) {
5745 return Arena::CreateMessageInternal< ::icing::lib::PropertyConfigProto_ScorableType >(arena);
5746 }
5747 template<> PROTOBUF_NOINLINE ::icing::lib::PropertyConfigProto*
CreateMaybeMessage(Arena * arena)5748 Arena::CreateMaybeMessage< ::icing::lib::PropertyConfigProto >(Arena* arena) {
5749 return Arena::CreateMessageInternal< ::icing::lib::PropertyConfigProto >(arena);
5750 }
5751 template<> PROTOBUF_NOINLINE ::icing::lib::SchemaProto*
CreateMaybeMessage(Arena * arena)5752 Arena::CreateMaybeMessage< ::icing::lib::SchemaProto >(Arena* arena) {
5753 return Arena::CreateMessageInternal< ::icing::lib::SchemaProto >(arena);
5754 }
5755 template<> PROTOBUF_NOINLINE ::icing::lib::SetSchemaResultProto*
CreateMaybeMessage(Arena * arena)5756 Arena::CreateMaybeMessage< ::icing::lib::SetSchemaResultProto >(Arena* arena) {
5757 return Arena::CreateMessageInternal< ::icing::lib::SetSchemaResultProto >(arena);
5758 }
5759 template<> PROTOBUF_NOINLINE ::icing::lib::GetSchemaResultProto*
CreateMaybeMessage(Arena * arena)5760 Arena::CreateMaybeMessage< ::icing::lib::GetSchemaResultProto >(Arena* arena) {
5761 return Arena::CreateMessageInternal< ::icing::lib::GetSchemaResultProto >(arena);
5762 }
5763 template<> PROTOBUF_NOINLINE ::icing::lib::GetSchemaTypeResultProto*
CreateMaybeMessage(Arena * arena)5764 Arena::CreateMaybeMessage< ::icing::lib::GetSchemaTypeResultProto >(Arena* arena) {
5765 return Arena::CreateMessageInternal< ::icing::lib::GetSchemaTypeResultProto >(arena);
5766 }
5767 PROTOBUF_NAMESPACE_CLOSE
5768
5769 // @@protoc_insertion_point(global_scope)
5770 #include <google/protobuf/port_undef.inc>
5771