1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: icing/proto/schema.proto
3 
4 #ifndef GOOGLE_PROTOBUF_INCLUDED_icing_2fproto_2fschema_2eproto
5 #define GOOGLE_PROTOBUF_INCLUDED_icing_2fproto_2fschema_2eproto
6 
7 #include <cstdint>
8 #include <limits>
9 #include <string>
10 
11 #include <google/protobuf/port_def.inc>
12 #if PROTOBUF_VERSION < 3021000
13 #error This file was generated by a newer version of protoc which is
14 #error incompatible with your Protocol Buffer headers. Please update
15 #error your headers.
16 #endif
17 #if 3021012 < PROTOBUF_MIN_PROTOC_VERSION
18 #error This file was generated by an older version of protoc which is
19 #error incompatible with your Protocol Buffer headers. Please
20 #error regenerate this file with a newer version of protoc.
21 #endif
22 
23 #include <google/protobuf/port_undef.inc>
24 #include <google/protobuf/io/coded_stream.h>
25 #include <google/protobuf/arena.h>
26 #include <google/protobuf/arenastring.h>
27 #include <google/protobuf/generated_message_util.h>
28 #include <google/protobuf/metadata_lite.h>
29 #include <google/protobuf/message_lite.h>
30 #include <google/protobuf/repeated_field.h>  // IWYU pragma: export
31 #include <google/protobuf/extension_set.h>  // IWYU pragma: export
32 #include <google/protobuf/generated_enum_util.h>
33 #include "icing/proto/status.pb.h"
34 #include "icing/proto/term.pb.h"
35 // @@protoc_insertion_point(includes)
36 #include <google/protobuf/port_def.inc>
37 #define PROTOBUF_INTERNAL_EXPORT_icing_2fproto_2fschema_2eproto
38 PROTOBUF_NAMESPACE_OPEN
39 namespace internal {
40 class AnyMetadata;
41 }  // namespace internal
42 PROTOBUF_NAMESPACE_CLOSE
43 
44 // Internal implementation detail -- do not use these members.
45 struct TableStruct_icing_2fproto_2fschema_2eproto {
46   static const ::uint32_t offsets[];
47 };
48 namespace icing {
49 namespace lib {
50 class DocumentIndexingConfig;
51 struct DocumentIndexingConfigDefaultTypeInternal;
52 extern DocumentIndexingConfigDefaultTypeInternal _DocumentIndexingConfig_default_instance_;
53 class EmbeddingIndexingConfig;
54 struct EmbeddingIndexingConfigDefaultTypeInternal;
55 extern EmbeddingIndexingConfigDefaultTypeInternal _EmbeddingIndexingConfig_default_instance_;
56 class EmbeddingIndexingConfig_EmbeddingIndexingType;
57 struct EmbeddingIndexingConfig_EmbeddingIndexingTypeDefaultTypeInternal;
58 extern EmbeddingIndexingConfig_EmbeddingIndexingTypeDefaultTypeInternal _EmbeddingIndexingConfig_EmbeddingIndexingType_default_instance_;
59 class EmbeddingIndexingConfig_QuantizationType;
60 struct EmbeddingIndexingConfig_QuantizationTypeDefaultTypeInternal;
61 extern EmbeddingIndexingConfig_QuantizationTypeDefaultTypeInternal _EmbeddingIndexingConfig_QuantizationType_default_instance_;
62 class GetSchemaResultProto;
63 struct GetSchemaResultProtoDefaultTypeInternal;
64 extern GetSchemaResultProtoDefaultTypeInternal _GetSchemaResultProto_default_instance_;
65 class GetSchemaTypeResultProto;
66 struct GetSchemaTypeResultProtoDefaultTypeInternal;
67 extern GetSchemaTypeResultProtoDefaultTypeInternal _GetSchemaTypeResultProto_default_instance_;
68 class IntegerIndexingConfig;
69 struct IntegerIndexingConfigDefaultTypeInternal;
70 extern IntegerIndexingConfigDefaultTypeInternal _IntegerIndexingConfig_default_instance_;
71 class IntegerIndexingConfig_NumericMatchType;
72 struct IntegerIndexingConfig_NumericMatchTypeDefaultTypeInternal;
73 extern IntegerIndexingConfig_NumericMatchTypeDefaultTypeInternal _IntegerIndexingConfig_NumericMatchType_default_instance_;
74 class JoinableConfig;
75 struct JoinableConfigDefaultTypeInternal;
76 extern JoinableConfigDefaultTypeInternal _JoinableConfig_default_instance_;
77 class JoinableConfig_DeletePropagationType;
78 struct JoinableConfig_DeletePropagationTypeDefaultTypeInternal;
79 extern JoinableConfig_DeletePropagationTypeDefaultTypeInternal _JoinableConfig_DeletePropagationType_default_instance_;
80 class JoinableConfig_ValueType;
81 struct JoinableConfig_ValueTypeDefaultTypeInternal;
82 extern JoinableConfig_ValueTypeDefaultTypeInternal _JoinableConfig_ValueType_default_instance_;
83 class PropertyConfigProto;
84 struct PropertyConfigProtoDefaultTypeInternal;
85 extern PropertyConfigProtoDefaultTypeInternal _PropertyConfigProto_default_instance_;
86 class PropertyConfigProto_Cardinality;
87 struct PropertyConfigProto_CardinalityDefaultTypeInternal;
88 extern PropertyConfigProto_CardinalityDefaultTypeInternal _PropertyConfigProto_Cardinality_default_instance_;
89 class PropertyConfigProto_DataType;
90 struct PropertyConfigProto_DataTypeDefaultTypeInternal;
91 extern PropertyConfigProto_DataTypeDefaultTypeInternal _PropertyConfigProto_DataType_default_instance_;
92 class PropertyConfigProto_ScorableType;
93 struct PropertyConfigProto_ScorableTypeDefaultTypeInternal;
94 extern PropertyConfigProto_ScorableTypeDefaultTypeInternal _PropertyConfigProto_ScorableType_default_instance_;
95 class SchemaProto;
96 struct SchemaProtoDefaultTypeInternal;
97 extern SchemaProtoDefaultTypeInternal _SchemaProto_default_instance_;
98 class SchemaTypeConfigProto;
99 struct SchemaTypeConfigProtoDefaultTypeInternal;
100 extern SchemaTypeConfigProtoDefaultTypeInternal _SchemaTypeConfigProto_default_instance_;
101 class SetSchemaResultProto;
102 struct SetSchemaResultProtoDefaultTypeInternal;
103 extern SetSchemaResultProtoDefaultTypeInternal _SetSchemaResultProto_default_instance_;
104 class StringIndexingConfig;
105 struct StringIndexingConfigDefaultTypeInternal;
106 extern StringIndexingConfigDefaultTypeInternal _StringIndexingConfig_default_instance_;
107 class StringIndexingConfig_TokenizerType;
108 struct StringIndexingConfig_TokenizerTypeDefaultTypeInternal;
109 extern StringIndexingConfig_TokenizerTypeDefaultTypeInternal _StringIndexingConfig_TokenizerType_default_instance_;
110 }  // namespace lib
111 }  // namespace icing
112 PROTOBUF_NAMESPACE_OPEN
113 template<> ::icing::lib::DocumentIndexingConfig* Arena::CreateMaybeMessage<::icing::lib::DocumentIndexingConfig>(Arena*);
114 template<> ::icing::lib::EmbeddingIndexingConfig* Arena::CreateMaybeMessage<::icing::lib::EmbeddingIndexingConfig>(Arena*);
115 template<> ::icing::lib::EmbeddingIndexingConfig_EmbeddingIndexingType* Arena::CreateMaybeMessage<::icing::lib::EmbeddingIndexingConfig_EmbeddingIndexingType>(Arena*);
116 template<> ::icing::lib::EmbeddingIndexingConfig_QuantizationType* Arena::CreateMaybeMessage<::icing::lib::EmbeddingIndexingConfig_QuantizationType>(Arena*);
117 template<> ::icing::lib::GetSchemaResultProto* Arena::CreateMaybeMessage<::icing::lib::GetSchemaResultProto>(Arena*);
118 template<> ::icing::lib::GetSchemaTypeResultProto* Arena::CreateMaybeMessage<::icing::lib::GetSchemaTypeResultProto>(Arena*);
119 template<> ::icing::lib::IntegerIndexingConfig* Arena::CreateMaybeMessage<::icing::lib::IntegerIndexingConfig>(Arena*);
120 template<> ::icing::lib::IntegerIndexingConfig_NumericMatchType* Arena::CreateMaybeMessage<::icing::lib::IntegerIndexingConfig_NumericMatchType>(Arena*);
121 template<> ::icing::lib::JoinableConfig* Arena::CreateMaybeMessage<::icing::lib::JoinableConfig>(Arena*);
122 template<> ::icing::lib::JoinableConfig_DeletePropagationType* Arena::CreateMaybeMessage<::icing::lib::JoinableConfig_DeletePropagationType>(Arena*);
123 template<> ::icing::lib::JoinableConfig_ValueType* Arena::CreateMaybeMessage<::icing::lib::JoinableConfig_ValueType>(Arena*);
124 template<> ::icing::lib::PropertyConfigProto* Arena::CreateMaybeMessage<::icing::lib::PropertyConfigProto>(Arena*);
125 template<> ::icing::lib::PropertyConfigProto_Cardinality* Arena::CreateMaybeMessage<::icing::lib::PropertyConfigProto_Cardinality>(Arena*);
126 template<> ::icing::lib::PropertyConfigProto_DataType* Arena::CreateMaybeMessage<::icing::lib::PropertyConfigProto_DataType>(Arena*);
127 template<> ::icing::lib::PropertyConfigProto_ScorableType* Arena::CreateMaybeMessage<::icing::lib::PropertyConfigProto_ScorableType>(Arena*);
128 template<> ::icing::lib::SchemaProto* Arena::CreateMaybeMessage<::icing::lib::SchemaProto>(Arena*);
129 template<> ::icing::lib::SchemaTypeConfigProto* Arena::CreateMaybeMessage<::icing::lib::SchemaTypeConfigProto>(Arena*);
130 template<> ::icing::lib::SetSchemaResultProto* Arena::CreateMaybeMessage<::icing::lib::SetSchemaResultProto>(Arena*);
131 template<> ::icing::lib::StringIndexingConfig* Arena::CreateMaybeMessage<::icing::lib::StringIndexingConfig>(Arena*);
132 template<> ::icing::lib::StringIndexingConfig_TokenizerType* Arena::CreateMaybeMessage<::icing::lib::StringIndexingConfig_TokenizerType>(Arena*);
133 PROTOBUF_NAMESPACE_CLOSE
134 namespace icing {
135 namespace lib {
136 
137 enum StringIndexingConfig_TokenizerType_Code : int {
138   StringIndexingConfig_TokenizerType_Code_NONE = 0,
139   StringIndexingConfig_TokenizerType_Code_PLAIN = 1,
140   StringIndexingConfig_TokenizerType_Code_VERBATIM = 2,
141   StringIndexingConfig_TokenizerType_Code_RFC822 = 3,
142   StringIndexingConfig_TokenizerType_Code_URL = 4
143 };
144 bool StringIndexingConfig_TokenizerType_Code_IsValid(int value);
145 constexpr StringIndexingConfig_TokenizerType_Code StringIndexingConfig_TokenizerType_Code_Code_MIN = StringIndexingConfig_TokenizerType_Code_NONE;
146 constexpr StringIndexingConfig_TokenizerType_Code StringIndexingConfig_TokenizerType_Code_Code_MAX = StringIndexingConfig_TokenizerType_Code_URL;
147 constexpr int StringIndexingConfig_TokenizerType_Code_Code_ARRAYSIZE = StringIndexingConfig_TokenizerType_Code_Code_MAX + 1;
148 
149 const std::string& StringIndexingConfig_TokenizerType_Code_Name(StringIndexingConfig_TokenizerType_Code value);
150 template<typename T>
StringIndexingConfig_TokenizerType_Code_Name(T enum_t_value)151 inline const std::string& StringIndexingConfig_TokenizerType_Code_Name(T enum_t_value) {
152   static_assert(::std::is_same<T, StringIndexingConfig_TokenizerType_Code>::value ||
153     ::std::is_integral<T>::value,
154     "Incorrect type passed to function StringIndexingConfig_TokenizerType_Code_Name.");
155   return StringIndexingConfig_TokenizerType_Code_Name(static_cast<StringIndexingConfig_TokenizerType_Code>(enum_t_value));
156 }
157 bool StringIndexingConfig_TokenizerType_Code_Parse(
158     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StringIndexingConfig_TokenizerType_Code* value);
159 enum IntegerIndexingConfig_NumericMatchType_Code : int {
160   IntegerIndexingConfig_NumericMatchType_Code_UNKNOWN = 0,
161   IntegerIndexingConfig_NumericMatchType_Code_RANGE = 1
162 };
163 bool IntegerIndexingConfig_NumericMatchType_Code_IsValid(int value);
164 constexpr IntegerIndexingConfig_NumericMatchType_Code IntegerIndexingConfig_NumericMatchType_Code_Code_MIN = IntegerIndexingConfig_NumericMatchType_Code_UNKNOWN;
165 constexpr IntegerIndexingConfig_NumericMatchType_Code IntegerIndexingConfig_NumericMatchType_Code_Code_MAX = IntegerIndexingConfig_NumericMatchType_Code_RANGE;
166 constexpr int IntegerIndexingConfig_NumericMatchType_Code_Code_ARRAYSIZE = IntegerIndexingConfig_NumericMatchType_Code_Code_MAX + 1;
167 
168 const std::string& IntegerIndexingConfig_NumericMatchType_Code_Name(IntegerIndexingConfig_NumericMatchType_Code value);
169 template<typename T>
IntegerIndexingConfig_NumericMatchType_Code_Name(T enum_t_value)170 inline const std::string& IntegerIndexingConfig_NumericMatchType_Code_Name(T enum_t_value) {
171   static_assert(::std::is_same<T, IntegerIndexingConfig_NumericMatchType_Code>::value ||
172     ::std::is_integral<T>::value,
173     "Incorrect type passed to function IntegerIndexingConfig_NumericMatchType_Code_Name.");
174   return IntegerIndexingConfig_NumericMatchType_Code_Name(static_cast<IntegerIndexingConfig_NumericMatchType_Code>(enum_t_value));
175 }
176 bool IntegerIndexingConfig_NumericMatchType_Code_Parse(
177     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, IntegerIndexingConfig_NumericMatchType_Code* value);
178 enum EmbeddingIndexingConfig_EmbeddingIndexingType_Code : int {
179   EmbeddingIndexingConfig_EmbeddingIndexingType_Code_UNKNOWN = 0,
180   EmbeddingIndexingConfig_EmbeddingIndexingType_Code_LINEAR_SEARCH = 1
181 };
182 bool EmbeddingIndexingConfig_EmbeddingIndexingType_Code_IsValid(int value);
183 constexpr EmbeddingIndexingConfig_EmbeddingIndexingType_Code EmbeddingIndexingConfig_EmbeddingIndexingType_Code_Code_MIN = EmbeddingIndexingConfig_EmbeddingIndexingType_Code_UNKNOWN;
184 constexpr EmbeddingIndexingConfig_EmbeddingIndexingType_Code EmbeddingIndexingConfig_EmbeddingIndexingType_Code_Code_MAX = EmbeddingIndexingConfig_EmbeddingIndexingType_Code_LINEAR_SEARCH;
185 constexpr int EmbeddingIndexingConfig_EmbeddingIndexingType_Code_Code_ARRAYSIZE = EmbeddingIndexingConfig_EmbeddingIndexingType_Code_Code_MAX + 1;
186 
187 const std::string& EmbeddingIndexingConfig_EmbeddingIndexingType_Code_Name(EmbeddingIndexingConfig_EmbeddingIndexingType_Code value);
188 template<typename T>
EmbeddingIndexingConfig_EmbeddingIndexingType_Code_Name(T enum_t_value)189 inline const std::string& EmbeddingIndexingConfig_EmbeddingIndexingType_Code_Name(T enum_t_value) {
190   static_assert(::std::is_same<T, EmbeddingIndexingConfig_EmbeddingIndexingType_Code>::value ||
191     ::std::is_integral<T>::value,
192     "Incorrect type passed to function EmbeddingIndexingConfig_EmbeddingIndexingType_Code_Name.");
193   return EmbeddingIndexingConfig_EmbeddingIndexingType_Code_Name(static_cast<EmbeddingIndexingConfig_EmbeddingIndexingType_Code>(enum_t_value));
194 }
195 bool EmbeddingIndexingConfig_EmbeddingIndexingType_Code_Parse(
196     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, EmbeddingIndexingConfig_EmbeddingIndexingType_Code* value);
197 enum EmbeddingIndexingConfig_QuantizationType_Code : int {
198   EmbeddingIndexingConfig_QuantizationType_Code_NONE = 0,
199   EmbeddingIndexingConfig_QuantizationType_Code_QUANTIZE_8_BIT = 1
200 };
201 bool EmbeddingIndexingConfig_QuantizationType_Code_IsValid(int value);
202 constexpr EmbeddingIndexingConfig_QuantizationType_Code EmbeddingIndexingConfig_QuantizationType_Code_Code_MIN = EmbeddingIndexingConfig_QuantizationType_Code_NONE;
203 constexpr EmbeddingIndexingConfig_QuantizationType_Code EmbeddingIndexingConfig_QuantizationType_Code_Code_MAX = EmbeddingIndexingConfig_QuantizationType_Code_QUANTIZE_8_BIT;
204 constexpr int EmbeddingIndexingConfig_QuantizationType_Code_Code_ARRAYSIZE = EmbeddingIndexingConfig_QuantizationType_Code_Code_MAX + 1;
205 
206 const std::string& EmbeddingIndexingConfig_QuantizationType_Code_Name(EmbeddingIndexingConfig_QuantizationType_Code value);
207 template<typename T>
EmbeddingIndexingConfig_QuantizationType_Code_Name(T enum_t_value)208 inline const std::string& EmbeddingIndexingConfig_QuantizationType_Code_Name(T enum_t_value) {
209   static_assert(::std::is_same<T, EmbeddingIndexingConfig_QuantizationType_Code>::value ||
210     ::std::is_integral<T>::value,
211     "Incorrect type passed to function EmbeddingIndexingConfig_QuantizationType_Code_Name.");
212   return EmbeddingIndexingConfig_QuantizationType_Code_Name(static_cast<EmbeddingIndexingConfig_QuantizationType_Code>(enum_t_value));
213 }
214 bool EmbeddingIndexingConfig_QuantizationType_Code_Parse(
215     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, EmbeddingIndexingConfig_QuantizationType_Code* value);
216 enum JoinableConfig_ValueType_Code : int {
217   JoinableConfig_ValueType_Code_NONE = 0,
218   JoinableConfig_ValueType_Code_QUALIFIED_ID = 1
219 };
220 bool JoinableConfig_ValueType_Code_IsValid(int value);
221 constexpr JoinableConfig_ValueType_Code JoinableConfig_ValueType_Code_Code_MIN = JoinableConfig_ValueType_Code_NONE;
222 constexpr JoinableConfig_ValueType_Code JoinableConfig_ValueType_Code_Code_MAX = JoinableConfig_ValueType_Code_QUALIFIED_ID;
223 constexpr int JoinableConfig_ValueType_Code_Code_ARRAYSIZE = JoinableConfig_ValueType_Code_Code_MAX + 1;
224 
225 const std::string& JoinableConfig_ValueType_Code_Name(JoinableConfig_ValueType_Code value);
226 template<typename T>
JoinableConfig_ValueType_Code_Name(T enum_t_value)227 inline const std::string& JoinableConfig_ValueType_Code_Name(T enum_t_value) {
228   static_assert(::std::is_same<T, JoinableConfig_ValueType_Code>::value ||
229     ::std::is_integral<T>::value,
230     "Incorrect type passed to function JoinableConfig_ValueType_Code_Name.");
231   return JoinableConfig_ValueType_Code_Name(static_cast<JoinableConfig_ValueType_Code>(enum_t_value));
232 }
233 bool JoinableConfig_ValueType_Code_Parse(
234     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, JoinableConfig_ValueType_Code* value);
235 enum JoinableConfig_DeletePropagationType_Code : int {
236   JoinableConfig_DeletePropagationType_Code_NONE = 0,
237   JoinableConfig_DeletePropagationType_Code_PROPAGATE_FROM = 1
238 };
239 bool JoinableConfig_DeletePropagationType_Code_IsValid(int value);
240 constexpr JoinableConfig_DeletePropagationType_Code JoinableConfig_DeletePropagationType_Code_Code_MIN = JoinableConfig_DeletePropagationType_Code_NONE;
241 constexpr JoinableConfig_DeletePropagationType_Code JoinableConfig_DeletePropagationType_Code_Code_MAX = JoinableConfig_DeletePropagationType_Code_PROPAGATE_FROM;
242 constexpr int JoinableConfig_DeletePropagationType_Code_Code_ARRAYSIZE = JoinableConfig_DeletePropagationType_Code_Code_MAX + 1;
243 
244 const std::string& JoinableConfig_DeletePropagationType_Code_Name(JoinableConfig_DeletePropagationType_Code value);
245 template<typename T>
JoinableConfig_DeletePropagationType_Code_Name(T enum_t_value)246 inline const std::string& JoinableConfig_DeletePropagationType_Code_Name(T enum_t_value) {
247   static_assert(::std::is_same<T, JoinableConfig_DeletePropagationType_Code>::value ||
248     ::std::is_integral<T>::value,
249     "Incorrect type passed to function JoinableConfig_DeletePropagationType_Code_Name.");
250   return JoinableConfig_DeletePropagationType_Code_Name(static_cast<JoinableConfig_DeletePropagationType_Code>(enum_t_value));
251 }
252 bool JoinableConfig_DeletePropagationType_Code_Parse(
253     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, JoinableConfig_DeletePropagationType_Code* value);
254 enum PropertyConfigProto_DataType_Code : int {
255   PropertyConfigProto_DataType_Code_UNKNOWN = 0,
256   PropertyConfigProto_DataType_Code_STRING = 1,
257   PropertyConfigProto_DataType_Code_INT64 = 2,
258   PropertyConfigProto_DataType_Code_DOUBLE = 3,
259   PropertyConfigProto_DataType_Code_BOOLEAN = 4,
260   PropertyConfigProto_DataType_Code_BYTES = 5,
261   PropertyConfigProto_DataType_Code_DOCUMENT = 6,
262   PropertyConfigProto_DataType_Code_VECTOR = 7,
263   PropertyConfigProto_DataType_Code_BLOB_HANDLE = 8
264 };
265 bool PropertyConfigProto_DataType_Code_IsValid(int value);
266 constexpr PropertyConfigProto_DataType_Code PropertyConfigProto_DataType_Code_Code_MIN = PropertyConfigProto_DataType_Code_UNKNOWN;
267 constexpr PropertyConfigProto_DataType_Code PropertyConfigProto_DataType_Code_Code_MAX = PropertyConfigProto_DataType_Code_BLOB_HANDLE;
268 constexpr int PropertyConfigProto_DataType_Code_Code_ARRAYSIZE = PropertyConfigProto_DataType_Code_Code_MAX + 1;
269 
270 const std::string& PropertyConfigProto_DataType_Code_Name(PropertyConfigProto_DataType_Code value);
271 template<typename T>
PropertyConfigProto_DataType_Code_Name(T enum_t_value)272 inline const std::string& PropertyConfigProto_DataType_Code_Name(T enum_t_value) {
273   static_assert(::std::is_same<T, PropertyConfigProto_DataType_Code>::value ||
274     ::std::is_integral<T>::value,
275     "Incorrect type passed to function PropertyConfigProto_DataType_Code_Name.");
276   return PropertyConfigProto_DataType_Code_Name(static_cast<PropertyConfigProto_DataType_Code>(enum_t_value));
277 }
278 bool PropertyConfigProto_DataType_Code_Parse(
279     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PropertyConfigProto_DataType_Code* value);
280 enum PropertyConfigProto_Cardinality_Code : int {
281   PropertyConfigProto_Cardinality_Code_UNKNOWN = 0,
282   PropertyConfigProto_Cardinality_Code_REPEATED = 1,
283   PropertyConfigProto_Cardinality_Code_OPTIONAL = 2,
284   PropertyConfigProto_Cardinality_Code_REQUIRED = 3
285 };
286 bool PropertyConfigProto_Cardinality_Code_IsValid(int value);
287 constexpr PropertyConfigProto_Cardinality_Code PropertyConfigProto_Cardinality_Code_Code_MIN = PropertyConfigProto_Cardinality_Code_UNKNOWN;
288 constexpr PropertyConfigProto_Cardinality_Code PropertyConfigProto_Cardinality_Code_Code_MAX = PropertyConfigProto_Cardinality_Code_REQUIRED;
289 constexpr int PropertyConfigProto_Cardinality_Code_Code_ARRAYSIZE = PropertyConfigProto_Cardinality_Code_Code_MAX + 1;
290 
291 const std::string& PropertyConfigProto_Cardinality_Code_Name(PropertyConfigProto_Cardinality_Code value);
292 template<typename T>
PropertyConfigProto_Cardinality_Code_Name(T enum_t_value)293 inline const std::string& PropertyConfigProto_Cardinality_Code_Name(T enum_t_value) {
294   static_assert(::std::is_same<T, PropertyConfigProto_Cardinality_Code>::value ||
295     ::std::is_integral<T>::value,
296     "Incorrect type passed to function PropertyConfigProto_Cardinality_Code_Name.");
297   return PropertyConfigProto_Cardinality_Code_Name(static_cast<PropertyConfigProto_Cardinality_Code>(enum_t_value));
298 }
299 bool PropertyConfigProto_Cardinality_Code_Parse(
300     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PropertyConfigProto_Cardinality_Code* value);
301 enum PropertyConfigProto_ScorableType_Code : int {
302   PropertyConfigProto_ScorableType_Code_UNKNOWN = 0,
303   PropertyConfigProto_ScorableType_Code_DISABLED = 1,
304   PropertyConfigProto_ScorableType_Code_ENABLED = 2
305 };
306 bool PropertyConfigProto_ScorableType_Code_IsValid(int value);
307 constexpr PropertyConfigProto_ScorableType_Code PropertyConfigProto_ScorableType_Code_Code_MIN = PropertyConfigProto_ScorableType_Code_UNKNOWN;
308 constexpr PropertyConfigProto_ScorableType_Code PropertyConfigProto_ScorableType_Code_Code_MAX = PropertyConfigProto_ScorableType_Code_ENABLED;
309 constexpr int PropertyConfigProto_ScorableType_Code_Code_ARRAYSIZE = PropertyConfigProto_ScorableType_Code_Code_MAX + 1;
310 
311 const std::string& PropertyConfigProto_ScorableType_Code_Name(PropertyConfigProto_ScorableType_Code value);
312 template<typename T>
PropertyConfigProto_ScorableType_Code_Name(T enum_t_value)313 inline const std::string& PropertyConfigProto_ScorableType_Code_Name(T enum_t_value) {
314   static_assert(::std::is_same<T, PropertyConfigProto_ScorableType_Code>::value ||
315     ::std::is_integral<T>::value,
316     "Incorrect type passed to function PropertyConfigProto_ScorableType_Code_Name.");
317   return PropertyConfigProto_ScorableType_Code_Name(static_cast<PropertyConfigProto_ScorableType_Code>(enum_t_value));
318 }
319 bool PropertyConfigProto_ScorableType_Code_Parse(
320     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PropertyConfigProto_ScorableType_Code* value);
321 // ===================================================================
322 
323 class SchemaTypeConfigProto final :
324     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.SchemaTypeConfigProto) */ {
325  public:
SchemaTypeConfigProto()326   inline SchemaTypeConfigProto() : SchemaTypeConfigProto(nullptr) {}
327   ~SchemaTypeConfigProto() override;
328   explicit PROTOBUF_CONSTEXPR SchemaTypeConfigProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
329 
330   SchemaTypeConfigProto(const SchemaTypeConfigProto& from);
SchemaTypeConfigProto(SchemaTypeConfigProto && from)331   SchemaTypeConfigProto(SchemaTypeConfigProto&& from) noexcept
332     : SchemaTypeConfigProto() {
333     *this = ::std::move(from);
334   }
335 
336   inline SchemaTypeConfigProto& operator=(const SchemaTypeConfigProto& from) {
337     if (this == &from) return *this;
338     CopyFrom(from);
339     return *this;
340   }
341   inline SchemaTypeConfigProto& operator=(SchemaTypeConfigProto&& from) noexcept {
342     if (this == &from) return *this;
343     if (GetOwningArena() == from.GetOwningArena()
344   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
345         && GetOwningArena() != nullptr
346   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
347     ) {
348       InternalSwap(&from);
349     } else {
350       CopyFrom(from);
351     }
352     return *this;
353   }
354 
unknown_fields()355   inline const std::string& unknown_fields() const {
356     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
357   }
mutable_unknown_fields()358   inline std::string* mutable_unknown_fields() {
359     return _internal_metadata_.mutable_unknown_fields<std::string>();
360   }
361 
default_instance()362   static const SchemaTypeConfigProto& default_instance() {
363     return *internal_default_instance();
364   }
internal_default_instance()365   static inline const SchemaTypeConfigProto* internal_default_instance() {
366     return reinterpret_cast<const SchemaTypeConfigProto*>(
367                &_SchemaTypeConfigProto_default_instance_);
368   }
369   static constexpr int kIndexInFileMessages =
370     0;
371 
swap(SchemaTypeConfigProto & a,SchemaTypeConfigProto & b)372   friend void swap(SchemaTypeConfigProto& a, SchemaTypeConfigProto& b) {
373     a.Swap(&b);
374   }
Swap(SchemaTypeConfigProto * other)375   inline void Swap(SchemaTypeConfigProto* other) {
376     if (other == this) return;
377   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
378     if (GetOwningArena() != nullptr &&
379         GetOwningArena() == other->GetOwningArena()) {
380    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
381     if (GetOwningArena() == other->GetOwningArena()) {
382   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
383       InternalSwap(other);
384     } else {
385       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
386     }
387   }
388   void UnsafeArenaSwap(SchemaTypeConfigProto* other) {
389     if (other == this) return;
390     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
391     InternalSwap(other);
392   }
393 
394   // implements Message ----------------------------------------------
395 
396   SchemaTypeConfigProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
397     return CreateMaybeMessage<SchemaTypeConfigProto>(arena);
398   }
399   SchemaTypeConfigProto* New() const {
400     return New(nullptr);
401   }
402   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
403   void CopyFrom(const SchemaTypeConfigProto& from);
404   void MergeFrom(const SchemaTypeConfigProto& from);
405   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
406   bool IsInitialized() const final;
407 
408   size_t ByteSizeLong() const final;
409   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
410   ::uint8_t* _InternalSerialize(
411       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
412   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
413 
414   private:
415   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
416   void SharedDtor();
417   void SetCachedSize(int size) const;
418   void InternalSwap(SchemaTypeConfigProto* other);
419 
420   private:
421   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
422   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
423     return "icing.lib.SchemaTypeConfigProto";
424   }
425   protected:
426   explicit SchemaTypeConfigProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
427                        bool is_message_owned = false);
428   public:
429 
430   std::string GetTypeName() const final;
431 
432   // nested types ----------------------------------------------------
433 
434   // accessors -------------------------------------------------------
435 
436   enum : int {
437     kPropertiesFieldNumber = 4,
438     kParentTypesFieldNumber = 6,
439     kSchemaTypeFieldNumber = 1,
440     kDescriptionFieldNumber = 7,
441     kDatabaseFieldNumber = 8,
442     kVersionFieldNumber = 5,
443   };
444   // repeated .icing.lib.PropertyConfigProto properties = 4;
445   int properties_size() const;
446   private:
447   int _internal_properties_size() const;
448   public:
449   void clear_properties();
450   ::icing::lib::PropertyConfigProto* mutable_properties(int index);
451   ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::PropertyConfigProto >*
452       mutable_properties();
453   private:
454   const ::icing::lib::PropertyConfigProto& _internal_properties(int index) const;
455   ::icing::lib::PropertyConfigProto* _internal_add_properties();
456   public:
457   const ::icing::lib::PropertyConfigProto& properties(int index) const;
458   ::icing::lib::PropertyConfigProto* add_properties();
459   const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::PropertyConfigProto >&
460       properties() const;
461 
462   // repeated string parent_types = 6;
463   int parent_types_size() const;
464   private:
465   int _internal_parent_types_size() const;
466   public:
467   void clear_parent_types();
468   const std::string& parent_types(int index) const;
469   std::string* mutable_parent_types(int index);
470   void set_parent_types(int index, const std::string& value);
471   void set_parent_types(int index, std::string&& value);
472   void set_parent_types(int index, const char* value);
473   void set_parent_types(int index, const char* value, size_t size);
474   std::string* add_parent_types();
475   void add_parent_types(const std::string& value);
476   void add_parent_types(std::string&& value);
477   void add_parent_types(const char* value);
478   void add_parent_types(const char* value, size_t size);
479   const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& parent_types() const;
480   ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_parent_types();
481   private:
482   const std::string& _internal_parent_types(int index) const;
483   std::string* _internal_add_parent_types();
484   public:
485 
486   // optional string schema_type = 1;
487   bool has_schema_type() const;
488   private:
489   bool _internal_has_schema_type() const;
490   public:
491   void clear_schema_type();
492   const std::string& schema_type() const;
493   template <typename ArgT0 = const std::string&, typename... ArgT>
494   void set_schema_type(ArgT0&& arg0, ArgT... args);
495   std::string* mutable_schema_type();
496   PROTOBUF_NODISCARD std::string* release_schema_type();
497   void set_allocated_schema_type(std::string* schema_type);
498   private:
499   const std::string& _internal_schema_type() const;
500   inline PROTOBUF_ALWAYS_INLINE void _internal_set_schema_type(const std::string& value);
501   std::string* _internal_mutable_schema_type();
502   public:
503 
504   // optional string description = 7;
505   bool has_description() const;
506   private:
507   bool _internal_has_description() const;
508   public:
509   void clear_description();
510   const std::string& description() const;
511   template <typename ArgT0 = const std::string&, typename... ArgT>
512   void set_description(ArgT0&& arg0, ArgT... args);
513   std::string* mutable_description();
514   PROTOBUF_NODISCARD std::string* release_description();
515   void set_allocated_description(std::string* description);
516   private:
517   const std::string& _internal_description() const;
518   inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value);
519   std::string* _internal_mutable_description();
520   public:
521 
522   // optional string database = 8;
523   bool has_database() const;
524   private:
525   bool _internal_has_database() const;
526   public:
527   void clear_database();
528   const std::string& database() const;
529   template <typename ArgT0 = const std::string&, typename... ArgT>
530   void set_database(ArgT0&& arg0, ArgT... args);
531   std::string* mutable_database();
532   PROTOBUF_NODISCARD std::string* release_database();
533   void set_allocated_database(std::string* database);
534   private:
535   const std::string& _internal_database() const;
536   inline PROTOBUF_ALWAYS_INLINE void _internal_set_database(const std::string& value);
537   std::string* _internal_mutable_database();
538   public:
539 
540   // optional int32 version = 5;
541   bool has_version() const;
542   private:
543   bool _internal_has_version() const;
544   public:
545   void clear_version();
546   ::int32_t version() const;
547   void set_version(::int32_t value);
548   private:
549   ::int32_t _internal_version() const;
550   void _internal_set_version(::int32_t value);
551   public:
552 
553   // @@protoc_insertion_point(class_scope:icing.lib.SchemaTypeConfigProto)
554  private:
555   class _Internal;
556 
557   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
558   typedef void InternalArenaConstructable_;
559   typedef void DestructorSkippable_;
560   struct Impl_ {
561     ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
562     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
563     ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::PropertyConfigProto > properties_;
564     ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> parent_types_;
565     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr schema_type_;
566     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
567     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr database_;
568     ::int32_t version_;
569   };
570   union { Impl_ _impl_; };
571   friend struct ::TableStruct_icing_2fproto_2fschema_2eproto;
572 };
573 // -------------------------------------------------------------------
574 
575 class StringIndexingConfig_TokenizerType final :
576     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.StringIndexingConfig.TokenizerType) */ {
577  public:
StringIndexingConfig_TokenizerType()578   inline StringIndexingConfig_TokenizerType() : StringIndexingConfig_TokenizerType(nullptr) {}
579   ~StringIndexingConfig_TokenizerType() override;
580   explicit PROTOBUF_CONSTEXPR StringIndexingConfig_TokenizerType(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
581 
582   StringIndexingConfig_TokenizerType(const StringIndexingConfig_TokenizerType& from);
StringIndexingConfig_TokenizerType(StringIndexingConfig_TokenizerType && from)583   StringIndexingConfig_TokenizerType(StringIndexingConfig_TokenizerType&& from) noexcept
584     : StringIndexingConfig_TokenizerType() {
585     *this = ::std::move(from);
586   }
587 
588   inline StringIndexingConfig_TokenizerType& operator=(const StringIndexingConfig_TokenizerType& from) {
589     if (this == &from) return *this;
590     CopyFrom(from);
591     return *this;
592   }
593   inline StringIndexingConfig_TokenizerType& operator=(StringIndexingConfig_TokenizerType&& from) noexcept {
594     if (this == &from) return *this;
595     if (GetOwningArena() == from.GetOwningArena()
596   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
597         && GetOwningArena() != nullptr
598   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
599     ) {
600       InternalSwap(&from);
601     } else {
602       CopyFrom(from);
603     }
604     return *this;
605   }
606 
unknown_fields()607   inline const std::string& unknown_fields() const {
608     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
609   }
mutable_unknown_fields()610   inline std::string* mutable_unknown_fields() {
611     return _internal_metadata_.mutable_unknown_fields<std::string>();
612   }
613 
default_instance()614   static const StringIndexingConfig_TokenizerType& default_instance() {
615     return *internal_default_instance();
616   }
internal_default_instance()617   static inline const StringIndexingConfig_TokenizerType* internal_default_instance() {
618     return reinterpret_cast<const StringIndexingConfig_TokenizerType*>(
619                &_StringIndexingConfig_TokenizerType_default_instance_);
620   }
621   static constexpr int kIndexInFileMessages =
622     1;
623 
swap(StringIndexingConfig_TokenizerType & a,StringIndexingConfig_TokenizerType & b)624   friend void swap(StringIndexingConfig_TokenizerType& a, StringIndexingConfig_TokenizerType& b) {
625     a.Swap(&b);
626   }
Swap(StringIndexingConfig_TokenizerType * other)627   inline void Swap(StringIndexingConfig_TokenizerType* other) {
628     if (other == this) return;
629   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
630     if (GetOwningArena() != nullptr &&
631         GetOwningArena() == other->GetOwningArena()) {
632    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
633     if (GetOwningArena() == other->GetOwningArena()) {
634   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
635       InternalSwap(other);
636     } else {
637       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
638     }
639   }
640   void UnsafeArenaSwap(StringIndexingConfig_TokenizerType* other) {
641     if (other == this) return;
642     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
643     InternalSwap(other);
644   }
645 
646   // implements Message ----------------------------------------------
647 
648   StringIndexingConfig_TokenizerType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
649     return CreateMaybeMessage<StringIndexingConfig_TokenizerType>(arena);
650   }
651   StringIndexingConfig_TokenizerType* New() const {
652     return New(nullptr);
653   }
654   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
655   void CopyFrom(const StringIndexingConfig_TokenizerType& from);
656   void MergeFrom(const StringIndexingConfig_TokenizerType& from);
657   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
658   bool IsInitialized() const final;
659 
660   size_t ByteSizeLong() const final;
661   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
662   ::uint8_t* _InternalSerialize(
663       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
664   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
665 
666   private:
667   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
668   void SharedDtor();
669   void SetCachedSize(int size) const;
670   void InternalSwap(StringIndexingConfig_TokenizerType* other);
671 
672   private:
673   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
674   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
675     return "icing.lib.StringIndexingConfig.TokenizerType";
676   }
677   protected:
678   explicit StringIndexingConfig_TokenizerType(::PROTOBUF_NAMESPACE_ID::Arena* arena,
679                        bool is_message_owned = false);
680   public:
681 
682   std::string GetTypeName() const final;
683 
684   // nested types ----------------------------------------------------
685 
686   typedef StringIndexingConfig_TokenizerType_Code Code;
687   static constexpr Code NONE =
688     StringIndexingConfig_TokenizerType_Code_NONE;
689   static constexpr Code PLAIN =
690     StringIndexingConfig_TokenizerType_Code_PLAIN;
691   static constexpr Code VERBATIM =
692     StringIndexingConfig_TokenizerType_Code_VERBATIM;
693   static constexpr Code RFC822 =
694     StringIndexingConfig_TokenizerType_Code_RFC822;
695   static constexpr Code URL =
696     StringIndexingConfig_TokenizerType_Code_URL;
697   static inline bool Code_IsValid(int value) {
698     return StringIndexingConfig_TokenizerType_Code_IsValid(value);
699   }
700   static constexpr Code Code_MIN =
701     StringIndexingConfig_TokenizerType_Code_Code_MIN;
702   static constexpr Code Code_MAX =
703     StringIndexingConfig_TokenizerType_Code_Code_MAX;
704   static constexpr int Code_ARRAYSIZE =
705     StringIndexingConfig_TokenizerType_Code_Code_ARRAYSIZE;
706   template<typename T>
707   static inline const std::string& Code_Name(T enum_t_value) {
708     static_assert(::std::is_same<T, Code>::value ||
709       ::std::is_integral<T>::value,
710       "Incorrect type passed to function Code_Name.");
711     return StringIndexingConfig_TokenizerType_Code_Name(enum_t_value);
712   }
713   static inline bool Code_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
714       Code* value) {
715     return StringIndexingConfig_TokenizerType_Code_Parse(name, value);
716   }
717 
718   // accessors -------------------------------------------------------
719 
720   // @@protoc_insertion_point(class_scope:icing.lib.StringIndexingConfig.TokenizerType)
721  private:
722   class _Internal;
723 
724   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
725   typedef void InternalArenaConstructable_;
726   typedef void DestructorSkippable_;
727   struct Impl_ {
728     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
729   };
730   union { Impl_ _impl_; };
731   friend struct ::TableStruct_icing_2fproto_2fschema_2eproto;
732 };
733 // -------------------------------------------------------------------
734 
735 class StringIndexingConfig final :
736     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.StringIndexingConfig) */ {
737  public:
StringIndexingConfig()738   inline StringIndexingConfig() : StringIndexingConfig(nullptr) {}
739   ~StringIndexingConfig() override;
740   explicit PROTOBUF_CONSTEXPR StringIndexingConfig(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
741 
742   StringIndexingConfig(const StringIndexingConfig& from);
StringIndexingConfig(StringIndexingConfig && from)743   StringIndexingConfig(StringIndexingConfig&& from) noexcept
744     : StringIndexingConfig() {
745     *this = ::std::move(from);
746   }
747 
748   inline StringIndexingConfig& operator=(const StringIndexingConfig& from) {
749     if (this == &from) return *this;
750     CopyFrom(from);
751     return *this;
752   }
753   inline StringIndexingConfig& operator=(StringIndexingConfig&& from) noexcept {
754     if (this == &from) return *this;
755     if (GetOwningArena() == from.GetOwningArena()
756   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
757         && GetOwningArena() != nullptr
758   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
759     ) {
760       InternalSwap(&from);
761     } else {
762       CopyFrom(from);
763     }
764     return *this;
765   }
766 
unknown_fields()767   inline const std::string& unknown_fields() const {
768     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
769   }
mutable_unknown_fields()770   inline std::string* mutable_unknown_fields() {
771     return _internal_metadata_.mutable_unknown_fields<std::string>();
772   }
773 
default_instance()774   static const StringIndexingConfig& default_instance() {
775     return *internal_default_instance();
776   }
internal_default_instance()777   static inline const StringIndexingConfig* internal_default_instance() {
778     return reinterpret_cast<const StringIndexingConfig*>(
779                &_StringIndexingConfig_default_instance_);
780   }
781   static constexpr int kIndexInFileMessages =
782     2;
783 
swap(StringIndexingConfig & a,StringIndexingConfig & b)784   friend void swap(StringIndexingConfig& a, StringIndexingConfig& b) {
785     a.Swap(&b);
786   }
Swap(StringIndexingConfig * other)787   inline void Swap(StringIndexingConfig* other) {
788     if (other == this) return;
789   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
790     if (GetOwningArena() != nullptr &&
791         GetOwningArena() == other->GetOwningArena()) {
792    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
793     if (GetOwningArena() == other->GetOwningArena()) {
794   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
795       InternalSwap(other);
796     } else {
797       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
798     }
799   }
800   void UnsafeArenaSwap(StringIndexingConfig* other) {
801     if (other == this) return;
802     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
803     InternalSwap(other);
804   }
805 
806   // implements Message ----------------------------------------------
807 
808   StringIndexingConfig* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
809     return CreateMaybeMessage<StringIndexingConfig>(arena);
810   }
811   StringIndexingConfig* New() const {
812     return New(nullptr);
813   }
814   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
815   void CopyFrom(const StringIndexingConfig& from);
816   void MergeFrom(const StringIndexingConfig& from);
817   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
818   bool IsInitialized() const final;
819 
820   size_t ByteSizeLong() const final;
821   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
822   ::uint8_t* _InternalSerialize(
823       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
824   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
825 
826   private:
827   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
828   void SharedDtor();
829   void SetCachedSize(int size) const;
830   void InternalSwap(StringIndexingConfig* other);
831 
832   private:
833   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
834   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
835     return "icing.lib.StringIndexingConfig";
836   }
837   protected:
838   explicit StringIndexingConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
839                        bool is_message_owned = false);
840   public:
841 
842   std::string GetTypeName() const final;
843 
844   // nested types ----------------------------------------------------
845 
846   typedef StringIndexingConfig_TokenizerType TokenizerType;
847 
848   // accessors -------------------------------------------------------
849 
850   enum : int {
851     kTermMatchTypeFieldNumber = 1,
852     kTokenizerTypeFieldNumber = 2,
853   };
854   // optional .icing.lib.TermMatchType.Code term_match_type = 1;
855   bool has_term_match_type() const;
856   private:
857   bool _internal_has_term_match_type() const;
858   public:
859   void clear_term_match_type();
860   ::icing::lib::TermMatchType_Code term_match_type() const;
861   void set_term_match_type(::icing::lib::TermMatchType_Code value);
862   private:
863   ::icing::lib::TermMatchType_Code _internal_term_match_type() const;
864   void _internal_set_term_match_type(::icing::lib::TermMatchType_Code value);
865   public:
866 
867   // optional .icing.lib.StringIndexingConfig.TokenizerType.Code tokenizer_type = 2;
868   bool has_tokenizer_type() const;
869   private:
870   bool _internal_has_tokenizer_type() const;
871   public:
872   void clear_tokenizer_type();
873   ::icing::lib::StringIndexingConfig_TokenizerType_Code tokenizer_type() const;
874   void set_tokenizer_type(::icing::lib::StringIndexingConfig_TokenizerType_Code value);
875   private:
876   ::icing::lib::StringIndexingConfig_TokenizerType_Code _internal_tokenizer_type() const;
877   void _internal_set_tokenizer_type(::icing::lib::StringIndexingConfig_TokenizerType_Code value);
878   public:
879 
880   // @@protoc_insertion_point(class_scope:icing.lib.StringIndexingConfig)
881  private:
882   class _Internal;
883 
884   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
885   typedef void InternalArenaConstructable_;
886   typedef void DestructorSkippable_;
887   struct Impl_ {
888     ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
889     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
890     int term_match_type_;
891     int tokenizer_type_;
892   };
893   union { Impl_ _impl_; };
894   friend struct ::TableStruct_icing_2fproto_2fschema_2eproto;
895 };
896 // -------------------------------------------------------------------
897 
898 class DocumentIndexingConfig final :
899     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.DocumentIndexingConfig) */ {
900  public:
DocumentIndexingConfig()901   inline DocumentIndexingConfig() : DocumentIndexingConfig(nullptr) {}
902   ~DocumentIndexingConfig() override;
903   explicit PROTOBUF_CONSTEXPR DocumentIndexingConfig(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
904 
905   DocumentIndexingConfig(const DocumentIndexingConfig& from);
DocumentIndexingConfig(DocumentIndexingConfig && from)906   DocumentIndexingConfig(DocumentIndexingConfig&& from) noexcept
907     : DocumentIndexingConfig() {
908     *this = ::std::move(from);
909   }
910 
911   inline DocumentIndexingConfig& operator=(const DocumentIndexingConfig& from) {
912     if (this == &from) return *this;
913     CopyFrom(from);
914     return *this;
915   }
916   inline DocumentIndexingConfig& operator=(DocumentIndexingConfig&& from) noexcept {
917     if (this == &from) return *this;
918     if (GetOwningArena() == from.GetOwningArena()
919   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
920         && GetOwningArena() != nullptr
921   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
922     ) {
923       InternalSwap(&from);
924     } else {
925       CopyFrom(from);
926     }
927     return *this;
928   }
929 
unknown_fields()930   inline const std::string& unknown_fields() const {
931     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
932   }
mutable_unknown_fields()933   inline std::string* mutable_unknown_fields() {
934     return _internal_metadata_.mutable_unknown_fields<std::string>();
935   }
936 
default_instance()937   static const DocumentIndexingConfig& default_instance() {
938     return *internal_default_instance();
939   }
internal_default_instance()940   static inline const DocumentIndexingConfig* internal_default_instance() {
941     return reinterpret_cast<const DocumentIndexingConfig*>(
942                &_DocumentIndexingConfig_default_instance_);
943   }
944   static constexpr int kIndexInFileMessages =
945     3;
946 
swap(DocumentIndexingConfig & a,DocumentIndexingConfig & b)947   friend void swap(DocumentIndexingConfig& a, DocumentIndexingConfig& b) {
948     a.Swap(&b);
949   }
Swap(DocumentIndexingConfig * other)950   inline void Swap(DocumentIndexingConfig* other) {
951     if (other == this) return;
952   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
953     if (GetOwningArena() != nullptr &&
954         GetOwningArena() == other->GetOwningArena()) {
955    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
956     if (GetOwningArena() == other->GetOwningArena()) {
957   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
958       InternalSwap(other);
959     } else {
960       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
961     }
962   }
963   void UnsafeArenaSwap(DocumentIndexingConfig* other) {
964     if (other == this) return;
965     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
966     InternalSwap(other);
967   }
968 
969   // implements Message ----------------------------------------------
970 
971   DocumentIndexingConfig* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
972     return CreateMaybeMessage<DocumentIndexingConfig>(arena);
973   }
974   DocumentIndexingConfig* New() const {
975     return New(nullptr);
976   }
977   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
978   void CopyFrom(const DocumentIndexingConfig& from);
979   void MergeFrom(const DocumentIndexingConfig& from);
980   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
981   bool IsInitialized() const final;
982 
983   size_t ByteSizeLong() const final;
984   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
985   ::uint8_t* _InternalSerialize(
986       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
987   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
988 
989   private:
990   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
991   void SharedDtor();
992   void SetCachedSize(int size) const;
993   void InternalSwap(DocumentIndexingConfig* other);
994 
995   private:
996   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
997   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
998     return "icing.lib.DocumentIndexingConfig";
999   }
1000   protected:
1001   explicit DocumentIndexingConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1002                        bool is_message_owned = false);
1003   public:
1004 
1005   std::string GetTypeName() const final;
1006 
1007   // nested types ----------------------------------------------------
1008 
1009   // accessors -------------------------------------------------------
1010 
1011   enum : int {
1012     kIndexableNestedPropertiesListFieldNumber = 2,
1013     kIndexNestedPropertiesFieldNumber = 1,
1014   };
1015   // repeated string indexable_nested_properties_list = 2;
1016   int indexable_nested_properties_list_size() const;
1017   private:
1018   int _internal_indexable_nested_properties_list_size() const;
1019   public:
1020   void clear_indexable_nested_properties_list();
1021   const std::string& indexable_nested_properties_list(int index) const;
1022   std::string* mutable_indexable_nested_properties_list(int index);
1023   void set_indexable_nested_properties_list(int index, const std::string& value);
1024   void set_indexable_nested_properties_list(int index, std::string&& value);
1025   void set_indexable_nested_properties_list(int index, const char* value);
1026   void set_indexable_nested_properties_list(int index, const char* value, size_t size);
1027   std::string* add_indexable_nested_properties_list();
1028   void add_indexable_nested_properties_list(const std::string& value);
1029   void add_indexable_nested_properties_list(std::string&& value);
1030   void add_indexable_nested_properties_list(const char* value);
1031   void add_indexable_nested_properties_list(const char* value, size_t size);
1032   const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& indexable_nested_properties_list() const;
1033   ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_indexable_nested_properties_list();
1034   private:
1035   const std::string& _internal_indexable_nested_properties_list(int index) const;
1036   std::string* _internal_add_indexable_nested_properties_list();
1037   public:
1038 
1039   // optional bool index_nested_properties = 1;
1040   bool has_index_nested_properties() const;
1041   private:
1042   bool _internal_has_index_nested_properties() const;
1043   public:
1044   void clear_index_nested_properties();
1045   bool index_nested_properties() const;
1046   void set_index_nested_properties(bool value);
1047   private:
1048   bool _internal_index_nested_properties() const;
1049   void _internal_set_index_nested_properties(bool value);
1050   public:
1051 
1052   // @@protoc_insertion_point(class_scope:icing.lib.DocumentIndexingConfig)
1053  private:
1054   class _Internal;
1055 
1056   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1057   typedef void InternalArenaConstructable_;
1058   typedef void DestructorSkippable_;
1059   struct Impl_ {
1060     ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1061     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1062     ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> indexable_nested_properties_list_;
1063     bool index_nested_properties_;
1064   };
1065   union { Impl_ _impl_; };
1066   friend struct ::TableStruct_icing_2fproto_2fschema_2eproto;
1067 };
1068 // -------------------------------------------------------------------
1069 
1070 class IntegerIndexingConfig_NumericMatchType final :
1071     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.IntegerIndexingConfig.NumericMatchType) */ {
1072  public:
IntegerIndexingConfig_NumericMatchType()1073   inline IntegerIndexingConfig_NumericMatchType() : IntegerIndexingConfig_NumericMatchType(nullptr) {}
1074   ~IntegerIndexingConfig_NumericMatchType() override;
1075   explicit PROTOBUF_CONSTEXPR IntegerIndexingConfig_NumericMatchType(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1076 
1077   IntegerIndexingConfig_NumericMatchType(const IntegerIndexingConfig_NumericMatchType& from);
IntegerIndexingConfig_NumericMatchType(IntegerIndexingConfig_NumericMatchType && from)1078   IntegerIndexingConfig_NumericMatchType(IntegerIndexingConfig_NumericMatchType&& from) noexcept
1079     : IntegerIndexingConfig_NumericMatchType() {
1080     *this = ::std::move(from);
1081   }
1082 
1083   inline IntegerIndexingConfig_NumericMatchType& operator=(const IntegerIndexingConfig_NumericMatchType& from) {
1084     if (this == &from) return *this;
1085     CopyFrom(from);
1086     return *this;
1087   }
1088   inline IntegerIndexingConfig_NumericMatchType& operator=(IntegerIndexingConfig_NumericMatchType&& from) noexcept {
1089     if (this == &from) return *this;
1090     if (GetOwningArena() == from.GetOwningArena()
1091   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1092         && GetOwningArena() != nullptr
1093   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
1094     ) {
1095       InternalSwap(&from);
1096     } else {
1097       CopyFrom(from);
1098     }
1099     return *this;
1100   }
1101 
unknown_fields()1102   inline const std::string& unknown_fields() const {
1103     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1104   }
mutable_unknown_fields()1105   inline std::string* mutable_unknown_fields() {
1106     return _internal_metadata_.mutable_unknown_fields<std::string>();
1107   }
1108 
default_instance()1109   static const IntegerIndexingConfig_NumericMatchType& default_instance() {
1110     return *internal_default_instance();
1111   }
internal_default_instance()1112   static inline const IntegerIndexingConfig_NumericMatchType* internal_default_instance() {
1113     return reinterpret_cast<const IntegerIndexingConfig_NumericMatchType*>(
1114                &_IntegerIndexingConfig_NumericMatchType_default_instance_);
1115   }
1116   static constexpr int kIndexInFileMessages =
1117     4;
1118 
swap(IntegerIndexingConfig_NumericMatchType & a,IntegerIndexingConfig_NumericMatchType & b)1119   friend void swap(IntegerIndexingConfig_NumericMatchType& a, IntegerIndexingConfig_NumericMatchType& b) {
1120     a.Swap(&b);
1121   }
Swap(IntegerIndexingConfig_NumericMatchType * other)1122   inline void Swap(IntegerIndexingConfig_NumericMatchType* other) {
1123     if (other == this) return;
1124   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1125     if (GetOwningArena() != nullptr &&
1126         GetOwningArena() == other->GetOwningArena()) {
1127    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
1128     if (GetOwningArena() == other->GetOwningArena()) {
1129   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
1130       InternalSwap(other);
1131     } else {
1132       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1133     }
1134   }
1135   void UnsafeArenaSwap(IntegerIndexingConfig_NumericMatchType* other) {
1136     if (other == this) return;
1137     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1138     InternalSwap(other);
1139   }
1140 
1141   // implements Message ----------------------------------------------
1142 
1143   IntegerIndexingConfig_NumericMatchType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1144     return CreateMaybeMessage<IntegerIndexingConfig_NumericMatchType>(arena);
1145   }
1146   IntegerIndexingConfig_NumericMatchType* New() const {
1147     return New(nullptr);
1148   }
1149   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
1150   void CopyFrom(const IntegerIndexingConfig_NumericMatchType& from);
1151   void MergeFrom(const IntegerIndexingConfig_NumericMatchType& from);
1152   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1153   bool IsInitialized() const final;
1154 
1155   size_t ByteSizeLong() const final;
1156   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1157   ::uint8_t* _InternalSerialize(
1158       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1159   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1160 
1161   private:
1162   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1163   void SharedDtor();
1164   void SetCachedSize(int size) const;
1165   void InternalSwap(IntegerIndexingConfig_NumericMatchType* other);
1166 
1167   private:
1168   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1169   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1170     return "icing.lib.IntegerIndexingConfig.NumericMatchType";
1171   }
1172   protected:
1173   explicit IntegerIndexingConfig_NumericMatchType(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1174                        bool is_message_owned = false);
1175   public:
1176 
1177   std::string GetTypeName() const final;
1178 
1179   // nested types ----------------------------------------------------
1180 
1181   typedef IntegerIndexingConfig_NumericMatchType_Code Code;
1182   static constexpr Code UNKNOWN =
1183     IntegerIndexingConfig_NumericMatchType_Code_UNKNOWN;
1184   static constexpr Code RANGE =
1185     IntegerIndexingConfig_NumericMatchType_Code_RANGE;
1186   static inline bool Code_IsValid(int value) {
1187     return IntegerIndexingConfig_NumericMatchType_Code_IsValid(value);
1188   }
1189   static constexpr Code Code_MIN =
1190     IntegerIndexingConfig_NumericMatchType_Code_Code_MIN;
1191   static constexpr Code Code_MAX =
1192     IntegerIndexingConfig_NumericMatchType_Code_Code_MAX;
1193   static constexpr int Code_ARRAYSIZE =
1194     IntegerIndexingConfig_NumericMatchType_Code_Code_ARRAYSIZE;
1195   template<typename T>
1196   static inline const std::string& Code_Name(T enum_t_value) {
1197     static_assert(::std::is_same<T, Code>::value ||
1198       ::std::is_integral<T>::value,
1199       "Incorrect type passed to function Code_Name.");
1200     return IntegerIndexingConfig_NumericMatchType_Code_Name(enum_t_value);
1201   }
1202   static inline bool Code_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
1203       Code* value) {
1204     return IntegerIndexingConfig_NumericMatchType_Code_Parse(name, value);
1205   }
1206 
1207   // accessors -------------------------------------------------------
1208 
1209   // @@protoc_insertion_point(class_scope:icing.lib.IntegerIndexingConfig.NumericMatchType)
1210  private:
1211   class _Internal;
1212 
1213   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1214   typedef void InternalArenaConstructable_;
1215   typedef void DestructorSkippable_;
1216   struct Impl_ {
1217     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1218   };
1219   union { Impl_ _impl_; };
1220   friend struct ::TableStruct_icing_2fproto_2fschema_2eproto;
1221 };
1222 // -------------------------------------------------------------------
1223 
1224 class IntegerIndexingConfig final :
1225     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.IntegerIndexingConfig) */ {
1226  public:
IntegerIndexingConfig()1227   inline IntegerIndexingConfig() : IntegerIndexingConfig(nullptr) {}
1228   ~IntegerIndexingConfig() override;
1229   explicit PROTOBUF_CONSTEXPR IntegerIndexingConfig(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1230 
1231   IntegerIndexingConfig(const IntegerIndexingConfig& from);
IntegerIndexingConfig(IntegerIndexingConfig && from)1232   IntegerIndexingConfig(IntegerIndexingConfig&& from) noexcept
1233     : IntegerIndexingConfig() {
1234     *this = ::std::move(from);
1235   }
1236 
1237   inline IntegerIndexingConfig& operator=(const IntegerIndexingConfig& from) {
1238     if (this == &from) return *this;
1239     CopyFrom(from);
1240     return *this;
1241   }
1242   inline IntegerIndexingConfig& operator=(IntegerIndexingConfig&& from) noexcept {
1243     if (this == &from) return *this;
1244     if (GetOwningArena() == from.GetOwningArena()
1245   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1246         && GetOwningArena() != nullptr
1247   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
1248     ) {
1249       InternalSwap(&from);
1250     } else {
1251       CopyFrom(from);
1252     }
1253     return *this;
1254   }
1255 
unknown_fields()1256   inline const std::string& unknown_fields() const {
1257     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1258   }
mutable_unknown_fields()1259   inline std::string* mutable_unknown_fields() {
1260     return _internal_metadata_.mutable_unknown_fields<std::string>();
1261   }
1262 
default_instance()1263   static const IntegerIndexingConfig& default_instance() {
1264     return *internal_default_instance();
1265   }
internal_default_instance()1266   static inline const IntegerIndexingConfig* internal_default_instance() {
1267     return reinterpret_cast<const IntegerIndexingConfig*>(
1268                &_IntegerIndexingConfig_default_instance_);
1269   }
1270   static constexpr int kIndexInFileMessages =
1271     5;
1272 
swap(IntegerIndexingConfig & a,IntegerIndexingConfig & b)1273   friend void swap(IntegerIndexingConfig& a, IntegerIndexingConfig& b) {
1274     a.Swap(&b);
1275   }
Swap(IntegerIndexingConfig * other)1276   inline void Swap(IntegerIndexingConfig* other) {
1277     if (other == this) return;
1278   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1279     if (GetOwningArena() != nullptr &&
1280         GetOwningArena() == other->GetOwningArena()) {
1281    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
1282     if (GetOwningArena() == other->GetOwningArena()) {
1283   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
1284       InternalSwap(other);
1285     } else {
1286       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1287     }
1288   }
1289   void UnsafeArenaSwap(IntegerIndexingConfig* other) {
1290     if (other == this) return;
1291     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1292     InternalSwap(other);
1293   }
1294 
1295   // implements Message ----------------------------------------------
1296 
1297   IntegerIndexingConfig* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1298     return CreateMaybeMessage<IntegerIndexingConfig>(arena);
1299   }
1300   IntegerIndexingConfig* New() const {
1301     return New(nullptr);
1302   }
1303   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
1304   void CopyFrom(const IntegerIndexingConfig& from);
1305   void MergeFrom(const IntegerIndexingConfig& from);
1306   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1307   bool IsInitialized() const final;
1308 
1309   size_t ByteSizeLong() const final;
1310   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1311   ::uint8_t* _InternalSerialize(
1312       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1313   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1314 
1315   private:
1316   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1317   void SharedDtor();
1318   void SetCachedSize(int size) const;
1319   void InternalSwap(IntegerIndexingConfig* other);
1320 
1321   private:
1322   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1323   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1324     return "icing.lib.IntegerIndexingConfig";
1325   }
1326   protected:
1327   explicit IntegerIndexingConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1328                        bool is_message_owned = false);
1329   public:
1330 
1331   std::string GetTypeName() const final;
1332 
1333   // nested types ----------------------------------------------------
1334 
1335   typedef IntegerIndexingConfig_NumericMatchType NumericMatchType;
1336 
1337   // accessors -------------------------------------------------------
1338 
1339   enum : int {
1340     kNumericMatchTypeFieldNumber = 1,
1341   };
1342   // optional .icing.lib.IntegerIndexingConfig.NumericMatchType.Code numeric_match_type = 1;
1343   bool has_numeric_match_type() const;
1344   private:
1345   bool _internal_has_numeric_match_type() const;
1346   public:
1347   void clear_numeric_match_type();
1348   ::icing::lib::IntegerIndexingConfig_NumericMatchType_Code numeric_match_type() const;
1349   void set_numeric_match_type(::icing::lib::IntegerIndexingConfig_NumericMatchType_Code value);
1350   private:
1351   ::icing::lib::IntegerIndexingConfig_NumericMatchType_Code _internal_numeric_match_type() const;
1352   void _internal_set_numeric_match_type(::icing::lib::IntegerIndexingConfig_NumericMatchType_Code value);
1353   public:
1354 
1355   // @@protoc_insertion_point(class_scope:icing.lib.IntegerIndexingConfig)
1356  private:
1357   class _Internal;
1358 
1359   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1360   typedef void InternalArenaConstructable_;
1361   typedef void DestructorSkippable_;
1362   struct Impl_ {
1363     ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1364     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1365     int numeric_match_type_;
1366   };
1367   union { Impl_ _impl_; };
1368   friend struct ::TableStruct_icing_2fproto_2fschema_2eproto;
1369 };
1370 // -------------------------------------------------------------------
1371 
1372 class EmbeddingIndexingConfig_EmbeddingIndexingType final :
1373     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.EmbeddingIndexingConfig.EmbeddingIndexingType) */ {
1374  public:
EmbeddingIndexingConfig_EmbeddingIndexingType()1375   inline EmbeddingIndexingConfig_EmbeddingIndexingType() : EmbeddingIndexingConfig_EmbeddingIndexingType(nullptr) {}
1376   ~EmbeddingIndexingConfig_EmbeddingIndexingType() override;
1377   explicit PROTOBUF_CONSTEXPR EmbeddingIndexingConfig_EmbeddingIndexingType(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1378 
1379   EmbeddingIndexingConfig_EmbeddingIndexingType(const EmbeddingIndexingConfig_EmbeddingIndexingType& from);
EmbeddingIndexingConfig_EmbeddingIndexingType(EmbeddingIndexingConfig_EmbeddingIndexingType && from)1380   EmbeddingIndexingConfig_EmbeddingIndexingType(EmbeddingIndexingConfig_EmbeddingIndexingType&& from) noexcept
1381     : EmbeddingIndexingConfig_EmbeddingIndexingType() {
1382     *this = ::std::move(from);
1383   }
1384 
1385   inline EmbeddingIndexingConfig_EmbeddingIndexingType& operator=(const EmbeddingIndexingConfig_EmbeddingIndexingType& from) {
1386     if (this == &from) return *this;
1387     CopyFrom(from);
1388     return *this;
1389   }
1390   inline EmbeddingIndexingConfig_EmbeddingIndexingType& operator=(EmbeddingIndexingConfig_EmbeddingIndexingType&& from) noexcept {
1391     if (this == &from) return *this;
1392     if (GetOwningArena() == from.GetOwningArena()
1393   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1394         && GetOwningArena() != nullptr
1395   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
1396     ) {
1397       InternalSwap(&from);
1398     } else {
1399       CopyFrom(from);
1400     }
1401     return *this;
1402   }
1403 
unknown_fields()1404   inline const std::string& unknown_fields() const {
1405     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1406   }
mutable_unknown_fields()1407   inline std::string* mutable_unknown_fields() {
1408     return _internal_metadata_.mutable_unknown_fields<std::string>();
1409   }
1410 
default_instance()1411   static const EmbeddingIndexingConfig_EmbeddingIndexingType& default_instance() {
1412     return *internal_default_instance();
1413   }
internal_default_instance()1414   static inline const EmbeddingIndexingConfig_EmbeddingIndexingType* internal_default_instance() {
1415     return reinterpret_cast<const EmbeddingIndexingConfig_EmbeddingIndexingType*>(
1416                &_EmbeddingIndexingConfig_EmbeddingIndexingType_default_instance_);
1417   }
1418   static constexpr int kIndexInFileMessages =
1419     6;
1420 
swap(EmbeddingIndexingConfig_EmbeddingIndexingType & a,EmbeddingIndexingConfig_EmbeddingIndexingType & b)1421   friend void swap(EmbeddingIndexingConfig_EmbeddingIndexingType& a, EmbeddingIndexingConfig_EmbeddingIndexingType& b) {
1422     a.Swap(&b);
1423   }
Swap(EmbeddingIndexingConfig_EmbeddingIndexingType * other)1424   inline void Swap(EmbeddingIndexingConfig_EmbeddingIndexingType* other) {
1425     if (other == this) return;
1426   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1427     if (GetOwningArena() != nullptr &&
1428         GetOwningArena() == other->GetOwningArena()) {
1429    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
1430     if (GetOwningArena() == other->GetOwningArena()) {
1431   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
1432       InternalSwap(other);
1433     } else {
1434       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1435     }
1436   }
1437   void UnsafeArenaSwap(EmbeddingIndexingConfig_EmbeddingIndexingType* other) {
1438     if (other == this) return;
1439     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1440     InternalSwap(other);
1441   }
1442 
1443   // implements Message ----------------------------------------------
1444 
1445   EmbeddingIndexingConfig_EmbeddingIndexingType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1446     return CreateMaybeMessage<EmbeddingIndexingConfig_EmbeddingIndexingType>(arena);
1447   }
1448   EmbeddingIndexingConfig_EmbeddingIndexingType* New() const {
1449     return New(nullptr);
1450   }
1451   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
1452   void CopyFrom(const EmbeddingIndexingConfig_EmbeddingIndexingType& from);
1453   void MergeFrom(const EmbeddingIndexingConfig_EmbeddingIndexingType& from);
1454   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1455   bool IsInitialized() const final;
1456 
1457   size_t ByteSizeLong() const final;
1458   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1459   ::uint8_t* _InternalSerialize(
1460       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1461   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1462 
1463   private:
1464   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1465   void SharedDtor();
1466   void SetCachedSize(int size) const;
1467   void InternalSwap(EmbeddingIndexingConfig_EmbeddingIndexingType* other);
1468 
1469   private:
1470   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1471   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1472     return "icing.lib.EmbeddingIndexingConfig.EmbeddingIndexingType";
1473   }
1474   protected:
1475   explicit EmbeddingIndexingConfig_EmbeddingIndexingType(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1476                        bool is_message_owned = false);
1477   public:
1478 
1479   std::string GetTypeName() const final;
1480 
1481   // nested types ----------------------------------------------------
1482 
1483   typedef EmbeddingIndexingConfig_EmbeddingIndexingType_Code Code;
1484   static constexpr Code UNKNOWN =
1485     EmbeddingIndexingConfig_EmbeddingIndexingType_Code_UNKNOWN;
1486   static constexpr Code LINEAR_SEARCH =
1487     EmbeddingIndexingConfig_EmbeddingIndexingType_Code_LINEAR_SEARCH;
1488   static inline bool Code_IsValid(int value) {
1489     return EmbeddingIndexingConfig_EmbeddingIndexingType_Code_IsValid(value);
1490   }
1491   static constexpr Code Code_MIN =
1492     EmbeddingIndexingConfig_EmbeddingIndexingType_Code_Code_MIN;
1493   static constexpr Code Code_MAX =
1494     EmbeddingIndexingConfig_EmbeddingIndexingType_Code_Code_MAX;
1495   static constexpr int Code_ARRAYSIZE =
1496     EmbeddingIndexingConfig_EmbeddingIndexingType_Code_Code_ARRAYSIZE;
1497   template<typename T>
1498   static inline const std::string& Code_Name(T enum_t_value) {
1499     static_assert(::std::is_same<T, Code>::value ||
1500       ::std::is_integral<T>::value,
1501       "Incorrect type passed to function Code_Name.");
1502     return EmbeddingIndexingConfig_EmbeddingIndexingType_Code_Name(enum_t_value);
1503   }
1504   static inline bool Code_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
1505       Code* value) {
1506     return EmbeddingIndexingConfig_EmbeddingIndexingType_Code_Parse(name, value);
1507   }
1508 
1509   // accessors -------------------------------------------------------
1510 
1511   // @@protoc_insertion_point(class_scope:icing.lib.EmbeddingIndexingConfig.EmbeddingIndexingType)
1512  private:
1513   class _Internal;
1514 
1515   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1516   typedef void InternalArenaConstructable_;
1517   typedef void DestructorSkippable_;
1518   struct Impl_ {
1519     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1520   };
1521   union { Impl_ _impl_; };
1522   friend struct ::TableStruct_icing_2fproto_2fschema_2eproto;
1523 };
1524 // -------------------------------------------------------------------
1525 
1526 class EmbeddingIndexingConfig_QuantizationType final :
1527     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.EmbeddingIndexingConfig.QuantizationType) */ {
1528  public:
EmbeddingIndexingConfig_QuantizationType()1529   inline EmbeddingIndexingConfig_QuantizationType() : EmbeddingIndexingConfig_QuantizationType(nullptr) {}
1530   ~EmbeddingIndexingConfig_QuantizationType() override;
1531   explicit PROTOBUF_CONSTEXPR EmbeddingIndexingConfig_QuantizationType(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1532 
1533   EmbeddingIndexingConfig_QuantizationType(const EmbeddingIndexingConfig_QuantizationType& from);
EmbeddingIndexingConfig_QuantizationType(EmbeddingIndexingConfig_QuantizationType && from)1534   EmbeddingIndexingConfig_QuantizationType(EmbeddingIndexingConfig_QuantizationType&& from) noexcept
1535     : EmbeddingIndexingConfig_QuantizationType() {
1536     *this = ::std::move(from);
1537   }
1538 
1539   inline EmbeddingIndexingConfig_QuantizationType& operator=(const EmbeddingIndexingConfig_QuantizationType& from) {
1540     if (this == &from) return *this;
1541     CopyFrom(from);
1542     return *this;
1543   }
1544   inline EmbeddingIndexingConfig_QuantizationType& operator=(EmbeddingIndexingConfig_QuantizationType&& from) noexcept {
1545     if (this == &from) return *this;
1546     if (GetOwningArena() == from.GetOwningArena()
1547   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1548         && GetOwningArena() != nullptr
1549   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
1550     ) {
1551       InternalSwap(&from);
1552     } else {
1553       CopyFrom(from);
1554     }
1555     return *this;
1556   }
1557 
unknown_fields()1558   inline const std::string& unknown_fields() const {
1559     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1560   }
mutable_unknown_fields()1561   inline std::string* mutable_unknown_fields() {
1562     return _internal_metadata_.mutable_unknown_fields<std::string>();
1563   }
1564 
default_instance()1565   static const EmbeddingIndexingConfig_QuantizationType& default_instance() {
1566     return *internal_default_instance();
1567   }
internal_default_instance()1568   static inline const EmbeddingIndexingConfig_QuantizationType* internal_default_instance() {
1569     return reinterpret_cast<const EmbeddingIndexingConfig_QuantizationType*>(
1570                &_EmbeddingIndexingConfig_QuantizationType_default_instance_);
1571   }
1572   static constexpr int kIndexInFileMessages =
1573     7;
1574 
swap(EmbeddingIndexingConfig_QuantizationType & a,EmbeddingIndexingConfig_QuantizationType & b)1575   friend void swap(EmbeddingIndexingConfig_QuantizationType& a, EmbeddingIndexingConfig_QuantizationType& b) {
1576     a.Swap(&b);
1577   }
Swap(EmbeddingIndexingConfig_QuantizationType * other)1578   inline void Swap(EmbeddingIndexingConfig_QuantizationType* other) {
1579     if (other == this) return;
1580   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1581     if (GetOwningArena() != nullptr &&
1582         GetOwningArena() == other->GetOwningArena()) {
1583    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
1584     if (GetOwningArena() == other->GetOwningArena()) {
1585   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
1586       InternalSwap(other);
1587     } else {
1588       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1589     }
1590   }
1591   void UnsafeArenaSwap(EmbeddingIndexingConfig_QuantizationType* other) {
1592     if (other == this) return;
1593     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1594     InternalSwap(other);
1595   }
1596 
1597   // implements Message ----------------------------------------------
1598 
1599   EmbeddingIndexingConfig_QuantizationType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1600     return CreateMaybeMessage<EmbeddingIndexingConfig_QuantizationType>(arena);
1601   }
1602   EmbeddingIndexingConfig_QuantizationType* New() const {
1603     return New(nullptr);
1604   }
1605   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
1606   void CopyFrom(const EmbeddingIndexingConfig_QuantizationType& from);
1607   void MergeFrom(const EmbeddingIndexingConfig_QuantizationType& from);
1608   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1609   bool IsInitialized() const final;
1610 
1611   size_t ByteSizeLong() const final;
1612   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1613   ::uint8_t* _InternalSerialize(
1614       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1615   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1616 
1617   private:
1618   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1619   void SharedDtor();
1620   void SetCachedSize(int size) const;
1621   void InternalSwap(EmbeddingIndexingConfig_QuantizationType* other);
1622 
1623   private:
1624   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1625   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1626     return "icing.lib.EmbeddingIndexingConfig.QuantizationType";
1627   }
1628   protected:
1629   explicit EmbeddingIndexingConfig_QuantizationType(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1630                        bool is_message_owned = false);
1631   public:
1632 
1633   std::string GetTypeName() const final;
1634 
1635   // nested types ----------------------------------------------------
1636 
1637   typedef EmbeddingIndexingConfig_QuantizationType_Code Code;
1638   static constexpr Code NONE =
1639     EmbeddingIndexingConfig_QuantizationType_Code_NONE;
1640   static constexpr Code QUANTIZE_8_BIT =
1641     EmbeddingIndexingConfig_QuantizationType_Code_QUANTIZE_8_BIT;
1642   static inline bool Code_IsValid(int value) {
1643     return EmbeddingIndexingConfig_QuantizationType_Code_IsValid(value);
1644   }
1645   static constexpr Code Code_MIN =
1646     EmbeddingIndexingConfig_QuantizationType_Code_Code_MIN;
1647   static constexpr Code Code_MAX =
1648     EmbeddingIndexingConfig_QuantizationType_Code_Code_MAX;
1649   static constexpr int Code_ARRAYSIZE =
1650     EmbeddingIndexingConfig_QuantizationType_Code_Code_ARRAYSIZE;
1651   template<typename T>
1652   static inline const std::string& Code_Name(T enum_t_value) {
1653     static_assert(::std::is_same<T, Code>::value ||
1654       ::std::is_integral<T>::value,
1655       "Incorrect type passed to function Code_Name.");
1656     return EmbeddingIndexingConfig_QuantizationType_Code_Name(enum_t_value);
1657   }
1658   static inline bool Code_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
1659       Code* value) {
1660     return EmbeddingIndexingConfig_QuantizationType_Code_Parse(name, value);
1661   }
1662 
1663   // accessors -------------------------------------------------------
1664 
1665   // @@protoc_insertion_point(class_scope:icing.lib.EmbeddingIndexingConfig.QuantizationType)
1666  private:
1667   class _Internal;
1668 
1669   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1670   typedef void InternalArenaConstructable_;
1671   typedef void DestructorSkippable_;
1672   struct Impl_ {
1673     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1674   };
1675   union { Impl_ _impl_; };
1676   friend struct ::TableStruct_icing_2fproto_2fschema_2eproto;
1677 };
1678 // -------------------------------------------------------------------
1679 
1680 class EmbeddingIndexingConfig final :
1681     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.EmbeddingIndexingConfig) */ {
1682  public:
EmbeddingIndexingConfig()1683   inline EmbeddingIndexingConfig() : EmbeddingIndexingConfig(nullptr) {}
1684   ~EmbeddingIndexingConfig() override;
1685   explicit PROTOBUF_CONSTEXPR EmbeddingIndexingConfig(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1686 
1687   EmbeddingIndexingConfig(const EmbeddingIndexingConfig& from);
EmbeddingIndexingConfig(EmbeddingIndexingConfig && from)1688   EmbeddingIndexingConfig(EmbeddingIndexingConfig&& from) noexcept
1689     : EmbeddingIndexingConfig() {
1690     *this = ::std::move(from);
1691   }
1692 
1693   inline EmbeddingIndexingConfig& operator=(const EmbeddingIndexingConfig& from) {
1694     if (this == &from) return *this;
1695     CopyFrom(from);
1696     return *this;
1697   }
1698   inline EmbeddingIndexingConfig& operator=(EmbeddingIndexingConfig&& from) noexcept {
1699     if (this == &from) return *this;
1700     if (GetOwningArena() == from.GetOwningArena()
1701   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1702         && GetOwningArena() != nullptr
1703   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
1704     ) {
1705       InternalSwap(&from);
1706     } else {
1707       CopyFrom(from);
1708     }
1709     return *this;
1710   }
1711 
unknown_fields()1712   inline const std::string& unknown_fields() const {
1713     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1714   }
mutable_unknown_fields()1715   inline std::string* mutable_unknown_fields() {
1716     return _internal_metadata_.mutable_unknown_fields<std::string>();
1717   }
1718 
default_instance()1719   static const EmbeddingIndexingConfig& default_instance() {
1720     return *internal_default_instance();
1721   }
internal_default_instance()1722   static inline const EmbeddingIndexingConfig* internal_default_instance() {
1723     return reinterpret_cast<const EmbeddingIndexingConfig*>(
1724                &_EmbeddingIndexingConfig_default_instance_);
1725   }
1726   static constexpr int kIndexInFileMessages =
1727     8;
1728 
swap(EmbeddingIndexingConfig & a,EmbeddingIndexingConfig & b)1729   friend void swap(EmbeddingIndexingConfig& a, EmbeddingIndexingConfig& b) {
1730     a.Swap(&b);
1731   }
Swap(EmbeddingIndexingConfig * other)1732   inline void Swap(EmbeddingIndexingConfig* other) {
1733     if (other == this) return;
1734   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1735     if (GetOwningArena() != nullptr &&
1736         GetOwningArena() == other->GetOwningArena()) {
1737    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
1738     if (GetOwningArena() == other->GetOwningArena()) {
1739   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
1740       InternalSwap(other);
1741     } else {
1742       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1743     }
1744   }
1745   void UnsafeArenaSwap(EmbeddingIndexingConfig* other) {
1746     if (other == this) return;
1747     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1748     InternalSwap(other);
1749   }
1750 
1751   // implements Message ----------------------------------------------
1752 
1753   EmbeddingIndexingConfig* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1754     return CreateMaybeMessage<EmbeddingIndexingConfig>(arena);
1755   }
1756   EmbeddingIndexingConfig* New() const {
1757     return New(nullptr);
1758   }
1759   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
1760   void CopyFrom(const EmbeddingIndexingConfig& from);
1761   void MergeFrom(const EmbeddingIndexingConfig& from);
1762   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1763   bool IsInitialized() const final;
1764 
1765   size_t ByteSizeLong() const final;
1766   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1767   ::uint8_t* _InternalSerialize(
1768       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1769   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1770 
1771   private:
1772   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1773   void SharedDtor();
1774   void SetCachedSize(int size) const;
1775   void InternalSwap(EmbeddingIndexingConfig* other);
1776 
1777   private:
1778   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1779   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1780     return "icing.lib.EmbeddingIndexingConfig";
1781   }
1782   protected:
1783   explicit EmbeddingIndexingConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1784                        bool is_message_owned = false);
1785   public:
1786 
1787   std::string GetTypeName() const final;
1788 
1789   // nested types ----------------------------------------------------
1790 
1791   typedef EmbeddingIndexingConfig_EmbeddingIndexingType EmbeddingIndexingType;
1792   typedef EmbeddingIndexingConfig_QuantizationType QuantizationType;
1793 
1794   // accessors -------------------------------------------------------
1795 
1796   enum : int {
1797     kEmbeddingIndexingTypeFieldNumber = 1,
1798     kQuantizationTypeFieldNumber = 2,
1799   };
1800   // optional .icing.lib.EmbeddingIndexingConfig.EmbeddingIndexingType.Code embedding_indexing_type = 1;
1801   bool has_embedding_indexing_type() const;
1802   private:
1803   bool _internal_has_embedding_indexing_type() const;
1804   public:
1805   void clear_embedding_indexing_type();
1806   ::icing::lib::EmbeddingIndexingConfig_EmbeddingIndexingType_Code embedding_indexing_type() const;
1807   void set_embedding_indexing_type(::icing::lib::EmbeddingIndexingConfig_EmbeddingIndexingType_Code value);
1808   private:
1809   ::icing::lib::EmbeddingIndexingConfig_EmbeddingIndexingType_Code _internal_embedding_indexing_type() const;
1810   void _internal_set_embedding_indexing_type(::icing::lib::EmbeddingIndexingConfig_EmbeddingIndexingType_Code value);
1811   public:
1812 
1813   // optional .icing.lib.EmbeddingIndexingConfig.QuantizationType.Code quantization_type = 2;
1814   bool has_quantization_type() const;
1815   private:
1816   bool _internal_has_quantization_type() const;
1817   public:
1818   void clear_quantization_type();
1819   ::icing::lib::EmbeddingIndexingConfig_QuantizationType_Code quantization_type() const;
1820   void set_quantization_type(::icing::lib::EmbeddingIndexingConfig_QuantizationType_Code value);
1821   private:
1822   ::icing::lib::EmbeddingIndexingConfig_QuantizationType_Code _internal_quantization_type() const;
1823   void _internal_set_quantization_type(::icing::lib::EmbeddingIndexingConfig_QuantizationType_Code value);
1824   public:
1825 
1826   // @@protoc_insertion_point(class_scope:icing.lib.EmbeddingIndexingConfig)
1827  private:
1828   class _Internal;
1829 
1830   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1831   typedef void InternalArenaConstructable_;
1832   typedef void DestructorSkippable_;
1833   struct Impl_ {
1834     ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1835     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1836     int embedding_indexing_type_;
1837     int quantization_type_;
1838   };
1839   union { Impl_ _impl_; };
1840   friend struct ::TableStruct_icing_2fproto_2fschema_2eproto;
1841 };
1842 // -------------------------------------------------------------------
1843 
1844 class JoinableConfig_ValueType final :
1845     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.JoinableConfig.ValueType) */ {
1846  public:
JoinableConfig_ValueType()1847   inline JoinableConfig_ValueType() : JoinableConfig_ValueType(nullptr) {}
1848   ~JoinableConfig_ValueType() override;
1849   explicit PROTOBUF_CONSTEXPR JoinableConfig_ValueType(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1850 
1851   JoinableConfig_ValueType(const JoinableConfig_ValueType& from);
JoinableConfig_ValueType(JoinableConfig_ValueType && from)1852   JoinableConfig_ValueType(JoinableConfig_ValueType&& from) noexcept
1853     : JoinableConfig_ValueType() {
1854     *this = ::std::move(from);
1855   }
1856 
1857   inline JoinableConfig_ValueType& operator=(const JoinableConfig_ValueType& from) {
1858     if (this == &from) return *this;
1859     CopyFrom(from);
1860     return *this;
1861   }
1862   inline JoinableConfig_ValueType& operator=(JoinableConfig_ValueType&& from) noexcept {
1863     if (this == &from) return *this;
1864     if (GetOwningArena() == from.GetOwningArena()
1865   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1866         && GetOwningArena() != nullptr
1867   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
1868     ) {
1869       InternalSwap(&from);
1870     } else {
1871       CopyFrom(from);
1872     }
1873     return *this;
1874   }
1875 
unknown_fields()1876   inline const std::string& unknown_fields() const {
1877     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1878   }
mutable_unknown_fields()1879   inline std::string* mutable_unknown_fields() {
1880     return _internal_metadata_.mutable_unknown_fields<std::string>();
1881   }
1882 
default_instance()1883   static const JoinableConfig_ValueType& default_instance() {
1884     return *internal_default_instance();
1885   }
internal_default_instance()1886   static inline const JoinableConfig_ValueType* internal_default_instance() {
1887     return reinterpret_cast<const JoinableConfig_ValueType*>(
1888                &_JoinableConfig_ValueType_default_instance_);
1889   }
1890   static constexpr int kIndexInFileMessages =
1891     9;
1892 
swap(JoinableConfig_ValueType & a,JoinableConfig_ValueType & b)1893   friend void swap(JoinableConfig_ValueType& a, JoinableConfig_ValueType& b) {
1894     a.Swap(&b);
1895   }
Swap(JoinableConfig_ValueType * other)1896   inline void Swap(JoinableConfig_ValueType* other) {
1897     if (other == this) return;
1898   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1899     if (GetOwningArena() != nullptr &&
1900         GetOwningArena() == other->GetOwningArena()) {
1901    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
1902     if (GetOwningArena() == other->GetOwningArena()) {
1903   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
1904       InternalSwap(other);
1905     } else {
1906       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1907     }
1908   }
1909   void UnsafeArenaSwap(JoinableConfig_ValueType* other) {
1910     if (other == this) return;
1911     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1912     InternalSwap(other);
1913   }
1914 
1915   // implements Message ----------------------------------------------
1916 
1917   JoinableConfig_ValueType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1918     return CreateMaybeMessage<JoinableConfig_ValueType>(arena);
1919   }
1920   JoinableConfig_ValueType* New() const {
1921     return New(nullptr);
1922   }
1923   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
1924   void CopyFrom(const JoinableConfig_ValueType& from);
1925   void MergeFrom(const JoinableConfig_ValueType& from);
1926   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1927   bool IsInitialized() const final;
1928 
1929   size_t ByteSizeLong() const final;
1930   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1931   ::uint8_t* _InternalSerialize(
1932       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1933   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1934 
1935   private:
1936   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1937   void SharedDtor();
1938   void SetCachedSize(int size) const;
1939   void InternalSwap(JoinableConfig_ValueType* other);
1940 
1941   private:
1942   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1943   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1944     return "icing.lib.JoinableConfig.ValueType";
1945   }
1946   protected:
1947   explicit JoinableConfig_ValueType(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1948                        bool is_message_owned = false);
1949   public:
1950 
1951   std::string GetTypeName() const final;
1952 
1953   // nested types ----------------------------------------------------
1954 
1955   typedef JoinableConfig_ValueType_Code Code;
1956   static constexpr Code NONE =
1957     JoinableConfig_ValueType_Code_NONE;
1958   static constexpr Code QUALIFIED_ID =
1959     JoinableConfig_ValueType_Code_QUALIFIED_ID;
1960   static inline bool Code_IsValid(int value) {
1961     return JoinableConfig_ValueType_Code_IsValid(value);
1962   }
1963   static constexpr Code Code_MIN =
1964     JoinableConfig_ValueType_Code_Code_MIN;
1965   static constexpr Code Code_MAX =
1966     JoinableConfig_ValueType_Code_Code_MAX;
1967   static constexpr int Code_ARRAYSIZE =
1968     JoinableConfig_ValueType_Code_Code_ARRAYSIZE;
1969   template<typename T>
1970   static inline const std::string& Code_Name(T enum_t_value) {
1971     static_assert(::std::is_same<T, Code>::value ||
1972       ::std::is_integral<T>::value,
1973       "Incorrect type passed to function Code_Name.");
1974     return JoinableConfig_ValueType_Code_Name(enum_t_value);
1975   }
1976   static inline bool Code_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
1977       Code* value) {
1978     return JoinableConfig_ValueType_Code_Parse(name, value);
1979   }
1980 
1981   // accessors -------------------------------------------------------
1982 
1983   // @@protoc_insertion_point(class_scope:icing.lib.JoinableConfig.ValueType)
1984  private:
1985   class _Internal;
1986 
1987   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1988   typedef void InternalArenaConstructable_;
1989   typedef void DestructorSkippable_;
1990   struct Impl_ {
1991     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1992   };
1993   union { Impl_ _impl_; };
1994   friend struct ::TableStruct_icing_2fproto_2fschema_2eproto;
1995 };
1996 // -------------------------------------------------------------------
1997 
1998 class JoinableConfig_DeletePropagationType final :
1999     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.JoinableConfig.DeletePropagationType) */ {
2000  public:
JoinableConfig_DeletePropagationType()2001   inline JoinableConfig_DeletePropagationType() : JoinableConfig_DeletePropagationType(nullptr) {}
2002   ~JoinableConfig_DeletePropagationType() override;
2003   explicit PROTOBUF_CONSTEXPR JoinableConfig_DeletePropagationType(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2004 
2005   JoinableConfig_DeletePropagationType(const JoinableConfig_DeletePropagationType& from);
JoinableConfig_DeletePropagationType(JoinableConfig_DeletePropagationType && from)2006   JoinableConfig_DeletePropagationType(JoinableConfig_DeletePropagationType&& from) noexcept
2007     : JoinableConfig_DeletePropagationType() {
2008     *this = ::std::move(from);
2009   }
2010 
2011   inline JoinableConfig_DeletePropagationType& operator=(const JoinableConfig_DeletePropagationType& from) {
2012     if (this == &from) return *this;
2013     CopyFrom(from);
2014     return *this;
2015   }
2016   inline JoinableConfig_DeletePropagationType& operator=(JoinableConfig_DeletePropagationType&& from) noexcept {
2017     if (this == &from) return *this;
2018     if (GetOwningArena() == from.GetOwningArena()
2019   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2020         && GetOwningArena() != nullptr
2021   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
2022     ) {
2023       InternalSwap(&from);
2024     } else {
2025       CopyFrom(from);
2026     }
2027     return *this;
2028   }
2029 
unknown_fields()2030   inline const std::string& unknown_fields() const {
2031     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
2032   }
mutable_unknown_fields()2033   inline std::string* mutable_unknown_fields() {
2034     return _internal_metadata_.mutable_unknown_fields<std::string>();
2035   }
2036 
default_instance()2037   static const JoinableConfig_DeletePropagationType& default_instance() {
2038     return *internal_default_instance();
2039   }
internal_default_instance()2040   static inline const JoinableConfig_DeletePropagationType* internal_default_instance() {
2041     return reinterpret_cast<const JoinableConfig_DeletePropagationType*>(
2042                &_JoinableConfig_DeletePropagationType_default_instance_);
2043   }
2044   static constexpr int kIndexInFileMessages =
2045     10;
2046 
swap(JoinableConfig_DeletePropagationType & a,JoinableConfig_DeletePropagationType & b)2047   friend void swap(JoinableConfig_DeletePropagationType& a, JoinableConfig_DeletePropagationType& b) {
2048     a.Swap(&b);
2049   }
Swap(JoinableConfig_DeletePropagationType * other)2050   inline void Swap(JoinableConfig_DeletePropagationType* other) {
2051     if (other == this) return;
2052   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2053     if (GetOwningArena() != nullptr &&
2054         GetOwningArena() == other->GetOwningArena()) {
2055    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
2056     if (GetOwningArena() == other->GetOwningArena()) {
2057   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
2058       InternalSwap(other);
2059     } else {
2060       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2061     }
2062   }
2063   void UnsafeArenaSwap(JoinableConfig_DeletePropagationType* other) {
2064     if (other == this) return;
2065     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2066     InternalSwap(other);
2067   }
2068 
2069   // implements Message ----------------------------------------------
2070 
2071   JoinableConfig_DeletePropagationType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2072     return CreateMaybeMessage<JoinableConfig_DeletePropagationType>(arena);
2073   }
2074   JoinableConfig_DeletePropagationType* New() const {
2075     return New(nullptr);
2076   }
2077   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
2078   void CopyFrom(const JoinableConfig_DeletePropagationType& from);
2079   void MergeFrom(const JoinableConfig_DeletePropagationType& from);
2080   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2081   bool IsInitialized() const final;
2082 
2083   size_t ByteSizeLong() const final;
2084   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2085   ::uint8_t* _InternalSerialize(
2086       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2087   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2088 
2089   private:
2090   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2091   void SharedDtor();
2092   void SetCachedSize(int size) const;
2093   void InternalSwap(JoinableConfig_DeletePropagationType* other);
2094 
2095   private:
2096   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2097   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2098     return "icing.lib.JoinableConfig.DeletePropagationType";
2099   }
2100   protected:
2101   explicit JoinableConfig_DeletePropagationType(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2102                        bool is_message_owned = false);
2103   public:
2104 
2105   std::string GetTypeName() const final;
2106 
2107   // nested types ----------------------------------------------------
2108 
2109   typedef JoinableConfig_DeletePropagationType_Code Code;
2110   static constexpr Code NONE =
2111     JoinableConfig_DeletePropagationType_Code_NONE;
2112   static constexpr Code PROPAGATE_FROM =
2113     JoinableConfig_DeletePropagationType_Code_PROPAGATE_FROM;
2114   static inline bool Code_IsValid(int value) {
2115     return JoinableConfig_DeletePropagationType_Code_IsValid(value);
2116   }
2117   static constexpr Code Code_MIN =
2118     JoinableConfig_DeletePropagationType_Code_Code_MIN;
2119   static constexpr Code Code_MAX =
2120     JoinableConfig_DeletePropagationType_Code_Code_MAX;
2121   static constexpr int Code_ARRAYSIZE =
2122     JoinableConfig_DeletePropagationType_Code_Code_ARRAYSIZE;
2123   template<typename T>
2124   static inline const std::string& Code_Name(T enum_t_value) {
2125     static_assert(::std::is_same<T, Code>::value ||
2126       ::std::is_integral<T>::value,
2127       "Incorrect type passed to function Code_Name.");
2128     return JoinableConfig_DeletePropagationType_Code_Name(enum_t_value);
2129   }
2130   static inline bool Code_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
2131       Code* value) {
2132     return JoinableConfig_DeletePropagationType_Code_Parse(name, value);
2133   }
2134 
2135   // accessors -------------------------------------------------------
2136 
2137   // @@protoc_insertion_point(class_scope:icing.lib.JoinableConfig.DeletePropagationType)
2138  private:
2139   class _Internal;
2140 
2141   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2142   typedef void InternalArenaConstructable_;
2143   typedef void DestructorSkippable_;
2144   struct Impl_ {
2145     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2146   };
2147   union { Impl_ _impl_; };
2148   friend struct ::TableStruct_icing_2fproto_2fschema_2eproto;
2149 };
2150 // -------------------------------------------------------------------
2151 
2152 class JoinableConfig final :
2153     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.JoinableConfig) */ {
2154  public:
JoinableConfig()2155   inline JoinableConfig() : JoinableConfig(nullptr) {}
2156   ~JoinableConfig() override;
2157   explicit PROTOBUF_CONSTEXPR JoinableConfig(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2158 
2159   JoinableConfig(const JoinableConfig& from);
JoinableConfig(JoinableConfig && from)2160   JoinableConfig(JoinableConfig&& from) noexcept
2161     : JoinableConfig() {
2162     *this = ::std::move(from);
2163   }
2164 
2165   inline JoinableConfig& operator=(const JoinableConfig& from) {
2166     if (this == &from) return *this;
2167     CopyFrom(from);
2168     return *this;
2169   }
2170   inline JoinableConfig& operator=(JoinableConfig&& from) noexcept {
2171     if (this == &from) return *this;
2172     if (GetOwningArena() == from.GetOwningArena()
2173   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2174         && GetOwningArena() != nullptr
2175   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
2176     ) {
2177       InternalSwap(&from);
2178     } else {
2179       CopyFrom(from);
2180     }
2181     return *this;
2182   }
2183 
unknown_fields()2184   inline const std::string& unknown_fields() const {
2185     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
2186   }
mutable_unknown_fields()2187   inline std::string* mutable_unknown_fields() {
2188     return _internal_metadata_.mutable_unknown_fields<std::string>();
2189   }
2190 
default_instance()2191   static const JoinableConfig& default_instance() {
2192     return *internal_default_instance();
2193   }
internal_default_instance()2194   static inline const JoinableConfig* internal_default_instance() {
2195     return reinterpret_cast<const JoinableConfig*>(
2196                &_JoinableConfig_default_instance_);
2197   }
2198   static constexpr int kIndexInFileMessages =
2199     11;
2200 
swap(JoinableConfig & a,JoinableConfig & b)2201   friend void swap(JoinableConfig& a, JoinableConfig& b) {
2202     a.Swap(&b);
2203   }
Swap(JoinableConfig * other)2204   inline void Swap(JoinableConfig* other) {
2205     if (other == this) return;
2206   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2207     if (GetOwningArena() != nullptr &&
2208         GetOwningArena() == other->GetOwningArena()) {
2209    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
2210     if (GetOwningArena() == other->GetOwningArena()) {
2211   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
2212       InternalSwap(other);
2213     } else {
2214       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2215     }
2216   }
2217   void UnsafeArenaSwap(JoinableConfig* other) {
2218     if (other == this) return;
2219     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2220     InternalSwap(other);
2221   }
2222 
2223   // implements Message ----------------------------------------------
2224 
2225   JoinableConfig* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2226     return CreateMaybeMessage<JoinableConfig>(arena);
2227   }
2228   JoinableConfig* New() const {
2229     return New(nullptr);
2230   }
2231   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
2232   void CopyFrom(const JoinableConfig& from);
2233   void MergeFrom(const JoinableConfig& from);
2234   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2235   bool IsInitialized() const final;
2236 
2237   size_t ByteSizeLong() const final;
2238   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2239   ::uint8_t* _InternalSerialize(
2240       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2241   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2242 
2243   private:
2244   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2245   void SharedDtor();
2246   void SetCachedSize(int size) const;
2247   void InternalSwap(JoinableConfig* other);
2248 
2249   private:
2250   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2251   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2252     return "icing.lib.JoinableConfig";
2253   }
2254   protected:
2255   explicit JoinableConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2256                        bool is_message_owned = false);
2257   public:
2258 
2259   std::string GetTypeName() const final;
2260 
2261   // nested types ----------------------------------------------------
2262 
2263   typedef JoinableConfig_ValueType ValueType;
2264   typedef JoinableConfig_DeletePropagationType DeletePropagationType;
2265 
2266   // accessors -------------------------------------------------------
2267 
2268   enum : int {
2269     kValueTypeFieldNumber = 1,
2270     kDeletePropagationTypeFieldNumber = 3,
2271   };
2272   // optional .icing.lib.JoinableConfig.ValueType.Code value_type = 1;
2273   bool has_value_type() const;
2274   private:
2275   bool _internal_has_value_type() const;
2276   public:
2277   void clear_value_type();
2278   ::icing::lib::JoinableConfig_ValueType_Code value_type() const;
2279   void set_value_type(::icing::lib::JoinableConfig_ValueType_Code value);
2280   private:
2281   ::icing::lib::JoinableConfig_ValueType_Code _internal_value_type() const;
2282   void _internal_set_value_type(::icing::lib::JoinableConfig_ValueType_Code value);
2283   public:
2284 
2285   // optional .icing.lib.JoinableConfig.DeletePropagationType.Code delete_propagation_type = 3;
2286   bool has_delete_propagation_type() const;
2287   private:
2288   bool _internal_has_delete_propagation_type() const;
2289   public:
2290   void clear_delete_propagation_type();
2291   ::icing::lib::JoinableConfig_DeletePropagationType_Code delete_propagation_type() const;
2292   void set_delete_propagation_type(::icing::lib::JoinableConfig_DeletePropagationType_Code value);
2293   private:
2294   ::icing::lib::JoinableConfig_DeletePropagationType_Code _internal_delete_propagation_type() const;
2295   void _internal_set_delete_propagation_type(::icing::lib::JoinableConfig_DeletePropagationType_Code value);
2296   public:
2297 
2298   // @@protoc_insertion_point(class_scope:icing.lib.JoinableConfig)
2299  private:
2300   class _Internal;
2301 
2302   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2303   typedef void InternalArenaConstructable_;
2304   typedef void DestructorSkippable_;
2305   struct Impl_ {
2306     ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
2307     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2308     int value_type_;
2309     int delete_propagation_type_;
2310   };
2311   union { Impl_ _impl_; };
2312   friend struct ::TableStruct_icing_2fproto_2fschema_2eproto;
2313 };
2314 // -------------------------------------------------------------------
2315 
2316 class PropertyConfigProto_DataType final :
2317     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.PropertyConfigProto.DataType) */ {
2318  public:
PropertyConfigProto_DataType()2319   inline PropertyConfigProto_DataType() : PropertyConfigProto_DataType(nullptr) {}
2320   ~PropertyConfigProto_DataType() override;
2321   explicit PROTOBUF_CONSTEXPR PropertyConfigProto_DataType(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2322 
2323   PropertyConfigProto_DataType(const PropertyConfigProto_DataType& from);
PropertyConfigProto_DataType(PropertyConfigProto_DataType && from)2324   PropertyConfigProto_DataType(PropertyConfigProto_DataType&& from) noexcept
2325     : PropertyConfigProto_DataType() {
2326     *this = ::std::move(from);
2327   }
2328 
2329   inline PropertyConfigProto_DataType& operator=(const PropertyConfigProto_DataType& from) {
2330     if (this == &from) return *this;
2331     CopyFrom(from);
2332     return *this;
2333   }
2334   inline PropertyConfigProto_DataType& operator=(PropertyConfigProto_DataType&& from) noexcept {
2335     if (this == &from) return *this;
2336     if (GetOwningArena() == from.GetOwningArena()
2337   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2338         && GetOwningArena() != nullptr
2339   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
2340     ) {
2341       InternalSwap(&from);
2342     } else {
2343       CopyFrom(from);
2344     }
2345     return *this;
2346   }
2347 
unknown_fields()2348   inline const std::string& unknown_fields() const {
2349     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
2350   }
mutable_unknown_fields()2351   inline std::string* mutable_unknown_fields() {
2352     return _internal_metadata_.mutable_unknown_fields<std::string>();
2353   }
2354 
default_instance()2355   static const PropertyConfigProto_DataType& default_instance() {
2356     return *internal_default_instance();
2357   }
internal_default_instance()2358   static inline const PropertyConfigProto_DataType* internal_default_instance() {
2359     return reinterpret_cast<const PropertyConfigProto_DataType*>(
2360                &_PropertyConfigProto_DataType_default_instance_);
2361   }
2362   static constexpr int kIndexInFileMessages =
2363     12;
2364 
swap(PropertyConfigProto_DataType & a,PropertyConfigProto_DataType & b)2365   friend void swap(PropertyConfigProto_DataType& a, PropertyConfigProto_DataType& b) {
2366     a.Swap(&b);
2367   }
Swap(PropertyConfigProto_DataType * other)2368   inline void Swap(PropertyConfigProto_DataType* other) {
2369     if (other == this) return;
2370   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2371     if (GetOwningArena() != nullptr &&
2372         GetOwningArena() == other->GetOwningArena()) {
2373    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
2374     if (GetOwningArena() == other->GetOwningArena()) {
2375   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
2376       InternalSwap(other);
2377     } else {
2378       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2379     }
2380   }
2381   void UnsafeArenaSwap(PropertyConfigProto_DataType* other) {
2382     if (other == this) return;
2383     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2384     InternalSwap(other);
2385   }
2386 
2387   // implements Message ----------------------------------------------
2388 
2389   PropertyConfigProto_DataType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2390     return CreateMaybeMessage<PropertyConfigProto_DataType>(arena);
2391   }
2392   PropertyConfigProto_DataType* New() const {
2393     return New(nullptr);
2394   }
2395   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
2396   void CopyFrom(const PropertyConfigProto_DataType& from);
2397   void MergeFrom(const PropertyConfigProto_DataType& from);
2398   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2399   bool IsInitialized() const final;
2400 
2401   size_t ByteSizeLong() const final;
2402   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2403   ::uint8_t* _InternalSerialize(
2404       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2405   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2406 
2407   private:
2408   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2409   void SharedDtor();
2410   void SetCachedSize(int size) const;
2411   void InternalSwap(PropertyConfigProto_DataType* other);
2412 
2413   private:
2414   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2415   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2416     return "icing.lib.PropertyConfigProto.DataType";
2417   }
2418   protected:
2419   explicit PropertyConfigProto_DataType(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2420                        bool is_message_owned = false);
2421   public:
2422 
2423   std::string GetTypeName() const final;
2424 
2425   // nested types ----------------------------------------------------
2426 
2427   typedef PropertyConfigProto_DataType_Code Code;
2428   static constexpr Code UNKNOWN =
2429     PropertyConfigProto_DataType_Code_UNKNOWN;
2430   static constexpr Code STRING =
2431     PropertyConfigProto_DataType_Code_STRING;
2432   static constexpr Code INT64 =
2433     PropertyConfigProto_DataType_Code_INT64;
2434   static constexpr Code DOUBLE =
2435     PropertyConfigProto_DataType_Code_DOUBLE;
2436   static constexpr Code BOOLEAN =
2437     PropertyConfigProto_DataType_Code_BOOLEAN;
2438   static constexpr Code BYTES =
2439     PropertyConfigProto_DataType_Code_BYTES;
2440   static constexpr Code DOCUMENT =
2441     PropertyConfigProto_DataType_Code_DOCUMENT;
2442   static constexpr Code VECTOR =
2443     PropertyConfigProto_DataType_Code_VECTOR;
2444   static constexpr Code BLOB_HANDLE =
2445     PropertyConfigProto_DataType_Code_BLOB_HANDLE;
2446   static inline bool Code_IsValid(int value) {
2447     return PropertyConfigProto_DataType_Code_IsValid(value);
2448   }
2449   static constexpr Code Code_MIN =
2450     PropertyConfigProto_DataType_Code_Code_MIN;
2451   static constexpr Code Code_MAX =
2452     PropertyConfigProto_DataType_Code_Code_MAX;
2453   static constexpr int Code_ARRAYSIZE =
2454     PropertyConfigProto_DataType_Code_Code_ARRAYSIZE;
2455   template<typename T>
2456   static inline const std::string& Code_Name(T enum_t_value) {
2457     static_assert(::std::is_same<T, Code>::value ||
2458       ::std::is_integral<T>::value,
2459       "Incorrect type passed to function Code_Name.");
2460     return PropertyConfigProto_DataType_Code_Name(enum_t_value);
2461   }
2462   static inline bool Code_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
2463       Code* value) {
2464     return PropertyConfigProto_DataType_Code_Parse(name, value);
2465   }
2466 
2467   // accessors -------------------------------------------------------
2468 
2469   // @@protoc_insertion_point(class_scope:icing.lib.PropertyConfigProto.DataType)
2470  private:
2471   class _Internal;
2472 
2473   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2474   typedef void InternalArenaConstructable_;
2475   typedef void DestructorSkippable_;
2476   struct Impl_ {
2477     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2478   };
2479   union { Impl_ _impl_; };
2480   friend struct ::TableStruct_icing_2fproto_2fschema_2eproto;
2481 };
2482 // -------------------------------------------------------------------
2483 
2484 class PropertyConfigProto_Cardinality final :
2485     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.PropertyConfigProto.Cardinality) */ {
2486  public:
PropertyConfigProto_Cardinality()2487   inline PropertyConfigProto_Cardinality() : PropertyConfigProto_Cardinality(nullptr) {}
2488   ~PropertyConfigProto_Cardinality() override;
2489   explicit PROTOBUF_CONSTEXPR PropertyConfigProto_Cardinality(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2490 
2491   PropertyConfigProto_Cardinality(const PropertyConfigProto_Cardinality& from);
PropertyConfigProto_Cardinality(PropertyConfigProto_Cardinality && from)2492   PropertyConfigProto_Cardinality(PropertyConfigProto_Cardinality&& from) noexcept
2493     : PropertyConfigProto_Cardinality() {
2494     *this = ::std::move(from);
2495   }
2496 
2497   inline PropertyConfigProto_Cardinality& operator=(const PropertyConfigProto_Cardinality& from) {
2498     if (this == &from) return *this;
2499     CopyFrom(from);
2500     return *this;
2501   }
2502   inline PropertyConfigProto_Cardinality& operator=(PropertyConfigProto_Cardinality&& from) noexcept {
2503     if (this == &from) return *this;
2504     if (GetOwningArena() == from.GetOwningArena()
2505   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2506         && GetOwningArena() != nullptr
2507   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
2508     ) {
2509       InternalSwap(&from);
2510     } else {
2511       CopyFrom(from);
2512     }
2513     return *this;
2514   }
2515 
unknown_fields()2516   inline const std::string& unknown_fields() const {
2517     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
2518   }
mutable_unknown_fields()2519   inline std::string* mutable_unknown_fields() {
2520     return _internal_metadata_.mutable_unknown_fields<std::string>();
2521   }
2522 
default_instance()2523   static const PropertyConfigProto_Cardinality& default_instance() {
2524     return *internal_default_instance();
2525   }
internal_default_instance()2526   static inline const PropertyConfigProto_Cardinality* internal_default_instance() {
2527     return reinterpret_cast<const PropertyConfigProto_Cardinality*>(
2528                &_PropertyConfigProto_Cardinality_default_instance_);
2529   }
2530   static constexpr int kIndexInFileMessages =
2531     13;
2532 
swap(PropertyConfigProto_Cardinality & a,PropertyConfigProto_Cardinality & b)2533   friend void swap(PropertyConfigProto_Cardinality& a, PropertyConfigProto_Cardinality& b) {
2534     a.Swap(&b);
2535   }
Swap(PropertyConfigProto_Cardinality * other)2536   inline void Swap(PropertyConfigProto_Cardinality* other) {
2537     if (other == this) return;
2538   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2539     if (GetOwningArena() != nullptr &&
2540         GetOwningArena() == other->GetOwningArena()) {
2541    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
2542     if (GetOwningArena() == other->GetOwningArena()) {
2543   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
2544       InternalSwap(other);
2545     } else {
2546       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2547     }
2548   }
2549   void UnsafeArenaSwap(PropertyConfigProto_Cardinality* other) {
2550     if (other == this) return;
2551     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2552     InternalSwap(other);
2553   }
2554 
2555   // implements Message ----------------------------------------------
2556 
2557   PropertyConfigProto_Cardinality* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2558     return CreateMaybeMessage<PropertyConfigProto_Cardinality>(arena);
2559   }
2560   PropertyConfigProto_Cardinality* New() const {
2561     return New(nullptr);
2562   }
2563   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
2564   void CopyFrom(const PropertyConfigProto_Cardinality& from);
2565   void MergeFrom(const PropertyConfigProto_Cardinality& from);
2566   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2567   bool IsInitialized() const final;
2568 
2569   size_t ByteSizeLong() const final;
2570   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2571   ::uint8_t* _InternalSerialize(
2572       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2573   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2574 
2575   private:
2576   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2577   void SharedDtor();
2578   void SetCachedSize(int size) const;
2579   void InternalSwap(PropertyConfigProto_Cardinality* other);
2580 
2581   private:
2582   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2583   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2584     return "icing.lib.PropertyConfigProto.Cardinality";
2585   }
2586   protected:
2587   explicit PropertyConfigProto_Cardinality(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2588                        bool is_message_owned = false);
2589   public:
2590 
2591   std::string GetTypeName() const final;
2592 
2593   // nested types ----------------------------------------------------
2594 
2595   typedef PropertyConfigProto_Cardinality_Code Code;
2596   static constexpr Code UNKNOWN =
2597     PropertyConfigProto_Cardinality_Code_UNKNOWN;
2598   static constexpr Code REPEATED =
2599     PropertyConfigProto_Cardinality_Code_REPEATED;
2600   static constexpr Code OPTIONAL =
2601     PropertyConfigProto_Cardinality_Code_OPTIONAL;
2602   static constexpr Code REQUIRED =
2603     PropertyConfigProto_Cardinality_Code_REQUIRED;
2604   static inline bool Code_IsValid(int value) {
2605     return PropertyConfigProto_Cardinality_Code_IsValid(value);
2606   }
2607   static constexpr Code Code_MIN =
2608     PropertyConfigProto_Cardinality_Code_Code_MIN;
2609   static constexpr Code Code_MAX =
2610     PropertyConfigProto_Cardinality_Code_Code_MAX;
2611   static constexpr int Code_ARRAYSIZE =
2612     PropertyConfigProto_Cardinality_Code_Code_ARRAYSIZE;
2613   template<typename T>
2614   static inline const std::string& Code_Name(T enum_t_value) {
2615     static_assert(::std::is_same<T, Code>::value ||
2616       ::std::is_integral<T>::value,
2617       "Incorrect type passed to function Code_Name.");
2618     return PropertyConfigProto_Cardinality_Code_Name(enum_t_value);
2619   }
2620   static inline bool Code_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
2621       Code* value) {
2622     return PropertyConfigProto_Cardinality_Code_Parse(name, value);
2623   }
2624 
2625   // accessors -------------------------------------------------------
2626 
2627   // @@protoc_insertion_point(class_scope:icing.lib.PropertyConfigProto.Cardinality)
2628  private:
2629   class _Internal;
2630 
2631   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2632   typedef void InternalArenaConstructable_;
2633   typedef void DestructorSkippable_;
2634   struct Impl_ {
2635     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2636   };
2637   union { Impl_ _impl_; };
2638   friend struct ::TableStruct_icing_2fproto_2fschema_2eproto;
2639 };
2640 // -------------------------------------------------------------------
2641 
2642 class PropertyConfigProto_ScorableType final :
2643     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.PropertyConfigProto.ScorableType) */ {
2644  public:
PropertyConfigProto_ScorableType()2645   inline PropertyConfigProto_ScorableType() : PropertyConfigProto_ScorableType(nullptr) {}
2646   ~PropertyConfigProto_ScorableType() override;
2647   explicit PROTOBUF_CONSTEXPR PropertyConfigProto_ScorableType(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2648 
2649   PropertyConfigProto_ScorableType(const PropertyConfigProto_ScorableType& from);
PropertyConfigProto_ScorableType(PropertyConfigProto_ScorableType && from)2650   PropertyConfigProto_ScorableType(PropertyConfigProto_ScorableType&& from) noexcept
2651     : PropertyConfigProto_ScorableType() {
2652     *this = ::std::move(from);
2653   }
2654 
2655   inline PropertyConfigProto_ScorableType& operator=(const PropertyConfigProto_ScorableType& from) {
2656     if (this == &from) return *this;
2657     CopyFrom(from);
2658     return *this;
2659   }
2660   inline PropertyConfigProto_ScorableType& operator=(PropertyConfigProto_ScorableType&& from) noexcept {
2661     if (this == &from) return *this;
2662     if (GetOwningArena() == from.GetOwningArena()
2663   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2664         && GetOwningArena() != nullptr
2665   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
2666     ) {
2667       InternalSwap(&from);
2668     } else {
2669       CopyFrom(from);
2670     }
2671     return *this;
2672   }
2673 
unknown_fields()2674   inline const std::string& unknown_fields() const {
2675     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
2676   }
mutable_unknown_fields()2677   inline std::string* mutable_unknown_fields() {
2678     return _internal_metadata_.mutable_unknown_fields<std::string>();
2679   }
2680 
default_instance()2681   static const PropertyConfigProto_ScorableType& default_instance() {
2682     return *internal_default_instance();
2683   }
internal_default_instance()2684   static inline const PropertyConfigProto_ScorableType* internal_default_instance() {
2685     return reinterpret_cast<const PropertyConfigProto_ScorableType*>(
2686                &_PropertyConfigProto_ScorableType_default_instance_);
2687   }
2688   static constexpr int kIndexInFileMessages =
2689     14;
2690 
swap(PropertyConfigProto_ScorableType & a,PropertyConfigProto_ScorableType & b)2691   friend void swap(PropertyConfigProto_ScorableType& a, PropertyConfigProto_ScorableType& b) {
2692     a.Swap(&b);
2693   }
Swap(PropertyConfigProto_ScorableType * other)2694   inline void Swap(PropertyConfigProto_ScorableType* other) {
2695     if (other == this) return;
2696   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2697     if (GetOwningArena() != nullptr &&
2698         GetOwningArena() == other->GetOwningArena()) {
2699    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
2700     if (GetOwningArena() == other->GetOwningArena()) {
2701   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
2702       InternalSwap(other);
2703     } else {
2704       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2705     }
2706   }
2707   void UnsafeArenaSwap(PropertyConfigProto_ScorableType* other) {
2708     if (other == this) return;
2709     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2710     InternalSwap(other);
2711   }
2712 
2713   // implements Message ----------------------------------------------
2714 
2715   PropertyConfigProto_ScorableType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2716     return CreateMaybeMessage<PropertyConfigProto_ScorableType>(arena);
2717   }
2718   PropertyConfigProto_ScorableType* New() const {
2719     return New(nullptr);
2720   }
2721   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
2722   void CopyFrom(const PropertyConfigProto_ScorableType& from);
2723   void MergeFrom(const PropertyConfigProto_ScorableType& from);
2724   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2725   bool IsInitialized() const final;
2726 
2727   size_t ByteSizeLong() const final;
2728   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2729   ::uint8_t* _InternalSerialize(
2730       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2731   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2732 
2733   private:
2734   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2735   void SharedDtor();
2736   void SetCachedSize(int size) const;
2737   void InternalSwap(PropertyConfigProto_ScorableType* other);
2738 
2739   private:
2740   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2741   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2742     return "icing.lib.PropertyConfigProto.ScorableType";
2743   }
2744   protected:
2745   explicit PropertyConfigProto_ScorableType(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2746                        bool is_message_owned = false);
2747   public:
2748 
2749   std::string GetTypeName() const final;
2750 
2751   // nested types ----------------------------------------------------
2752 
2753   typedef PropertyConfigProto_ScorableType_Code Code;
2754   static constexpr Code UNKNOWN =
2755     PropertyConfigProto_ScorableType_Code_UNKNOWN;
2756   static constexpr Code DISABLED =
2757     PropertyConfigProto_ScorableType_Code_DISABLED;
2758   static constexpr Code ENABLED =
2759     PropertyConfigProto_ScorableType_Code_ENABLED;
2760   static inline bool Code_IsValid(int value) {
2761     return PropertyConfigProto_ScorableType_Code_IsValid(value);
2762   }
2763   static constexpr Code Code_MIN =
2764     PropertyConfigProto_ScorableType_Code_Code_MIN;
2765   static constexpr Code Code_MAX =
2766     PropertyConfigProto_ScorableType_Code_Code_MAX;
2767   static constexpr int Code_ARRAYSIZE =
2768     PropertyConfigProto_ScorableType_Code_Code_ARRAYSIZE;
2769   template<typename T>
2770   static inline const std::string& Code_Name(T enum_t_value) {
2771     static_assert(::std::is_same<T, Code>::value ||
2772       ::std::is_integral<T>::value,
2773       "Incorrect type passed to function Code_Name.");
2774     return PropertyConfigProto_ScorableType_Code_Name(enum_t_value);
2775   }
2776   static inline bool Code_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
2777       Code* value) {
2778     return PropertyConfigProto_ScorableType_Code_Parse(name, value);
2779   }
2780 
2781   // accessors -------------------------------------------------------
2782 
2783   // @@protoc_insertion_point(class_scope:icing.lib.PropertyConfigProto.ScorableType)
2784  private:
2785   class _Internal;
2786 
2787   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2788   typedef void InternalArenaConstructable_;
2789   typedef void DestructorSkippable_;
2790   struct Impl_ {
2791     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2792   };
2793   union { Impl_ _impl_; };
2794   friend struct ::TableStruct_icing_2fproto_2fschema_2eproto;
2795 };
2796 // -------------------------------------------------------------------
2797 
2798 class PropertyConfigProto final :
2799     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.PropertyConfigProto) */ {
2800  public:
PropertyConfigProto()2801   inline PropertyConfigProto() : PropertyConfigProto(nullptr) {}
2802   ~PropertyConfigProto() override;
2803   explicit PROTOBUF_CONSTEXPR PropertyConfigProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2804 
2805   PropertyConfigProto(const PropertyConfigProto& from);
PropertyConfigProto(PropertyConfigProto && from)2806   PropertyConfigProto(PropertyConfigProto&& from) noexcept
2807     : PropertyConfigProto() {
2808     *this = ::std::move(from);
2809   }
2810 
2811   inline PropertyConfigProto& operator=(const PropertyConfigProto& from) {
2812     if (this == &from) return *this;
2813     CopyFrom(from);
2814     return *this;
2815   }
2816   inline PropertyConfigProto& operator=(PropertyConfigProto&& from) noexcept {
2817     if (this == &from) return *this;
2818     if (GetOwningArena() == from.GetOwningArena()
2819   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2820         && GetOwningArena() != nullptr
2821   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
2822     ) {
2823       InternalSwap(&from);
2824     } else {
2825       CopyFrom(from);
2826     }
2827     return *this;
2828   }
2829 
unknown_fields()2830   inline const std::string& unknown_fields() const {
2831     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
2832   }
mutable_unknown_fields()2833   inline std::string* mutable_unknown_fields() {
2834     return _internal_metadata_.mutable_unknown_fields<std::string>();
2835   }
2836 
default_instance()2837   static const PropertyConfigProto& default_instance() {
2838     return *internal_default_instance();
2839   }
internal_default_instance()2840   static inline const PropertyConfigProto* internal_default_instance() {
2841     return reinterpret_cast<const PropertyConfigProto*>(
2842                &_PropertyConfigProto_default_instance_);
2843   }
2844   static constexpr int kIndexInFileMessages =
2845     15;
2846 
swap(PropertyConfigProto & a,PropertyConfigProto & b)2847   friend void swap(PropertyConfigProto& a, PropertyConfigProto& b) {
2848     a.Swap(&b);
2849   }
Swap(PropertyConfigProto * other)2850   inline void Swap(PropertyConfigProto* other) {
2851     if (other == this) return;
2852   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2853     if (GetOwningArena() != nullptr &&
2854         GetOwningArena() == other->GetOwningArena()) {
2855    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
2856     if (GetOwningArena() == other->GetOwningArena()) {
2857   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
2858       InternalSwap(other);
2859     } else {
2860       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2861     }
2862   }
2863   void UnsafeArenaSwap(PropertyConfigProto* other) {
2864     if (other == this) return;
2865     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2866     InternalSwap(other);
2867   }
2868 
2869   // implements Message ----------------------------------------------
2870 
2871   PropertyConfigProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2872     return CreateMaybeMessage<PropertyConfigProto>(arena);
2873   }
2874   PropertyConfigProto* New() const {
2875     return New(nullptr);
2876   }
2877   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
2878   void CopyFrom(const PropertyConfigProto& from);
2879   void MergeFrom(const PropertyConfigProto& from);
2880   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2881   bool IsInitialized() const final;
2882 
2883   size_t ByteSizeLong() const final;
2884   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2885   ::uint8_t* _InternalSerialize(
2886       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2887   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2888 
2889   private:
2890   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2891   void SharedDtor();
2892   void SetCachedSize(int size) const;
2893   void InternalSwap(PropertyConfigProto* other);
2894 
2895   private:
2896   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2897   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2898     return "icing.lib.PropertyConfigProto";
2899   }
2900   protected:
2901   explicit PropertyConfigProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2902                        bool is_message_owned = false);
2903   public:
2904 
2905   std::string GetTypeName() const final;
2906 
2907   // nested types ----------------------------------------------------
2908 
2909   typedef PropertyConfigProto_DataType DataType;
2910   typedef PropertyConfigProto_Cardinality Cardinality;
2911   typedef PropertyConfigProto_ScorableType ScorableType;
2912 
2913   // accessors -------------------------------------------------------
2914 
2915   enum : int {
2916     kPropertyNameFieldNumber = 1,
2917     kSchemaTypeFieldNumber = 3,
2918     kDescriptionFieldNumber = 9,
2919     kStringIndexingConfigFieldNumber = 5,
2920     kDocumentIndexingConfigFieldNumber = 6,
2921     kIntegerIndexingConfigFieldNumber = 7,
2922     kJoinableConfigFieldNumber = 8,
2923     kEmbeddingIndexingConfigFieldNumber = 10,
2924     kDataTypeFieldNumber = 2,
2925     kCardinalityFieldNumber = 4,
2926     kScorableTypeFieldNumber = 11,
2927   };
2928   // optional string property_name = 1;
2929   bool has_property_name() const;
2930   private:
2931   bool _internal_has_property_name() const;
2932   public:
2933   void clear_property_name();
2934   const std::string& property_name() const;
2935   template <typename ArgT0 = const std::string&, typename... ArgT>
2936   void set_property_name(ArgT0&& arg0, ArgT... args);
2937   std::string* mutable_property_name();
2938   PROTOBUF_NODISCARD std::string* release_property_name();
2939   void set_allocated_property_name(std::string* property_name);
2940   private:
2941   const std::string& _internal_property_name() const;
2942   inline PROTOBUF_ALWAYS_INLINE void _internal_set_property_name(const std::string& value);
2943   std::string* _internal_mutable_property_name();
2944   public:
2945 
2946   // optional string schema_type = 3;
2947   bool has_schema_type() const;
2948   private:
2949   bool _internal_has_schema_type() const;
2950   public:
2951   void clear_schema_type();
2952   const std::string& schema_type() const;
2953   template <typename ArgT0 = const std::string&, typename... ArgT>
2954   void set_schema_type(ArgT0&& arg0, ArgT... args);
2955   std::string* mutable_schema_type();
2956   PROTOBUF_NODISCARD std::string* release_schema_type();
2957   void set_allocated_schema_type(std::string* schema_type);
2958   private:
2959   const std::string& _internal_schema_type() const;
2960   inline PROTOBUF_ALWAYS_INLINE void _internal_set_schema_type(const std::string& value);
2961   std::string* _internal_mutable_schema_type();
2962   public:
2963 
2964   // optional string description = 9;
2965   bool has_description() const;
2966   private:
2967   bool _internal_has_description() const;
2968   public:
2969   void clear_description();
2970   const std::string& description() const;
2971   template <typename ArgT0 = const std::string&, typename... ArgT>
2972   void set_description(ArgT0&& arg0, ArgT... args);
2973   std::string* mutable_description();
2974   PROTOBUF_NODISCARD std::string* release_description();
2975   void set_allocated_description(std::string* description);
2976   private:
2977   const std::string& _internal_description() const;
2978   inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value);
2979   std::string* _internal_mutable_description();
2980   public:
2981 
2982   // optional .icing.lib.StringIndexingConfig string_indexing_config = 5;
2983   bool has_string_indexing_config() const;
2984   private:
2985   bool _internal_has_string_indexing_config() const;
2986   public:
2987   void clear_string_indexing_config();
2988   const ::icing::lib::StringIndexingConfig& string_indexing_config() const;
2989   PROTOBUF_NODISCARD ::icing::lib::StringIndexingConfig* release_string_indexing_config();
2990   ::icing::lib::StringIndexingConfig* mutable_string_indexing_config();
2991   void set_allocated_string_indexing_config(::icing::lib::StringIndexingConfig* string_indexing_config);
2992   private:
2993   const ::icing::lib::StringIndexingConfig& _internal_string_indexing_config() const;
2994   ::icing::lib::StringIndexingConfig* _internal_mutable_string_indexing_config();
2995   public:
2996   void unsafe_arena_set_allocated_string_indexing_config(
2997       ::icing::lib::StringIndexingConfig* string_indexing_config);
2998   ::icing::lib::StringIndexingConfig* unsafe_arena_release_string_indexing_config();
2999 
3000   // optional .icing.lib.DocumentIndexingConfig document_indexing_config = 6;
3001   bool has_document_indexing_config() const;
3002   private:
3003   bool _internal_has_document_indexing_config() const;
3004   public:
3005   void clear_document_indexing_config();
3006   const ::icing::lib::DocumentIndexingConfig& document_indexing_config() const;
3007   PROTOBUF_NODISCARD ::icing::lib::DocumentIndexingConfig* release_document_indexing_config();
3008   ::icing::lib::DocumentIndexingConfig* mutable_document_indexing_config();
3009   void set_allocated_document_indexing_config(::icing::lib::DocumentIndexingConfig* document_indexing_config);
3010   private:
3011   const ::icing::lib::DocumentIndexingConfig& _internal_document_indexing_config() const;
3012   ::icing::lib::DocumentIndexingConfig* _internal_mutable_document_indexing_config();
3013   public:
3014   void unsafe_arena_set_allocated_document_indexing_config(
3015       ::icing::lib::DocumentIndexingConfig* document_indexing_config);
3016   ::icing::lib::DocumentIndexingConfig* unsafe_arena_release_document_indexing_config();
3017 
3018   // optional .icing.lib.IntegerIndexingConfig integer_indexing_config = 7;
3019   bool has_integer_indexing_config() const;
3020   private:
3021   bool _internal_has_integer_indexing_config() const;
3022   public:
3023   void clear_integer_indexing_config();
3024   const ::icing::lib::IntegerIndexingConfig& integer_indexing_config() const;
3025   PROTOBUF_NODISCARD ::icing::lib::IntegerIndexingConfig* release_integer_indexing_config();
3026   ::icing::lib::IntegerIndexingConfig* mutable_integer_indexing_config();
3027   void set_allocated_integer_indexing_config(::icing::lib::IntegerIndexingConfig* integer_indexing_config);
3028   private:
3029   const ::icing::lib::IntegerIndexingConfig& _internal_integer_indexing_config() const;
3030   ::icing::lib::IntegerIndexingConfig* _internal_mutable_integer_indexing_config();
3031   public:
3032   void unsafe_arena_set_allocated_integer_indexing_config(
3033       ::icing::lib::IntegerIndexingConfig* integer_indexing_config);
3034   ::icing::lib::IntegerIndexingConfig* unsafe_arena_release_integer_indexing_config();
3035 
3036   // optional .icing.lib.JoinableConfig joinable_config = 8;
3037   bool has_joinable_config() const;
3038   private:
3039   bool _internal_has_joinable_config() const;
3040   public:
3041   void clear_joinable_config();
3042   const ::icing::lib::JoinableConfig& joinable_config() const;
3043   PROTOBUF_NODISCARD ::icing::lib::JoinableConfig* release_joinable_config();
3044   ::icing::lib::JoinableConfig* mutable_joinable_config();
3045   void set_allocated_joinable_config(::icing::lib::JoinableConfig* joinable_config);
3046   private:
3047   const ::icing::lib::JoinableConfig& _internal_joinable_config() const;
3048   ::icing::lib::JoinableConfig* _internal_mutable_joinable_config();
3049   public:
3050   void unsafe_arena_set_allocated_joinable_config(
3051       ::icing::lib::JoinableConfig* joinable_config);
3052   ::icing::lib::JoinableConfig* unsafe_arena_release_joinable_config();
3053 
3054   // optional .icing.lib.EmbeddingIndexingConfig embedding_indexing_config = 10;
3055   bool has_embedding_indexing_config() const;
3056   private:
3057   bool _internal_has_embedding_indexing_config() const;
3058   public:
3059   void clear_embedding_indexing_config();
3060   const ::icing::lib::EmbeddingIndexingConfig& embedding_indexing_config() const;
3061   PROTOBUF_NODISCARD ::icing::lib::EmbeddingIndexingConfig* release_embedding_indexing_config();
3062   ::icing::lib::EmbeddingIndexingConfig* mutable_embedding_indexing_config();
3063   void set_allocated_embedding_indexing_config(::icing::lib::EmbeddingIndexingConfig* embedding_indexing_config);
3064   private:
3065   const ::icing::lib::EmbeddingIndexingConfig& _internal_embedding_indexing_config() const;
3066   ::icing::lib::EmbeddingIndexingConfig* _internal_mutable_embedding_indexing_config();
3067   public:
3068   void unsafe_arena_set_allocated_embedding_indexing_config(
3069       ::icing::lib::EmbeddingIndexingConfig* embedding_indexing_config);
3070   ::icing::lib::EmbeddingIndexingConfig* unsafe_arena_release_embedding_indexing_config();
3071 
3072   // optional .icing.lib.PropertyConfigProto.DataType.Code data_type = 2;
3073   bool has_data_type() const;
3074   private:
3075   bool _internal_has_data_type() const;
3076   public:
3077   void clear_data_type();
3078   ::icing::lib::PropertyConfigProto_DataType_Code data_type() const;
3079   void set_data_type(::icing::lib::PropertyConfigProto_DataType_Code value);
3080   private:
3081   ::icing::lib::PropertyConfigProto_DataType_Code _internal_data_type() const;
3082   void _internal_set_data_type(::icing::lib::PropertyConfigProto_DataType_Code value);
3083   public:
3084 
3085   // optional .icing.lib.PropertyConfigProto.Cardinality.Code cardinality = 4;
3086   bool has_cardinality() const;
3087   private:
3088   bool _internal_has_cardinality() const;
3089   public:
3090   void clear_cardinality();
3091   ::icing::lib::PropertyConfigProto_Cardinality_Code cardinality() const;
3092   void set_cardinality(::icing::lib::PropertyConfigProto_Cardinality_Code value);
3093   private:
3094   ::icing::lib::PropertyConfigProto_Cardinality_Code _internal_cardinality() const;
3095   void _internal_set_cardinality(::icing::lib::PropertyConfigProto_Cardinality_Code value);
3096   public:
3097 
3098   // optional .icing.lib.PropertyConfigProto.ScorableType.Code scorable_type = 11;
3099   bool has_scorable_type() const;
3100   private:
3101   bool _internal_has_scorable_type() const;
3102   public:
3103   void clear_scorable_type();
3104   ::icing::lib::PropertyConfigProto_ScorableType_Code scorable_type() const;
3105   void set_scorable_type(::icing::lib::PropertyConfigProto_ScorableType_Code value);
3106   private:
3107   ::icing::lib::PropertyConfigProto_ScorableType_Code _internal_scorable_type() const;
3108   void _internal_set_scorable_type(::icing::lib::PropertyConfigProto_ScorableType_Code value);
3109   public:
3110 
3111   // @@protoc_insertion_point(class_scope:icing.lib.PropertyConfigProto)
3112  private:
3113   class _Internal;
3114 
3115   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3116   typedef void InternalArenaConstructable_;
3117   typedef void DestructorSkippable_;
3118   struct Impl_ {
3119     ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
3120     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3121     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr property_name_;
3122     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr schema_type_;
3123     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
3124     ::icing::lib::StringIndexingConfig* string_indexing_config_;
3125     ::icing::lib::DocumentIndexingConfig* document_indexing_config_;
3126     ::icing::lib::IntegerIndexingConfig* integer_indexing_config_;
3127     ::icing::lib::JoinableConfig* joinable_config_;
3128     ::icing::lib::EmbeddingIndexingConfig* embedding_indexing_config_;
3129     int data_type_;
3130     int cardinality_;
3131     int scorable_type_;
3132   };
3133   union { Impl_ _impl_; };
3134   friend struct ::TableStruct_icing_2fproto_2fschema_2eproto;
3135 };
3136 // -------------------------------------------------------------------
3137 
3138 class SchemaProto final :
3139     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.SchemaProto) */ {
3140  public:
SchemaProto()3141   inline SchemaProto() : SchemaProto(nullptr) {}
3142   ~SchemaProto() override;
3143   explicit PROTOBUF_CONSTEXPR SchemaProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
3144 
3145   SchemaProto(const SchemaProto& from);
SchemaProto(SchemaProto && from)3146   SchemaProto(SchemaProto&& from) noexcept
3147     : SchemaProto() {
3148     *this = ::std::move(from);
3149   }
3150 
3151   inline SchemaProto& operator=(const SchemaProto& from) {
3152     if (this == &from) return *this;
3153     CopyFrom(from);
3154     return *this;
3155   }
3156   inline SchemaProto& operator=(SchemaProto&& from) noexcept {
3157     if (this == &from) return *this;
3158     if (GetOwningArena() == from.GetOwningArena()
3159   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
3160         && GetOwningArena() != nullptr
3161   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
3162     ) {
3163       InternalSwap(&from);
3164     } else {
3165       CopyFrom(from);
3166     }
3167     return *this;
3168   }
3169 
unknown_fields()3170   inline const std::string& unknown_fields() const {
3171     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
3172   }
mutable_unknown_fields()3173   inline std::string* mutable_unknown_fields() {
3174     return _internal_metadata_.mutable_unknown_fields<std::string>();
3175   }
3176 
default_instance()3177   static const SchemaProto& default_instance() {
3178     return *internal_default_instance();
3179   }
internal_default_instance()3180   static inline const SchemaProto* internal_default_instance() {
3181     return reinterpret_cast<const SchemaProto*>(
3182                &_SchemaProto_default_instance_);
3183   }
3184   static constexpr int kIndexInFileMessages =
3185     16;
3186 
swap(SchemaProto & a,SchemaProto & b)3187   friend void swap(SchemaProto& a, SchemaProto& b) {
3188     a.Swap(&b);
3189   }
Swap(SchemaProto * other)3190   inline void Swap(SchemaProto* other) {
3191     if (other == this) return;
3192   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
3193     if (GetOwningArena() != nullptr &&
3194         GetOwningArena() == other->GetOwningArena()) {
3195    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
3196     if (GetOwningArena() == other->GetOwningArena()) {
3197   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
3198       InternalSwap(other);
3199     } else {
3200       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
3201     }
3202   }
3203   void UnsafeArenaSwap(SchemaProto* other) {
3204     if (other == this) return;
3205     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
3206     InternalSwap(other);
3207   }
3208 
3209   // implements Message ----------------------------------------------
3210 
3211   SchemaProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3212     return CreateMaybeMessage<SchemaProto>(arena);
3213   }
3214   SchemaProto* New() const {
3215     return New(nullptr);
3216   }
3217   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
3218   void CopyFrom(const SchemaProto& from);
3219   void MergeFrom(const SchemaProto& from);
3220   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3221   bool IsInitialized() const final;
3222 
3223   size_t ByteSizeLong() const final;
3224   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3225   ::uint8_t* _InternalSerialize(
3226       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3227   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
3228 
3229   private:
3230   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
3231   void SharedDtor();
3232   void SetCachedSize(int size) const;
3233   void InternalSwap(SchemaProto* other);
3234 
3235   private:
3236   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3237   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3238     return "icing.lib.SchemaProto";
3239   }
3240   protected:
3241   explicit SchemaProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3242                        bool is_message_owned = false);
3243   public:
3244 
3245   std::string GetTypeName() const final;
3246 
3247   // nested types ----------------------------------------------------
3248 
3249   // accessors -------------------------------------------------------
3250 
3251   enum : int {
3252     kTypesFieldNumber = 1,
3253   };
3254   // repeated .icing.lib.SchemaTypeConfigProto types = 1;
3255   int types_size() const;
3256   private:
3257   int _internal_types_size() const;
3258   public:
3259   void clear_types();
3260   ::icing::lib::SchemaTypeConfigProto* mutable_types(int index);
3261   ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::SchemaTypeConfigProto >*
3262       mutable_types();
3263   private:
3264   const ::icing::lib::SchemaTypeConfigProto& _internal_types(int index) const;
3265   ::icing::lib::SchemaTypeConfigProto* _internal_add_types();
3266   public:
3267   const ::icing::lib::SchemaTypeConfigProto& types(int index) const;
3268   ::icing::lib::SchemaTypeConfigProto* add_types();
3269   const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::SchemaTypeConfigProto >&
3270       types() const;
3271 
3272   // @@protoc_insertion_point(class_scope:icing.lib.SchemaProto)
3273  private:
3274   class _Internal;
3275 
3276   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3277   typedef void InternalArenaConstructable_;
3278   typedef void DestructorSkippable_;
3279   struct Impl_ {
3280     ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::SchemaTypeConfigProto > types_;
3281     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3282   };
3283   union { Impl_ _impl_; };
3284   friend struct ::TableStruct_icing_2fproto_2fschema_2eproto;
3285 };
3286 // -------------------------------------------------------------------
3287 
3288 class SetSchemaResultProto final :
3289     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.SetSchemaResultProto) */ {
3290  public:
SetSchemaResultProto()3291   inline SetSchemaResultProto() : SetSchemaResultProto(nullptr) {}
3292   ~SetSchemaResultProto() override;
3293   explicit PROTOBUF_CONSTEXPR SetSchemaResultProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
3294 
3295   SetSchemaResultProto(const SetSchemaResultProto& from);
SetSchemaResultProto(SetSchemaResultProto && from)3296   SetSchemaResultProto(SetSchemaResultProto&& from) noexcept
3297     : SetSchemaResultProto() {
3298     *this = ::std::move(from);
3299   }
3300 
3301   inline SetSchemaResultProto& operator=(const SetSchemaResultProto& from) {
3302     if (this == &from) return *this;
3303     CopyFrom(from);
3304     return *this;
3305   }
3306   inline SetSchemaResultProto& operator=(SetSchemaResultProto&& from) noexcept {
3307     if (this == &from) return *this;
3308     if (GetOwningArena() == from.GetOwningArena()
3309   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
3310         && GetOwningArena() != nullptr
3311   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
3312     ) {
3313       InternalSwap(&from);
3314     } else {
3315       CopyFrom(from);
3316     }
3317     return *this;
3318   }
3319 
unknown_fields()3320   inline const std::string& unknown_fields() const {
3321     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
3322   }
mutable_unknown_fields()3323   inline std::string* mutable_unknown_fields() {
3324     return _internal_metadata_.mutable_unknown_fields<std::string>();
3325   }
3326 
default_instance()3327   static const SetSchemaResultProto& default_instance() {
3328     return *internal_default_instance();
3329   }
internal_default_instance()3330   static inline const SetSchemaResultProto* internal_default_instance() {
3331     return reinterpret_cast<const SetSchemaResultProto*>(
3332                &_SetSchemaResultProto_default_instance_);
3333   }
3334   static constexpr int kIndexInFileMessages =
3335     17;
3336 
swap(SetSchemaResultProto & a,SetSchemaResultProto & b)3337   friend void swap(SetSchemaResultProto& a, SetSchemaResultProto& b) {
3338     a.Swap(&b);
3339   }
Swap(SetSchemaResultProto * other)3340   inline void Swap(SetSchemaResultProto* other) {
3341     if (other == this) return;
3342   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
3343     if (GetOwningArena() != nullptr &&
3344         GetOwningArena() == other->GetOwningArena()) {
3345    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
3346     if (GetOwningArena() == other->GetOwningArena()) {
3347   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
3348       InternalSwap(other);
3349     } else {
3350       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
3351     }
3352   }
3353   void UnsafeArenaSwap(SetSchemaResultProto* other) {
3354     if (other == this) return;
3355     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
3356     InternalSwap(other);
3357   }
3358 
3359   // implements Message ----------------------------------------------
3360 
3361   SetSchemaResultProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3362     return CreateMaybeMessage<SetSchemaResultProto>(arena);
3363   }
3364   SetSchemaResultProto* New() const {
3365     return New(nullptr);
3366   }
3367   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
3368   void CopyFrom(const SetSchemaResultProto& from);
3369   void MergeFrom(const SetSchemaResultProto& from);
3370   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3371   bool IsInitialized() const final;
3372 
3373   size_t ByteSizeLong() const final;
3374   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3375   ::uint8_t* _InternalSerialize(
3376       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3377   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
3378 
3379   private:
3380   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
3381   void SharedDtor();
3382   void SetCachedSize(int size) const;
3383   void InternalSwap(SetSchemaResultProto* other);
3384 
3385   private:
3386   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3387   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3388     return "icing.lib.SetSchemaResultProto";
3389   }
3390   protected:
3391   explicit SetSchemaResultProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3392                        bool is_message_owned = false);
3393   public:
3394 
3395   std::string GetTypeName() const final;
3396 
3397   // nested types ----------------------------------------------------
3398 
3399   // accessors -------------------------------------------------------
3400 
3401   enum : int {
3402     kDeletedSchemaTypesFieldNumber = 2,
3403     kIncompatibleSchemaTypesFieldNumber = 3,
3404     kNewSchemaTypesFieldNumber = 4,
3405     kFullyCompatibleChangedSchemaTypesFieldNumber = 5,
3406     kIndexIncompatibleChangedSchemaTypesFieldNumber = 6,
3407     kJoinIncompatibleChangedSchemaTypesFieldNumber = 8,
3408     kStatusFieldNumber = 1,
3409     kLatencyMsFieldNumber = 7,
3410   };
3411   // repeated string deleted_schema_types = 2;
3412   int deleted_schema_types_size() const;
3413   private:
3414   int _internal_deleted_schema_types_size() const;
3415   public:
3416   void clear_deleted_schema_types();
3417   const std::string& deleted_schema_types(int index) const;
3418   std::string* mutable_deleted_schema_types(int index);
3419   void set_deleted_schema_types(int index, const std::string& value);
3420   void set_deleted_schema_types(int index, std::string&& value);
3421   void set_deleted_schema_types(int index, const char* value);
3422   void set_deleted_schema_types(int index, const char* value, size_t size);
3423   std::string* add_deleted_schema_types();
3424   void add_deleted_schema_types(const std::string& value);
3425   void add_deleted_schema_types(std::string&& value);
3426   void add_deleted_schema_types(const char* value);
3427   void add_deleted_schema_types(const char* value, size_t size);
3428   const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& deleted_schema_types() const;
3429   ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_deleted_schema_types();
3430   private:
3431   const std::string& _internal_deleted_schema_types(int index) const;
3432   std::string* _internal_add_deleted_schema_types();
3433   public:
3434 
3435   // repeated string incompatible_schema_types = 3;
3436   int incompatible_schema_types_size() const;
3437   private:
3438   int _internal_incompatible_schema_types_size() const;
3439   public:
3440   void clear_incompatible_schema_types();
3441   const std::string& incompatible_schema_types(int index) const;
3442   std::string* mutable_incompatible_schema_types(int index);
3443   void set_incompatible_schema_types(int index, const std::string& value);
3444   void set_incompatible_schema_types(int index, std::string&& value);
3445   void set_incompatible_schema_types(int index, const char* value);
3446   void set_incompatible_schema_types(int index, const char* value, size_t size);
3447   std::string* add_incompatible_schema_types();
3448   void add_incompatible_schema_types(const std::string& value);
3449   void add_incompatible_schema_types(std::string&& value);
3450   void add_incompatible_schema_types(const char* value);
3451   void add_incompatible_schema_types(const char* value, size_t size);
3452   const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& incompatible_schema_types() const;
3453   ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_incompatible_schema_types();
3454   private:
3455   const std::string& _internal_incompatible_schema_types(int index) const;
3456   std::string* _internal_add_incompatible_schema_types();
3457   public:
3458 
3459   // repeated string new_schema_types = 4;
3460   int new_schema_types_size() const;
3461   private:
3462   int _internal_new_schema_types_size() const;
3463   public:
3464   void clear_new_schema_types();
3465   const std::string& new_schema_types(int index) const;
3466   std::string* mutable_new_schema_types(int index);
3467   void set_new_schema_types(int index, const std::string& value);
3468   void set_new_schema_types(int index, std::string&& value);
3469   void set_new_schema_types(int index, const char* value);
3470   void set_new_schema_types(int index, const char* value, size_t size);
3471   std::string* add_new_schema_types();
3472   void add_new_schema_types(const std::string& value);
3473   void add_new_schema_types(std::string&& value);
3474   void add_new_schema_types(const char* value);
3475   void add_new_schema_types(const char* value, size_t size);
3476   const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& new_schema_types() const;
3477   ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_new_schema_types();
3478   private:
3479   const std::string& _internal_new_schema_types(int index) const;
3480   std::string* _internal_add_new_schema_types();
3481   public:
3482 
3483   // repeated string fully_compatible_changed_schema_types = 5;
3484   int fully_compatible_changed_schema_types_size() const;
3485   private:
3486   int _internal_fully_compatible_changed_schema_types_size() const;
3487   public:
3488   void clear_fully_compatible_changed_schema_types();
3489   const std::string& fully_compatible_changed_schema_types(int index) const;
3490   std::string* mutable_fully_compatible_changed_schema_types(int index);
3491   void set_fully_compatible_changed_schema_types(int index, const std::string& value);
3492   void set_fully_compatible_changed_schema_types(int index, std::string&& value);
3493   void set_fully_compatible_changed_schema_types(int index, const char* value);
3494   void set_fully_compatible_changed_schema_types(int index, const char* value, size_t size);
3495   std::string* add_fully_compatible_changed_schema_types();
3496   void add_fully_compatible_changed_schema_types(const std::string& value);
3497   void add_fully_compatible_changed_schema_types(std::string&& value);
3498   void add_fully_compatible_changed_schema_types(const char* value);
3499   void add_fully_compatible_changed_schema_types(const char* value, size_t size);
3500   const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& fully_compatible_changed_schema_types() const;
3501   ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_fully_compatible_changed_schema_types();
3502   private:
3503   const std::string& _internal_fully_compatible_changed_schema_types(int index) const;
3504   std::string* _internal_add_fully_compatible_changed_schema_types();
3505   public:
3506 
3507   // repeated string index_incompatible_changed_schema_types = 6;
3508   int index_incompatible_changed_schema_types_size() const;
3509   private:
3510   int _internal_index_incompatible_changed_schema_types_size() const;
3511   public:
3512   void clear_index_incompatible_changed_schema_types();
3513   const std::string& index_incompatible_changed_schema_types(int index) const;
3514   std::string* mutable_index_incompatible_changed_schema_types(int index);
3515   void set_index_incompatible_changed_schema_types(int index, const std::string& value);
3516   void set_index_incompatible_changed_schema_types(int index, std::string&& value);
3517   void set_index_incompatible_changed_schema_types(int index, const char* value);
3518   void set_index_incompatible_changed_schema_types(int index, const char* value, size_t size);
3519   std::string* add_index_incompatible_changed_schema_types();
3520   void add_index_incompatible_changed_schema_types(const std::string& value);
3521   void add_index_incompatible_changed_schema_types(std::string&& value);
3522   void add_index_incompatible_changed_schema_types(const char* value);
3523   void add_index_incompatible_changed_schema_types(const char* value, size_t size);
3524   const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& index_incompatible_changed_schema_types() const;
3525   ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_index_incompatible_changed_schema_types();
3526   private:
3527   const std::string& _internal_index_incompatible_changed_schema_types(int index) const;
3528   std::string* _internal_add_index_incompatible_changed_schema_types();
3529   public:
3530 
3531   // repeated string join_incompatible_changed_schema_types = 8;
3532   int join_incompatible_changed_schema_types_size() const;
3533   private:
3534   int _internal_join_incompatible_changed_schema_types_size() const;
3535   public:
3536   void clear_join_incompatible_changed_schema_types();
3537   const std::string& join_incompatible_changed_schema_types(int index) const;
3538   std::string* mutable_join_incompatible_changed_schema_types(int index);
3539   void set_join_incompatible_changed_schema_types(int index, const std::string& value);
3540   void set_join_incompatible_changed_schema_types(int index, std::string&& value);
3541   void set_join_incompatible_changed_schema_types(int index, const char* value);
3542   void set_join_incompatible_changed_schema_types(int index, const char* value, size_t size);
3543   std::string* add_join_incompatible_changed_schema_types();
3544   void add_join_incompatible_changed_schema_types(const std::string& value);
3545   void add_join_incompatible_changed_schema_types(std::string&& value);
3546   void add_join_incompatible_changed_schema_types(const char* value);
3547   void add_join_incompatible_changed_schema_types(const char* value, size_t size);
3548   const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& join_incompatible_changed_schema_types() const;
3549   ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_join_incompatible_changed_schema_types();
3550   private:
3551   const std::string& _internal_join_incompatible_changed_schema_types(int index) const;
3552   std::string* _internal_add_join_incompatible_changed_schema_types();
3553   public:
3554 
3555   // optional .icing.lib.StatusProto status = 1;
3556   bool has_status() const;
3557   private:
3558   bool _internal_has_status() const;
3559   public:
3560   void clear_status();
3561   const ::icing::lib::StatusProto& status() const;
3562   PROTOBUF_NODISCARD ::icing::lib::StatusProto* release_status();
3563   ::icing::lib::StatusProto* mutable_status();
3564   void set_allocated_status(::icing::lib::StatusProto* status);
3565   private:
3566   const ::icing::lib::StatusProto& _internal_status() const;
3567   ::icing::lib::StatusProto* _internal_mutable_status();
3568   public:
3569   void unsafe_arena_set_allocated_status(
3570       ::icing::lib::StatusProto* status);
3571   ::icing::lib::StatusProto* unsafe_arena_release_status();
3572 
3573   // optional int32 latency_ms = 7;
3574   bool has_latency_ms() const;
3575   private:
3576   bool _internal_has_latency_ms() const;
3577   public:
3578   void clear_latency_ms();
3579   ::int32_t latency_ms() const;
3580   void set_latency_ms(::int32_t value);
3581   private:
3582   ::int32_t _internal_latency_ms() const;
3583   void _internal_set_latency_ms(::int32_t value);
3584   public:
3585 
3586   // @@protoc_insertion_point(class_scope:icing.lib.SetSchemaResultProto)
3587  private:
3588   class _Internal;
3589 
3590   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3591   typedef void InternalArenaConstructable_;
3592   typedef void DestructorSkippable_;
3593   struct Impl_ {
3594     ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
3595     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3596     ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> deleted_schema_types_;
3597     ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> incompatible_schema_types_;
3598     ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> new_schema_types_;
3599     ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> fully_compatible_changed_schema_types_;
3600     ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> index_incompatible_changed_schema_types_;
3601     ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> join_incompatible_changed_schema_types_;
3602     ::icing::lib::StatusProto* status_;
3603     ::int32_t latency_ms_;
3604   };
3605   union { Impl_ _impl_; };
3606   friend struct ::TableStruct_icing_2fproto_2fschema_2eproto;
3607 };
3608 // -------------------------------------------------------------------
3609 
3610 class GetSchemaResultProto final :
3611     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.GetSchemaResultProto) */ {
3612  public:
GetSchemaResultProto()3613   inline GetSchemaResultProto() : GetSchemaResultProto(nullptr) {}
3614   ~GetSchemaResultProto() override;
3615   explicit PROTOBUF_CONSTEXPR GetSchemaResultProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
3616 
3617   GetSchemaResultProto(const GetSchemaResultProto& from);
GetSchemaResultProto(GetSchemaResultProto && from)3618   GetSchemaResultProto(GetSchemaResultProto&& from) noexcept
3619     : GetSchemaResultProto() {
3620     *this = ::std::move(from);
3621   }
3622 
3623   inline GetSchemaResultProto& operator=(const GetSchemaResultProto& from) {
3624     if (this == &from) return *this;
3625     CopyFrom(from);
3626     return *this;
3627   }
3628   inline GetSchemaResultProto& operator=(GetSchemaResultProto&& from) noexcept {
3629     if (this == &from) return *this;
3630     if (GetOwningArena() == from.GetOwningArena()
3631   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
3632         && GetOwningArena() != nullptr
3633   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
3634     ) {
3635       InternalSwap(&from);
3636     } else {
3637       CopyFrom(from);
3638     }
3639     return *this;
3640   }
3641 
unknown_fields()3642   inline const std::string& unknown_fields() const {
3643     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
3644   }
mutable_unknown_fields()3645   inline std::string* mutable_unknown_fields() {
3646     return _internal_metadata_.mutable_unknown_fields<std::string>();
3647   }
3648 
default_instance()3649   static const GetSchemaResultProto& default_instance() {
3650     return *internal_default_instance();
3651   }
internal_default_instance()3652   static inline const GetSchemaResultProto* internal_default_instance() {
3653     return reinterpret_cast<const GetSchemaResultProto*>(
3654                &_GetSchemaResultProto_default_instance_);
3655   }
3656   static constexpr int kIndexInFileMessages =
3657     18;
3658 
swap(GetSchemaResultProto & a,GetSchemaResultProto & b)3659   friend void swap(GetSchemaResultProto& a, GetSchemaResultProto& b) {
3660     a.Swap(&b);
3661   }
Swap(GetSchemaResultProto * other)3662   inline void Swap(GetSchemaResultProto* other) {
3663     if (other == this) return;
3664   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
3665     if (GetOwningArena() != nullptr &&
3666         GetOwningArena() == other->GetOwningArena()) {
3667    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
3668     if (GetOwningArena() == other->GetOwningArena()) {
3669   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
3670       InternalSwap(other);
3671     } else {
3672       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
3673     }
3674   }
3675   void UnsafeArenaSwap(GetSchemaResultProto* other) {
3676     if (other == this) return;
3677     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
3678     InternalSwap(other);
3679   }
3680 
3681   // implements Message ----------------------------------------------
3682 
3683   GetSchemaResultProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3684     return CreateMaybeMessage<GetSchemaResultProto>(arena);
3685   }
3686   GetSchemaResultProto* New() const {
3687     return New(nullptr);
3688   }
3689   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
3690   void CopyFrom(const GetSchemaResultProto& from);
3691   void MergeFrom(const GetSchemaResultProto& from);
3692   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3693   bool IsInitialized() const final;
3694 
3695   size_t ByteSizeLong() const final;
3696   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3697   ::uint8_t* _InternalSerialize(
3698       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3699   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
3700 
3701   private:
3702   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
3703   void SharedDtor();
3704   void SetCachedSize(int size) const;
3705   void InternalSwap(GetSchemaResultProto* other);
3706 
3707   private:
3708   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3709   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3710     return "icing.lib.GetSchemaResultProto";
3711   }
3712   protected:
3713   explicit GetSchemaResultProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3714                        bool is_message_owned = false);
3715   public:
3716 
3717   std::string GetTypeName() const final;
3718 
3719   // nested types ----------------------------------------------------
3720 
3721   // accessors -------------------------------------------------------
3722 
3723   enum : int {
3724     kStatusFieldNumber = 1,
3725     kSchemaFieldNumber = 2,
3726   };
3727   // optional .icing.lib.StatusProto status = 1;
3728   bool has_status() const;
3729   private:
3730   bool _internal_has_status() const;
3731   public:
3732   void clear_status();
3733   const ::icing::lib::StatusProto& status() const;
3734   PROTOBUF_NODISCARD ::icing::lib::StatusProto* release_status();
3735   ::icing::lib::StatusProto* mutable_status();
3736   void set_allocated_status(::icing::lib::StatusProto* status);
3737   private:
3738   const ::icing::lib::StatusProto& _internal_status() const;
3739   ::icing::lib::StatusProto* _internal_mutable_status();
3740   public:
3741   void unsafe_arena_set_allocated_status(
3742       ::icing::lib::StatusProto* status);
3743   ::icing::lib::StatusProto* unsafe_arena_release_status();
3744 
3745   // optional .icing.lib.SchemaProto schema = 2;
3746   bool has_schema() const;
3747   private:
3748   bool _internal_has_schema() const;
3749   public:
3750   void clear_schema();
3751   const ::icing::lib::SchemaProto& schema() const;
3752   PROTOBUF_NODISCARD ::icing::lib::SchemaProto* release_schema();
3753   ::icing::lib::SchemaProto* mutable_schema();
3754   void set_allocated_schema(::icing::lib::SchemaProto* schema);
3755   private:
3756   const ::icing::lib::SchemaProto& _internal_schema() const;
3757   ::icing::lib::SchemaProto* _internal_mutable_schema();
3758   public:
3759   void unsafe_arena_set_allocated_schema(
3760       ::icing::lib::SchemaProto* schema);
3761   ::icing::lib::SchemaProto* unsafe_arena_release_schema();
3762 
3763   // @@protoc_insertion_point(class_scope:icing.lib.GetSchemaResultProto)
3764  private:
3765   class _Internal;
3766 
3767   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3768   typedef void InternalArenaConstructable_;
3769   typedef void DestructorSkippable_;
3770   struct Impl_ {
3771     ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
3772     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3773     ::icing::lib::StatusProto* status_;
3774     ::icing::lib::SchemaProto* schema_;
3775   };
3776   union { Impl_ _impl_; };
3777   friend struct ::TableStruct_icing_2fproto_2fschema_2eproto;
3778 };
3779 // -------------------------------------------------------------------
3780 
3781 class GetSchemaTypeResultProto final :
3782     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.GetSchemaTypeResultProto) */ {
3783  public:
GetSchemaTypeResultProto()3784   inline GetSchemaTypeResultProto() : GetSchemaTypeResultProto(nullptr) {}
3785   ~GetSchemaTypeResultProto() override;
3786   explicit PROTOBUF_CONSTEXPR GetSchemaTypeResultProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
3787 
3788   GetSchemaTypeResultProto(const GetSchemaTypeResultProto& from);
GetSchemaTypeResultProto(GetSchemaTypeResultProto && from)3789   GetSchemaTypeResultProto(GetSchemaTypeResultProto&& from) noexcept
3790     : GetSchemaTypeResultProto() {
3791     *this = ::std::move(from);
3792   }
3793 
3794   inline GetSchemaTypeResultProto& operator=(const GetSchemaTypeResultProto& from) {
3795     if (this == &from) return *this;
3796     CopyFrom(from);
3797     return *this;
3798   }
3799   inline GetSchemaTypeResultProto& operator=(GetSchemaTypeResultProto&& from) noexcept {
3800     if (this == &from) return *this;
3801     if (GetOwningArena() == from.GetOwningArena()
3802   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
3803         && GetOwningArena() != nullptr
3804   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
3805     ) {
3806       InternalSwap(&from);
3807     } else {
3808       CopyFrom(from);
3809     }
3810     return *this;
3811   }
3812 
unknown_fields()3813   inline const std::string& unknown_fields() const {
3814     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
3815   }
mutable_unknown_fields()3816   inline std::string* mutable_unknown_fields() {
3817     return _internal_metadata_.mutable_unknown_fields<std::string>();
3818   }
3819 
default_instance()3820   static const GetSchemaTypeResultProto& default_instance() {
3821     return *internal_default_instance();
3822   }
internal_default_instance()3823   static inline const GetSchemaTypeResultProto* internal_default_instance() {
3824     return reinterpret_cast<const GetSchemaTypeResultProto*>(
3825                &_GetSchemaTypeResultProto_default_instance_);
3826   }
3827   static constexpr int kIndexInFileMessages =
3828     19;
3829 
swap(GetSchemaTypeResultProto & a,GetSchemaTypeResultProto & b)3830   friend void swap(GetSchemaTypeResultProto& a, GetSchemaTypeResultProto& b) {
3831     a.Swap(&b);
3832   }
Swap(GetSchemaTypeResultProto * other)3833   inline void Swap(GetSchemaTypeResultProto* other) {
3834     if (other == this) return;
3835   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
3836     if (GetOwningArena() != nullptr &&
3837         GetOwningArena() == other->GetOwningArena()) {
3838    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
3839     if (GetOwningArena() == other->GetOwningArena()) {
3840   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
3841       InternalSwap(other);
3842     } else {
3843       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
3844     }
3845   }
3846   void UnsafeArenaSwap(GetSchemaTypeResultProto* other) {
3847     if (other == this) return;
3848     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
3849     InternalSwap(other);
3850   }
3851 
3852   // implements Message ----------------------------------------------
3853 
3854   GetSchemaTypeResultProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3855     return CreateMaybeMessage<GetSchemaTypeResultProto>(arena);
3856   }
3857   GetSchemaTypeResultProto* New() const {
3858     return New(nullptr);
3859   }
3860   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
3861   void CopyFrom(const GetSchemaTypeResultProto& from);
3862   void MergeFrom(const GetSchemaTypeResultProto& from);
3863   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3864   bool IsInitialized() const final;
3865 
3866   size_t ByteSizeLong() const final;
3867   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3868   ::uint8_t* _InternalSerialize(
3869       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3870   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
3871 
3872   private:
3873   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
3874   void SharedDtor();
3875   void SetCachedSize(int size) const;
3876   void InternalSwap(GetSchemaTypeResultProto* other);
3877 
3878   private:
3879   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3880   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3881     return "icing.lib.GetSchemaTypeResultProto";
3882   }
3883   protected:
3884   explicit GetSchemaTypeResultProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3885                        bool is_message_owned = false);
3886   public:
3887 
3888   std::string GetTypeName() const final;
3889 
3890   // nested types ----------------------------------------------------
3891 
3892   // accessors -------------------------------------------------------
3893 
3894   enum : int {
3895     kStatusFieldNumber = 1,
3896     kSchemaTypeConfigFieldNumber = 2,
3897   };
3898   // optional .icing.lib.StatusProto status = 1;
3899   bool has_status() const;
3900   private:
3901   bool _internal_has_status() const;
3902   public:
3903   void clear_status();
3904   const ::icing::lib::StatusProto& status() const;
3905   PROTOBUF_NODISCARD ::icing::lib::StatusProto* release_status();
3906   ::icing::lib::StatusProto* mutable_status();
3907   void set_allocated_status(::icing::lib::StatusProto* status);
3908   private:
3909   const ::icing::lib::StatusProto& _internal_status() const;
3910   ::icing::lib::StatusProto* _internal_mutable_status();
3911   public:
3912   void unsafe_arena_set_allocated_status(
3913       ::icing::lib::StatusProto* status);
3914   ::icing::lib::StatusProto* unsafe_arena_release_status();
3915 
3916   // optional .icing.lib.SchemaTypeConfigProto schema_type_config = 2;
3917   bool has_schema_type_config() const;
3918   private:
3919   bool _internal_has_schema_type_config() const;
3920   public:
3921   void clear_schema_type_config();
3922   const ::icing::lib::SchemaTypeConfigProto& schema_type_config() const;
3923   PROTOBUF_NODISCARD ::icing::lib::SchemaTypeConfigProto* release_schema_type_config();
3924   ::icing::lib::SchemaTypeConfigProto* mutable_schema_type_config();
3925   void set_allocated_schema_type_config(::icing::lib::SchemaTypeConfigProto* schema_type_config);
3926   private:
3927   const ::icing::lib::SchemaTypeConfigProto& _internal_schema_type_config() const;
3928   ::icing::lib::SchemaTypeConfigProto* _internal_mutable_schema_type_config();
3929   public:
3930   void unsafe_arena_set_allocated_schema_type_config(
3931       ::icing::lib::SchemaTypeConfigProto* schema_type_config);
3932   ::icing::lib::SchemaTypeConfigProto* unsafe_arena_release_schema_type_config();
3933 
3934   // @@protoc_insertion_point(class_scope:icing.lib.GetSchemaTypeResultProto)
3935  private:
3936   class _Internal;
3937 
3938   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3939   typedef void InternalArenaConstructable_;
3940   typedef void DestructorSkippable_;
3941   struct Impl_ {
3942     ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
3943     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3944     ::icing::lib::StatusProto* status_;
3945     ::icing::lib::SchemaTypeConfigProto* schema_type_config_;
3946   };
3947   union { Impl_ _impl_; };
3948   friend struct ::TableStruct_icing_2fproto_2fschema_2eproto;
3949 };
3950 // ===================================================================
3951 
3952 
3953 // ===================================================================
3954 
3955 #ifdef __GNUC__
3956   #pragma GCC diagnostic push
3957   #pragma GCC diagnostic ignored "-Wstrict-aliasing"
3958 #endif  // __GNUC__
3959 // SchemaTypeConfigProto
3960 
3961 // optional string schema_type = 1;
_internal_has_schema_type()3962 inline bool SchemaTypeConfigProto::_internal_has_schema_type() const {
3963   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
3964   return value;
3965 }
has_schema_type()3966 inline bool SchemaTypeConfigProto::has_schema_type() const {
3967   return _internal_has_schema_type();
3968 }
clear_schema_type()3969 inline void SchemaTypeConfigProto::clear_schema_type() {
3970   _impl_.schema_type_.ClearToEmpty();
3971   _impl_._has_bits_[0] &= ~0x00000001u;
3972 }
schema_type()3973 inline const std::string& SchemaTypeConfigProto::schema_type() const {
3974   // @@protoc_insertion_point(field_get:icing.lib.SchemaTypeConfigProto.schema_type)
3975   return _internal_schema_type();
3976 }
3977 template <typename ArgT0, typename... ArgT>
3978 inline PROTOBUF_ALWAYS_INLINE
set_schema_type(ArgT0 && arg0,ArgT...args)3979 void SchemaTypeConfigProto::set_schema_type(ArgT0&& arg0, ArgT... args) {
3980  _impl_._has_bits_[0] |= 0x00000001u;
3981  _impl_.schema_type_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3982   // @@protoc_insertion_point(field_set:icing.lib.SchemaTypeConfigProto.schema_type)
3983 }
mutable_schema_type()3984 inline std::string* SchemaTypeConfigProto::mutable_schema_type() {
3985   std::string* _s = _internal_mutable_schema_type();
3986   // @@protoc_insertion_point(field_mutable:icing.lib.SchemaTypeConfigProto.schema_type)
3987   return _s;
3988 }
_internal_schema_type()3989 inline const std::string& SchemaTypeConfigProto::_internal_schema_type() const {
3990   return _impl_.schema_type_.Get();
3991 }
_internal_set_schema_type(const std::string & value)3992 inline void SchemaTypeConfigProto::_internal_set_schema_type(const std::string& value) {
3993   _impl_._has_bits_[0] |= 0x00000001u;
3994   _impl_.schema_type_.Set(value, GetArenaForAllocation());
3995 }
_internal_mutable_schema_type()3996 inline std::string* SchemaTypeConfigProto::_internal_mutable_schema_type() {
3997   _impl_._has_bits_[0] |= 0x00000001u;
3998   return _impl_.schema_type_.Mutable(GetArenaForAllocation());
3999 }
release_schema_type()4000 inline std::string* SchemaTypeConfigProto::release_schema_type() {
4001   // @@protoc_insertion_point(field_release:icing.lib.SchemaTypeConfigProto.schema_type)
4002   if (!_internal_has_schema_type()) {
4003     return nullptr;
4004   }
4005   _impl_._has_bits_[0] &= ~0x00000001u;
4006   auto* p = _impl_.schema_type_.Release();
4007 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4008   if (_impl_.schema_type_.IsDefault()) {
4009     _impl_.schema_type_.Set("", GetArenaForAllocation());
4010   }
4011 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4012   return p;
4013 }
set_allocated_schema_type(std::string * schema_type)4014 inline void SchemaTypeConfigProto::set_allocated_schema_type(std::string* schema_type) {
4015   if (schema_type != nullptr) {
4016     _impl_._has_bits_[0] |= 0x00000001u;
4017   } else {
4018     _impl_._has_bits_[0] &= ~0x00000001u;
4019   }
4020   _impl_.schema_type_.SetAllocated(schema_type, GetArenaForAllocation());
4021 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4022   if (_impl_.schema_type_.IsDefault()) {
4023     _impl_.schema_type_.Set("", GetArenaForAllocation());
4024   }
4025 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4026   // @@protoc_insertion_point(field_set_allocated:icing.lib.SchemaTypeConfigProto.schema_type)
4027 }
4028 
4029 // optional string description = 7;
_internal_has_description()4030 inline bool SchemaTypeConfigProto::_internal_has_description() const {
4031   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
4032   return value;
4033 }
has_description()4034 inline bool SchemaTypeConfigProto::has_description() const {
4035   return _internal_has_description();
4036 }
clear_description()4037 inline void SchemaTypeConfigProto::clear_description() {
4038   _impl_.description_.ClearToEmpty();
4039   _impl_._has_bits_[0] &= ~0x00000002u;
4040 }
description()4041 inline const std::string& SchemaTypeConfigProto::description() const {
4042   // @@protoc_insertion_point(field_get:icing.lib.SchemaTypeConfigProto.description)
4043   return _internal_description();
4044 }
4045 template <typename ArgT0, typename... ArgT>
4046 inline PROTOBUF_ALWAYS_INLINE
set_description(ArgT0 && arg0,ArgT...args)4047 void SchemaTypeConfigProto::set_description(ArgT0&& arg0, ArgT... args) {
4048  _impl_._has_bits_[0] |= 0x00000002u;
4049  _impl_.description_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
4050   // @@protoc_insertion_point(field_set:icing.lib.SchemaTypeConfigProto.description)
4051 }
mutable_description()4052 inline std::string* SchemaTypeConfigProto::mutable_description() {
4053   std::string* _s = _internal_mutable_description();
4054   // @@protoc_insertion_point(field_mutable:icing.lib.SchemaTypeConfigProto.description)
4055   return _s;
4056 }
_internal_description()4057 inline const std::string& SchemaTypeConfigProto::_internal_description() const {
4058   return _impl_.description_.Get();
4059 }
_internal_set_description(const std::string & value)4060 inline void SchemaTypeConfigProto::_internal_set_description(const std::string& value) {
4061   _impl_._has_bits_[0] |= 0x00000002u;
4062   _impl_.description_.Set(value, GetArenaForAllocation());
4063 }
_internal_mutable_description()4064 inline std::string* SchemaTypeConfigProto::_internal_mutable_description() {
4065   _impl_._has_bits_[0] |= 0x00000002u;
4066   return _impl_.description_.Mutable(GetArenaForAllocation());
4067 }
release_description()4068 inline std::string* SchemaTypeConfigProto::release_description() {
4069   // @@protoc_insertion_point(field_release:icing.lib.SchemaTypeConfigProto.description)
4070   if (!_internal_has_description()) {
4071     return nullptr;
4072   }
4073   _impl_._has_bits_[0] &= ~0x00000002u;
4074   auto* p = _impl_.description_.Release();
4075 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4076   if (_impl_.description_.IsDefault()) {
4077     _impl_.description_.Set("", GetArenaForAllocation());
4078   }
4079 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4080   return p;
4081 }
set_allocated_description(std::string * description)4082 inline void SchemaTypeConfigProto::set_allocated_description(std::string* description) {
4083   if (description != nullptr) {
4084     _impl_._has_bits_[0] |= 0x00000002u;
4085   } else {
4086     _impl_._has_bits_[0] &= ~0x00000002u;
4087   }
4088   _impl_.description_.SetAllocated(description, GetArenaForAllocation());
4089 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4090   if (_impl_.description_.IsDefault()) {
4091     _impl_.description_.Set("", GetArenaForAllocation());
4092   }
4093 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4094   // @@protoc_insertion_point(field_set_allocated:icing.lib.SchemaTypeConfigProto.description)
4095 }
4096 
4097 // optional string database = 8;
_internal_has_database()4098 inline bool SchemaTypeConfigProto::_internal_has_database() const {
4099   bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
4100   return value;
4101 }
has_database()4102 inline bool SchemaTypeConfigProto::has_database() const {
4103   return _internal_has_database();
4104 }
clear_database()4105 inline void SchemaTypeConfigProto::clear_database() {
4106   _impl_.database_.ClearToEmpty();
4107   _impl_._has_bits_[0] &= ~0x00000004u;
4108 }
database()4109 inline const std::string& SchemaTypeConfigProto::database() const {
4110   // @@protoc_insertion_point(field_get:icing.lib.SchemaTypeConfigProto.database)
4111   return _internal_database();
4112 }
4113 template <typename ArgT0, typename... ArgT>
4114 inline PROTOBUF_ALWAYS_INLINE
set_database(ArgT0 && arg0,ArgT...args)4115 void SchemaTypeConfigProto::set_database(ArgT0&& arg0, ArgT... args) {
4116  _impl_._has_bits_[0] |= 0x00000004u;
4117  _impl_.database_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
4118   // @@protoc_insertion_point(field_set:icing.lib.SchemaTypeConfigProto.database)
4119 }
mutable_database()4120 inline std::string* SchemaTypeConfigProto::mutable_database() {
4121   std::string* _s = _internal_mutable_database();
4122   // @@protoc_insertion_point(field_mutable:icing.lib.SchemaTypeConfigProto.database)
4123   return _s;
4124 }
_internal_database()4125 inline const std::string& SchemaTypeConfigProto::_internal_database() const {
4126   return _impl_.database_.Get();
4127 }
_internal_set_database(const std::string & value)4128 inline void SchemaTypeConfigProto::_internal_set_database(const std::string& value) {
4129   _impl_._has_bits_[0] |= 0x00000004u;
4130   _impl_.database_.Set(value, GetArenaForAllocation());
4131 }
_internal_mutable_database()4132 inline std::string* SchemaTypeConfigProto::_internal_mutable_database() {
4133   _impl_._has_bits_[0] |= 0x00000004u;
4134   return _impl_.database_.Mutable(GetArenaForAllocation());
4135 }
release_database()4136 inline std::string* SchemaTypeConfigProto::release_database() {
4137   // @@protoc_insertion_point(field_release:icing.lib.SchemaTypeConfigProto.database)
4138   if (!_internal_has_database()) {
4139     return nullptr;
4140   }
4141   _impl_._has_bits_[0] &= ~0x00000004u;
4142   auto* p = _impl_.database_.Release();
4143 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4144   if (_impl_.database_.IsDefault()) {
4145     _impl_.database_.Set("", GetArenaForAllocation());
4146   }
4147 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4148   return p;
4149 }
set_allocated_database(std::string * database)4150 inline void SchemaTypeConfigProto::set_allocated_database(std::string* database) {
4151   if (database != nullptr) {
4152     _impl_._has_bits_[0] |= 0x00000004u;
4153   } else {
4154     _impl_._has_bits_[0] &= ~0x00000004u;
4155   }
4156   _impl_.database_.SetAllocated(database, GetArenaForAllocation());
4157 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4158   if (_impl_.database_.IsDefault()) {
4159     _impl_.database_.Set("", GetArenaForAllocation());
4160   }
4161 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4162   // @@protoc_insertion_point(field_set_allocated:icing.lib.SchemaTypeConfigProto.database)
4163 }
4164 
4165 // repeated .icing.lib.PropertyConfigProto properties = 4;
_internal_properties_size()4166 inline int SchemaTypeConfigProto::_internal_properties_size() const {
4167   return _impl_.properties_.size();
4168 }
properties_size()4169 inline int SchemaTypeConfigProto::properties_size() const {
4170   return _internal_properties_size();
4171 }
clear_properties()4172 inline void SchemaTypeConfigProto::clear_properties() {
4173   _impl_.properties_.Clear();
4174 }
mutable_properties(int index)4175 inline ::icing::lib::PropertyConfigProto* SchemaTypeConfigProto::mutable_properties(int index) {
4176   // @@protoc_insertion_point(field_mutable:icing.lib.SchemaTypeConfigProto.properties)
4177   return _impl_.properties_.Mutable(index);
4178 }
4179 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::PropertyConfigProto >*
mutable_properties()4180 SchemaTypeConfigProto::mutable_properties() {
4181   // @@protoc_insertion_point(field_mutable_list:icing.lib.SchemaTypeConfigProto.properties)
4182   return &_impl_.properties_;
4183 }
_internal_properties(int index)4184 inline const ::icing::lib::PropertyConfigProto& SchemaTypeConfigProto::_internal_properties(int index) const {
4185   return _impl_.properties_.Get(index);
4186 }
properties(int index)4187 inline const ::icing::lib::PropertyConfigProto& SchemaTypeConfigProto::properties(int index) const {
4188   // @@protoc_insertion_point(field_get:icing.lib.SchemaTypeConfigProto.properties)
4189   return _internal_properties(index);
4190 }
_internal_add_properties()4191 inline ::icing::lib::PropertyConfigProto* SchemaTypeConfigProto::_internal_add_properties() {
4192   return _impl_.properties_.Add();
4193 }
add_properties()4194 inline ::icing::lib::PropertyConfigProto* SchemaTypeConfigProto::add_properties() {
4195   ::icing::lib::PropertyConfigProto* _add = _internal_add_properties();
4196   // @@protoc_insertion_point(field_add:icing.lib.SchemaTypeConfigProto.properties)
4197   return _add;
4198 }
4199 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::PropertyConfigProto >&
properties()4200 SchemaTypeConfigProto::properties() const {
4201   // @@protoc_insertion_point(field_list:icing.lib.SchemaTypeConfigProto.properties)
4202   return _impl_.properties_;
4203 }
4204 
4205 // optional int32 version = 5;
_internal_has_version()4206 inline bool SchemaTypeConfigProto::_internal_has_version() const {
4207   bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
4208   return value;
4209 }
has_version()4210 inline bool SchemaTypeConfigProto::has_version() const {
4211   return _internal_has_version();
4212 }
clear_version()4213 inline void SchemaTypeConfigProto::clear_version() {
4214   _impl_.version_ = 0;
4215   _impl_._has_bits_[0] &= ~0x00000008u;
4216 }
_internal_version()4217 inline ::int32_t SchemaTypeConfigProto::_internal_version() const {
4218   return _impl_.version_;
4219 }
version()4220 inline ::int32_t SchemaTypeConfigProto::version() const {
4221   // @@protoc_insertion_point(field_get:icing.lib.SchemaTypeConfigProto.version)
4222   return _internal_version();
4223 }
_internal_set_version(::int32_t value)4224 inline void SchemaTypeConfigProto::_internal_set_version(::int32_t value) {
4225   _impl_._has_bits_[0] |= 0x00000008u;
4226   _impl_.version_ = value;
4227 }
set_version(::int32_t value)4228 inline void SchemaTypeConfigProto::set_version(::int32_t value) {
4229   _internal_set_version(value);
4230   // @@protoc_insertion_point(field_set:icing.lib.SchemaTypeConfigProto.version)
4231 }
4232 
4233 // repeated string parent_types = 6;
_internal_parent_types_size()4234 inline int SchemaTypeConfigProto::_internal_parent_types_size() const {
4235   return _impl_.parent_types_.size();
4236 }
parent_types_size()4237 inline int SchemaTypeConfigProto::parent_types_size() const {
4238   return _internal_parent_types_size();
4239 }
clear_parent_types()4240 inline void SchemaTypeConfigProto::clear_parent_types() {
4241   _impl_.parent_types_.Clear();
4242 }
add_parent_types()4243 inline std::string* SchemaTypeConfigProto::add_parent_types() {
4244   std::string* _s = _internal_add_parent_types();
4245   // @@protoc_insertion_point(field_add_mutable:icing.lib.SchemaTypeConfigProto.parent_types)
4246   return _s;
4247 }
_internal_parent_types(int index)4248 inline const std::string& SchemaTypeConfigProto::_internal_parent_types(int index) const {
4249   return _impl_.parent_types_.Get(index);
4250 }
parent_types(int index)4251 inline const std::string& SchemaTypeConfigProto::parent_types(int index) const {
4252   // @@protoc_insertion_point(field_get:icing.lib.SchemaTypeConfigProto.parent_types)
4253   return _internal_parent_types(index);
4254 }
mutable_parent_types(int index)4255 inline std::string* SchemaTypeConfigProto::mutable_parent_types(int index) {
4256   // @@protoc_insertion_point(field_mutable:icing.lib.SchemaTypeConfigProto.parent_types)
4257   return _impl_.parent_types_.Mutable(index);
4258 }
set_parent_types(int index,const std::string & value)4259 inline void SchemaTypeConfigProto::set_parent_types(int index, const std::string& value) {
4260   _impl_.parent_types_.Mutable(index)->assign(value);
4261   // @@protoc_insertion_point(field_set:icing.lib.SchemaTypeConfigProto.parent_types)
4262 }
set_parent_types(int index,std::string && value)4263 inline void SchemaTypeConfigProto::set_parent_types(int index, std::string&& value) {
4264   _impl_.parent_types_.Mutable(index)->assign(std::move(value));
4265   // @@protoc_insertion_point(field_set:icing.lib.SchemaTypeConfigProto.parent_types)
4266 }
set_parent_types(int index,const char * value)4267 inline void SchemaTypeConfigProto::set_parent_types(int index, const char* value) {
4268   GOOGLE_DCHECK(value != nullptr);
4269   _impl_.parent_types_.Mutable(index)->assign(value);
4270   // @@protoc_insertion_point(field_set_char:icing.lib.SchemaTypeConfigProto.parent_types)
4271 }
set_parent_types(int index,const char * value,size_t size)4272 inline void SchemaTypeConfigProto::set_parent_types(int index, const char* value, size_t size) {
4273   _impl_.parent_types_.Mutable(index)->assign(
4274     reinterpret_cast<const char*>(value), size);
4275   // @@protoc_insertion_point(field_set_pointer:icing.lib.SchemaTypeConfigProto.parent_types)
4276 }
_internal_add_parent_types()4277 inline std::string* SchemaTypeConfigProto::_internal_add_parent_types() {
4278   return _impl_.parent_types_.Add();
4279 }
add_parent_types(const std::string & value)4280 inline void SchemaTypeConfigProto::add_parent_types(const std::string& value) {
4281   _impl_.parent_types_.Add()->assign(value);
4282   // @@protoc_insertion_point(field_add:icing.lib.SchemaTypeConfigProto.parent_types)
4283 }
add_parent_types(std::string && value)4284 inline void SchemaTypeConfigProto::add_parent_types(std::string&& value) {
4285   _impl_.parent_types_.Add(std::move(value));
4286   // @@protoc_insertion_point(field_add:icing.lib.SchemaTypeConfigProto.parent_types)
4287 }
add_parent_types(const char * value)4288 inline void SchemaTypeConfigProto::add_parent_types(const char* value) {
4289   GOOGLE_DCHECK(value != nullptr);
4290   _impl_.parent_types_.Add()->assign(value);
4291   // @@protoc_insertion_point(field_add_char:icing.lib.SchemaTypeConfigProto.parent_types)
4292 }
add_parent_types(const char * value,size_t size)4293 inline void SchemaTypeConfigProto::add_parent_types(const char* value, size_t size) {
4294   _impl_.parent_types_.Add()->assign(reinterpret_cast<const char*>(value), size);
4295   // @@protoc_insertion_point(field_add_pointer:icing.lib.SchemaTypeConfigProto.parent_types)
4296 }
4297 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
parent_types()4298 SchemaTypeConfigProto::parent_types() const {
4299   // @@protoc_insertion_point(field_list:icing.lib.SchemaTypeConfigProto.parent_types)
4300   return _impl_.parent_types_;
4301 }
4302 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_parent_types()4303 SchemaTypeConfigProto::mutable_parent_types() {
4304   // @@protoc_insertion_point(field_mutable_list:icing.lib.SchemaTypeConfigProto.parent_types)
4305   return &_impl_.parent_types_;
4306 }
4307 
4308 // -------------------------------------------------------------------
4309 
4310 // StringIndexingConfig_TokenizerType
4311 
4312 // -------------------------------------------------------------------
4313 
4314 // StringIndexingConfig
4315 
4316 // optional .icing.lib.TermMatchType.Code term_match_type = 1;
_internal_has_term_match_type()4317 inline bool StringIndexingConfig::_internal_has_term_match_type() const {
4318   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
4319   return value;
4320 }
has_term_match_type()4321 inline bool StringIndexingConfig::has_term_match_type() const {
4322   return _internal_has_term_match_type();
4323 }
clear_term_match_type()4324 inline void StringIndexingConfig::clear_term_match_type() {
4325   _impl_.term_match_type_ = 0;
4326   _impl_._has_bits_[0] &= ~0x00000001u;
4327 }
_internal_term_match_type()4328 inline ::icing::lib::TermMatchType_Code StringIndexingConfig::_internal_term_match_type() const {
4329   return static_cast< ::icing::lib::TermMatchType_Code >(_impl_.term_match_type_);
4330 }
term_match_type()4331 inline ::icing::lib::TermMatchType_Code StringIndexingConfig::term_match_type() const {
4332   // @@protoc_insertion_point(field_get:icing.lib.StringIndexingConfig.term_match_type)
4333   return _internal_term_match_type();
4334 }
_internal_set_term_match_type(::icing::lib::TermMatchType_Code value)4335 inline void StringIndexingConfig::_internal_set_term_match_type(::icing::lib::TermMatchType_Code value) {
4336   assert(::icing::lib::TermMatchType_Code_IsValid(value));
4337   _impl_._has_bits_[0] |= 0x00000001u;
4338   _impl_.term_match_type_ = value;
4339 }
set_term_match_type(::icing::lib::TermMatchType_Code value)4340 inline void StringIndexingConfig::set_term_match_type(::icing::lib::TermMatchType_Code value) {
4341   _internal_set_term_match_type(value);
4342   // @@protoc_insertion_point(field_set:icing.lib.StringIndexingConfig.term_match_type)
4343 }
4344 
4345 // optional .icing.lib.StringIndexingConfig.TokenizerType.Code tokenizer_type = 2;
_internal_has_tokenizer_type()4346 inline bool StringIndexingConfig::_internal_has_tokenizer_type() const {
4347   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
4348   return value;
4349 }
has_tokenizer_type()4350 inline bool StringIndexingConfig::has_tokenizer_type() const {
4351   return _internal_has_tokenizer_type();
4352 }
clear_tokenizer_type()4353 inline void StringIndexingConfig::clear_tokenizer_type() {
4354   _impl_.tokenizer_type_ = 0;
4355   _impl_._has_bits_[0] &= ~0x00000002u;
4356 }
_internal_tokenizer_type()4357 inline ::icing::lib::StringIndexingConfig_TokenizerType_Code StringIndexingConfig::_internal_tokenizer_type() const {
4358   return static_cast< ::icing::lib::StringIndexingConfig_TokenizerType_Code >(_impl_.tokenizer_type_);
4359 }
tokenizer_type()4360 inline ::icing::lib::StringIndexingConfig_TokenizerType_Code StringIndexingConfig::tokenizer_type() const {
4361   // @@protoc_insertion_point(field_get:icing.lib.StringIndexingConfig.tokenizer_type)
4362   return _internal_tokenizer_type();
4363 }
_internal_set_tokenizer_type(::icing::lib::StringIndexingConfig_TokenizerType_Code value)4364 inline void StringIndexingConfig::_internal_set_tokenizer_type(::icing::lib::StringIndexingConfig_TokenizerType_Code value) {
4365   assert(::icing::lib::StringIndexingConfig_TokenizerType_Code_IsValid(value));
4366   _impl_._has_bits_[0] |= 0x00000002u;
4367   _impl_.tokenizer_type_ = value;
4368 }
set_tokenizer_type(::icing::lib::StringIndexingConfig_TokenizerType_Code value)4369 inline void StringIndexingConfig::set_tokenizer_type(::icing::lib::StringIndexingConfig_TokenizerType_Code value) {
4370   _internal_set_tokenizer_type(value);
4371   // @@protoc_insertion_point(field_set:icing.lib.StringIndexingConfig.tokenizer_type)
4372 }
4373 
4374 // -------------------------------------------------------------------
4375 
4376 // DocumentIndexingConfig
4377 
4378 // optional bool index_nested_properties = 1;
_internal_has_index_nested_properties()4379 inline bool DocumentIndexingConfig::_internal_has_index_nested_properties() const {
4380   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
4381   return value;
4382 }
has_index_nested_properties()4383 inline bool DocumentIndexingConfig::has_index_nested_properties() const {
4384   return _internal_has_index_nested_properties();
4385 }
clear_index_nested_properties()4386 inline void DocumentIndexingConfig::clear_index_nested_properties() {
4387   _impl_.index_nested_properties_ = false;
4388   _impl_._has_bits_[0] &= ~0x00000001u;
4389 }
_internal_index_nested_properties()4390 inline bool DocumentIndexingConfig::_internal_index_nested_properties() const {
4391   return _impl_.index_nested_properties_;
4392 }
index_nested_properties()4393 inline bool DocumentIndexingConfig::index_nested_properties() const {
4394   // @@protoc_insertion_point(field_get:icing.lib.DocumentIndexingConfig.index_nested_properties)
4395   return _internal_index_nested_properties();
4396 }
_internal_set_index_nested_properties(bool value)4397 inline void DocumentIndexingConfig::_internal_set_index_nested_properties(bool value) {
4398   _impl_._has_bits_[0] |= 0x00000001u;
4399   _impl_.index_nested_properties_ = value;
4400 }
set_index_nested_properties(bool value)4401 inline void DocumentIndexingConfig::set_index_nested_properties(bool value) {
4402   _internal_set_index_nested_properties(value);
4403   // @@protoc_insertion_point(field_set:icing.lib.DocumentIndexingConfig.index_nested_properties)
4404 }
4405 
4406 // repeated string indexable_nested_properties_list = 2;
_internal_indexable_nested_properties_list_size()4407 inline int DocumentIndexingConfig::_internal_indexable_nested_properties_list_size() const {
4408   return _impl_.indexable_nested_properties_list_.size();
4409 }
indexable_nested_properties_list_size()4410 inline int DocumentIndexingConfig::indexable_nested_properties_list_size() const {
4411   return _internal_indexable_nested_properties_list_size();
4412 }
clear_indexable_nested_properties_list()4413 inline void DocumentIndexingConfig::clear_indexable_nested_properties_list() {
4414   _impl_.indexable_nested_properties_list_.Clear();
4415 }
add_indexable_nested_properties_list()4416 inline std::string* DocumentIndexingConfig::add_indexable_nested_properties_list() {
4417   std::string* _s = _internal_add_indexable_nested_properties_list();
4418   // @@protoc_insertion_point(field_add_mutable:icing.lib.DocumentIndexingConfig.indexable_nested_properties_list)
4419   return _s;
4420 }
_internal_indexable_nested_properties_list(int index)4421 inline const std::string& DocumentIndexingConfig::_internal_indexable_nested_properties_list(int index) const {
4422   return _impl_.indexable_nested_properties_list_.Get(index);
4423 }
indexable_nested_properties_list(int index)4424 inline const std::string& DocumentIndexingConfig::indexable_nested_properties_list(int index) const {
4425   // @@protoc_insertion_point(field_get:icing.lib.DocumentIndexingConfig.indexable_nested_properties_list)
4426   return _internal_indexable_nested_properties_list(index);
4427 }
mutable_indexable_nested_properties_list(int index)4428 inline std::string* DocumentIndexingConfig::mutable_indexable_nested_properties_list(int index) {
4429   // @@protoc_insertion_point(field_mutable:icing.lib.DocumentIndexingConfig.indexable_nested_properties_list)
4430   return _impl_.indexable_nested_properties_list_.Mutable(index);
4431 }
set_indexable_nested_properties_list(int index,const std::string & value)4432 inline void DocumentIndexingConfig::set_indexable_nested_properties_list(int index, const std::string& value) {
4433   _impl_.indexable_nested_properties_list_.Mutable(index)->assign(value);
4434   // @@protoc_insertion_point(field_set:icing.lib.DocumentIndexingConfig.indexable_nested_properties_list)
4435 }
set_indexable_nested_properties_list(int index,std::string && value)4436 inline void DocumentIndexingConfig::set_indexable_nested_properties_list(int index, std::string&& value) {
4437   _impl_.indexable_nested_properties_list_.Mutable(index)->assign(std::move(value));
4438   // @@protoc_insertion_point(field_set:icing.lib.DocumentIndexingConfig.indexable_nested_properties_list)
4439 }
set_indexable_nested_properties_list(int index,const char * value)4440 inline void DocumentIndexingConfig::set_indexable_nested_properties_list(int index, const char* value) {
4441   GOOGLE_DCHECK(value != nullptr);
4442   _impl_.indexable_nested_properties_list_.Mutable(index)->assign(value);
4443   // @@protoc_insertion_point(field_set_char:icing.lib.DocumentIndexingConfig.indexable_nested_properties_list)
4444 }
set_indexable_nested_properties_list(int index,const char * value,size_t size)4445 inline void DocumentIndexingConfig::set_indexable_nested_properties_list(int index, const char* value, size_t size) {
4446   _impl_.indexable_nested_properties_list_.Mutable(index)->assign(
4447     reinterpret_cast<const char*>(value), size);
4448   // @@protoc_insertion_point(field_set_pointer:icing.lib.DocumentIndexingConfig.indexable_nested_properties_list)
4449 }
_internal_add_indexable_nested_properties_list()4450 inline std::string* DocumentIndexingConfig::_internal_add_indexable_nested_properties_list() {
4451   return _impl_.indexable_nested_properties_list_.Add();
4452 }
add_indexable_nested_properties_list(const std::string & value)4453 inline void DocumentIndexingConfig::add_indexable_nested_properties_list(const std::string& value) {
4454   _impl_.indexable_nested_properties_list_.Add()->assign(value);
4455   // @@protoc_insertion_point(field_add:icing.lib.DocumentIndexingConfig.indexable_nested_properties_list)
4456 }
add_indexable_nested_properties_list(std::string && value)4457 inline void DocumentIndexingConfig::add_indexable_nested_properties_list(std::string&& value) {
4458   _impl_.indexable_nested_properties_list_.Add(std::move(value));
4459   // @@protoc_insertion_point(field_add:icing.lib.DocumentIndexingConfig.indexable_nested_properties_list)
4460 }
add_indexable_nested_properties_list(const char * value)4461 inline void DocumentIndexingConfig::add_indexable_nested_properties_list(const char* value) {
4462   GOOGLE_DCHECK(value != nullptr);
4463   _impl_.indexable_nested_properties_list_.Add()->assign(value);
4464   // @@protoc_insertion_point(field_add_char:icing.lib.DocumentIndexingConfig.indexable_nested_properties_list)
4465 }
add_indexable_nested_properties_list(const char * value,size_t size)4466 inline void DocumentIndexingConfig::add_indexable_nested_properties_list(const char* value, size_t size) {
4467   _impl_.indexable_nested_properties_list_.Add()->assign(reinterpret_cast<const char*>(value), size);
4468   // @@protoc_insertion_point(field_add_pointer:icing.lib.DocumentIndexingConfig.indexable_nested_properties_list)
4469 }
4470 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
indexable_nested_properties_list()4471 DocumentIndexingConfig::indexable_nested_properties_list() const {
4472   // @@protoc_insertion_point(field_list:icing.lib.DocumentIndexingConfig.indexable_nested_properties_list)
4473   return _impl_.indexable_nested_properties_list_;
4474 }
4475 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_indexable_nested_properties_list()4476 DocumentIndexingConfig::mutable_indexable_nested_properties_list() {
4477   // @@protoc_insertion_point(field_mutable_list:icing.lib.DocumentIndexingConfig.indexable_nested_properties_list)
4478   return &_impl_.indexable_nested_properties_list_;
4479 }
4480 
4481 // -------------------------------------------------------------------
4482 
4483 // IntegerIndexingConfig_NumericMatchType
4484 
4485 // -------------------------------------------------------------------
4486 
4487 // IntegerIndexingConfig
4488 
4489 // optional .icing.lib.IntegerIndexingConfig.NumericMatchType.Code numeric_match_type = 1;
_internal_has_numeric_match_type()4490 inline bool IntegerIndexingConfig::_internal_has_numeric_match_type() const {
4491   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
4492   return value;
4493 }
has_numeric_match_type()4494 inline bool IntegerIndexingConfig::has_numeric_match_type() const {
4495   return _internal_has_numeric_match_type();
4496 }
clear_numeric_match_type()4497 inline void IntegerIndexingConfig::clear_numeric_match_type() {
4498   _impl_.numeric_match_type_ = 0;
4499   _impl_._has_bits_[0] &= ~0x00000001u;
4500 }
_internal_numeric_match_type()4501 inline ::icing::lib::IntegerIndexingConfig_NumericMatchType_Code IntegerIndexingConfig::_internal_numeric_match_type() const {
4502   return static_cast< ::icing::lib::IntegerIndexingConfig_NumericMatchType_Code >(_impl_.numeric_match_type_);
4503 }
numeric_match_type()4504 inline ::icing::lib::IntegerIndexingConfig_NumericMatchType_Code IntegerIndexingConfig::numeric_match_type() const {
4505   // @@protoc_insertion_point(field_get:icing.lib.IntegerIndexingConfig.numeric_match_type)
4506   return _internal_numeric_match_type();
4507 }
_internal_set_numeric_match_type(::icing::lib::IntegerIndexingConfig_NumericMatchType_Code value)4508 inline void IntegerIndexingConfig::_internal_set_numeric_match_type(::icing::lib::IntegerIndexingConfig_NumericMatchType_Code value) {
4509   assert(::icing::lib::IntegerIndexingConfig_NumericMatchType_Code_IsValid(value));
4510   _impl_._has_bits_[0] |= 0x00000001u;
4511   _impl_.numeric_match_type_ = value;
4512 }
set_numeric_match_type(::icing::lib::IntegerIndexingConfig_NumericMatchType_Code value)4513 inline void IntegerIndexingConfig::set_numeric_match_type(::icing::lib::IntegerIndexingConfig_NumericMatchType_Code value) {
4514   _internal_set_numeric_match_type(value);
4515   // @@protoc_insertion_point(field_set:icing.lib.IntegerIndexingConfig.numeric_match_type)
4516 }
4517 
4518 // -------------------------------------------------------------------
4519 
4520 // EmbeddingIndexingConfig_EmbeddingIndexingType
4521 
4522 // -------------------------------------------------------------------
4523 
4524 // EmbeddingIndexingConfig_QuantizationType
4525 
4526 // -------------------------------------------------------------------
4527 
4528 // EmbeddingIndexingConfig
4529 
4530 // optional .icing.lib.EmbeddingIndexingConfig.EmbeddingIndexingType.Code embedding_indexing_type = 1;
_internal_has_embedding_indexing_type()4531 inline bool EmbeddingIndexingConfig::_internal_has_embedding_indexing_type() const {
4532   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
4533   return value;
4534 }
has_embedding_indexing_type()4535 inline bool EmbeddingIndexingConfig::has_embedding_indexing_type() const {
4536   return _internal_has_embedding_indexing_type();
4537 }
clear_embedding_indexing_type()4538 inline void EmbeddingIndexingConfig::clear_embedding_indexing_type() {
4539   _impl_.embedding_indexing_type_ = 0;
4540   _impl_._has_bits_[0] &= ~0x00000001u;
4541 }
_internal_embedding_indexing_type()4542 inline ::icing::lib::EmbeddingIndexingConfig_EmbeddingIndexingType_Code EmbeddingIndexingConfig::_internal_embedding_indexing_type() const {
4543   return static_cast< ::icing::lib::EmbeddingIndexingConfig_EmbeddingIndexingType_Code >(_impl_.embedding_indexing_type_);
4544 }
embedding_indexing_type()4545 inline ::icing::lib::EmbeddingIndexingConfig_EmbeddingIndexingType_Code EmbeddingIndexingConfig::embedding_indexing_type() const {
4546   // @@protoc_insertion_point(field_get:icing.lib.EmbeddingIndexingConfig.embedding_indexing_type)
4547   return _internal_embedding_indexing_type();
4548 }
_internal_set_embedding_indexing_type(::icing::lib::EmbeddingIndexingConfig_EmbeddingIndexingType_Code value)4549 inline void EmbeddingIndexingConfig::_internal_set_embedding_indexing_type(::icing::lib::EmbeddingIndexingConfig_EmbeddingIndexingType_Code value) {
4550   assert(::icing::lib::EmbeddingIndexingConfig_EmbeddingIndexingType_Code_IsValid(value));
4551   _impl_._has_bits_[0] |= 0x00000001u;
4552   _impl_.embedding_indexing_type_ = value;
4553 }
set_embedding_indexing_type(::icing::lib::EmbeddingIndexingConfig_EmbeddingIndexingType_Code value)4554 inline void EmbeddingIndexingConfig::set_embedding_indexing_type(::icing::lib::EmbeddingIndexingConfig_EmbeddingIndexingType_Code value) {
4555   _internal_set_embedding_indexing_type(value);
4556   // @@protoc_insertion_point(field_set:icing.lib.EmbeddingIndexingConfig.embedding_indexing_type)
4557 }
4558 
4559 // optional .icing.lib.EmbeddingIndexingConfig.QuantizationType.Code quantization_type = 2;
_internal_has_quantization_type()4560 inline bool EmbeddingIndexingConfig::_internal_has_quantization_type() const {
4561   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
4562   return value;
4563 }
has_quantization_type()4564 inline bool EmbeddingIndexingConfig::has_quantization_type() const {
4565   return _internal_has_quantization_type();
4566 }
clear_quantization_type()4567 inline void EmbeddingIndexingConfig::clear_quantization_type() {
4568   _impl_.quantization_type_ = 0;
4569   _impl_._has_bits_[0] &= ~0x00000002u;
4570 }
_internal_quantization_type()4571 inline ::icing::lib::EmbeddingIndexingConfig_QuantizationType_Code EmbeddingIndexingConfig::_internal_quantization_type() const {
4572   return static_cast< ::icing::lib::EmbeddingIndexingConfig_QuantizationType_Code >(_impl_.quantization_type_);
4573 }
quantization_type()4574 inline ::icing::lib::EmbeddingIndexingConfig_QuantizationType_Code EmbeddingIndexingConfig::quantization_type() const {
4575   // @@protoc_insertion_point(field_get:icing.lib.EmbeddingIndexingConfig.quantization_type)
4576   return _internal_quantization_type();
4577 }
_internal_set_quantization_type(::icing::lib::EmbeddingIndexingConfig_QuantizationType_Code value)4578 inline void EmbeddingIndexingConfig::_internal_set_quantization_type(::icing::lib::EmbeddingIndexingConfig_QuantizationType_Code value) {
4579   assert(::icing::lib::EmbeddingIndexingConfig_QuantizationType_Code_IsValid(value));
4580   _impl_._has_bits_[0] |= 0x00000002u;
4581   _impl_.quantization_type_ = value;
4582 }
set_quantization_type(::icing::lib::EmbeddingIndexingConfig_QuantizationType_Code value)4583 inline void EmbeddingIndexingConfig::set_quantization_type(::icing::lib::EmbeddingIndexingConfig_QuantizationType_Code value) {
4584   _internal_set_quantization_type(value);
4585   // @@protoc_insertion_point(field_set:icing.lib.EmbeddingIndexingConfig.quantization_type)
4586 }
4587 
4588 // -------------------------------------------------------------------
4589 
4590 // JoinableConfig_ValueType
4591 
4592 // -------------------------------------------------------------------
4593 
4594 // JoinableConfig_DeletePropagationType
4595 
4596 // -------------------------------------------------------------------
4597 
4598 // JoinableConfig
4599 
4600 // optional .icing.lib.JoinableConfig.ValueType.Code value_type = 1;
_internal_has_value_type()4601 inline bool JoinableConfig::_internal_has_value_type() const {
4602   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
4603   return value;
4604 }
has_value_type()4605 inline bool JoinableConfig::has_value_type() const {
4606   return _internal_has_value_type();
4607 }
clear_value_type()4608 inline void JoinableConfig::clear_value_type() {
4609   _impl_.value_type_ = 0;
4610   _impl_._has_bits_[0] &= ~0x00000001u;
4611 }
_internal_value_type()4612 inline ::icing::lib::JoinableConfig_ValueType_Code JoinableConfig::_internal_value_type() const {
4613   return static_cast< ::icing::lib::JoinableConfig_ValueType_Code >(_impl_.value_type_);
4614 }
value_type()4615 inline ::icing::lib::JoinableConfig_ValueType_Code JoinableConfig::value_type() const {
4616   // @@protoc_insertion_point(field_get:icing.lib.JoinableConfig.value_type)
4617   return _internal_value_type();
4618 }
_internal_set_value_type(::icing::lib::JoinableConfig_ValueType_Code value)4619 inline void JoinableConfig::_internal_set_value_type(::icing::lib::JoinableConfig_ValueType_Code value) {
4620   assert(::icing::lib::JoinableConfig_ValueType_Code_IsValid(value));
4621   _impl_._has_bits_[0] |= 0x00000001u;
4622   _impl_.value_type_ = value;
4623 }
set_value_type(::icing::lib::JoinableConfig_ValueType_Code value)4624 inline void JoinableConfig::set_value_type(::icing::lib::JoinableConfig_ValueType_Code value) {
4625   _internal_set_value_type(value);
4626   // @@protoc_insertion_point(field_set:icing.lib.JoinableConfig.value_type)
4627 }
4628 
4629 // optional .icing.lib.JoinableConfig.DeletePropagationType.Code delete_propagation_type = 3;
_internal_has_delete_propagation_type()4630 inline bool JoinableConfig::_internal_has_delete_propagation_type() const {
4631   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
4632   return value;
4633 }
has_delete_propagation_type()4634 inline bool JoinableConfig::has_delete_propagation_type() const {
4635   return _internal_has_delete_propagation_type();
4636 }
clear_delete_propagation_type()4637 inline void JoinableConfig::clear_delete_propagation_type() {
4638   _impl_.delete_propagation_type_ = 0;
4639   _impl_._has_bits_[0] &= ~0x00000002u;
4640 }
_internal_delete_propagation_type()4641 inline ::icing::lib::JoinableConfig_DeletePropagationType_Code JoinableConfig::_internal_delete_propagation_type() const {
4642   return static_cast< ::icing::lib::JoinableConfig_DeletePropagationType_Code >(_impl_.delete_propagation_type_);
4643 }
delete_propagation_type()4644 inline ::icing::lib::JoinableConfig_DeletePropagationType_Code JoinableConfig::delete_propagation_type() const {
4645   // @@protoc_insertion_point(field_get:icing.lib.JoinableConfig.delete_propagation_type)
4646   return _internal_delete_propagation_type();
4647 }
_internal_set_delete_propagation_type(::icing::lib::JoinableConfig_DeletePropagationType_Code value)4648 inline void JoinableConfig::_internal_set_delete_propagation_type(::icing::lib::JoinableConfig_DeletePropagationType_Code value) {
4649   assert(::icing::lib::JoinableConfig_DeletePropagationType_Code_IsValid(value));
4650   _impl_._has_bits_[0] |= 0x00000002u;
4651   _impl_.delete_propagation_type_ = value;
4652 }
set_delete_propagation_type(::icing::lib::JoinableConfig_DeletePropagationType_Code value)4653 inline void JoinableConfig::set_delete_propagation_type(::icing::lib::JoinableConfig_DeletePropagationType_Code value) {
4654   _internal_set_delete_propagation_type(value);
4655   // @@protoc_insertion_point(field_set:icing.lib.JoinableConfig.delete_propagation_type)
4656 }
4657 
4658 // -------------------------------------------------------------------
4659 
4660 // PropertyConfigProto_DataType
4661 
4662 // -------------------------------------------------------------------
4663 
4664 // PropertyConfigProto_Cardinality
4665 
4666 // -------------------------------------------------------------------
4667 
4668 // PropertyConfigProto_ScorableType
4669 
4670 // -------------------------------------------------------------------
4671 
4672 // PropertyConfigProto
4673 
4674 // optional string property_name = 1;
_internal_has_property_name()4675 inline bool PropertyConfigProto::_internal_has_property_name() const {
4676   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
4677   return value;
4678 }
has_property_name()4679 inline bool PropertyConfigProto::has_property_name() const {
4680   return _internal_has_property_name();
4681 }
clear_property_name()4682 inline void PropertyConfigProto::clear_property_name() {
4683   _impl_.property_name_.ClearToEmpty();
4684   _impl_._has_bits_[0] &= ~0x00000001u;
4685 }
property_name()4686 inline const std::string& PropertyConfigProto::property_name() const {
4687   // @@protoc_insertion_point(field_get:icing.lib.PropertyConfigProto.property_name)
4688   return _internal_property_name();
4689 }
4690 template <typename ArgT0, typename... ArgT>
4691 inline PROTOBUF_ALWAYS_INLINE
set_property_name(ArgT0 && arg0,ArgT...args)4692 void PropertyConfigProto::set_property_name(ArgT0&& arg0, ArgT... args) {
4693  _impl_._has_bits_[0] |= 0x00000001u;
4694  _impl_.property_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
4695   // @@protoc_insertion_point(field_set:icing.lib.PropertyConfigProto.property_name)
4696 }
mutable_property_name()4697 inline std::string* PropertyConfigProto::mutable_property_name() {
4698   std::string* _s = _internal_mutable_property_name();
4699   // @@protoc_insertion_point(field_mutable:icing.lib.PropertyConfigProto.property_name)
4700   return _s;
4701 }
_internal_property_name()4702 inline const std::string& PropertyConfigProto::_internal_property_name() const {
4703   return _impl_.property_name_.Get();
4704 }
_internal_set_property_name(const std::string & value)4705 inline void PropertyConfigProto::_internal_set_property_name(const std::string& value) {
4706   _impl_._has_bits_[0] |= 0x00000001u;
4707   _impl_.property_name_.Set(value, GetArenaForAllocation());
4708 }
_internal_mutable_property_name()4709 inline std::string* PropertyConfigProto::_internal_mutable_property_name() {
4710   _impl_._has_bits_[0] |= 0x00000001u;
4711   return _impl_.property_name_.Mutable(GetArenaForAllocation());
4712 }
release_property_name()4713 inline std::string* PropertyConfigProto::release_property_name() {
4714   // @@protoc_insertion_point(field_release:icing.lib.PropertyConfigProto.property_name)
4715   if (!_internal_has_property_name()) {
4716     return nullptr;
4717   }
4718   _impl_._has_bits_[0] &= ~0x00000001u;
4719   auto* p = _impl_.property_name_.Release();
4720 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4721   if (_impl_.property_name_.IsDefault()) {
4722     _impl_.property_name_.Set("", GetArenaForAllocation());
4723   }
4724 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4725   return p;
4726 }
set_allocated_property_name(std::string * property_name)4727 inline void PropertyConfigProto::set_allocated_property_name(std::string* property_name) {
4728   if (property_name != nullptr) {
4729     _impl_._has_bits_[0] |= 0x00000001u;
4730   } else {
4731     _impl_._has_bits_[0] &= ~0x00000001u;
4732   }
4733   _impl_.property_name_.SetAllocated(property_name, GetArenaForAllocation());
4734 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4735   if (_impl_.property_name_.IsDefault()) {
4736     _impl_.property_name_.Set("", GetArenaForAllocation());
4737   }
4738 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4739   // @@protoc_insertion_point(field_set_allocated:icing.lib.PropertyConfigProto.property_name)
4740 }
4741 
4742 // optional string description = 9;
_internal_has_description()4743 inline bool PropertyConfigProto::_internal_has_description() const {
4744   bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
4745   return value;
4746 }
has_description()4747 inline bool PropertyConfigProto::has_description() const {
4748   return _internal_has_description();
4749 }
clear_description()4750 inline void PropertyConfigProto::clear_description() {
4751   _impl_.description_.ClearToEmpty();
4752   _impl_._has_bits_[0] &= ~0x00000004u;
4753 }
description()4754 inline const std::string& PropertyConfigProto::description() const {
4755   // @@protoc_insertion_point(field_get:icing.lib.PropertyConfigProto.description)
4756   return _internal_description();
4757 }
4758 template <typename ArgT0, typename... ArgT>
4759 inline PROTOBUF_ALWAYS_INLINE
set_description(ArgT0 && arg0,ArgT...args)4760 void PropertyConfigProto::set_description(ArgT0&& arg0, ArgT... args) {
4761  _impl_._has_bits_[0] |= 0x00000004u;
4762  _impl_.description_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
4763   // @@protoc_insertion_point(field_set:icing.lib.PropertyConfigProto.description)
4764 }
mutable_description()4765 inline std::string* PropertyConfigProto::mutable_description() {
4766   std::string* _s = _internal_mutable_description();
4767   // @@protoc_insertion_point(field_mutable:icing.lib.PropertyConfigProto.description)
4768   return _s;
4769 }
_internal_description()4770 inline const std::string& PropertyConfigProto::_internal_description() const {
4771   return _impl_.description_.Get();
4772 }
_internal_set_description(const std::string & value)4773 inline void PropertyConfigProto::_internal_set_description(const std::string& value) {
4774   _impl_._has_bits_[0] |= 0x00000004u;
4775   _impl_.description_.Set(value, GetArenaForAllocation());
4776 }
_internal_mutable_description()4777 inline std::string* PropertyConfigProto::_internal_mutable_description() {
4778   _impl_._has_bits_[0] |= 0x00000004u;
4779   return _impl_.description_.Mutable(GetArenaForAllocation());
4780 }
release_description()4781 inline std::string* PropertyConfigProto::release_description() {
4782   // @@protoc_insertion_point(field_release:icing.lib.PropertyConfigProto.description)
4783   if (!_internal_has_description()) {
4784     return nullptr;
4785   }
4786   _impl_._has_bits_[0] &= ~0x00000004u;
4787   auto* p = _impl_.description_.Release();
4788 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4789   if (_impl_.description_.IsDefault()) {
4790     _impl_.description_.Set("", GetArenaForAllocation());
4791   }
4792 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4793   return p;
4794 }
set_allocated_description(std::string * description)4795 inline void PropertyConfigProto::set_allocated_description(std::string* description) {
4796   if (description != nullptr) {
4797     _impl_._has_bits_[0] |= 0x00000004u;
4798   } else {
4799     _impl_._has_bits_[0] &= ~0x00000004u;
4800   }
4801   _impl_.description_.SetAllocated(description, GetArenaForAllocation());
4802 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4803   if (_impl_.description_.IsDefault()) {
4804     _impl_.description_.Set("", GetArenaForAllocation());
4805   }
4806 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4807   // @@protoc_insertion_point(field_set_allocated:icing.lib.PropertyConfigProto.description)
4808 }
4809 
4810 // optional .icing.lib.PropertyConfigProto.DataType.Code data_type = 2;
_internal_has_data_type()4811 inline bool PropertyConfigProto::_internal_has_data_type() const {
4812   bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
4813   return value;
4814 }
has_data_type()4815 inline bool PropertyConfigProto::has_data_type() const {
4816   return _internal_has_data_type();
4817 }
clear_data_type()4818 inline void PropertyConfigProto::clear_data_type() {
4819   _impl_.data_type_ = 0;
4820   _impl_._has_bits_[0] &= ~0x00000100u;
4821 }
_internal_data_type()4822 inline ::icing::lib::PropertyConfigProto_DataType_Code PropertyConfigProto::_internal_data_type() const {
4823   return static_cast< ::icing::lib::PropertyConfigProto_DataType_Code >(_impl_.data_type_);
4824 }
data_type()4825 inline ::icing::lib::PropertyConfigProto_DataType_Code PropertyConfigProto::data_type() const {
4826   // @@protoc_insertion_point(field_get:icing.lib.PropertyConfigProto.data_type)
4827   return _internal_data_type();
4828 }
_internal_set_data_type(::icing::lib::PropertyConfigProto_DataType_Code value)4829 inline void PropertyConfigProto::_internal_set_data_type(::icing::lib::PropertyConfigProto_DataType_Code value) {
4830   assert(::icing::lib::PropertyConfigProto_DataType_Code_IsValid(value));
4831   _impl_._has_bits_[0] |= 0x00000100u;
4832   _impl_.data_type_ = value;
4833 }
set_data_type(::icing::lib::PropertyConfigProto_DataType_Code value)4834 inline void PropertyConfigProto::set_data_type(::icing::lib::PropertyConfigProto_DataType_Code value) {
4835   _internal_set_data_type(value);
4836   // @@protoc_insertion_point(field_set:icing.lib.PropertyConfigProto.data_type)
4837 }
4838 
4839 // optional string schema_type = 3;
_internal_has_schema_type()4840 inline bool PropertyConfigProto::_internal_has_schema_type() const {
4841   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
4842   return value;
4843 }
has_schema_type()4844 inline bool PropertyConfigProto::has_schema_type() const {
4845   return _internal_has_schema_type();
4846 }
clear_schema_type()4847 inline void PropertyConfigProto::clear_schema_type() {
4848   _impl_.schema_type_.ClearToEmpty();
4849   _impl_._has_bits_[0] &= ~0x00000002u;
4850 }
schema_type()4851 inline const std::string& PropertyConfigProto::schema_type() const {
4852   // @@protoc_insertion_point(field_get:icing.lib.PropertyConfigProto.schema_type)
4853   return _internal_schema_type();
4854 }
4855 template <typename ArgT0, typename... ArgT>
4856 inline PROTOBUF_ALWAYS_INLINE
set_schema_type(ArgT0 && arg0,ArgT...args)4857 void PropertyConfigProto::set_schema_type(ArgT0&& arg0, ArgT... args) {
4858  _impl_._has_bits_[0] |= 0x00000002u;
4859  _impl_.schema_type_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
4860   // @@protoc_insertion_point(field_set:icing.lib.PropertyConfigProto.schema_type)
4861 }
mutable_schema_type()4862 inline std::string* PropertyConfigProto::mutable_schema_type() {
4863   std::string* _s = _internal_mutable_schema_type();
4864   // @@protoc_insertion_point(field_mutable:icing.lib.PropertyConfigProto.schema_type)
4865   return _s;
4866 }
_internal_schema_type()4867 inline const std::string& PropertyConfigProto::_internal_schema_type() const {
4868   return _impl_.schema_type_.Get();
4869 }
_internal_set_schema_type(const std::string & value)4870 inline void PropertyConfigProto::_internal_set_schema_type(const std::string& value) {
4871   _impl_._has_bits_[0] |= 0x00000002u;
4872   _impl_.schema_type_.Set(value, GetArenaForAllocation());
4873 }
_internal_mutable_schema_type()4874 inline std::string* PropertyConfigProto::_internal_mutable_schema_type() {
4875   _impl_._has_bits_[0] |= 0x00000002u;
4876   return _impl_.schema_type_.Mutable(GetArenaForAllocation());
4877 }
release_schema_type()4878 inline std::string* PropertyConfigProto::release_schema_type() {
4879   // @@protoc_insertion_point(field_release:icing.lib.PropertyConfigProto.schema_type)
4880   if (!_internal_has_schema_type()) {
4881     return nullptr;
4882   }
4883   _impl_._has_bits_[0] &= ~0x00000002u;
4884   auto* p = _impl_.schema_type_.Release();
4885 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4886   if (_impl_.schema_type_.IsDefault()) {
4887     _impl_.schema_type_.Set("", GetArenaForAllocation());
4888   }
4889 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4890   return p;
4891 }
set_allocated_schema_type(std::string * schema_type)4892 inline void PropertyConfigProto::set_allocated_schema_type(std::string* schema_type) {
4893   if (schema_type != nullptr) {
4894     _impl_._has_bits_[0] |= 0x00000002u;
4895   } else {
4896     _impl_._has_bits_[0] &= ~0x00000002u;
4897   }
4898   _impl_.schema_type_.SetAllocated(schema_type, GetArenaForAllocation());
4899 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4900   if (_impl_.schema_type_.IsDefault()) {
4901     _impl_.schema_type_.Set("", GetArenaForAllocation());
4902   }
4903 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4904   // @@protoc_insertion_point(field_set_allocated:icing.lib.PropertyConfigProto.schema_type)
4905 }
4906 
4907 // optional .icing.lib.PropertyConfigProto.Cardinality.Code cardinality = 4;
_internal_has_cardinality()4908 inline bool PropertyConfigProto::_internal_has_cardinality() const {
4909   bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
4910   return value;
4911 }
has_cardinality()4912 inline bool PropertyConfigProto::has_cardinality() const {
4913   return _internal_has_cardinality();
4914 }
clear_cardinality()4915 inline void PropertyConfigProto::clear_cardinality() {
4916   _impl_.cardinality_ = 0;
4917   _impl_._has_bits_[0] &= ~0x00000200u;
4918 }
_internal_cardinality()4919 inline ::icing::lib::PropertyConfigProto_Cardinality_Code PropertyConfigProto::_internal_cardinality() const {
4920   return static_cast< ::icing::lib::PropertyConfigProto_Cardinality_Code >(_impl_.cardinality_);
4921 }
cardinality()4922 inline ::icing::lib::PropertyConfigProto_Cardinality_Code PropertyConfigProto::cardinality() const {
4923   // @@protoc_insertion_point(field_get:icing.lib.PropertyConfigProto.cardinality)
4924   return _internal_cardinality();
4925 }
_internal_set_cardinality(::icing::lib::PropertyConfigProto_Cardinality_Code value)4926 inline void PropertyConfigProto::_internal_set_cardinality(::icing::lib::PropertyConfigProto_Cardinality_Code value) {
4927   assert(::icing::lib::PropertyConfigProto_Cardinality_Code_IsValid(value));
4928   _impl_._has_bits_[0] |= 0x00000200u;
4929   _impl_.cardinality_ = value;
4930 }
set_cardinality(::icing::lib::PropertyConfigProto_Cardinality_Code value)4931 inline void PropertyConfigProto::set_cardinality(::icing::lib::PropertyConfigProto_Cardinality_Code value) {
4932   _internal_set_cardinality(value);
4933   // @@protoc_insertion_point(field_set:icing.lib.PropertyConfigProto.cardinality)
4934 }
4935 
4936 // optional .icing.lib.StringIndexingConfig string_indexing_config = 5;
_internal_has_string_indexing_config()4937 inline bool PropertyConfigProto::_internal_has_string_indexing_config() const {
4938   bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
4939   PROTOBUF_ASSUME(!value || _impl_.string_indexing_config_ != nullptr);
4940   return value;
4941 }
has_string_indexing_config()4942 inline bool PropertyConfigProto::has_string_indexing_config() const {
4943   return _internal_has_string_indexing_config();
4944 }
clear_string_indexing_config()4945 inline void PropertyConfigProto::clear_string_indexing_config() {
4946   if (_impl_.string_indexing_config_ != nullptr) _impl_.string_indexing_config_->Clear();
4947   _impl_._has_bits_[0] &= ~0x00000008u;
4948 }
_internal_string_indexing_config()4949 inline const ::icing::lib::StringIndexingConfig& PropertyConfigProto::_internal_string_indexing_config() const {
4950   const ::icing::lib::StringIndexingConfig* p = _impl_.string_indexing_config_;
4951   return p != nullptr ? *p : reinterpret_cast<const ::icing::lib::StringIndexingConfig&>(
4952       ::icing::lib::_StringIndexingConfig_default_instance_);
4953 }
string_indexing_config()4954 inline const ::icing::lib::StringIndexingConfig& PropertyConfigProto::string_indexing_config() const {
4955   // @@protoc_insertion_point(field_get:icing.lib.PropertyConfigProto.string_indexing_config)
4956   return _internal_string_indexing_config();
4957 }
unsafe_arena_set_allocated_string_indexing_config(::icing::lib::StringIndexingConfig * string_indexing_config)4958 inline void PropertyConfigProto::unsafe_arena_set_allocated_string_indexing_config(
4959     ::icing::lib::StringIndexingConfig* string_indexing_config) {
4960   if (GetArenaForAllocation() == nullptr) {
4961     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.string_indexing_config_);
4962   }
4963   _impl_.string_indexing_config_ = string_indexing_config;
4964   if (string_indexing_config) {
4965     _impl_._has_bits_[0] |= 0x00000008u;
4966   } else {
4967     _impl_._has_bits_[0] &= ~0x00000008u;
4968   }
4969   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:icing.lib.PropertyConfigProto.string_indexing_config)
4970 }
release_string_indexing_config()4971 inline ::icing::lib::StringIndexingConfig* PropertyConfigProto::release_string_indexing_config() {
4972   _impl_._has_bits_[0] &= ~0x00000008u;
4973   ::icing::lib::StringIndexingConfig* temp = _impl_.string_indexing_config_;
4974   _impl_.string_indexing_config_ = nullptr;
4975 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
4976   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
4977   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
4978   if (GetArenaForAllocation() == nullptr) { delete old; }
4979 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
4980   if (GetArenaForAllocation() != nullptr) {
4981     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
4982   }
4983 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
4984   return temp;
4985 }
unsafe_arena_release_string_indexing_config()4986 inline ::icing::lib::StringIndexingConfig* PropertyConfigProto::unsafe_arena_release_string_indexing_config() {
4987   // @@protoc_insertion_point(field_release:icing.lib.PropertyConfigProto.string_indexing_config)
4988   _impl_._has_bits_[0] &= ~0x00000008u;
4989   ::icing::lib::StringIndexingConfig* temp = _impl_.string_indexing_config_;
4990   _impl_.string_indexing_config_ = nullptr;
4991   return temp;
4992 }
_internal_mutable_string_indexing_config()4993 inline ::icing::lib::StringIndexingConfig* PropertyConfigProto::_internal_mutable_string_indexing_config() {
4994   _impl_._has_bits_[0] |= 0x00000008u;
4995   if (_impl_.string_indexing_config_ == nullptr) {
4996     auto* p = CreateMaybeMessage<::icing::lib::StringIndexingConfig>(GetArenaForAllocation());
4997     _impl_.string_indexing_config_ = p;
4998   }
4999   return _impl_.string_indexing_config_;
5000 }
mutable_string_indexing_config()5001 inline ::icing::lib::StringIndexingConfig* PropertyConfigProto::mutable_string_indexing_config() {
5002   ::icing::lib::StringIndexingConfig* _msg = _internal_mutable_string_indexing_config();
5003   // @@protoc_insertion_point(field_mutable:icing.lib.PropertyConfigProto.string_indexing_config)
5004   return _msg;
5005 }
set_allocated_string_indexing_config(::icing::lib::StringIndexingConfig * string_indexing_config)5006 inline void PropertyConfigProto::set_allocated_string_indexing_config(::icing::lib::StringIndexingConfig* string_indexing_config) {
5007   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
5008   if (message_arena == nullptr) {
5009     delete _impl_.string_indexing_config_;
5010   }
5011   if (string_indexing_config) {
5012     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
5013         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(string_indexing_config);
5014     if (message_arena != submessage_arena) {
5015       string_indexing_config = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
5016           message_arena, string_indexing_config, submessage_arena);
5017     }
5018     _impl_._has_bits_[0] |= 0x00000008u;
5019   } else {
5020     _impl_._has_bits_[0] &= ~0x00000008u;
5021   }
5022   _impl_.string_indexing_config_ = string_indexing_config;
5023   // @@protoc_insertion_point(field_set_allocated:icing.lib.PropertyConfigProto.string_indexing_config)
5024 }
5025 
5026 // optional .icing.lib.DocumentIndexingConfig document_indexing_config = 6;
_internal_has_document_indexing_config()5027 inline bool PropertyConfigProto::_internal_has_document_indexing_config() const {
5028   bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
5029   PROTOBUF_ASSUME(!value || _impl_.document_indexing_config_ != nullptr);
5030   return value;
5031 }
has_document_indexing_config()5032 inline bool PropertyConfigProto::has_document_indexing_config() const {
5033   return _internal_has_document_indexing_config();
5034 }
clear_document_indexing_config()5035 inline void PropertyConfigProto::clear_document_indexing_config() {
5036   if (_impl_.document_indexing_config_ != nullptr) _impl_.document_indexing_config_->Clear();
5037   _impl_._has_bits_[0] &= ~0x00000010u;
5038 }
_internal_document_indexing_config()5039 inline const ::icing::lib::DocumentIndexingConfig& PropertyConfigProto::_internal_document_indexing_config() const {
5040   const ::icing::lib::DocumentIndexingConfig* p = _impl_.document_indexing_config_;
5041   return p != nullptr ? *p : reinterpret_cast<const ::icing::lib::DocumentIndexingConfig&>(
5042       ::icing::lib::_DocumentIndexingConfig_default_instance_);
5043 }
document_indexing_config()5044 inline const ::icing::lib::DocumentIndexingConfig& PropertyConfigProto::document_indexing_config() const {
5045   // @@protoc_insertion_point(field_get:icing.lib.PropertyConfigProto.document_indexing_config)
5046   return _internal_document_indexing_config();
5047 }
unsafe_arena_set_allocated_document_indexing_config(::icing::lib::DocumentIndexingConfig * document_indexing_config)5048 inline void PropertyConfigProto::unsafe_arena_set_allocated_document_indexing_config(
5049     ::icing::lib::DocumentIndexingConfig* document_indexing_config) {
5050   if (GetArenaForAllocation() == nullptr) {
5051     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.document_indexing_config_);
5052   }
5053   _impl_.document_indexing_config_ = document_indexing_config;
5054   if (document_indexing_config) {
5055     _impl_._has_bits_[0] |= 0x00000010u;
5056   } else {
5057     _impl_._has_bits_[0] &= ~0x00000010u;
5058   }
5059   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:icing.lib.PropertyConfigProto.document_indexing_config)
5060 }
release_document_indexing_config()5061 inline ::icing::lib::DocumentIndexingConfig* PropertyConfigProto::release_document_indexing_config() {
5062   _impl_._has_bits_[0] &= ~0x00000010u;
5063   ::icing::lib::DocumentIndexingConfig* temp = _impl_.document_indexing_config_;
5064   _impl_.document_indexing_config_ = nullptr;
5065 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
5066   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
5067   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
5068   if (GetArenaForAllocation() == nullptr) { delete old; }
5069 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
5070   if (GetArenaForAllocation() != nullptr) {
5071     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
5072   }
5073 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
5074   return temp;
5075 }
unsafe_arena_release_document_indexing_config()5076 inline ::icing::lib::DocumentIndexingConfig* PropertyConfigProto::unsafe_arena_release_document_indexing_config() {
5077   // @@protoc_insertion_point(field_release:icing.lib.PropertyConfigProto.document_indexing_config)
5078   _impl_._has_bits_[0] &= ~0x00000010u;
5079   ::icing::lib::DocumentIndexingConfig* temp = _impl_.document_indexing_config_;
5080   _impl_.document_indexing_config_ = nullptr;
5081   return temp;
5082 }
_internal_mutable_document_indexing_config()5083 inline ::icing::lib::DocumentIndexingConfig* PropertyConfigProto::_internal_mutable_document_indexing_config() {
5084   _impl_._has_bits_[0] |= 0x00000010u;
5085   if (_impl_.document_indexing_config_ == nullptr) {
5086     auto* p = CreateMaybeMessage<::icing::lib::DocumentIndexingConfig>(GetArenaForAllocation());
5087     _impl_.document_indexing_config_ = p;
5088   }
5089   return _impl_.document_indexing_config_;
5090 }
mutable_document_indexing_config()5091 inline ::icing::lib::DocumentIndexingConfig* PropertyConfigProto::mutable_document_indexing_config() {
5092   ::icing::lib::DocumentIndexingConfig* _msg = _internal_mutable_document_indexing_config();
5093   // @@protoc_insertion_point(field_mutable:icing.lib.PropertyConfigProto.document_indexing_config)
5094   return _msg;
5095 }
set_allocated_document_indexing_config(::icing::lib::DocumentIndexingConfig * document_indexing_config)5096 inline void PropertyConfigProto::set_allocated_document_indexing_config(::icing::lib::DocumentIndexingConfig* document_indexing_config) {
5097   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
5098   if (message_arena == nullptr) {
5099     delete _impl_.document_indexing_config_;
5100   }
5101   if (document_indexing_config) {
5102     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
5103         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(document_indexing_config);
5104     if (message_arena != submessage_arena) {
5105       document_indexing_config = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
5106           message_arena, document_indexing_config, submessage_arena);
5107     }
5108     _impl_._has_bits_[0] |= 0x00000010u;
5109   } else {
5110     _impl_._has_bits_[0] &= ~0x00000010u;
5111   }
5112   _impl_.document_indexing_config_ = document_indexing_config;
5113   // @@protoc_insertion_point(field_set_allocated:icing.lib.PropertyConfigProto.document_indexing_config)
5114 }
5115 
5116 // optional .icing.lib.IntegerIndexingConfig integer_indexing_config = 7;
_internal_has_integer_indexing_config()5117 inline bool PropertyConfigProto::_internal_has_integer_indexing_config() const {
5118   bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
5119   PROTOBUF_ASSUME(!value || _impl_.integer_indexing_config_ != nullptr);
5120   return value;
5121 }
has_integer_indexing_config()5122 inline bool PropertyConfigProto::has_integer_indexing_config() const {
5123   return _internal_has_integer_indexing_config();
5124 }
clear_integer_indexing_config()5125 inline void PropertyConfigProto::clear_integer_indexing_config() {
5126   if (_impl_.integer_indexing_config_ != nullptr) _impl_.integer_indexing_config_->Clear();
5127   _impl_._has_bits_[0] &= ~0x00000020u;
5128 }
_internal_integer_indexing_config()5129 inline const ::icing::lib::IntegerIndexingConfig& PropertyConfigProto::_internal_integer_indexing_config() const {
5130   const ::icing::lib::IntegerIndexingConfig* p = _impl_.integer_indexing_config_;
5131   return p != nullptr ? *p : reinterpret_cast<const ::icing::lib::IntegerIndexingConfig&>(
5132       ::icing::lib::_IntegerIndexingConfig_default_instance_);
5133 }
integer_indexing_config()5134 inline const ::icing::lib::IntegerIndexingConfig& PropertyConfigProto::integer_indexing_config() const {
5135   // @@protoc_insertion_point(field_get:icing.lib.PropertyConfigProto.integer_indexing_config)
5136   return _internal_integer_indexing_config();
5137 }
unsafe_arena_set_allocated_integer_indexing_config(::icing::lib::IntegerIndexingConfig * integer_indexing_config)5138 inline void PropertyConfigProto::unsafe_arena_set_allocated_integer_indexing_config(
5139     ::icing::lib::IntegerIndexingConfig* integer_indexing_config) {
5140   if (GetArenaForAllocation() == nullptr) {
5141     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.integer_indexing_config_);
5142   }
5143   _impl_.integer_indexing_config_ = integer_indexing_config;
5144   if (integer_indexing_config) {
5145     _impl_._has_bits_[0] |= 0x00000020u;
5146   } else {
5147     _impl_._has_bits_[0] &= ~0x00000020u;
5148   }
5149   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:icing.lib.PropertyConfigProto.integer_indexing_config)
5150 }
release_integer_indexing_config()5151 inline ::icing::lib::IntegerIndexingConfig* PropertyConfigProto::release_integer_indexing_config() {
5152   _impl_._has_bits_[0] &= ~0x00000020u;
5153   ::icing::lib::IntegerIndexingConfig* temp = _impl_.integer_indexing_config_;
5154   _impl_.integer_indexing_config_ = nullptr;
5155 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
5156   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
5157   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
5158   if (GetArenaForAllocation() == nullptr) { delete old; }
5159 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
5160   if (GetArenaForAllocation() != nullptr) {
5161     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
5162   }
5163 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
5164   return temp;
5165 }
unsafe_arena_release_integer_indexing_config()5166 inline ::icing::lib::IntegerIndexingConfig* PropertyConfigProto::unsafe_arena_release_integer_indexing_config() {
5167   // @@protoc_insertion_point(field_release:icing.lib.PropertyConfigProto.integer_indexing_config)
5168   _impl_._has_bits_[0] &= ~0x00000020u;
5169   ::icing::lib::IntegerIndexingConfig* temp = _impl_.integer_indexing_config_;
5170   _impl_.integer_indexing_config_ = nullptr;
5171   return temp;
5172 }
_internal_mutable_integer_indexing_config()5173 inline ::icing::lib::IntegerIndexingConfig* PropertyConfigProto::_internal_mutable_integer_indexing_config() {
5174   _impl_._has_bits_[0] |= 0x00000020u;
5175   if (_impl_.integer_indexing_config_ == nullptr) {
5176     auto* p = CreateMaybeMessage<::icing::lib::IntegerIndexingConfig>(GetArenaForAllocation());
5177     _impl_.integer_indexing_config_ = p;
5178   }
5179   return _impl_.integer_indexing_config_;
5180 }
mutable_integer_indexing_config()5181 inline ::icing::lib::IntegerIndexingConfig* PropertyConfigProto::mutable_integer_indexing_config() {
5182   ::icing::lib::IntegerIndexingConfig* _msg = _internal_mutable_integer_indexing_config();
5183   // @@protoc_insertion_point(field_mutable:icing.lib.PropertyConfigProto.integer_indexing_config)
5184   return _msg;
5185 }
set_allocated_integer_indexing_config(::icing::lib::IntegerIndexingConfig * integer_indexing_config)5186 inline void PropertyConfigProto::set_allocated_integer_indexing_config(::icing::lib::IntegerIndexingConfig* integer_indexing_config) {
5187   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
5188   if (message_arena == nullptr) {
5189     delete _impl_.integer_indexing_config_;
5190   }
5191   if (integer_indexing_config) {
5192     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
5193         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(integer_indexing_config);
5194     if (message_arena != submessage_arena) {
5195       integer_indexing_config = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
5196           message_arena, integer_indexing_config, submessage_arena);
5197     }
5198     _impl_._has_bits_[0] |= 0x00000020u;
5199   } else {
5200     _impl_._has_bits_[0] &= ~0x00000020u;
5201   }
5202   _impl_.integer_indexing_config_ = integer_indexing_config;
5203   // @@protoc_insertion_point(field_set_allocated:icing.lib.PropertyConfigProto.integer_indexing_config)
5204 }
5205 
5206 // optional .icing.lib.JoinableConfig joinable_config = 8;
_internal_has_joinable_config()5207 inline bool PropertyConfigProto::_internal_has_joinable_config() const {
5208   bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
5209   PROTOBUF_ASSUME(!value || _impl_.joinable_config_ != nullptr);
5210   return value;
5211 }
has_joinable_config()5212 inline bool PropertyConfigProto::has_joinable_config() const {
5213   return _internal_has_joinable_config();
5214 }
clear_joinable_config()5215 inline void PropertyConfigProto::clear_joinable_config() {
5216   if (_impl_.joinable_config_ != nullptr) _impl_.joinable_config_->Clear();
5217   _impl_._has_bits_[0] &= ~0x00000040u;
5218 }
_internal_joinable_config()5219 inline const ::icing::lib::JoinableConfig& PropertyConfigProto::_internal_joinable_config() const {
5220   const ::icing::lib::JoinableConfig* p = _impl_.joinable_config_;
5221   return p != nullptr ? *p : reinterpret_cast<const ::icing::lib::JoinableConfig&>(
5222       ::icing::lib::_JoinableConfig_default_instance_);
5223 }
joinable_config()5224 inline const ::icing::lib::JoinableConfig& PropertyConfigProto::joinable_config() const {
5225   // @@protoc_insertion_point(field_get:icing.lib.PropertyConfigProto.joinable_config)
5226   return _internal_joinable_config();
5227 }
unsafe_arena_set_allocated_joinable_config(::icing::lib::JoinableConfig * joinable_config)5228 inline void PropertyConfigProto::unsafe_arena_set_allocated_joinable_config(
5229     ::icing::lib::JoinableConfig* joinable_config) {
5230   if (GetArenaForAllocation() == nullptr) {
5231     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.joinable_config_);
5232   }
5233   _impl_.joinable_config_ = joinable_config;
5234   if (joinable_config) {
5235     _impl_._has_bits_[0] |= 0x00000040u;
5236   } else {
5237     _impl_._has_bits_[0] &= ~0x00000040u;
5238   }
5239   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:icing.lib.PropertyConfigProto.joinable_config)
5240 }
release_joinable_config()5241 inline ::icing::lib::JoinableConfig* PropertyConfigProto::release_joinable_config() {
5242   _impl_._has_bits_[0] &= ~0x00000040u;
5243   ::icing::lib::JoinableConfig* temp = _impl_.joinable_config_;
5244   _impl_.joinable_config_ = nullptr;
5245 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
5246   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
5247   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
5248   if (GetArenaForAllocation() == nullptr) { delete old; }
5249 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
5250   if (GetArenaForAllocation() != nullptr) {
5251     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
5252   }
5253 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
5254   return temp;
5255 }
unsafe_arena_release_joinable_config()5256 inline ::icing::lib::JoinableConfig* PropertyConfigProto::unsafe_arena_release_joinable_config() {
5257   // @@protoc_insertion_point(field_release:icing.lib.PropertyConfigProto.joinable_config)
5258   _impl_._has_bits_[0] &= ~0x00000040u;
5259   ::icing::lib::JoinableConfig* temp = _impl_.joinable_config_;
5260   _impl_.joinable_config_ = nullptr;
5261   return temp;
5262 }
_internal_mutable_joinable_config()5263 inline ::icing::lib::JoinableConfig* PropertyConfigProto::_internal_mutable_joinable_config() {
5264   _impl_._has_bits_[0] |= 0x00000040u;
5265   if (_impl_.joinable_config_ == nullptr) {
5266     auto* p = CreateMaybeMessage<::icing::lib::JoinableConfig>(GetArenaForAllocation());
5267     _impl_.joinable_config_ = p;
5268   }
5269   return _impl_.joinable_config_;
5270 }
mutable_joinable_config()5271 inline ::icing::lib::JoinableConfig* PropertyConfigProto::mutable_joinable_config() {
5272   ::icing::lib::JoinableConfig* _msg = _internal_mutable_joinable_config();
5273   // @@protoc_insertion_point(field_mutable:icing.lib.PropertyConfigProto.joinable_config)
5274   return _msg;
5275 }
set_allocated_joinable_config(::icing::lib::JoinableConfig * joinable_config)5276 inline void PropertyConfigProto::set_allocated_joinable_config(::icing::lib::JoinableConfig* joinable_config) {
5277   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
5278   if (message_arena == nullptr) {
5279     delete _impl_.joinable_config_;
5280   }
5281   if (joinable_config) {
5282     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
5283         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(joinable_config);
5284     if (message_arena != submessage_arena) {
5285       joinable_config = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
5286           message_arena, joinable_config, submessage_arena);
5287     }
5288     _impl_._has_bits_[0] |= 0x00000040u;
5289   } else {
5290     _impl_._has_bits_[0] &= ~0x00000040u;
5291   }
5292   _impl_.joinable_config_ = joinable_config;
5293   // @@protoc_insertion_point(field_set_allocated:icing.lib.PropertyConfigProto.joinable_config)
5294 }
5295 
5296 // optional .icing.lib.EmbeddingIndexingConfig embedding_indexing_config = 10;
_internal_has_embedding_indexing_config()5297 inline bool PropertyConfigProto::_internal_has_embedding_indexing_config() const {
5298   bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
5299   PROTOBUF_ASSUME(!value || _impl_.embedding_indexing_config_ != nullptr);
5300   return value;
5301 }
has_embedding_indexing_config()5302 inline bool PropertyConfigProto::has_embedding_indexing_config() const {
5303   return _internal_has_embedding_indexing_config();
5304 }
clear_embedding_indexing_config()5305 inline void PropertyConfigProto::clear_embedding_indexing_config() {
5306   if (_impl_.embedding_indexing_config_ != nullptr) _impl_.embedding_indexing_config_->Clear();
5307   _impl_._has_bits_[0] &= ~0x00000080u;
5308 }
_internal_embedding_indexing_config()5309 inline const ::icing::lib::EmbeddingIndexingConfig& PropertyConfigProto::_internal_embedding_indexing_config() const {
5310   const ::icing::lib::EmbeddingIndexingConfig* p = _impl_.embedding_indexing_config_;
5311   return p != nullptr ? *p : reinterpret_cast<const ::icing::lib::EmbeddingIndexingConfig&>(
5312       ::icing::lib::_EmbeddingIndexingConfig_default_instance_);
5313 }
embedding_indexing_config()5314 inline const ::icing::lib::EmbeddingIndexingConfig& PropertyConfigProto::embedding_indexing_config() const {
5315   // @@protoc_insertion_point(field_get:icing.lib.PropertyConfigProto.embedding_indexing_config)
5316   return _internal_embedding_indexing_config();
5317 }
unsafe_arena_set_allocated_embedding_indexing_config(::icing::lib::EmbeddingIndexingConfig * embedding_indexing_config)5318 inline void PropertyConfigProto::unsafe_arena_set_allocated_embedding_indexing_config(
5319     ::icing::lib::EmbeddingIndexingConfig* embedding_indexing_config) {
5320   if (GetArenaForAllocation() == nullptr) {
5321     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.embedding_indexing_config_);
5322   }
5323   _impl_.embedding_indexing_config_ = embedding_indexing_config;
5324   if (embedding_indexing_config) {
5325     _impl_._has_bits_[0] |= 0x00000080u;
5326   } else {
5327     _impl_._has_bits_[0] &= ~0x00000080u;
5328   }
5329   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:icing.lib.PropertyConfigProto.embedding_indexing_config)
5330 }
release_embedding_indexing_config()5331 inline ::icing::lib::EmbeddingIndexingConfig* PropertyConfigProto::release_embedding_indexing_config() {
5332   _impl_._has_bits_[0] &= ~0x00000080u;
5333   ::icing::lib::EmbeddingIndexingConfig* temp = _impl_.embedding_indexing_config_;
5334   _impl_.embedding_indexing_config_ = nullptr;
5335 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
5336   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
5337   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
5338   if (GetArenaForAllocation() == nullptr) { delete old; }
5339 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
5340   if (GetArenaForAllocation() != nullptr) {
5341     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
5342   }
5343 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
5344   return temp;
5345 }
unsafe_arena_release_embedding_indexing_config()5346 inline ::icing::lib::EmbeddingIndexingConfig* PropertyConfigProto::unsafe_arena_release_embedding_indexing_config() {
5347   // @@protoc_insertion_point(field_release:icing.lib.PropertyConfigProto.embedding_indexing_config)
5348   _impl_._has_bits_[0] &= ~0x00000080u;
5349   ::icing::lib::EmbeddingIndexingConfig* temp = _impl_.embedding_indexing_config_;
5350   _impl_.embedding_indexing_config_ = nullptr;
5351   return temp;
5352 }
_internal_mutable_embedding_indexing_config()5353 inline ::icing::lib::EmbeddingIndexingConfig* PropertyConfigProto::_internal_mutable_embedding_indexing_config() {
5354   _impl_._has_bits_[0] |= 0x00000080u;
5355   if (_impl_.embedding_indexing_config_ == nullptr) {
5356     auto* p = CreateMaybeMessage<::icing::lib::EmbeddingIndexingConfig>(GetArenaForAllocation());
5357     _impl_.embedding_indexing_config_ = p;
5358   }
5359   return _impl_.embedding_indexing_config_;
5360 }
mutable_embedding_indexing_config()5361 inline ::icing::lib::EmbeddingIndexingConfig* PropertyConfigProto::mutable_embedding_indexing_config() {
5362   ::icing::lib::EmbeddingIndexingConfig* _msg = _internal_mutable_embedding_indexing_config();
5363   // @@protoc_insertion_point(field_mutable:icing.lib.PropertyConfigProto.embedding_indexing_config)
5364   return _msg;
5365 }
set_allocated_embedding_indexing_config(::icing::lib::EmbeddingIndexingConfig * embedding_indexing_config)5366 inline void PropertyConfigProto::set_allocated_embedding_indexing_config(::icing::lib::EmbeddingIndexingConfig* embedding_indexing_config) {
5367   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
5368   if (message_arena == nullptr) {
5369     delete _impl_.embedding_indexing_config_;
5370   }
5371   if (embedding_indexing_config) {
5372     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
5373         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(embedding_indexing_config);
5374     if (message_arena != submessage_arena) {
5375       embedding_indexing_config = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
5376           message_arena, embedding_indexing_config, submessage_arena);
5377     }
5378     _impl_._has_bits_[0] |= 0x00000080u;
5379   } else {
5380     _impl_._has_bits_[0] &= ~0x00000080u;
5381   }
5382   _impl_.embedding_indexing_config_ = embedding_indexing_config;
5383   // @@protoc_insertion_point(field_set_allocated:icing.lib.PropertyConfigProto.embedding_indexing_config)
5384 }
5385 
5386 // optional .icing.lib.PropertyConfigProto.ScorableType.Code scorable_type = 11;
_internal_has_scorable_type()5387 inline bool PropertyConfigProto::_internal_has_scorable_type() const {
5388   bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
5389   return value;
5390 }
has_scorable_type()5391 inline bool PropertyConfigProto::has_scorable_type() const {
5392   return _internal_has_scorable_type();
5393 }
clear_scorable_type()5394 inline void PropertyConfigProto::clear_scorable_type() {
5395   _impl_.scorable_type_ = 0;
5396   _impl_._has_bits_[0] &= ~0x00000400u;
5397 }
_internal_scorable_type()5398 inline ::icing::lib::PropertyConfigProto_ScorableType_Code PropertyConfigProto::_internal_scorable_type() const {
5399   return static_cast< ::icing::lib::PropertyConfigProto_ScorableType_Code >(_impl_.scorable_type_);
5400 }
scorable_type()5401 inline ::icing::lib::PropertyConfigProto_ScorableType_Code PropertyConfigProto::scorable_type() const {
5402   // @@protoc_insertion_point(field_get:icing.lib.PropertyConfigProto.scorable_type)
5403   return _internal_scorable_type();
5404 }
_internal_set_scorable_type(::icing::lib::PropertyConfigProto_ScorableType_Code value)5405 inline void PropertyConfigProto::_internal_set_scorable_type(::icing::lib::PropertyConfigProto_ScorableType_Code value) {
5406   assert(::icing::lib::PropertyConfigProto_ScorableType_Code_IsValid(value));
5407   _impl_._has_bits_[0] |= 0x00000400u;
5408   _impl_.scorable_type_ = value;
5409 }
set_scorable_type(::icing::lib::PropertyConfigProto_ScorableType_Code value)5410 inline void PropertyConfigProto::set_scorable_type(::icing::lib::PropertyConfigProto_ScorableType_Code value) {
5411   _internal_set_scorable_type(value);
5412   // @@protoc_insertion_point(field_set:icing.lib.PropertyConfigProto.scorable_type)
5413 }
5414 
5415 // -------------------------------------------------------------------
5416 
5417 // SchemaProto
5418 
5419 // repeated .icing.lib.SchemaTypeConfigProto types = 1;
_internal_types_size()5420 inline int SchemaProto::_internal_types_size() const {
5421   return _impl_.types_.size();
5422 }
types_size()5423 inline int SchemaProto::types_size() const {
5424   return _internal_types_size();
5425 }
clear_types()5426 inline void SchemaProto::clear_types() {
5427   _impl_.types_.Clear();
5428 }
mutable_types(int index)5429 inline ::icing::lib::SchemaTypeConfigProto* SchemaProto::mutable_types(int index) {
5430   // @@protoc_insertion_point(field_mutable:icing.lib.SchemaProto.types)
5431   return _impl_.types_.Mutable(index);
5432 }
5433 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::SchemaTypeConfigProto >*
mutable_types()5434 SchemaProto::mutable_types() {
5435   // @@protoc_insertion_point(field_mutable_list:icing.lib.SchemaProto.types)
5436   return &_impl_.types_;
5437 }
_internal_types(int index)5438 inline const ::icing::lib::SchemaTypeConfigProto& SchemaProto::_internal_types(int index) const {
5439   return _impl_.types_.Get(index);
5440 }
types(int index)5441 inline const ::icing::lib::SchemaTypeConfigProto& SchemaProto::types(int index) const {
5442   // @@protoc_insertion_point(field_get:icing.lib.SchemaProto.types)
5443   return _internal_types(index);
5444 }
_internal_add_types()5445 inline ::icing::lib::SchemaTypeConfigProto* SchemaProto::_internal_add_types() {
5446   return _impl_.types_.Add();
5447 }
add_types()5448 inline ::icing::lib::SchemaTypeConfigProto* SchemaProto::add_types() {
5449   ::icing::lib::SchemaTypeConfigProto* _add = _internal_add_types();
5450   // @@protoc_insertion_point(field_add:icing.lib.SchemaProto.types)
5451   return _add;
5452 }
5453 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::SchemaTypeConfigProto >&
types()5454 SchemaProto::types() const {
5455   // @@protoc_insertion_point(field_list:icing.lib.SchemaProto.types)
5456   return _impl_.types_;
5457 }
5458 
5459 // -------------------------------------------------------------------
5460 
5461 // SetSchemaResultProto
5462 
5463 // optional .icing.lib.StatusProto status = 1;
_internal_has_status()5464 inline bool SetSchemaResultProto::_internal_has_status() const {
5465   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
5466   PROTOBUF_ASSUME(!value || _impl_.status_ != nullptr);
5467   return value;
5468 }
has_status()5469 inline bool SetSchemaResultProto::has_status() const {
5470   return _internal_has_status();
5471 }
_internal_status()5472 inline const ::icing::lib::StatusProto& SetSchemaResultProto::_internal_status() const {
5473   const ::icing::lib::StatusProto* p = _impl_.status_;
5474   return p != nullptr ? *p : reinterpret_cast<const ::icing::lib::StatusProto&>(
5475       ::icing::lib::_StatusProto_default_instance_);
5476 }
status()5477 inline const ::icing::lib::StatusProto& SetSchemaResultProto::status() const {
5478   // @@protoc_insertion_point(field_get:icing.lib.SetSchemaResultProto.status)
5479   return _internal_status();
5480 }
unsafe_arena_set_allocated_status(::icing::lib::StatusProto * status)5481 inline void SetSchemaResultProto::unsafe_arena_set_allocated_status(
5482     ::icing::lib::StatusProto* status) {
5483   if (GetArenaForAllocation() == nullptr) {
5484     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.status_);
5485   }
5486   _impl_.status_ = status;
5487   if (status) {
5488     _impl_._has_bits_[0] |= 0x00000001u;
5489   } else {
5490     _impl_._has_bits_[0] &= ~0x00000001u;
5491   }
5492   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:icing.lib.SetSchemaResultProto.status)
5493 }
release_status()5494 inline ::icing::lib::StatusProto* SetSchemaResultProto::release_status() {
5495   _impl_._has_bits_[0] &= ~0x00000001u;
5496   ::icing::lib::StatusProto* temp = _impl_.status_;
5497   _impl_.status_ = nullptr;
5498 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
5499   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
5500   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
5501   if (GetArenaForAllocation() == nullptr) { delete old; }
5502 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
5503   if (GetArenaForAllocation() != nullptr) {
5504     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
5505   }
5506 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
5507   return temp;
5508 }
unsafe_arena_release_status()5509 inline ::icing::lib::StatusProto* SetSchemaResultProto::unsafe_arena_release_status() {
5510   // @@protoc_insertion_point(field_release:icing.lib.SetSchemaResultProto.status)
5511   _impl_._has_bits_[0] &= ~0x00000001u;
5512   ::icing::lib::StatusProto* temp = _impl_.status_;
5513   _impl_.status_ = nullptr;
5514   return temp;
5515 }
_internal_mutable_status()5516 inline ::icing::lib::StatusProto* SetSchemaResultProto::_internal_mutable_status() {
5517   _impl_._has_bits_[0] |= 0x00000001u;
5518   if (_impl_.status_ == nullptr) {
5519     auto* p = CreateMaybeMessage<::icing::lib::StatusProto>(GetArenaForAllocation());
5520     _impl_.status_ = p;
5521   }
5522   return _impl_.status_;
5523 }
mutable_status()5524 inline ::icing::lib::StatusProto* SetSchemaResultProto::mutable_status() {
5525   ::icing::lib::StatusProto* _msg = _internal_mutable_status();
5526   // @@protoc_insertion_point(field_mutable:icing.lib.SetSchemaResultProto.status)
5527   return _msg;
5528 }
set_allocated_status(::icing::lib::StatusProto * status)5529 inline void SetSchemaResultProto::set_allocated_status(::icing::lib::StatusProto* status) {
5530   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
5531   if (message_arena == nullptr) {
5532     delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.status_);
5533   }
5534   if (status) {
5535     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
5536         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
5537                 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(status));
5538     if (message_arena != submessage_arena) {
5539       status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
5540           message_arena, status, submessage_arena);
5541     }
5542     _impl_._has_bits_[0] |= 0x00000001u;
5543   } else {
5544     _impl_._has_bits_[0] &= ~0x00000001u;
5545   }
5546   _impl_.status_ = status;
5547   // @@protoc_insertion_point(field_set_allocated:icing.lib.SetSchemaResultProto.status)
5548 }
5549 
5550 // repeated string deleted_schema_types = 2;
_internal_deleted_schema_types_size()5551 inline int SetSchemaResultProto::_internal_deleted_schema_types_size() const {
5552   return _impl_.deleted_schema_types_.size();
5553 }
deleted_schema_types_size()5554 inline int SetSchemaResultProto::deleted_schema_types_size() const {
5555   return _internal_deleted_schema_types_size();
5556 }
clear_deleted_schema_types()5557 inline void SetSchemaResultProto::clear_deleted_schema_types() {
5558   _impl_.deleted_schema_types_.Clear();
5559 }
add_deleted_schema_types()5560 inline std::string* SetSchemaResultProto::add_deleted_schema_types() {
5561   std::string* _s = _internal_add_deleted_schema_types();
5562   // @@protoc_insertion_point(field_add_mutable:icing.lib.SetSchemaResultProto.deleted_schema_types)
5563   return _s;
5564 }
_internal_deleted_schema_types(int index)5565 inline const std::string& SetSchemaResultProto::_internal_deleted_schema_types(int index) const {
5566   return _impl_.deleted_schema_types_.Get(index);
5567 }
deleted_schema_types(int index)5568 inline const std::string& SetSchemaResultProto::deleted_schema_types(int index) const {
5569   // @@protoc_insertion_point(field_get:icing.lib.SetSchemaResultProto.deleted_schema_types)
5570   return _internal_deleted_schema_types(index);
5571 }
mutable_deleted_schema_types(int index)5572 inline std::string* SetSchemaResultProto::mutable_deleted_schema_types(int index) {
5573   // @@protoc_insertion_point(field_mutable:icing.lib.SetSchemaResultProto.deleted_schema_types)
5574   return _impl_.deleted_schema_types_.Mutable(index);
5575 }
set_deleted_schema_types(int index,const std::string & value)5576 inline void SetSchemaResultProto::set_deleted_schema_types(int index, const std::string& value) {
5577   _impl_.deleted_schema_types_.Mutable(index)->assign(value);
5578   // @@protoc_insertion_point(field_set:icing.lib.SetSchemaResultProto.deleted_schema_types)
5579 }
set_deleted_schema_types(int index,std::string && value)5580 inline void SetSchemaResultProto::set_deleted_schema_types(int index, std::string&& value) {
5581   _impl_.deleted_schema_types_.Mutable(index)->assign(std::move(value));
5582   // @@protoc_insertion_point(field_set:icing.lib.SetSchemaResultProto.deleted_schema_types)
5583 }
set_deleted_schema_types(int index,const char * value)5584 inline void SetSchemaResultProto::set_deleted_schema_types(int index, const char* value) {
5585   GOOGLE_DCHECK(value != nullptr);
5586   _impl_.deleted_schema_types_.Mutable(index)->assign(value);
5587   // @@protoc_insertion_point(field_set_char:icing.lib.SetSchemaResultProto.deleted_schema_types)
5588 }
set_deleted_schema_types(int index,const char * value,size_t size)5589 inline void SetSchemaResultProto::set_deleted_schema_types(int index, const char* value, size_t size) {
5590   _impl_.deleted_schema_types_.Mutable(index)->assign(
5591     reinterpret_cast<const char*>(value), size);
5592   // @@protoc_insertion_point(field_set_pointer:icing.lib.SetSchemaResultProto.deleted_schema_types)
5593 }
_internal_add_deleted_schema_types()5594 inline std::string* SetSchemaResultProto::_internal_add_deleted_schema_types() {
5595   return _impl_.deleted_schema_types_.Add();
5596 }
add_deleted_schema_types(const std::string & value)5597 inline void SetSchemaResultProto::add_deleted_schema_types(const std::string& value) {
5598   _impl_.deleted_schema_types_.Add()->assign(value);
5599   // @@protoc_insertion_point(field_add:icing.lib.SetSchemaResultProto.deleted_schema_types)
5600 }
add_deleted_schema_types(std::string && value)5601 inline void SetSchemaResultProto::add_deleted_schema_types(std::string&& value) {
5602   _impl_.deleted_schema_types_.Add(std::move(value));
5603   // @@protoc_insertion_point(field_add:icing.lib.SetSchemaResultProto.deleted_schema_types)
5604 }
add_deleted_schema_types(const char * value)5605 inline void SetSchemaResultProto::add_deleted_schema_types(const char* value) {
5606   GOOGLE_DCHECK(value != nullptr);
5607   _impl_.deleted_schema_types_.Add()->assign(value);
5608   // @@protoc_insertion_point(field_add_char:icing.lib.SetSchemaResultProto.deleted_schema_types)
5609 }
add_deleted_schema_types(const char * value,size_t size)5610 inline void SetSchemaResultProto::add_deleted_schema_types(const char* value, size_t size) {
5611   _impl_.deleted_schema_types_.Add()->assign(reinterpret_cast<const char*>(value), size);
5612   // @@protoc_insertion_point(field_add_pointer:icing.lib.SetSchemaResultProto.deleted_schema_types)
5613 }
5614 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
deleted_schema_types()5615 SetSchemaResultProto::deleted_schema_types() const {
5616   // @@protoc_insertion_point(field_list:icing.lib.SetSchemaResultProto.deleted_schema_types)
5617   return _impl_.deleted_schema_types_;
5618 }
5619 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_deleted_schema_types()5620 SetSchemaResultProto::mutable_deleted_schema_types() {
5621   // @@protoc_insertion_point(field_mutable_list:icing.lib.SetSchemaResultProto.deleted_schema_types)
5622   return &_impl_.deleted_schema_types_;
5623 }
5624 
5625 // repeated string incompatible_schema_types = 3;
_internal_incompatible_schema_types_size()5626 inline int SetSchemaResultProto::_internal_incompatible_schema_types_size() const {
5627   return _impl_.incompatible_schema_types_.size();
5628 }
incompatible_schema_types_size()5629 inline int SetSchemaResultProto::incompatible_schema_types_size() const {
5630   return _internal_incompatible_schema_types_size();
5631 }
clear_incompatible_schema_types()5632 inline void SetSchemaResultProto::clear_incompatible_schema_types() {
5633   _impl_.incompatible_schema_types_.Clear();
5634 }
add_incompatible_schema_types()5635 inline std::string* SetSchemaResultProto::add_incompatible_schema_types() {
5636   std::string* _s = _internal_add_incompatible_schema_types();
5637   // @@protoc_insertion_point(field_add_mutable:icing.lib.SetSchemaResultProto.incompatible_schema_types)
5638   return _s;
5639 }
_internal_incompatible_schema_types(int index)5640 inline const std::string& SetSchemaResultProto::_internal_incompatible_schema_types(int index) const {
5641   return _impl_.incompatible_schema_types_.Get(index);
5642 }
incompatible_schema_types(int index)5643 inline const std::string& SetSchemaResultProto::incompatible_schema_types(int index) const {
5644   // @@protoc_insertion_point(field_get:icing.lib.SetSchemaResultProto.incompatible_schema_types)
5645   return _internal_incompatible_schema_types(index);
5646 }
mutable_incompatible_schema_types(int index)5647 inline std::string* SetSchemaResultProto::mutable_incompatible_schema_types(int index) {
5648   // @@protoc_insertion_point(field_mutable:icing.lib.SetSchemaResultProto.incompatible_schema_types)
5649   return _impl_.incompatible_schema_types_.Mutable(index);
5650 }
set_incompatible_schema_types(int index,const std::string & value)5651 inline void SetSchemaResultProto::set_incompatible_schema_types(int index, const std::string& value) {
5652   _impl_.incompatible_schema_types_.Mutable(index)->assign(value);
5653   // @@protoc_insertion_point(field_set:icing.lib.SetSchemaResultProto.incompatible_schema_types)
5654 }
set_incompatible_schema_types(int index,std::string && value)5655 inline void SetSchemaResultProto::set_incompatible_schema_types(int index, std::string&& value) {
5656   _impl_.incompatible_schema_types_.Mutable(index)->assign(std::move(value));
5657   // @@protoc_insertion_point(field_set:icing.lib.SetSchemaResultProto.incompatible_schema_types)
5658 }
set_incompatible_schema_types(int index,const char * value)5659 inline void SetSchemaResultProto::set_incompatible_schema_types(int index, const char* value) {
5660   GOOGLE_DCHECK(value != nullptr);
5661   _impl_.incompatible_schema_types_.Mutable(index)->assign(value);
5662   // @@protoc_insertion_point(field_set_char:icing.lib.SetSchemaResultProto.incompatible_schema_types)
5663 }
set_incompatible_schema_types(int index,const char * value,size_t size)5664 inline void SetSchemaResultProto::set_incompatible_schema_types(int index, const char* value, size_t size) {
5665   _impl_.incompatible_schema_types_.Mutable(index)->assign(
5666     reinterpret_cast<const char*>(value), size);
5667   // @@protoc_insertion_point(field_set_pointer:icing.lib.SetSchemaResultProto.incompatible_schema_types)
5668 }
_internal_add_incompatible_schema_types()5669 inline std::string* SetSchemaResultProto::_internal_add_incompatible_schema_types() {
5670   return _impl_.incompatible_schema_types_.Add();
5671 }
add_incompatible_schema_types(const std::string & value)5672 inline void SetSchemaResultProto::add_incompatible_schema_types(const std::string& value) {
5673   _impl_.incompatible_schema_types_.Add()->assign(value);
5674   // @@protoc_insertion_point(field_add:icing.lib.SetSchemaResultProto.incompatible_schema_types)
5675 }
add_incompatible_schema_types(std::string && value)5676 inline void SetSchemaResultProto::add_incompatible_schema_types(std::string&& value) {
5677   _impl_.incompatible_schema_types_.Add(std::move(value));
5678   // @@protoc_insertion_point(field_add:icing.lib.SetSchemaResultProto.incompatible_schema_types)
5679 }
add_incompatible_schema_types(const char * value)5680 inline void SetSchemaResultProto::add_incompatible_schema_types(const char* value) {
5681   GOOGLE_DCHECK(value != nullptr);
5682   _impl_.incompatible_schema_types_.Add()->assign(value);
5683   // @@protoc_insertion_point(field_add_char:icing.lib.SetSchemaResultProto.incompatible_schema_types)
5684 }
add_incompatible_schema_types(const char * value,size_t size)5685 inline void SetSchemaResultProto::add_incompatible_schema_types(const char* value, size_t size) {
5686   _impl_.incompatible_schema_types_.Add()->assign(reinterpret_cast<const char*>(value), size);
5687   // @@protoc_insertion_point(field_add_pointer:icing.lib.SetSchemaResultProto.incompatible_schema_types)
5688 }
5689 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
incompatible_schema_types()5690 SetSchemaResultProto::incompatible_schema_types() const {
5691   // @@protoc_insertion_point(field_list:icing.lib.SetSchemaResultProto.incompatible_schema_types)
5692   return _impl_.incompatible_schema_types_;
5693 }
5694 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_incompatible_schema_types()5695 SetSchemaResultProto::mutable_incompatible_schema_types() {
5696   // @@protoc_insertion_point(field_mutable_list:icing.lib.SetSchemaResultProto.incompatible_schema_types)
5697   return &_impl_.incompatible_schema_types_;
5698 }
5699 
5700 // repeated string new_schema_types = 4;
_internal_new_schema_types_size()5701 inline int SetSchemaResultProto::_internal_new_schema_types_size() const {
5702   return _impl_.new_schema_types_.size();
5703 }
new_schema_types_size()5704 inline int SetSchemaResultProto::new_schema_types_size() const {
5705   return _internal_new_schema_types_size();
5706 }
clear_new_schema_types()5707 inline void SetSchemaResultProto::clear_new_schema_types() {
5708   _impl_.new_schema_types_.Clear();
5709 }
add_new_schema_types()5710 inline std::string* SetSchemaResultProto::add_new_schema_types() {
5711   std::string* _s = _internal_add_new_schema_types();
5712   // @@protoc_insertion_point(field_add_mutable:icing.lib.SetSchemaResultProto.new_schema_types)
5713   return _s;
5714 }
_internal_new_schema_types(int index)5715 inline const std::string& SetSchemaResultProto::_internal_new_schema_types(int index) const {
5716   return _impl_.new_schema_types_.Get(index);
5717 }
new_schema_types(int index)5718 inline const std::string& SetSchemaResultProto::new_schema_types(int index) const {
5719   // @@protoc_insertion_point(field_get:icing.lib.SetSchemaResultProto.new_schema_types)
5720   return _internal_new_schema_types(index);
5721 }
mutable_new_schema_types(int index)5722 inline std::string* SetSchemaResultProto::mutable_new_schema_types(int index) {
5723   // @@protoc_insertion_point(field_mutable:icing.lib.SetSchemaResultProto.new_schema_types)
5724   return _impl_.new_schema_types_.Mutable(index);
5725 }
set_new_schema_types(int index,const std::string & value)5726 inline void SetSchemaResultProto::set_new_schema_types(int index, const std::string& value) {
5727   _impl_.new_schema_types_.Mutable(index)->assign(value);
5728   // @@protoc_insertion_point(field_set:icing.lib.SetSchemaResultProto.new_schema_types)
5729 }
set_new_schema_types(int index,std::string && value)5730 inline void SetSchemaResultProto::set_new_schema_types(int index, std::string&& value) {
5731   _impl_.new_schema_types_.Mutable(index)->assign(std::move(value));
5732   // @@protoc_insertion_point(field_set:icing.lib.SetSchemaResultProto.new_schema_types)
5733 }
set_new_schema_types(int index,const char * value)5734 inline void SetSchemaResultProto::set_new_schema_types(int index, const char* value) {
5735   GOOGLE_DCHECK(value != nullptr);
5736   _impl_.new_schema_types_.Mutable(index)->assign(value);
5737   // @@protoc_insertion_point(field_set_char:icing.lib.SetSchemaResultProto.new_schema_types)
5738 }
set_new_schema_types(int index,const char * value,size_t size)5739 inline void SetSchemaResultProto::set_new_schema_types(int index, const char* value, size_t size) {
5740   _impl_.new_schema_types_.Mutable(index)->assign(
5741     reinterpret_cast<const char*>(value), size);
5742   // @@protoc_insertion_point(field_set_pointer:icing.lib.SetSchemaResultProto.new_schema_types)
5743 }
_internal_add_new_schema_types()5744 inline std::string* SetSchemaResultProto::_internal_add_new_schema_types() {
5745   return _impl_.new_schema_types_.Add();
5746 }
add_new_schema_types(const std::string & value)5747 inline void SetSchemaResultProto::add_new_schema_types(const std::string& value) {
5748   _impl_.new_schema_types_.Add()->assign(value);
5749   // @@protoc_insertion_point(field_add:icing.lib.SetSchemaResultProto.new_schema_types)
5750 }
add_new_schema_types(std::string && value)5751 inline void SetSchemaResultProto::add_new_schema_types(std::string&& value) {
5752   _impl_.new_schema_types_.Add(std::move(value));
5753   // @@protoc_insertion_point(field_add:icing.lib.SetSchemaResultProto.new_schema_types)
5754 }
add_new_schema_types(const char * value)5755 inline void SetSchemaResultProto::add_new_schema_types(const char* value) {
5756   GOOGLE_DCHECK(value != nullptr);
5757   _impl_.new_schema_types_.Add()->assign(value);
5758   // @@protoc_insertion_point(field_add_char:icing.lib.SetSchemaResultProto.new_schema_types)
5759 }
add_new_schema_types(const char * value,size_t size)5760 inline void SetSchemaResultProto::add_new_schema_types(const char* value, size_t size) {
5761   _impl_.new_schema_types_.Add()->assign(reinterpret_cast<const char*>(value), size);
5762   // @@protoc_insertion_point(field_add_pointer:icing.lib.SetSchemaResultProto.new_schema_types)
5763 }
5764 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
new_schema_types()5765 SetSchemaResultProto::new_schema_types() const {
5766   // @@protoc_insertion_point(field_list:icing.lib.SetSchemaResultProto.new_schema_types)
5767   return _impl_.new_schema_types_;
5768 }
5769 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_new_schema_types()5770 SetSchemaResultProto::mutable_new_schema_types() {
5771   // @@protoc_insertion_point(field_mutable_list:icing.lib.SetSchemaResultProto.new_schema_types)
5772   return &_impl_.new_schema_types_;
5773 }
5774 
5775 // repeated string fully_compatible_changed_schema_types = 5;
_internal_fully_compatible_changed_schema_types_size()5776 inline int SetSchemaResultProto::_internal_fully_compatible_changed_schema_types_size() const {
5777   return _impl_.fully_compatible_changed_schema_types_.size();
5778 }
fully_compatible_changed_schema_types_size()5779 inline int SetSchemaResultProto::fully_compatible_changed_schema_types_size() const {
5780   return _internal_fully_compatible_changed_schema_types_size();
5781 }
clear_fully_compatible_changed_schema_types()5782 inline void SetSchemaResultProto::clear_fully_compatible_changed_schema_types() {
5783   _impl_.fully_compatible_changed_schema_types_.Clear();
5784 }
add_fully_compatible_changed_schema_types()5785 inline std::string* SetSchemaResultProto::add_fully_compatible_changed_schema_types() {
5786   std::string* _s = _internal_add_fully_compatible_changed_schema_types();
5787   // @@protoc_insertion_point(field_add_mutable:icing.lib.SetSchemaResultProto.fully_compatible_changed_schema_types)
5788   return _s;
5789 }
_internal_fully_compatible_changed_schema_types(int index)5790 inline const std::string& SetSchemaResultProto::_internal_fully_compatible_changed_schema_types(int index) const {
5791   return _impl_.fully_compatible_changed_schema_types_.Get(index);
5792 }
fully_compatible_changed_schema_types(int index)5793 inline const std::string& SetSchemaResultProto::fully_compatible_changed_schema_types(int index) const {
5794   // @@protoc_insertion_point(field_get:icing.lib.SetSchemaResultProto.fully_compatible_changed_schema_types)
5795   return _internal_fully_compatible_changed_schema_types(index);
5796 }
mutable_fully_compatible_changed_schema_types(int index)5797 inline std::string* SetSchemaResultProto::mutable_fully_compatible_changed_schema_types(int index) {
5798   // @@protoc_insertion_point(field_mutable:icing.lib.SetSchemaResultProto.fully_compatible_changed_schema_types)
5799   return _impl_.fully_compatible_changed_schema_types_.Mutable(index);
5800 }
set_fully_compatible_changed_schema_types(int index,const std::string & value)5801 inline void SetSchemaResultProto::set_fully_compatible_changed_schema_types(int index, const std::string& value) {
5802   _impl_.fully_compatible_changed_schema_types_.Mutable(index)->assign(value);
5803   // @@protoc_insertion_point(field_set:icing.lib.SetSchemaResultProto.fully_compatible_changed_schema_types)
5804 }
set_fully_compatible_changed_schema_types(int index,std::string && value)5805 inline void SetSchemaResultProto::set_fully_compatible_changed_schema_types(int index, std::string&& value) {
5806   _impl_.fully_compatible_changed_schema_types_.Mutable(index)->assign(std::move(value));
5807   // @@protoc_insertion_point(field_set:icing.lib.SetSchemaResultProto.fully_compatible_changed_schema_types)
5808 }
set_fully_compatible_changed_schema_types(int index,const char * value)5809 inline void SetSchemaResultProto::set_fully_compatible_changed_schema_types(int index, const char* value) {
5810   GOOGLE_DCHECK(value != nullptr);
5811   _impl_.fully_compatible_changed_schema_types_.Mutable(index)->assign(value);
5812   // @@protoc_insertion_point(field_set_char:icing.lib.SetSchemaResultProto.fully_compatible_changed_schema_types)
5813 }
set_fully_compatible_changed_schema_types(int index,const char * value,size_t size)5814 inline void SetSchemaResultProto::set_fully_compatible_changed_schema_types(int index, const char* value, size_t size) {
5815   _impl_.fully_compatible_changed_schema_types_.Mutable(index)->assign(
5816     reinterpret_cast<const char*>(value), size);
5817   // @@protoc_insertion_point(field_set_pointer:icing.lib.SetSchemaResultProto.fully_compatible_changed_schema_types)
5818 }
_internal_add_fully_compatible_changed_schema_types()5819 inline std::string* SetSchemaResultProto::_internal_add_fully_compatible_changed_schema_types() {
5820   return _impl_.fully_compatible_changed_schema_types_.Add();
5821 }
add_fully_compatible_changed_schema_types(const std::string & value)5822 inline void SetSchemaResultProto::add_fully_compatible_changed_schema_types(const std::string& value) {
5823   _impl_.fully_compatible_changed_schema_types_.Add()->assign(value);
5824   // @@protoc_insertion_point(field_add:icing.lib.SetSchemaResultProto.fully_compatible_changed_schema_types)
5825 }
add_fully_compatible_changed_schema_types(std::string && value)5826 inline void SetSchemaResultProto::add_fully_compatible_changed_schema_types(std::string&& value) {
5827   _impl_.fully_compatible_changed_schema_types_.Add(std::move(value));
5828   // @@protoc_insertion_point(field_add:icing.lib.SetSchemaResultProto.fully_compatible_changed_schema_types)
5829 }
add_fully_compatible_changed_schema_types(const char * value)5830 inline void SetSchemaResultProto::add_fully_compatible_changed_schema_types(const char* value) {
5831   GOOGLE_DCHECK(value != nullptr);
5832   _impl_.fully_compatible_changed_schema_types_.Add()->assign(value);
5833   // @@protoc_insertion_point(field_add_char:icing.lib.SetSchemaResultProto.fully_compatible_changed_schema_types)
5834 }
add_fully_compatible_changed_schema_types(const char * value,size_t size)5835 inline void SetSchemaResultProto::add_fully_compatible_changed_schema_types(const char* value, size_t size) {
5836   _impl_.fully_compatible_changed_schema_types_.Add()->assign(reinterpret_cast<const char*>(value), size);
5837   // @@protoc_insertion_point(field_add_pointer:icing.lib.SetSchemaResultProto.fully_compatible_changed_schema_types)
5838 }
5839 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
fully_compatible_changed_schema_types()5840 SetSchemaResultProto::fully_compatible_changed_schema_types() const {
5841   // @@protoc_insertion_point(field_list:icing.lib.SetSchemaResultProto.fully_compatible_changed_schema_types)
5842   return _impl_.fully_compatible_changed_schema_types_;
5843 }
5844 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_fully_compatible_changed_schema_types()5845 SetSchemaResultProto::mutable_fully_compatible_changed_schema_types() {
5846   // @@protoc_insertion_point(field_mutable_list:icing.lib.SetSchemaResultProto.fully_compatible_changed_schema_types)
5847   return &_impl_.fully_compatible_changed_schema_types_;
5848 }
5849 
5850 // repeated string index_incompatible_changed_schema_types = 6;
_internal_index_incompatible_changed_schema_types_size()5851 inline int SetSchemaResultProto::_internal_index_incompatible_changed_schema_types_size() const {
5852   return _impl_.index_incompatible_changed_schema_types_.size();
5853 }
index_incompatible_changed_schema_types_size()5854 inline int SetSchemaResultProto::index_incompatible_changed_schema_types_size() const {
5855   return _internal_index_incompatible_changed_schema_types_size();
5856 }
clear_index_incompatible_changed_schema_types()5857 inline void SetSchemaResultProto::clear_index_incompatible_changed_schema_types() {
5858   _impl_.index_incompatible_changed_schema_types_.Clear();
5859 }
add_index_incompatible_changed_schema_types()5860 inline std::string* SetSchemaResultProto::add_index_incompatible_changed_schema_types() {
5861   std::string* _s = _internal_add_index_incompatible_changed_schema_types();
5862   // @@protoc_insertion_point(field_add_mutable:icing.lib.SetSchemaResultProto.index_incompatible_changed_schema_types)
5863   return _s;
5864 }
_internal_index_incompatible_changed_schema_types(int index)5865 inline const std::string& SetSchemaResultProto::_internal_index_incompatible_changed_schema_types(int index) const {
5866   return _impl_.index_incompatible_changed_schema_types_.Get(index);
5867 }
index_incompatible_changed_schema_types(int index)5868 inline const std::string& SetSchemaResultProto::index_incompatible_changed_schema_types(int index) const {
5869   // @@protoc_insertion_point(field_get:icing.lib.SetSchemaResultProto.index_incompatible_changed_schema_types)
5870   return _internal_index_incompatible_changed_schema_types(index);
5871 }
mutable_index_incompatible_changed_schema_types(int index)5872 inline std::string* SetSchemaResultProto::mutable_index_incompatible_changed_schema_types(int index) {
5873   // @@protoc_insertion_point(field_mutable:icing.lib.SetSchemaResultProto.index_incompatible_changed_schema_types)
5874   return _impl_.index_incompatible_changed_schema_types_.Mutable(index);
5875 }
set_index_incompatible_changed_schema_types(int index,const std::string & value)5876 inline void SetSchemaResultProto::set_index_incompatible_changed_schema_types(int index, const std::string& value) {
5877   _impl_.index_incompatible_changed_schema_types_.Mutable(index)->assign(value);
5878   // @@protoc_insertion_point(field_set:icing.lib.SetSchemaResultProto.index_incompatible_changed_schema_types)
5879 }
set_index_incompatible_changed_schema_types(int index,std::string && value)5880 inline void SetSchemaResultProto::set_index_incompatible_changed_schema_types(int index, std::string&& value) {
5881   _impl_.index_incompatible_changed_schema_types_.Mutable(index)->assign(std::move(value));
5882   // @@protoc_insertion_point(field_set:icing.lib.SetSchemaResultProto.index_incompatible_changed_schema_types)
5883 }
set_index_incompatible_changed_schema_types(int index,const char * value)5884 inline void SetSchemaResultProto::set_index_incompatible_changed_schema_types(int index, const char* value) {
5885   GOOGLE_DCHECK(value != nullptr);
5886   _impl_.index_incompatible_changed_schema_types_.Mutable(index)->assign(value);
5887   // @@protoc_insertion_point(field_set_char:icing.lib.SetSchemaResultProto.index_incompatible_changed_schema_types)
5888 }
set_index_incompatible_changed_schema_types(int index,const char * value,size_t size)5889 inline void SetSchemaResultProto::set_index_incompatible_changed_schema_types(int index, const char* value, size_t size) {
5890   _impl_.index_incompatible_changed_schema_types_.Mutable(index)->assign(
5891     reinterpret_cast<const char*>(value), size);
5892   // @@protoc_insertion_point(field_set_pointer:icing.lib.SetSchemaResultProto.index_incompatible_changed_schema_types)
5893 }
_internal_add_index_incompatible_changed_schema_types()5894 inline std::string* SetSchemaResultProto::_internal_add_index_incompatible_changed_schema_types() {
5895   return _impl_.index_incompatible_changed_schema_types_.Add();
5896 }
add_index_incompatible_changed_schema_types(const std::string & value)5897 inline void SetSchemaResultProto::add_index_incompatible_changed_schema_types(const std::string& value) {
5898   _impl_.index_incompatible_changed_schema_types_.Add()->assign(value);
5899   // @@protoc_insertion_point(field_add:icing.lib.SetSchemaResultProto.index_incompatible_changed_schema_types)
5900 }
add_index_incompatible_changed_schema_types(std::string && value)5901 inline void SetSchemaResultProto::add_index_incompatible_changed_schema_types(std::string&& value) {
5902   _impl_.index_incompatible_changed_schema_types_.Add(std::move(value));
5903   // @@protoc_insertion_point(field_add:icing.lib.SetSchemaResultProto.index_incompatible_changed_schema_types)
5904 }
add_index_incompatible_changed_schema_types(const char * value)5905 inline void SetSchemaResultProto::add_index_incompatible_changed_schema_types(const char* value) {
5906   GOOGLE_DCHECK(value != nullptr);
5907   _impl_.index_incompatible_changed_schema_types_.Add()->assign(value);
5908   // @@protoc_insertion_point(field_add_char:icing.lib.SetSchemaResultProto.index_incompatible_changed_schema_types)
5909 }
add_index_incompatible_changed_schema_types(const char * value,size_t size)5910 inline void SetSchemaResultProto::add_index_incompatible_changed_schema_types(const char* value, size_t size) {
5911   _impl_.index_incompatible_changed_schema_types_.Add()->assign(reinterpret_cast<const char*>(value), size);
5912   // @@protoc_insertion_point(field_add_pointer:icing.lib.SetSchemaResultProto.index_incompatible_changed_schema_types)
5913 }
5914 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
index_incompatible_changed_schema_types()5915 SetSchemaResultProto::index_incompatible_changed_schema_types() const {
5916   // @@protoc_insertion_point(field_list:icing.lib.SetSchemaResultProto.index_incompatible_changed_schema_types)
5917   return _impl_.index_incompatible_changed_schema_types_;
5918 }
5919 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_index_incompatible_changed_schema_types()5920 SetSchemaResultProto::mutable_index_incompatible_changed_schema_types() {
5921   // @@protoc_insertion_point(field_mutable_list:icing.lib.SetSchemaResultProto.index_incompatible_changed_schema_types)
5922   return &_impl_.index_incompatible_changed_schema_types_;
5923 }
5924 
5925 // optional int32 latency_ms = 7;
_internal_has_latency_ms()5926 inline bool SetSchemaResultProto::_internal_has_latency_ms() const {
5927   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
5928   return value;
5929 }
has_latency_ms()5930 inline bool SetSchemaResultProto::has_latency_ms() const {
5931   return _internal_has_latency_ms();
5932 }
clear_latency_ms()5933 inline void SetSchemaResultProto::clear_latency_ms() {
5934   _impl_.latency_ms_ = 0;
5935   _impl_._has_bits_[0] &= ~0x00000002u;
5936 }
_internal_latency_ms()5937 inline ::int32_t SetSchemaResultProto::_internal_latency_ms() const {
5938   return _impl_.latency_ms_;
5939 }
latency_ms()5940 inline ::int32_t SetSchemaResultProto::latency_ms() const {
5941   // @@protoc_insertion_point(field_get:icing.lib.SetSchemaResultProto.latency_ms)
5942   return _internal_latency_ms();
5943 }
_internal_set_latency_ms(::int32_t value)5944 inline void SetSchemaResultProto::_internal_set_latency_ms(::int32_t value) {
5945   _impl_._has_bits_[0] |= 0x00000002u;
5946   _impl_.latency_ms_ = value;
5947 }
set_latency_ms(::int32_t value)5948 inline void SetSchemaResultProto::set_latency_ms(::int32_t value) {
5949   _internal_set_latency_ms(value);
5950   // @@protoc_insertion_point(field_set:icing.lib.SetSchemaResultProto.latency_ms)
5951 }
5952 
5953 // repeated string join_incompatible_changed_schema_types = 8;
_internal_join_incompatible_changed_schema_types_size()5954 inline int SetSchemaResultProto::_internal_join_incompatible_changed_schema_types_size() const {
5955   return _impl_.join_incompatible_changed_schema_types_.size();
5956 }
join_incompatible_changed_schema_types_size()5957 inline int SetSchemaResultProto::join_incompatible_changed_schema_types_size() const {
5958   return _internal_join_incompatible_changed_schema_types_size();
5959 }
clear_join_incompatible_changed_schema_types()5960 inline void SetSchemaResultProto::clear_join_incompatible_changed_schema_types() {
5961   _impl_.join_incompatible_changed_schema_types_.Clear();
5962 }
add_join_incompatible_changed_schema_types()5963 inline std::string* SetSchemaResultProto::add_join_incompatible_changed_schema_types() {
5964   std::string* _s = _internal_add_join_incompatible_changed_schema_types();
5965   // @@protoc_insertion_point(field_add_mutable:icing.lib.SetSchemaResultProto.join_incompatible_changed_schema_types)
5966   return _s;
5967 }
_internal_join_incompatible_changed_schema_types(int index)5968 inline const std::string& SetSchemaResultProto::_internal_join_incompatible_changed_schema_types(int index) const {
5969   return _impl_.join_incompatible_changed_schema_types_.Get(index);
5970 }
join_incompatible_changed_schema_types(int index)5971 inline const std::string& SetSchemaResultProto::join_incompatible_changed_schema_types(int index) const {
5972   // @@protoc_insertion_point(field_get:icing.lib.SetSchemaResultProto.join_incompatible_changed_schema_types)
5973   return _internal_join_incompatible_changed_schema_types(index);
5974 }
mutable_join_incompatible_changed_schema_types(int index)5975 inline std::string* SetSchemaResultProto::mutable_join_incompatible_changed_schema_types(int index) {
5976   // @@protoc_insertion_point(field_mutable:icing.lib.SetSchemaResultProto.join_incompatible_changed_schema_types)
5977   return _impl_.join_incompatible_changed_schema_types_.Mutable(index);
5978 }
set_join_incompatible_changed_schema_types(int index,const std::string & value)5979 inline void SetSchemaResultProto::set_join_incompatible_changed_schema_types(int index, const std::string& value) {
5980   _impl_.join_incompatible_changed_schema_types_.Mutable(index)->assign(value);
5981   // @@protoc_insertion_point(field_set:icing.lib.SetSchemaResultProto.join_incompatible_changed_schema_types)
5982 }
set_join_incompatible_changed_schema_types(int index,std::string && value)5983 inline void SetSchemaResultProto::set_join_incompatible_changed_schema_types(int index, std::string&& value) {
5984   _impl_.join_incompatible_changed_schema_types_.Mutable(index)->assign(std::move(value));
5985   // @@protoc_insertion_point(field_set:icing.lib.SetSchemaResultProto.join_incompatible_changed_schema_types)
5986 }
set_join_incompatible_changed_schema_types(int index,const char * value)5987 inline void SetSchemaResultProto::set_join_incompatible_changed_schema_types(int index, const char* value) {
5988   GOOGLE_DCHECK(value != nullptr);
5989   _impl_.join_incompatible_changed_schema_types_.Mutable(index)->assign(value);
5990   // @@protoc_insertion_point(field_set_char:icing.lib.SetSchemaResultProto.join_incompatible_changed_schema_types)
5991 }
set_join_incompatible_changed_schema_types(int index,const char * value,size_t size)5992 inline void SetSchemaResultProto::set_join_incompatible_changed_schema_types(int index, const char* value, size_t size) {
5993   _impl_.join_incompatible_changed_schema_types_.Mutable(index)->assign(
5994     reinterpret_cast<const char*>(value), size);
5995   // @@protoc_insertion_point(field_set_pointer:icing.lib.SetSchemaResultProto.join_incompatible_changed_schema_types)
5996 }
_internal_add_join_incompatible_changed_schema_types()5997 inline std::string* SetSchemaResultProto::_internal_add_join_incompatible_changed_schema_types() {
5998   return _impl_.join_incompatible_changed_schema_types_.Add();
5999 }
add_join_incompatible_changed_schema_types(const std::string & value)6000 inline void SetSchemaResultProto::add_join_incompatible_changed_schema_types(const std::string& value) {
6001   _impl_.join_incompatible_changed_schema_types_.Add()->assign(value);
6002   // @@protoc_insertion_point(field_add:icing.lib.SetSchemaResultProto.join_incompatible_changed_schema_types)
6003 }
add_join_incompatible_changed_schema_types(std::string && value)6004 inline void SetSchemaResultProto::add_join_incompatible_changed_schema_types(std::string&& value) {
6005   _impl_.join_incompatible_changed_schema_types_.Add(std::move(value));
6006   // @@protoc_insertion_point(field_add:icing.lib.SetSchemaResultProto.join_incompatible_changed_schema_types)
6007 }
add_join_incompatible_changed_schema_types(const char * value)6008 inline void SetSchemaResultProto::add_join_incompatible_changed_schema_types(const char* value) {
6009   GOOGLE_DCHECK(value != nullptr);
6010   _impl_.join_incompatible_changed_schema_types_.Add()->assign(value);
6011   // @@protoc_insertion_point(field_add_char:icing.lib.SetSchemaResultProto.join_incompatible_changed_schema_types)
6012 }
add_join_incompatible_changed_schema_types(const char * value,size_t size)6013 inline void SetSchemaResultProto::add_join_incompatible_changed_schema_types(const char* value, size_t size) {
6014   _impl_.join_incompatible_changed_schema_types_.Add()->assign(reinterpret_cast<const char*>(value), size);
6015   // @@protoc_insertion_point(field_add_pointer:icing.lib.SetSchemaResultProto.join_incompatible_changed_schema_types)
6016 }
6017 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
join_incompatible_changed_schema_types()6018 SetSchemaResultProto::join_incompatible_changed_schema_types() const {
6019   // @@protoc_insertion_point(field_list:icing.lib.SetSchemaResultProto.join_incompatible_changed_schema_types)
6020   return _impl_.join_incompatible_changed_schema_types_;
6021 }
6022 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_join_incompatible_changed_schema_types()6023 SetSchemaResultProto::mutable_join_incompatible_changed_schema_types() {
6024   // @@protoc_insertion_point(field_mutable_list:icing.lib.SetSchemaResultProto.join_incompatible_changed_schema_types)
6025   return &_impl_.join_incompatible_changed_schema_types_;
6026 }
6027 
6028 // -------------------------------------------------------------------
6029 
6030 // GetSchemaResultProto
6031 
6032 // optional .icing.lib.StatusProto status = 1;
_internal_has_status()6033 inline bool GetSchemaResultProto::_internal_has_status() const {
6034   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
6035   PROTOBUF_ASSUME(!value || _impl_.status_ != nullptr);
6036   return value;
6037 }
has_status()6038 inline bool GetSchemaResultProto::has_status() const {
6039   return _internal_has_status();
6040 }
_internal_status()6041 inline const ::icing::lib::StatusProto& GetSchemaResultProto::_internal_status() const {
6042   const ::icing::lib::StatusProto* p = _impl_.status_;
6043   return p != nullptr ? *p : reinterpret_cast<const ::icing::lib::StatusProto&>(
6044       ::icing::lib::_StatusProto_default_instance_);
6045 }
status()6046 inline const ::icing::lib::StatusProto& GetSchemaResultProto::status() const {
6047   // @@protoc_insertion_point(field_get:icing.lib.GetSchemaResultProto.status)
6048   return _internal_status();
6049 }
unsafe_arena_set_allocated_status(::icing::lib::StatusProto * status)6050 inline void GetSchemaResultProto::unsafe_arena_set_allocated_status(
6051     ::icing::lib::StatusProto* status) {
6052   if (GetArenaForAllocation() == nullptr) {
6053     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.status_);
6054   }
6055   _impl_.status_ = status;
6056   if (status) {
6057     _impl_._has_bits_[0] |= 0x00000001u;
6058   } else {
6059     _impl_._has_bits_[0] &= ~0x00000001u;
6060   }
6061   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:icing.lib.GetSchemaResultProto.status)
6062 }
release_status()6063 inline ::icing::lib::StatusProto* GetSchemaResultProto::release_status() {
6064   _impl_._has_bits_[0] &= ~0x00000001u;
6065   ::icing::lib::StatusProto* temp = _impl_.status_;
6066   _impl_.status_ = nullptr;
6067 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
6068   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
6069   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6070   if (GetArenaForAllocation() == nullptr) { delete old; }
6071 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
6072   if (GetArenaForAllocation() != nullptr) {
6073     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6074   }
6075 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
6076   return temp;
6077 }
unsafe_arena_release_status()6078 inline ::icing::lib::StatusProto* GetSchemaResultProto::unsafe_arena_release_status() {
6079   // @@protoc_insertion_point(field_release:icing.lib.GetSchemaResultProto.status)
6080   _impl_._has_bits_[0] &= ~0x00000001u;
6081   ::icing::lib::StatusProto* temp = _impl_.status_;
6082   _impl_.status_ = nullptr;
6083   return temp;
6084 }
_internal_mutable_status()6085 inline ::icing::lib::StatusProto* GetSchemaResultProto::_internal_mutable_status() {
6086   _impl_._has_bits_[0] |= 0x00000001u;
6087   if (_impl_.status_ == nullptr) {
6088     auto* p = CreateMaybeMessage<::icing::lib::StatusProto>(GetArenaForAllocation());
6089     _impl_.status_ = p;
6090   }
6091   return _impl_.status_;
6092 }
mutable_status()6093 inline ::icing::lib::StatusProto* GetSchemaResultProto::mutable_status() {
6094   ::icing::lib::StatusProto* _msg = _internal_mutable_status();
6095   // @@protoc_insertion_point(field_mutable:icing.lib.GetSchemaResultProto.status)
6096   return _msg;
6097 }
set_allocated_status(::icing::lib::StatusProto * status)6098 inline void GetSchemaResultProto::set_allocated_status(::icing::lib::StatusProto* status) {
6099   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
6100   if (message_arena == nullptr) {
6101     delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.status_);
6102   }
6103   if (status) {
6104     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
6105         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
6106                 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(status));
6107     if (message_arena != submessage_arena) {
6108       status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
6109           message_arena, status, submessage_arena);
6110     }
6111     _impl_._has_bits_[0] |= 0x00000001u;
6112   } else {
6113     _impl_._has_bits_[0] &= ~0x00000001u;
6114   }
6115   _impl_.status_ = status;
6116   // @@protoc_insertion_point(field_set_allocated:icing.lib.GetSchemaResultProto.status)
6117 }
6118 
6119 // optional .icing.lib.SchemaProto schema = 2;
_internal_has_schema()6120 inline bool GetSchemaResultProto::_internal_has_schema() const {
6121   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
6122   PROTOBUF_ASSUME(!value || _impl_.schema_ != nullptr);
6123   return value;
6124 }
has_schema()6125 inline bool GetSchemaResultProto::has_schema() const {
6126   return _internal_has_schema();
6127 }
clear_schema()6128 inline void GetSchemaResultProto::clear_schema() {
6129   if (_impl_.schema_ != nullptr) _impl_.schema_->Clear();
6130   _impl_._has_bits_[0] &= ~0x00000002u;
6131 }
_internal_schema()6132 inline const ::icing::lib::SchemaProto& GetSchemaResultProto::_internal_schema() const {
6133   const ::icing::lib::SchemaProto* p = _impl_.schema_;
6134   return p != nullptr ? *p : reinterpret_cast<const ::icing::lib::SchemaProto&>(
6135       ::icing::lib::_SchemaProto_default_instance_);
6136 }
schema()6137 inline const ::icing::lib::SchemaProto& GetSchemaResultProto::schema() const {
6138   // @@protoc_insertion_point(field_get:icing.lib.GetSchemaResultProto.schema)
6139   return _internal_schema();
6140 }
unsafe_arena_set_allocated_schema(::icing::lib::SchemaProto * schema)6141 inline void GetSchemaResultProto::unsafe_arena_set_allocated_schema(
6142     ::icing::lib::SchemaProto* schema) {
6143   if (GetArenaForAllocation() == nullptr) {
6144     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.schema_);
6145   }
6146   _impl_.schema_ = schema;
6147   if (schema) {
6148     _impl_._has_bits_[0] |= 0x00000002u;
6149   } else {
6150     _impl_._has_bits_[0] &= ~0x00000002u;
6151   }
6152   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:icing.lib.GetSchemaResultProto.schema)
6153 }
release_schema()6154 inline ::icing::lib::SchemaProto* GetSchemaResultProto::release_schema() {
6155   _impl_._has_bits_[0] &= ~0x00000002u;
6156   ::icing::lib::SchemaProto* temp = _impl_.schema_;
6157   _impl_.schema_ = nullptr;
6158 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
6159   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
6160   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6161   if (GetArenaForAllocation() == nullptr) { delete old; }
6162 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
6163   if (GetArenaForAllocation() != nullptr) {
6164     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6165   }
6166 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
6167   return temp;
6168 }
unsafe_arena_release_schema()6169 inline ::icing::lib::SchemaProto* GetSchemaResultProto::unsafe_arena_release_schema() {
6170   // @@protoc_insertion_point(field_release:icing.lib.GetSchemaResultProto.schema)
6171   _impl_._has_bits_[0] &= ~0x00000002u;
6172   ::icing::lib::SchemaProto* temp = _impl_.schema_;
6173   _impl_.schema_ = nullptr;
6174   return temp;
6175 }
_internal_mutable_schema()6176 inline ::icing::lib::SchemaProto* GetSchemaResultProto::_internal_mutable_schema() {
6177   _impl_._has_bits_[0] |= 0x00000002u;
6178   if (_impl_.schema_ == nullptr) {
6179     auto* p = CreateMaybeMessage<::icing::lib::SchemaProto>(GetArenaForAllocation());
6180     _impl_.schema_ = p;
6181   }
6182   return _impl_.schema_;
6183 }
mutable_schema()6184 inline ::icing::lib::SchemaProto* GetSchemaResultProto::mutable_schema() {
6185   ::icing::lib::SchemaProto* _msg = _internal_mutable_schema();
6186   // @@protoc_insertion_point(field_mutable:icing.lib.GetSchemaResultProto.schema)
6187   return _msg;
6188 }
set_allocated_schema(::icing::lib::SchemaProto * schema)6189 inline void GetSchemaResultProto::set_allocated_schema(::icing::lib::SchemaProto* schema) {
6190   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
6191   if (message_arena == nullptr) {
6192     delete _impl_.schema_;
6193   }
6194   if (schema) {
6195     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
6196         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(schema);
6197     if (message_arena != submessage_arena) {
6198       schema = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
6199           message_arena, schema, submessage_arena);
6200     }
6201     _impl_._has_bits_[0] |= 0x00000002u;
6202   } else {
6203     _impl_._has_bits_[0] &= ~0x00000002u;
6204   }
6205   _impl_.schema_ = schema;
6206   // @@protoc_insertion_point(field_set_allocated:icing.lib.GetSchemaResultProto.schema)
6207 }
6208 
6209 // -------------------------------------------------------------------
6210 
6211 // GetSchemaTypeResultProto
6212 
6213 // optional .icing.lib.StatusProto status = 1;
_internal_has_status()6214 inline bool GetSchemaTypeResultProto::_internal_has_status() const {
6215   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
6216   PROTOBUF_ASSUME(!value || _impl_.status_ != nullptr);
6217   return value;
6218 }
has_status()6219 inline bool GetSchemaTypeResultProto::has_status() const {
6220   return _internal_has_status();
6221 }
_internal_status()6222 inline const ::icing::lib::StatusProto& GetSchemaTypeResultProto::_internal_status() const {
6223   const ::icing::lib::StatusProto* p = _impl_.status_;
6224   return p != nullptr ? *p : reinterpret_cast<const ::icing::lib::StatusProto&>(
6225       ::icing::lib::_StatusProto_default_instance_);
6226 }
status()6227 inline const ::icing::lib::StatusProto& GetSchemaTypeResultProto::status() const {
6228   // @@protoc_insertion_point(field_get:icing.lib.GetSchemaTypeResultProto.status)
6229   return _internal_status();
6230 }
unsafe_arena_set_allocated_status(::icing::lib::StatusProto * status)6231 inline void GetSchemaTypeResultProto::unsafe_arena_set_allocated_status(
6232     ::icing::lib::StatusProto* status) {
6233   if (GetArenaForAllocation() == nullptr) {
6234     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.status_);
6235   }
6236   _impl_.status_ = status;
6237   if (status) {
6238     _impl_._has_bits_[0] |= 0x00000001u;
6239   } else {
6240     _impl_._has_bits_[0] &= ~0x00000001u;
6241   }
6242   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:icing.lib.GetSchemaTypeResultProto.status)
6243 }
release_status()6244 inline ::icing::lib::StatusProto* GetSchemaTypeResultProto::release_status() {
6245   _impl_._has_bits_[0] &= ~0x00000001u;
6246   ::icing::lib::StatusProto* temp = _impl_.status_;
6247   _impl_.status_ = nullptr;
6248 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
6249   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
6250   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6251   if (GetArenaForAllocation() == nullptr) { delete old; }
6252 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
6253   if (GetArenaForAllocation() != nullptr) {
6254     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6255   }
6256 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
6257   return temp;
6258 }
unsafe_arena_release_status()6259 inline ::icing::lib::StatusProto* GetSchemaTypeResultProto::unsafe_arena_release_status() {
6260   // @@protoc_insertion_point(field_release:icing.lib.GetSchemaTypeResultProto.status)
6261   _impl_._has_bits_[0] &= ~0x00000001u;
6262   ::icing::lib::StatusProto* temp = _impl_.status_;
6263   _impl_.status_ = nullptr;
6264   return temp;
6265 }
_internal_mutable_status()6266 inline ::icing::lib::StatusProto* GetSchemaTypeResultProto::_internal_mutable_status() {
6267   _impl_._has_bits_[0] |= 0x00000001u;
6268   if (_impl_.status_ == nullptr) {
6269     auto* p = CreateMaybeMessage<::icing::lib::StatusProto>(GetArenaForAllocation());
6270     _impl_.status_ = p;
6271   }
6272   return _impl_.status_;
6273 }
mutable_status()6274 inline ::icing::lib::StatusProto* GetSchemaTypeResultProto::mutable_status() {
6275   ::icing::lib::StatusProto* _msg = _internal_mutable_status();
6276   // @@protoc_insertion_point(field_mutable:icing.lib.GetSchemaTypeResultProto.status)
6277   return _msg;
6278 }
set_allocated_status(::icing::lib::StatusProto * status)6279 inline void GetSchemaTypeResultProto::set_allocated_status(::icing::lib::StatusProto* status) {
6280   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
6281   if (message_arena == nullptr) {
6282     delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.status_);
6283   }
6284   if (status) {
6285     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
6286         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
6287                 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(status));
6288     if (message_arena != submessage_arena) {
6289       status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
6290           message_arena, status, submessage_arena);
6291     }
6292     _impl_._has_bits_[0] |= 0x00000001u;
6293   } else {
6294     _impl_._has_bits_[0] &= ~0x00000001u;
6295   }
6296   _impl_.status_ = status;
6297   // @@protoc_insertion_point(field_set_allocated:icing.lib.GetSchemaTypeResultProto.status)
6298 }
6299 
6300 // optional .icing.lib.SchemaTypeConfigProto schema_type_config = 2;
_internal_has_schema_type_config()6301 inline bool GetSchemaTypeResultProto::_internal_has_schema_type_config() const {
6302   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
6303   PROTOBUF_ASSUME(!value || _impl_.schema_type_config_ != nullptr);
6304   return value;
6305 }
has_schema_type_config()6306 inline bool GetSchemaTypeResultProto::has_schema_type_config() const {
6307   return _internal_has_schema_type_config();
6308 }
clear_schema_type_config()6309 inline void GetSchemaTypeResultProto::clear_schema_type_config() {
6310   if (_impl_.schema_type_config_ != nullptr) _impl_.schema_type_config_->Clear();
6311   _impl_._has_bits_[0] &= ~0x00000002u;
6312 }
_internal_schema_type_config()6313 inline const ::icing::lib::SchemaTypeConfigProto& GetSchemaTypeResultProto::_internal_schema_type_config() const {
6314   const ::icing::lib::SchemaTypeConfigProto* p = _impl_.schema_type_config_;
6315   return p != nullptr ? *p : reinterpret_cast<const ::icing::lib::SchemaTypeConfigProto&>(
6316       ::icing::lib::_SchemaTypeConfigProto_default_instance_);
6317 }
schema_type_config()6318 inline const ::icing::lib::SchemaTypeConfigProto& GetSchemaTypeResultProto::schema_type_config() const {
6319   // @@protoc_insertion_point(field_get:icing.lib.GetSchemaTypeResultProto.schema_type_config)
6320   return _internal_schema_type_config();
6321 }
unsafe_arena_set_allocated_schema_type_config(::icing::lib::SchemaTypeConfigProto * schema_type_config)6322 inline void GetSchemaTypeResultProto::unsafe_arena_set_allocated_schema_type_config(
6323     ::icing::lib::SchemaTypeConfigProto* schema_type_config) {
6324   if (GetArenaForAllocation() == nullptr) {
6325     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.schema_type_config_);
6326   }
6327   _impl_.schema_type_config_ = schema_type_config;
6328   if (schema_type_config) {
6329     _impl_._has_bits_[0] |= 0x00000002u;
6330   } else {
6331     _impl_._has_bits_[0] &= ~0x00000002u;
6332   }
6333   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:icing.lib.GetSchemaTypeResultProto.schema_type_config)
6334 }
release_schema_type_config()6335 inline ::icing::lib::SchemaTypeConfigProto* GetSchemaTypeResultProto::release_schema_type_config() {
6336   _impl_._has_bits_[0] &= ~0x00000002u;
6337   ::icing::lib::SchemaTypeConfigProto* temp = _impl_.schema_type_config_;
6338   _impl_.schema_type_config_ = nullptr;
6339 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
6340   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
6341   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6342   if (GetArenaForAllocation() == nullptr) { delete old; }
6343 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
6344   if (GetArenaForAllocation() != nullptr) {
6345     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6346   }
6347 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
6348   return temp;
6349 }
unsafe_arena_release_schema_type_config()6350 inline ::icing::lib::SchemaTypeConfigProto* GetSchemaTypeResultProto::unsafe_arena_release_schema_type_config() {
6351   // @@protoc_insertion_point(field_release:icing.lib.GetSchemaTypeResultProto.schema_type_config)
6352   _impl_._has_bits_[0] &= ~0x00000002u;
6353   ::icing::lib::SchemaTypeConfigProto* temp = _impl_.schema_type_config_;
6354   _impl_.schema_type_config_ = nullptr;
6355   return temp;
6356 }
_internal_mutable_schema_type_config()6357 inline ::icing::lib::SchemaTypeConfigProto* GetSchemaTypeResultProto::_internal_mutable_schema_type_config() {
6358   _impl_._has_bits_[0] |= 0x00000002u;
6359   if (_impl_.schema_type_config_ == nullptr) {
6360     auto* p = CreateMaybeMessage<::icing::lib::SchemaTypeConfigProto>(GetArenaForAllocation());
6361     _impl_.schema_type_config_ = p;
6362   }
6363   return _impl_.schema_type_config_;
6364 }
mutable_schema_type_config()6365 inline ::icing::lib::SchemaTypeConfigProto* GetSchemaTypeResultProto::mutable_schema_type_config() {
6366   ::icing::lib::SchemaTypeConfigProto* _msg = _internal_mutable_schema_type_config();
6367   // @@protoc_insertion_point(field_mutable:icing.lib.GetSchemaTypeResultProto.schema_type_config)
6368   return _msg;
6369 }
set_allocated_schema_type_config(::icing::lib::SchemaTypeConfigProto * schema_type_config)6370 inline void GetSchemaTypeResultProto::set_allocated_schema_type_config(::icing::lib::SchemaTypeConfigProto* schema_type_config) {
6371   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
6372   if (message_arena == nullptr) {
6373     delete _impl_.schema_type_config_;
6374   }
6375   if (schema_type_config) {
6376     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
6377         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(schema_type_config);
6378     if (message_arena != submessage_arena) {
6379       schema_type_config = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
6380           message_arena, schema_type_config, submessage_arena);
6381     }
6382     _impl_._has_bits_[0] |= 0x00000002u;
6383   } else {
6384     _impl_._has_bits_[0] &= ~0x00000002u;
6385   }
6386   _impl_.schema_type_config_ = schema_type_config;
6387   // @@protoc_insertion_point(field_set_allocated:icing.lib.GetSchemaTypeResultProto.schema_type_config)
6388 }
6389 
6390 #ifdef __GNUC__
6391   #pragma GCC diagnostic pop
6392 #endif  // __GNUC__
6393 // -------------------------------------------------------------------
6394 
6395 // -------------------------------------------------------------------
6396 
6397 // -------------------------------------------------------------------
6398 
6399 // -------------------------------------------------------------------
6400 
6401 // -------------------------------------------------------------------
6402 
6403 // -------------------------------------------------------------------
6404 
6405 // -------------------------------------------------------------------
6406 
6407 // -------------------------------------------------------------------
6408 
6409 // -------------------------------------------------------------------
6410 
6411 // -------------------------------------------------------------------
6412 
6413 // -------------------------------------------------------------------
6414 
6415 // -------------------------------------------------------------------
6416 
6417 // -------------------------------------------------------------------
6418 
6419 // -------------------------------------------------------------------
6420 
6421 // -------------------------------------------------------------------
6422 
6423 // -------------------------------------------------------------------
6424 
6425 // -------------------------------------------------------------------
6426 
6427 // -------------------------------------------------------------------
6428 
6429 // -------------------------------------------------------------------
6430 
6431 
6432 // @@protoc_insertion_point(namespace_scope)
6433 
6434 }  // namespace lib
6435 }  // namespace icing
6436 
6437 PROTOBUF_NAMESPACE_OPEN
6438 
6439 template <> struct is_proto_enum< ::icing::lib::StringIndexingConfig_TokenizerType_Code> : ::std::true_type {};
6440 template <> struct is_proto_enum< ::icing::lib::IntegerIndexingConfig_NumericMatchType_Code> : ::std::true_type {};
6441 template <> struct is_proto_enum< ::icing::lib::EmbeddingIndexingConfig_EmbeddingIndexingType_Code> : ::std::true_type {};
6442 template <> struct is_proto_enum< ::icing::lib::EmbeddingIndexingConfig_QuantizationType_Code> : ::std::true_type {};
6443 template <> struct is_proto_enum< ::icing::lib::JoinableConfig_ValueType_Code> : ::std::true_type {};
6444 template <> struct is_proto_enum< ::icing::lib::JoinableConfig_DeletePropagationType_Code> : ::std::true_type {};
6445 template <> struct is_proto_enum< ::icing::lib::PropertyConfigProto_DataType_Code> : ::std::true_type {};
6446 template <> struct is_proto_enum< ::icing::lib::PropertyConfigProto_Cardinality_Code> : ::std::true_type {};
6447 template <> struct is_proto_enum< ::icing::lib::PropertyConfigProto_ScorableType_Code> : ::std::true_type {};
6448 
6449 PROTOBUF_NAMESPACE_CLOSE
6450 
6451 // @@protoc_insertion_point(global_scope)
6452 
6453 #include <google/protobuf/port_undef.inc>
6454 #endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_icing_2fproto_2fschema_2eproto
6455