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