1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: fcp/dictionary/dictionary.proto
3 
4 #include "fcp/dictionary/dictionary.pb.h"
5 
6 #include <algorithm>
7 #include <cstdint>
8 
9 #include <google/protobuf/io/coded_stream.h>
10 #include <google/protobuf/extension_set.h>
11 #include <google/protobuf/wire_format_lite.h>
12 #include <google/protobuf/io/zero_copy_stream_impl_lite.h>
13 // @@protoc_insertion_point(includes)
14 #include <google/protobuf/port_def.inc>
15 
16 PROTOBUF_PRAGMA_INIT_SEG
17 
18 namespace _pb = ::PROTOBUF_NAMESPACE_ID;
19 namespace _pbi = _pb::internal;
20 
21 namespace fcp {
22 namespace dictionary {
DictionaryDescription_SpecialIds(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR DictionaryDescription_SpecialIds::DictionaryDescription_SpecialIds(
24     ::_pbi::ConstantInitialized): _impl_{
25     /*decltype(_impl_._has_bits_)*/{}
26   , /*decltype(_impl_._cached_size_)*/{}
27   , /*decltype(_impl_.eos_)*/-1
28   , /*decltype(_impl_.unk_)*/-1
29   , /*decltype(_impl_.bos_)*/-1} {}
30 struct DictionaryDescription_SpecialIdsDefaultTypeInternal {
DictionaryDescription_SpecialIdsDefaultTypeInternalfcp::dictionary::DictionaryDescription_SpecialIdsDefaultTypeInternal31   PROTOBUF_CONSTEXPR DictionaryDescription_SpecialIdsDefaultTypeInternal()
32       : _instance(::_pbi::ConstantInitialized{}) {}
~DictionaryDescription_SpecialIdsDefaultTypeInternalfcp::dictionary::DictionaryDescription_SpecialIdsDefaultTypeInternal33   ~DictionaryDescription_SpecialIdsDefaultTypeInternal() {}
34   union {  // NOLINT(misc-non-private-member-variables-in-classes)
35     DictionaryDescription_SpecialIds _instance;
36   };
37 };
38 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DictionaryDescription_SpecialIdsDefaultTypeInternal _DictionaryDescription_SpecialIds_default_instance_;
DictionaryDescription_OutputBlocklistIds(::_pbi::ConstantInitialized)39 PROTOBUF_CONSTEXPR DictionaryDescription_OutputBlocklistIds::DictionaryDescription_OutputBlocklistIds(
40     ::_pbi::ConstantInitialized): _impl_{
41     /*decltype(_impl_.id_)*/{}
42   , /*decltype(_impl_._id_cached_byte_size_)*/{0}
43   , /*decltype(_impl_._cached_size_)*/{}} {}
44 struct DictionaryDescription_OutputBlocklistIdsDefaultTypeInternal {
DictionaryDescription_OutputBlocklistIdsDefaultTypeInternalfcp::dictionary::DictionaryDescription_OutputBlocklistIdsDefaultTypeInternal45   PROTOBUF_CONSTEXPR DictionaryDescription_OutputBlocklistIdsDefaultTypeInternal()
46       : _instance(::_pbi::ConstantInitialized{}) {}
~DictionaryDescription_OutputBlocklistIdsDefaultTypeInternalfcp::dictionary::DictionaryDescription_OutputBlocklistIdsDefaultTypeInternal47   ~DictionaryDescription_OutputBlocklistIdsDefaultTypeInternal() {}
48   union {  // NOLINT(misc-non-private-member-variables-in-classes)
49     DictionaryDescription_OutputBlocklistIds _instance;
50   };
51 };
52 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DictionaryDescription_OutputBlocklistIdsDefaultTypeInternal _DictionaryDescription_OutputBlocklistIds_default_instance_;
DictionaryDescription_Vocabulary_TokenIndex(::_pbi::ConstantInitialized)53 PROTOBUF_CONSTEXPR DictionaryDescription_Vocabulary_TokenIndex::DictionaryDescription_Vocabulary_TokenIndex(
54     ::_pbi::ConstantInitialized): _impl_{
55     /*decltype(_impl_.token_)*/{}
56   , /*decltype(_impl_._cached_size_)*/{}} {}
57 struct DictionaryDescription_Vocabulary_TokenIndexDefaultTypeInternal {
DictionaryDescription_Vocabulary_TokenIndexDefaultTypeInternalfcp::dictionary::DictionaryDescription_Vocabulary_TokenIndexDefaultTypeInternal58   PROTOBUF_CONSTEXPR DictionaryDescription_Vocabulary_TokenIndexDefaultTypeInternal()
59       : _instance(::_pbi::ConstantInitialized{}) {}
~DictionaryDescription_Vocabulary_TokenIndexDefaultTypeInternalfcp::dictionary::DictionaryDescription_Vocabulary_TokenIndexDefaultTypeInternal60   ~DictionaryDescription_Vocabulary_TokenIndexDefaultTypeInternal() {}
61   union {  // NOLINT(misc-non-private-member-variables-in-classes)
62     DictionaryDescription_Vocabulary_TokenIndex _instance;
63   };
64 };
65 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DictionaryDescription_Vocabulary_TokenIndexDefaultTypeInternal _DictionaryDescription_Vocabulary_TokenIndex_default_instance_;
DictionaryDescription_Vocabulary(::_pbi::ConstantInitialized)66 PROTOBUF_CONSTEXPR DictionaryDescription_Vocabulary::DictionaryDescription_Vocabulary(
67     ::_pbi::ConstantInitialized): _impl_{
68     /*decltype(_impl_.vocabulary_)*/{}
69   , /*decltype(_impl_._cached_size_)*/{}
70   , /*decltype(_impl_._oneof_case_)*/{}} {}
71 struct DictionaryDescription_VocabularyDefaultTypeInternal {
DictionaryDescription_VocabularyDefaultTypeInternalfcp::dictionary::DictionaryDescription_VocabularyDefaultTypeInternal72   PROTOBUF_CONSTEXPR DictionaryDescription_VocabularyDefaultTypeInternal()
73       : _instance(::_pbi::ConstantInitialized{}) {}
~DictionaryDescription_VocabularyDefaultTypeInternalfcp::dictionary::DictionaryDescription_VocabularyDefaultTypeInternal74   ~DictionaryDescription_VocabularyDefaultTypeInternal() {}
75   union {  // NOLINT(misc-non-private-member-variables-in-classes)
76     DictionaryDescription_Vocabulary _instance;
77   };
78 };
79 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DictionaryDescription_VocabularyDefaultTypeInternal _DictionaryDescription_Vocabulary_default_instance_;
DictionaryDescription(::_pbi::ConstantInitialized)80 PROTOBUF_CONSTEXPR DictionaryDescription::DictionaryDescription(
81     ::_pbi::ConstantInitialized): _impl_{
82     /*decltype(_impl_._has_bits_)*/{}
83   , /*decltype(_impl_._cached_size_)*/{}
84   , /*decltype(_impl_.special_ids_)*/nullptr
85   , /*decltype(_impl_.vocabulary_)*/nullptr
86   , /*decltype(_impl_.output_blocklist_ids_)*/nullptr} {}
87 struct DictionaryDescriptionDefaultTypeInternal {
DictionaryDescriptionDefaultTypeInternalfcp::dictionary::DictionaryDescriptionDefaultTypeInternal88   PROTOBUF_CONSTEXPR DictionaryDescriptionDefaultTypeInternal()
89       : _instance(::_pbi::ConstantInitialized{}) {}
~DictionaryDescriptionDefaultTypeInternalfcp::dictionary::DictionaryDescriptionDefaultTypeInternal90   ~DictionaryDescriptionDefaultTypeInternal() {}
91   union {  // NOLINT(misc-non-private-member-variables-in-classes)
92     DictionaryDescription _instance;
93   };
94 };
95 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DictionaryDescriptionDefaultTypeInternal _DictionaryDescription_default_instance_;
96 }  // namespace dictionary
97 }  // namespace fcp
98 namespace fcp {
99 namespace dictionary {
100 
101 // ===================================================================
102 
103 class DictionaryDescription_SpecialIds::_Internal {
104  public:
105   using HasBits = decltype(std::declval<DictionaryDescription_SpecialIds>()._impl_._has_bits_);
set_has_unk(HasBits * has_bits)106   static void set_has_unk(HasBits* has_bits) {
107     (*has_bits)[0] |= 2u;
108   }
set_has_bos(HasBits * has_bits)109   static void set_has_bos(HasBits* has_bits) {
110     (*has_bits)[0] |= 4u;
111   }
set_has_eos(HasBits * has_bits)112   static void set_has_eos(HasBits* has_bits) {
113     (*has_bits)[0] |= 1u;
114   }
115 };
116 
DictionaryDescription_SpecialIds(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)117 DictionaryDescription_SpecialIds::DictionaryDescription_SpecialIds(::PROTOBUF_NAMESPACE_ID::Arena* arena,
118                          bool is_message_owned)
119   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
120   SharedCtor(arena, is_message_owned);
121   // @@protoc_insertion_point(arena_constructor:fcp.dictionary.DictionaryDescription.SpecialIds)
122 }
DictionaryDescription_SpecialIds(const DictionaryDescription_SpecialIds & from)123 DictionaryDescription_SpecialIds::DictionaryDescription_SpecialIds(const DictionaryDescription_SpecialIds& from)
124   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
125   DictionaryDescription_SpecialIds* const _this = this; (void)_this;
126   new (&_impl_) Impl_{
127       decltype(_impl_._has_bits_){from._impl_._has_bits_}
128     , /*decltype(_impl_._cached_size_)*/{}
129     , decltype(_impl_.eos_){}
130     , decltype(_impl_.unk_){}
131     , decltype(_impl_.bos_){}};
132 
133   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
134   ::memcpy(&_impl_.eos_, &from._impl_.eos_,
135     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.bos_) -
136     reinterpret_cast<char*>(&_impl_.eos_)) + sizeof(_impl_.bos_));
137   // @@protoc_insertion_point(copy_constructor:fcp.dictionary.DictionaryDescription.SpecialIds)
138 }
139 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)140 inline void DictionaryDescription_SpecialIds::SharedCtor(
141     ::_pb::Arena* arena, bool is_message_owned) {
142   (void)arena;
143   (void)is_message_owned;
144   new (&_impl_) Impl_{
145       decltype(_impl_._has_bits_){}
146     , /*decltype(_impl_._cached_size_)*/{}
147     , decltype(_impl_.eos_){-1}
148     , decltype(_impl_.unk_){-1}
149     , decltype(_impl_.bos_){-1}
150   };
151 }
152 
~DictionaryDescription_SpecialIds()153 DictionaryDescription_SpecialIds::~DictionaryDescription_SpecialIds() {
154   // @@protoc_insertion_point(destructor:fcp.dictionary.DictionaryDescription.SpecialIds)
155   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
156   (void)arena;
157     return;
158   }
159   SharedDtor();
160 }
161 
SharedDtor()162 inline void DictionaryDescription_SpecialIds::SharedDtor() {
163   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
164 }
165 
SetCachedSize(int size) const166 void DictionaryDescription_SpecialIds::SetCachedSize(int size) const {
167   _impl_._cached_size_.Set(size);
168 }
169 
Clear()170 void DictionaryDescription_SpecialIds::Clear() {
171 // @@protoc_insertion_point(message_clear_start:fcp.dictionary.DictionaryDescription.SpecialIds)
172   ::uint32_t cached_has_bits = 0;
173   // Prevent compiler warnings about cached_has_bits being unused
174   (void) cached_has_bits;
175 
176   cached_has_bits = _impl_._has_bits_[0];
177   if (cached_has_bits & 0x00000007u) {
178     _impl_.eos_ = -1;
179     _impl_.unk_ = -1;
180     _impl_.bos_ = -1;
181   }
182   _impl_._has_bits_.Clear();
183   _internal_metadata_.Clear<std::string>();
184 }
185 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)186 const char* DictionaryDescription_SpecialIds::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
187 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
188   _Internal::HasBits has_bits{};
189   while (!ctx->Done(&ptr)) {
190     ::uint32_t tag;
191     ptr = ::_pbi::ReadTag(ptr, &tag);
192     switch (tag >> 3) {
193       // optional int32 unk = 1 [default = -1];
194       case 1:
195         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
196           _Internal::set_has_unk(&has_bits);
197           _impl_.unk_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
198           CHK_(ptr);
199         } else {
200           goto handle_unusual;
201         }
202         continue;
203       // optional int32 bos = 2 [default = -1];
204       case 2:
205         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
206           _Internal::set_has_bos(&has_bits);
207           _impl_.bos_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
208           CHK_(ptr);
209         } else {
210           goto handle_unusual;
211         }
212         continue;
213       // optional int32 eos = 3 [default = -1];
214       case 3:
215         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
216           _Internal::set_has_eos(&has_bits);
217           _impl_.eos_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
218           CHK_(ptr);
219         } else {
220           goto handle_unusual;
221         }
222         continue;
223       default:
224         goto handle_unusual;
225     }  // switch
226   handle_unusual:
227     if ((tag == 0) || ((tag & 7) == 4)) {
228       CHK_(ptr);
229       ctx->SetLastTag(tag);
230       goto message_done;
231     }
232     ptr = UnknownFieldParse(
233         tag,
234         _internal_metadata_.mutable_unknown_fields<std::string>(),
235         ptr, ctx);
236     CHK_(ptr != nullptr);
237   }  // while
238 message_done:
239   _impl_._has_bits_.Or(has_bits);
240   return ptr;
241 failure:
242   ptr = nullptr;
243   goto message_done;
244 #undef CHK_
245 }
246 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const247 ::uint8_t* DictionaryDescription_SpecialIds::_InternalSerialize(
248     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
249   // @@protoc_insertion_point(serialize_to_array_start:fcp.dictionary.DictionaryDescription.SpecialIds)
250   ::uint32_t cached_has_bits = 0;
251   (void) cached_has_bits;
252 
253   cached_has_bits = _impl_._has_bits_[0];
254   // optional int32 unk = 1 [default = -1];
255   if (cached_has_bits & 0x00000002u) {
256     target = stream->EnsureSpace(target);
257     target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_unk(), target);
258   }
259 
260   // optional int32 bos = 2 [default = -1];
261   if (cached_has_bits & 0x00000004u) {
262     target = stream->EnsureSpace(target);
263     target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_bos(), target);
264   }
265 
266   // optional int32 eos = 3 [default = -1];
267   if (cached_has_bits & 0x00000001u) {
268     target = stream->EnsureSpace(target);
269     target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_eos(), target);
270   }
271 
272   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
273     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
274         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
275   }
276   // @@protoc_insertion_point(serialize_to_array_end:fcp.dictionary.DictionaryDescription.SpecialIds)
277   return target;
278 }
279 
ByteSizeLong() const280 size_t DictionaryDescription_SpecialIds::ByteSizeLong() const {
281 // @@protoc_insertion_point(message_byte_size_start:fcp.dictionary.DictionaryDescription.SpecialIds)
282   size_t total_size = 0;
283 
284   ::uint32_t cached_has_bits = 0;
285   // Prevent compiler warnings about cached_has_bits being unused
286   (void) cached_has_bits;
287 
288   cached_has_bits = _impl_._has_bits_[0];
289   if (cached_has_bits & 0x00000007u) {
290     // optional int32 eos = 3 [default = -1];
291     if (cached_has_bits & 0x00000001u) {
292       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_eos());
293     }
294 
295     // optional int32 unk = 1 [default = -1];
296     if (cached_has_bits & 0x00000002u) {
297       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_unk());
298     }
299 
300     // optional int32 bos = 2 [default = -1];
301     if (cached_has_bits & 0x00000004u) {
302       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_bos());
303     }
304 
305   }
306   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
307     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
308   }
309   int cached_size = ::_pbi::ToCachedSize(total_size);
310   SetCachedSize(cached_size);
311   return total_size;
312 }
313 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)314 void DictionaryDescription_SpecialIds::CheckTypeAndMergeFrom(
315     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
316   MergeFrom(*::_pbi::DownCast<const DictionaryDescription_SpecialIds*>(
317       &from));
318 }
319 
MergeFrom(const DictionaryDescription_SpecialIds & from)320 void DictionaryDescription_SpecialIds::MergeFrom(const DictionaryDescription_SpecialIds& from) {
321   DictionaryDescription_SpecialIds* const _this = this;
322   // @@protoc_insertion_point(class_specific_merge_from_start:fcp.dictionary.DictionaryDescription.SpecialIds)
323   GOOGLE_DCHECK_NE(&from, _this);
324   ::uint32_t cached_has_bits = 0;
325   (void) cached_has_bits;
326 
327   cached_has_bits = from._impl_._has_bits_[0];
328   if (cached_has_bits & 0x00000007u) {
329     if (cached_has_bits & 0x00000001u) {
330       _this->_impl_.eos_ = from._impl_.eos_;
331     }
332     if (cached_has_bits & 0x00000002u) {
333       _this->_impl_.unk_ = from._impl_.unk_;
334     }
335     if (cached_has_bits & 0x00000004u) {
336       _this->_impl_.bos_ = from._impl_.bos_;
337     }
338     _this->_impl_._has_bits_[0] |= cached_has_bits;
339   }
340   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
341 }
342 
CopyFrom(const DictionaryDescription_SpecialIds & from)343 void DictionaryDescription_SpecialIds::CopyFrom(const DictionaryDescription_SpecialIds& from) {
344 // @@protoc_insertion_point(class_specific_copy_from_start:fcp.dictionary.DictionaryDescription.SpecialIds)
345   if (&from == this) return;
346   Clear();
347   MergeFrom(from);
348 }
349 
IsInitialized() const350 bool DictionaryDescription_SpecialIds::IsInitialized() const {
351   return true;
352 }
353 
InternalSwap(DictionaryDescription_SpecialIds * other)354 void DictionaryDescription_SpecialIds::InternalSwap(DictionaryDescription_SpecialIds* other) {
355   using std::swap;
356   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
357   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
358   swap(_impl_.eos_, other->_impl_.eos_);
359   swap(_impl_.unk_, other->_impl_.unk_);
360   swap(_impl_.bos_, other->_impl_.bos_);
361 }
362 
GetTypeName() const363 std::string DictionaryDescription_SpecialIds::GetTypeName() const {
364   return "fcp.dictionary.DictionaryDescription.SpecialIds";
365 }
366 
367 
368 // ===================================================================
369 
370 class DictionaryDescription_OutputBlocklistIds::_Internal {
371  public:
372 };
373 
DictionaryDescription_OutputBlocklistIds(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)374 DictionaryDescription_OutputBlocklistIds::DictionaryDescription_OutputBlocklistIds(::PROTOBUF_NAMESPACE_ID::Arena* arena,
375                          bool is_message_owned)
376   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
377   SharedCtor(arena, is_message_owned);
378   // @@protoc_insertion_point(arena_constructor:fcp.dictionary.DictionaryDescription.OutputBlocklistIds)
379 }
DictionaryDescription_OutputBlocklistIds(const DictionaryDescription_OutputBlocklistIds & from)380 DictionaryDescription_OutputBlocklistIds::DictionaryDescription_OutputBlocklistIds(const DictionaryDescription_OutputBlocklistIds& from)
381   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
382   DictionaryDescription_OutputBlocklistIds* const _this = this; (void)_this;
383   new (&_impl_) Impl_{
384       decltype(_impl_.id_){from._impl_.id_}
385     , /*decltype(_impl_._id_cached_byte_size_)*/{0}
386     , /*decltype(_impl_._cached_size_)*/{}};
387 
388   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
389   // @@protoc_insertion_point(copy_constructor:fcp.dictionary.DictionaryDescription.OutputBlocklistIds)
390 }
391 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)392 inline void DictionaryDescription_OutputBlocklistIds::SharedCtor(
393     ::_pb::Arena* arena, bool is_message_owned) {
394   (void)arena;
395   (void)is_message_owned;
396   new (&_impl_) Impl_{
397       decltype(_impl_.id_){arena}
398     , /*decltype(_impl_._id_cached_byte_size_)*/{0}
399     , /*decltype(_impl_._cached_size_)*/{}
400   };
401 }
402 
~DictionaryDescription_OutputBlocklistIds()403 DictionaryDescription_OutputBlocklistIds::~DictionaryDescription_OutputBlocklistIds() {
404   // @@protoc_insertion_point(destructor:fcp.dictionary.DictionaryDescription.OutputBlocklistIds)
405   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
406   (void)arena;
407     return;
408   }
409   SharedDtor();
410 }
411 
SharedDtor()412 inline void DictionaryDescription_OutputBlocklistIds::SharedDtor() {
413   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
414   _impl_.id_.~RepeatedField();
415 }
416 
SetCachedSize(int size) const417 void DictionaryDescription_OutputBlocklistIds::SetCachedSize(int size) const {
418   _impl_._cached_size_.Set(size);
419 }
420 
Clear()421 void DictionaryDescription_OutputBlocklistIds::Clear() {
422 // @@protoc_insertion_point(message_clear_start:fcp.dictionary.DictionaryDescription.OutputBlocklistIds)
423   ::uint32_t cached_has_bits = 0;
424   // Prevent compiler warnings about cached_has_bits being unused
425   (void) cached_has_bits;
426 
427   _impl_.id_.Clear();
428   _internal_metadata_.Clear<std::string>();
429 }
430 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)431 const char* DictionaryDescription_OutputBlocklistIds::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
432 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
433   while (!ctx->Done(&ptr)) {
434     ::uint32_t tag;
435     ptr = ::_pbi::ReadTag(ptr, &tag);
436     switch (tag >> 3) {
437       // repeated int32 id = 1 [packed = true];
438       case 1:
439         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
440           ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_id(), ptr, ctx);
441           CHK_(ptr);
442         } else if (static_cast<::uint8_t>(tag) == 8) {
443           _internal_add_id(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
444           CHK_(ptr);
445         } else {
446           goto handle_unusual;
447         }
448         continue;
449       default:
450         goto handle_unusual;
451     }  // switch
452   handle_unusual:
453     if ((tag == 0) || ((tag & 7) == 4)) {
454       CHK_(ptr);
455       ctx->SetLastTag(tag);
456       goto message_done;
457     }
458     ptr = UnknownFieldParse(
459         tag,
460         _internal_metadata_.mutable_unknown_fields<std::string>(),
461         ptr, ctx);
462     CHK_(ptr != nullptr);
463   }  // while
464 message_done:
465   return ptr;
466 failure:
467   ptr = nullptr;
468   goto message_done;
469 #undef CHK_
470 }
471 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const472 ::uint8_t* DictionaryDescription_OutputBlocklistIds::_InternalSerialize(
473     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
474   // @@protoc_insertion_point(serialize_to_array_start:fcp.dictionary.DictionaryDescription.OutputBlocklistIds)
475   ::uint32_t cached_has_bits = 0;
476   (void) cached_has_bits;
477 
478   // repeated int32 id = 1 [packed = true];
479   {
480     int byte_size = _impl_._id_cached_byte_size_.load(std::memory_order_relaxed);
481     if (byte_size > 0) {
482       target = stream->WriteInt32Packed(
483           1, _internal_id(), byte_size, target);
484     }
485   }
486 
487   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
488     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
489         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
490   }
491   // @@protoc_insertion_point(serialize_to_array_end:fcp.dictionary.DictionaryDescription.OutputBlocklistIds)
492   return target;
493 }
494 
ByteSizeLong() const495 size_t DictionaryDescription_OutputBlocklistIds::ByteSizeLong() const {
496 // @@protoc_insertion_point(message_byte_size_start:fcp.dictionary.DictionaryDescription.OutputBlocklistIds)
497   size_t total_size = 0;
498 
499   ::uint32_t cached_has_bits = 0;
500   // Prevent compiler warnings about cached_has_bits being unused
501   (void) cached_has_bits;
502 
503   // repeated int32 id = 1 [packed = true];
504   {
505     size_t data_size = ::_pbi::WireFormatLite::
506       Int32Size(this->_impl_.id_);
507     if (data_size > 0) {
508       total_size += 1 +
509         ::_pbi::WireFormatLite::Int32Size(static_cast<::int32_t>(data_size));
510     }
511     int cached_size = ::_pbi::ToCachedSize(data_size);
512     _impl_._id_cached_byte_size_.store(cached_size,
513                                     std::memory_order_relaxed);
514     total_size += data_size;
515   }
516 
517   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
518     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
519   }
520   int cached_size = ::_pbi::ToCachedSize(total_size);
521   SetCachedSize(cached_size);
522   return total_size;
523 }
524 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)525 void DictionaryDescription_OutputBlocklistIds::CheckTypeAndMergeFrom(
526     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
527   MergeFrom(*::_pbi::DownCast<const DictionaryDescription_OutputBlocklistIds*>(
528       &from));
529 }
530 
MergeFrom(const DictionaryDescription_OutputBlocklistIds & from)531 void DictionaryDescription_OutputBlocklistIds::MergeFrom(const DictionaryDescription_OutputBlocklistIds& from) {
532   DictionaryDescription_OutputBlocklistIds* const _this = this;
533   // @@protoc_insertion_point(class_specific_merge_from_start:fcp.dictionary.DictionaryDescription.OutputBlocklistIds)
534   GOOGLE_DCHECK_NE(&from, _this);
535   ::uint32_t cached_has_bits = 0;
536   (void) cached_has_bits;
537 
538   _this->_impl_.id_.MergeFrom(from._impl_.id_);
539   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
540 }
541 
CopyFrom(const DictionaryDescription_OutputBlocklistIds & from)542 void DictionaryDescription_OutputBlocklistIds::CopyFrom(const DictionaryDescription_OutputBlocklistIds& from) {
543 // @@protoc_insertion_point(class_specific_copy_from_start:fcp.dictionary.DictionaryDescription.OutputBlocklistIds)
544   if (&from == this) return;
545   Clear();
546   MergeFrom(from);
547 }
548 
IsInitialized() const549 bool DictionaryDescription_OutputBlocklistIds::IsInitialized() const {
550   return true;
551 }
552 
InternalSwap(DictionaryDescription_OutputBlocklistIds * other)553 void DictionaryDescription_OutputBlocklistIds::InternalSwap(DictionaryDescription_OutputBlocklistIds* other) {
554   using std::swap;
555   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
556   _impl_.id_.InternalSwap(&other->_impl_.id_);
557 }
558 
GetTypeName() const559 std::string DictionaryDescription_OutputBlocklistIds::GetTypeName() const {
560   return "fcp.dictionary.DictionaryDescription.OutputBlocklistIds";
561 }
562 
563 
564 // ===================================================================
565 
566 class DictionaryDescription_Vocabulary_TokenIndex::_Internal {
567  public:
568 };
569 
DictionaryDescription_Vocabulary_TokenIndex(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)570 DictionaryDescription_Vocabulary_TokenIndex::DictionaryDescription_Vocabulary_TokenIndex(::PROTOBUF_NAMESPACE_ID::Arena* arena,
571                          bool is_message_owned)
572   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
573   SharedCtor(arena, is_message_owned);
574   // @@protoc_insertion_point(arena_constructor:fcp.dictionary.DictionaryDescription.Vocabulary.TokenIndex)
575 }
DictionaryDescription_Vocabulary_TokenIndex(const DictionaryDescription_Vocabulary_TokenIndex & from)576 DictionaryDescription_Vocabulary_TokenIndex::DictionaryDescription_Vocabulary_TokenIndex(const DictionaryDescription_Vocabulary_TokenIndex& from)
577   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
578   DictionaryDescription_Vocabulary_TokenIndex* const _this = this; (void)_this;
579   new (&_impl_) Impl_{
580       decltype(_impl_.token_){from._impl_.token_}
581     , /*decltype(_impl_._cached_size_)*/{}};
582 
583   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
584   // @@protoc_insertion_point(copy_constructor:fcp.dictionary.DictionaryDescription.Vocabulary.TokenIndex)
585 }
586 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)587 inline void DictionaryDescription_Vocabulary_TokenIndex::SharedCtor(
588     ::_pb::Arena* arena, bool is_message_owned) {
589   (void)arena;
590   (void)is_message_owned;
591   new (&_impl_) Impl_{
592       decltype(_impl_.token_){arena}
593     , /*decltype(_impl_._cached_size_)*/{}
594   };
595 }
596 
~DictionaryDescription_Vocabulary_TokenIndex()597 DictionaryDescription_Vocabulary_TokenIndex::~DictionaryDescription_Vocabulary_TokenIndex() {
598   // @@protoc_insertion_point(destructor:fcp.dictionary.DictionaryDescription.Vocabulary.TokenIndex)
599   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
600   (void)arena;
601     return;
602   }
603   SharedDtor();
604 }
605 
SharedDtor()606 inline void DictionaryDescription_Vocabulary_TokenIndex::SharedDtor() {
607   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
608   _impl_.token_.~RepeatedPtrField();
609 }
610 
SetCachedSize(int size) const611 void DictionaryDescription_Vocabulary_TokenIndex::SetCachedSize(int size) const {
612   _impl_._cached_size_.Set(size);
613 }
614 
Clear()615 void DictionaryDescription_Vocabulary_TokenIndex::Clear() {
616 // @@protoc_insertion_point(message_clear_start:fcp.dictionary.DictionaryDescription.Vocabulary.TokenIndex)
617   ::uint32_t cached_has_bits = 0;
618   // Prevent compiler warnings about cached_has_bits being unused
619   (void) cached_has_bits;
620 
621   _impl_.token_.Clear();
622   _internal_metadata_.Clear<std::string>();
623 }
624 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)625 const char* DictionaryDescription_Vocabulary_TokenIndex::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
626 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
627   while (!ctx->Done(&ptr)) {
628     ::uint32_t tag;
629     ptr = ::_pbi::ReadTag(ptr, &tag);
630     switch (tag >> 3) {
631       // repeated string token = 1;
632       case 1:
633         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
634           ptr -= 1;
635           do {
636             ptr += 1;
637             auto str = _internal_add_token();
638             ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
639             CHK_(ptr);
640             if (!ctx->DataAvailable(ptr)) break;
641           } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
642         } else {
643           goto handle_unusual;
644         }
645         continue;
646       default:
647         goto handle_unusual;
648     }  // switch
649   handle_unusual:
650     if ((tag == 0) || ((tag & 7) == 4)) {
651       CHK_(ptr);
652       ctx->SetLastTag(tag);
653       goto message_done;
654     }
655     ptr = UnknownFieldParse(
656         tag,
657         _internal_metadata_.mutable_unknown_fields<std::string>(),
658         ptr, ctx);
659     CHK_(ptr != nullptr);
660   }  // while
661 message_done:
662   return ptr;
663 failure:
664   ptr = nullptr;
665   goto message_done;
666 #undef CHK_
667 }
668 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const669 ::uint8_t* DictionaryDescription_Vocabulary_TokenIndex::_InternalSerialize(
670     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
671   // @@protoc_insertion_point(serialize_to_array_start:fcp.dictionary.DictionaryDescription.Vocabulary.TokenIndex)
672   ::uint32_t cached_has_bits = 0;
673   (void) cached_has_bits;
674 
675   // repeated string token = 1;
676   for (int i = 0, n = this->_internal_token_size(); i < n; i++) {
677     const auto& s = this->_internal_token(i);
678     target = stream->WriteString(1, s, target);
679   }
680 
681   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
682     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
683         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
684   }
685   // @@protoc_insertion_point(serialize_to_array_end:fcp.dictionary.DictionaryDescription.Vocabulary.TokenIndex)
686   return target;
687 }
688 
ByteSizeLong() const689 size_t DictionaryDescription_Vocabulary_TokenIndex::ByteSizeLong() const {
690 // @@protoc_insertion_point(message_byte_size_start:fcp.dictionary.DictionaryDescription.Vocabulary.TokenIndex)
691   size_t total_size = 0;
692 
693   ::uint32_t cached_has_bits = 0;
694   // Prevent compiler warnings about cached_has_bits being unused
695   (void) cached_has_bits;
696 
697   // repeated string token = 1;
698   total_size += 1 *
699       ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.token_.size());
700   for (int i = 0, n = _impl_.token_.size(); i < n; i++) {
701     total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
702       _impl_.token_.Get(i));
703   }
704 
705   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
706     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
707   }
708   int cached_size = ::_pbi::ToCachedSize(total_size);
709   SetCachedSize(cached_size);
710   return total_size;
711 }
712 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)713 void DictionaryDescription_Vocabulary_TokenIndex::CheckTypeAndMergeFrom(
714     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
715   MergeFrom(*::_pbi::DownCast<const DictionaryDescription_Vocabulary_TokenIndex*>(
716       &from));
717 }
718 
MergeFrom(const DictionaryDescription_Vocabulary_TokenIndex & from)719 void DictionaryDescription_Vocabulary_TokenIndex::MergeFrom(const DictionaryDescription_Vocabulary_TokenIndex& from) {
720   DictionaryDescription_Vocabulary_TokenIndex* const _this = this;
721   // @@protoc_insertion_point(class_specific_merge_from_start:fcp.dictionary.DictionaryDescription.Vocabulary.TokenIndex)
722   GOOGLE_DCHECK_NE(&from, _this);
723   ::uint32_t cached_has_bits = 0;
724   (void) cached_has_bits;
725 
726   _this->_impl_.token_.MergeFrom(from._impl_.token_);
727   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
728 }
729 
CopyFrom(const DictionaryDescription_Vocabulary_TokenIndex & from)730 void DictionaryDescription_Vocabulary_TokenIndex::CopyFrom(const DictionaryDescription_Vocabulary_TokenIndex& from) {
731 // @@protoc_insertion_point(class_specific_copy_from_start:fcp.dictionary.DictionaryDescription.Vocabulary.TokenIndex)
732   if (&from == this) return;
733   Clear();
734   MergeFrom(from);
735 }
736 
IsInitialized() const737 bool DictionaryDescription_Vocabulary_TokenIndex::IsInitialized() const {
738   return true;
739 }
740 
InternalSwap(DictionaryDescription_Vocabulary_TokenIndex * other)741 void DictionaryDescription_Vocabulary_TokenIndex::InternalSwap(DictionaryDescription_Vocabulary_TokenIndex* other) {
742   using std::swap;
743   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
744   _impl_.token_.InternalSwap(&other->_impl_.token_);
745 }
746 
GetTypeName() const747 std::string DictionaryDescription_Vocabulary_TokenIndex::GetTypeName() const {
748   return "fcp.dictionary.DictionaryDescription.Vocabulary.TokenIndex";
749 }
750 
751 
752 // ===================================================================
753 
754 class DictionaryDescription_Vocabulary::_Internal {
755  public:
756   static const ::fcp::dictionary::DictionaryDescription_Vocabulary_TokenIndex& index(const DictionaryDescription_Vocabulary* msg);
757 };
758 
759 const ::fcp::dictionary::DictionaryDescription_Vocabulary_TokenIndex&
index(const DictionaryDescription_Vocabulary * msg)760 DictionaryDescription_Vocabulary::_Internal::index(const DictionaryDescription_Vocabulary* msg) {
761   return *msg->_impl_.vocabulary_.index_;
762 }
set_allocated_index(::fcp::dictionary::DictionaryDescription_Vocabulary_TokenIndex * index)763 void DictionaryDescription_Vocabulary::set_allocated_index(::fcp::dictionary::DictionaryDescription_Vocabulary_TokenIndex* index) {
764   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
765   clear_vocabulary();
766   if (index) {
767     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
768       ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(index);
769     if (message_arena != submessage_arena) {
770       index = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
771           message_arena, index, submessage_arena);
772     }
773     set_has_index();
774     _impl_.vocabulary_.index_ = index;
775   }
776   // @@protoc_insertion_point(field_set_allocated:fcp.dictionary.DictionaryDescription.Vocabulary.index)
777 }
DictionaryDescription_Vocabulary(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)778 DictionaryDescription_Vocabulary::DictionaryDescription_Vocabulary(::PROTOBUF_NAMESPACE_ID::Arena* arena,
779                          bool is_message_owned)
780   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
781   SharedCtor(arena, is_message_owned);
782   // @@protoc_insertion_point(arena_constructor:fcp.dictionary.DictionaryDescription.Vocabulary)
783 }
DictionaryDescription_Vocabulary(const DictionaryDescription_Vocabulary & from)784 DictionaryDescription_Vocabulary::DictionaryDescription_Vocabulary(const DictionaryDescription_Vocabulary& from)
785   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
786   DictionaryDescription_Vocabulary* const _this = this; (void)_this;
787   new (&_impl_) Impl_{
788       decltype(_impl_.vocabulary_){}
789     , /*decltype(_impl_._cached_size_)*/{}
790     , /*decltype(_impl_._oneof_case_)*/{}};
791 
792   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
793   clear_has_vocabulary();
794   switch (from.vocabulary_case()) {
795     case kIndex: {
796       _this->_internal_mutable_index()->::fcp::dictionary::DictionaryDescription_Vocabulary_TokenIndex::MergeFrom(
797           from._internal_index());
798       break;
799     }
800     case VOCABULARY_NOT_SET: {
801       break;
802     }
803   }
804   // @@protoc_insertion_point(copy_constructor:fcp.dictionary.DictionaryDescription.Vocabulary)
805 }
806 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)807 inline void DictionaryDescription_Vocabulary::SharedCtor(
808     ::_pb::Arena* arena, bool is_message_owned) {
809   (void)arena;
810   (void)is_message_owned;
811   new (&_impl_) Impl_{
812       decltype(_impl_.vocabulary_){}
813     , /*decltype(_impl_._cached_size_)*/{}
814     , /*decltype(_impl_._oneof_case_)*/{}
815   };
816   clear_has_vocabulary();
817 }
818 
~DictionaryDescription_Vocabulary()819 DictionaryDescription_Vocabulary::~DictionaryDescription_Vocabulary() {
820   // @@protoc_insertion_point(destructor:fcp.dictionary.DictionaryDescription.Vocabulary)
821   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
822   (void)arena;
823     return;
824   }
825   SharedDtor();
826 }
827 
SharedDtor()828 inline void DictionaryDescription_Vocabulary::SharedDtor() {
829   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
830   if (has_vocabulary()) {
831     clear_vocabulary();
832   }
833 }
834 
SetCachedSize(int size) const835 void DictionaryDescription_Vocabulary::SetCachedSize(int size) const {
836   _impl_._cached_size_.Set(size);
837 }
838 
clear_vocabulary()839 void DictionaryDescription_Vocabulary::clear_vocabulary() {
840 // @@protoc_insertion_point(one_of_clear_start:fcp.dictionary.DictionaryDescription.Vocabulary)
841   switch (vocabulary_case()) {
842     case kIndex: {
843       if (GetArenaForAllocation() == nullptr) {
844         delete _impl_.vocabulary_.index_;
845       }
846       break;
847     }
848     case VOCABULARY_NOT_SET: {
849       break;
850     }
851   }
852   _impl_._oneof_case_[0] = VOCABULARY_NOT_SET;
853 }
854 
855 
Clear()856 void DictionaryDescription_Vocabulary::Clear() {
857 // @@protoc_insertion_point(message_clear_start:fcp.dictionary.DictionaryDescription.Vocabulary)
858   ::uint32_t cached_has_bits = 0;
859   // Prevent compiler warnings about cached_has_bits being unused
860   (void) cached_has_bits;
861 
862   clear_vocabulary();
863   _internal_metadata_.Clear<std::string>();
864 }
865 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)866 const char* DictionaryDescription_Vocabulary::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
867 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
868   while (!ctx->Done(&ptr)) {
869     ::uint32_t tag;
870     ptr = ::_pbi::ReadTag(ptr, &tag);
871     switch (tag >> 3) {
872       // .fcp.dictionary.DictionaryDescription.Vocabulary.TokenIndex index = 2;
873       case 2:
874         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
875           ptr = ctx->ParseMessage(_internal_mutable_index(), ptr);
876           CHK_(ptr);
877         } else {
878           goto handle_unusual;
879         }
880         continue;
881       default:
882         goto handle_unusual;
883     }  // switch
884   handle_unusual:
885     if ((tag == 0) || ((tag & 7) == 4)) {
886       CHK_(ptr);
887       ctx->SetLastTag(tag);
888       goto message_done;
889     }
890     ptr = UnknownFieldParse(
891         tag,
892         _internal_metadata_.mutable_unknown_fields<std::string>(),
893         ptr, ctx);
894     CHK_(ptr != nullptr);
895   }  // while
896 message_done:
897   return ptr;
898 failure:
899   ptr = nullptr;
900   goto message_done;
901 #undef CHK_
902 }
903 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const904 ::uint8_t* DictionaryDescription_Vocabulary::_InternalSerialize(
905     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
906   // @@protoc_insertion_point(serialize_to_array_start:fcp.dictionary.DictionaryDescription.Vocabulary)
907   ::uint32_t cached_has_bits = 0;
908   (void) cached_has_bits;
909 
910   // .fcp.dictionary.DictionaryDescription.Vocabulary.TokenIndex index = 2;
911   if (_internal_has_index()) {
912     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
913       InternalWriteMessage(2, _Internal::index(this),
914         _Internal::index(this).GetCachedSize(), target, stream);
915   }
916 
917   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
918     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
919         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
920   }
921   // @@protoc_insertion_point(serialize_to_array_end:fcp.dictionary.DictionaryDescription.Vocabulary)
922   return target;
923 }
924 
ByteSizeLong() const925 size_t DictionaryDescription_Vocabulary::ByteSizeLong() const {
926 // @@protoc_insertion_point(message_byte_size_start:fcp.dictionary.DictionaryDescription.Vocabulary)
927   size_t total_size = 0;
928 
929   switch (vocabulary_case()) {
930     // .fcp.dictionary.DictionaryDescription.Vocabulary.TokenIndex index = 2;
931     case kIndex: {
932       total_size += 1 +
933         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
934           *_impl_.vocabulary_.index_);
935       break;
936     }
937     case VOCABULARY_NOT_SET: {
938       break;
939     }
940   }
941   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
942     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
943   }
944   int cached_size = ::_pbi::ToCachedSize(total_size);
945   SetCachedSize(cached_size);
946   return total_size;
947 }
948 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)949 void DictionaryDescription_Vocabulary::CheckTypeAndMergeFrom(
950     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
951   MergeFrom(*::_pbi::DownCast<const DictionaryDescription_Vocabulary*>(
952       &from));
953 }
954 
MergeFrom(const DictionaryDescription_Vocabulary & from)955 void DictionaryDescription_Vocabulary::MergeFrom(const DictionaryDescription_Vocabulary& from) {
956   DictionaryDescription_Vocabulary* const _this = this;
957   // @@protoc_insertion_point(class_specific_merge_from_start:fcp.dictionary.DictionaryDescription.Vocabulary)
958   GOOGLE_DCHECK_NE(&from, _this);
959   ::uint32_t cached_has_bits = 0;
960   (void) cached_has_bits;
961 
962   switch (from.vocabulary_case()) {
963     case kIndex: {
964       _this->_internal_mutable_index()->::fcp::dictionary::DictionaryDescription_Vocabulary_TokenIndex::MergeFrom(
965           from._internal_index());
966       break;
967     }
968     case VOCABULARY_NOT_SET: {
969       break;
970     }
971   }
972   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
973 }
974 
CopyFrom(const DictionaryDescription_Vocabulary & from)975 void DictionaryDescription_Vocabulary::CopyFrom(const DictionaryDescription_Vocabulary& from) {
976 // @@protoc_insertion_point(class_specific_copy_from_start:fcp.dictionary.DictionaryDescription.Vocabulary)
977   if (&from == this) return;
978   Clear();
979   MergeFrom(from);
980 }
981 
IsInitialized() const982 bool DictionaryDescription_Vocabulary::IsInitialized() const {
983   return true;
984 }
985 
InternalSwap(DictionaryDescription_Vocabulary * other)986 void DictionaryDescription_Vocabulary::InternalSwap(DictionaryDescription_Vocabulary* other) {
987   using std::swap;
988   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
989   swap(_impl_.vocabulary_, other->_impl_.vocabulary_);
990   swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
991 }
992 
GetTypeName() const993 std::string DictionaryDescription_Vocabulary::GetTypeName() const {
994   return "fcp.dictionary.DictionaryDescription.Vocabulary";
995 }
996 
997 
998 // ===================================================================
999 
1000 class DictionaryDescription::_Internal {
1001  public:
1002   using HasBits = decltype(std::declval<DictionaryDescription>()._impl_._has_bits_);
1003   static const ::fcp::dictionary::DictionaryDescription_SpecialIds& special_ids(const DictionaryDescription* msg);
set_has_special_ids(HasBits * has_bits)1004   static void set_has_special_ids(HasBits* has_bits) {
1005     (*has_bits)[0] |= 1u;
1006   }
1007   static const ::fcp::dictionary::DictionaryDescription_Vocabulary& vocabulary(const DictionaryDescription* msg);
set_has_vocabulary(HasBits * has_bits)1008   static void set_has_vocabulary(HasBits* has_bits) {
1009     (*has_bits)[0] |= 2u;
1010   }
1011   static const ::fcp::dictionary::DictionaryDescription_OutputBlocklistIds& output_blocklist_ids(const DictionaryDescription* msg);
set_has_output_blocklist_ids(HasBits * has_bits)1012   static void set_has_output_blocklist_ids(HasBits* has_bits) {
1013     (*has_bits)[0] |= 4u;
1014   }
1015 };
1016 
1017 const ::fcp::dictionary::DictionaryDescription_SpecialIds&
special_ids(const DictionaryDescription * msg)1018 DictionaryDescription::_Internal::special_ids(const DictionaryDescription* msg) {
1019   return *msg->_impl_.special_ids_;
1020 }
1021 const ::fcp::dictionary::DictionaryDescription_Vocabulary&
vocabulary(const DictionaryDescription * msg)1022 DictionaryDescription::_Internal::vocabulary(const DictionaryDescription* msg) {
1023   return *msg->_impl_.vocabulary_;
1024 }
1025 const ::fcp::dictionary::DictionaryDescription_OutputBlocklistIds&
output_blocklist_ids(const DictionaryDescription * msg)1026 DictionaryDescription::_Internal::output_blocklist_ids(const DictionaryDescription* msg) {
1027   return *msg->_impl_.output_blocklist_ids_;
1028 }
DictionaryDescription(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1029 DictionaryDescription::DictionaryDescription(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1030                          bool is_message_owned)
1031   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1032   SharedCtor(arena, is_message_owned);
1033   // @@protoc_insertion_point(arena_constructor:fcp.dictionary.DictionaryDescription)
1034 }
DictionaryDescription(const DictionaryDescription & from)1035 DictionaryDescription::DictionaryDescription(const DictionaryDescription& from)
1036   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1037   DictionaryDescription* const _this = this; (void)_this;
1038   new (&_impl_) Impl_{
1039       decltype(_impl_._has_bits_){from._impl_._has_bits_}
1040     , /*decltype(_impl_._cached_size_)*/{}
1041     , decltype(_impl_.special_ids_){nullptr}
1042     , decltype(_impl_.vocabulary_){nullptr}
1043     , decltype(_impl_.output_blocklist_ids_){nullptr}};
1044 
1045   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1046   if (from._internal_has_special_ids()) {
1047     _this->_impl_.special_ids_ = new ::fcp::dictionary::DictionaryDescription_SpecialIds(*from._impl_.special_ids_);
1048   }
1049   if (from._internal_has_vocabulary()) {
1050     _this->_impl_.vocabulary_ = new ::fcp::dictionary::DictionaryDescription_Vocabulary(*from._impl_.vocabulary_);
1051   }
1052   if (from._internal_has_output_blocklist_ids()) {
1053     _this->_impl_.output_blocklist_ids_ = new ::fcp::dictionary::DictionaryDescription_OutputBlocklistIds(*from._impl_.output_blocklist_ids_);
1054   }
1055   // @@protoc_insertion_point(copy_constructor:fcp.dictionary.DictionaryDescription)
1056 }
1057 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1058 inline void DictionaryDescription::SharedCtor(
1059     ::_pb::Arena* arena, bool is_message_owned) {
1060   (void)arena;
1061   (void)is_message_owned;
1062   new (&_impl_) Impl_{
1063       decltype(_impl_._has_bits_){}
1064     , /*decltype(_impl_._cached_size_)*/{}
1065     , decltype(_impl_.special_ids_){nullptr}
1066     , decltype(_impl_.vocabulary_){nullptr}
1067     , decltype(_impl_.output_blocklist_ids_){nullptr}
1068   };
1069 }
1070 
~DictionaryDescription()1071 DictionaryDescription::~DictionaryDescription() {
1072   // @@protoc_insertion_point(destructor:fcp.dictionary.DictionaryDescription)
1073   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1074   (void)arena;
1075     return;
1076   }
1077   SharedDtor();
1078 }
1079 
SharedDtor()1080 inline void DictionaryDescription::SharedDtor() {
1081   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1082   if (this != internal_default_instance()) delete _impl_.special_ids_;
1083   if (this != internal_default_instance()) delete _impl_.vocabulary_;
1084   if (this != internal_default_instance()) delete _impl_.output_blocklist_ids_;
1085 }
1086 
SetCachedSize(int size) const1087 void DictionaryDescription::SetCachedSize(int size) const {
1088   _impl_._cached_size_.Set(size);
1089 }
1090 
Clear()1091 void DictionaryDescription::Clear() {
1092 // @@protoc_insertion_point(message_clear_start:fcp.dictionary.DictionaryDescription)
1093   ::uint32_t cached_has_bits = 0;
1094   // Prevent compiler warnings about cached_has_bits being unused
1095   (void) cached_has_bits;
1096 
1097   cached_has_bits = _impl_._has_bits_[0];
1098   if (cached_has_bits & 0x00000007u) {
1099     if (cached_has_bits & 0x00000001u) {
1100       GOOGLE_DCHECK(_impl_.special_ids_ != nullptr);
1101       _impl_.special_ids_->Clear();
1102     }
1103     if (cached_has_bits & 0x00000002u) {
1104       GOOGLE_DCHECK(_impl_.vocabulary_ != nullptr);
1105       _impl_.vocabulary_->Clear();
1106     }
1107     if (cached_has_bits & 0x00000004u) {
1108       GOOGLE_DCHECK(_impl_.output_blocklist_ids_ != nullptr);
1109       _impl_.output_blocklist_ids_->Clear();
1110     }
1111   }
1112   _impl_._has_bits_.Clear();
1113   _internal_metadata_.Clear<std::string>();
1114 }
1115 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1116 const char* DictionaryDescription::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1117 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1118   _Internal::HasBits has_bits{};
1119   while (!ctx->Done(&ptr)) {
1120     ::uint32_t tag;
1121     ptr = ::_pbi::ReadTag(ptr, &tag);
1122     switch (tag >> 3) {
1123       // optional .fcp.dictionary.DictionaryDescription.SpecialIds special_ids = 1;
1124       case 1:
1125         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1126           ptr = ctx->ParseMessage(_internal_mutable_special_ids(), ptr);
1127           CHK_(ptr);
1128         } else {
1129           goto handle_unusual;
1130         }
1131         continue;
1132       // optional .fcp.dictionary.DictionaryDescription.Vocabulary vocabulary = 2;
1133       case 2:
1134         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
1135           ptr = ctx->ParseMessage(_internal_mutable_vocabulary(), ptr);
1136           CHK_(ptr);
1137         } else {
1138           goto handle_unusual;
1139         }
1140         continue;
1141       // optional .fcp.dictionary.DictionaryDescription.OutputBlocklistIds output_blocklist_ids = 3;
1142       case 3:
1143         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
1144           ptr = ctx->ParseMessage(_internal_mutable_output_blocklist_ids(), ptr);
1145           CHK_(ptr);
1146         } else {
1147           goto handle_unusual;
1148         }
1149         continue;
1150       default:
1151         goto handle_unusual;
1152     }  // switch
1153   handle_unusual:
1154     if ((tag == 0) || ((tag & 7) == 4)) {
1155       CHK_(ptr);
1156       ctx->SetLastTag(tag);
1157       goto message_done;
1158     }
1159     ptr = UnknownFieldParse(
1160         tag,
1161         _internal_metadata_.mutable_unknown_fields<std::string>(),
1162         ptr, ctx);
1163     CHK_(ptr != nullptr);
1164   }  // while
1165 message_done:
1166   _impl_._has_bits_.Or(has_bits);
1167   return ptr;
1168 failure:
1169   ptr = nullptr;
1170   goto message_done;
1171 #undef CHK_
1172 }
1173 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1174 ::uint8_t* DictionaryDescription::_InternalSerialize(
1175     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1176   // @@protoc_insertion_point(serialize_to_array_start:fcp.dictionary.DictionaryDescription)
1177   ::uint32_t cached_has_bits = 0;
1178   (void) cached_has_bits;
1179 
1180   cached_has_bits = _impl_._has_bits_[0];
1181   // optional .fcp.dictionary.DictionaryDescription.SpecialIds special_ids = 1;
1182   if (cached_has_bits & 0x00000001u) {
1183     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1184       InternalWriteMessage(1, _Internal::special_ids(this),
1185         _Internal::special_ids(this).GetCachedSize(), target, stream);
1186   }
1187 
1188   // optional .fcp.dictionary.DictionaryDescription.Vocabulary vocabulary = 2;
1189   if (cached_has_bits & 0x00000002u) {
1190     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1191       InternalWriteMessage(2, _Internal::vocabulary(this),
1192         _Internal::vocabulary(this).GetCachedSize(), target, stream);
1193   }
1194 
1195   // optional .fcp.dictionary.DictionaryDescription.OutputBlocklistIds output_blocklist_ids = 3;
1196   if (cached_has_bits & 0x00000004u) {
1197     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1198       InternalWriteMessage(3, _Internal::output_blocklist_ids(this),
1199         _Internal::output_blocklist_ids(this).GetCachedSize(), target, stream);
1200   }
1201 
1202   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1203     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1204         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1205   }
1206   // @@protoc_insertion_point(serialize_to_array_end:fcp.dictionary.DictionaryDescription)
1207   return target;
1208 }
1209 
ByteSizeLong() const1210 size_t DictionaryDescription::ByteSizeLong() const {
1211 // @@protoc_insertion_point(message_byte_size_start:fcp.dictionary.DictionaryDescription)
1212   size_t total_size = 0;
1213 
1214   ::uint32_t cached_has_bits = 0;
1215   // Prevent compiler warnings about cached_has_bits being unused
1216   (void) cached_has_bits;
1217 
1218   cached_has_bits = _impl_._has_bits_[0];
1219   if (cached_has_bits & 0x00000007u) {
1220     // optional .fcp.dictionary.DictionaryDescription.SpecialIds special_ids = 1;
1221     if (cached_has_bits & 0x00000001u) {
1222       total_size += 1 +
1223         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1224           *_impl_.special_ids_);
1225     }
1226 
1227     // optional .fcp.dictionary.DictionaryDescription.Vocabulary vocabulary = 2;
1228     if (cached_has_bits & 0x00000002u) {
1229       total_size += 1 +
1230         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1231           *_impl_.vocabulary_);
1232     }
1233 
1234     // optional .fcp.dictionary.DictionaryDescription.OutputBlocklistIds output_blocklist_ids = 3;
1235     if (cached_has_bits & 0x00000004u) {
1236       total_size += 1 +
1237         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1238           *_impl_.output_blocklist_ids_);
1239     }
1240 
1241   }
1242   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1243     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1244   }
1245   int cached_size = ::_pbi::ToCachedSize(total_size);
1246   SetCachedSize(cached_size);
1247   return total_size;
1248 }
1249 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1250 void DictionaryDescription::CheckTypeAndMergeFrom(
1251     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1252   MergeFrom(*::_pbi::DownCast<const DictionaryDescription*>(
1253       &from));
1254 }
1255 
MergeFrom(const DictionaryDescription & from)1256 void DictionaryDescription::MergeFrom(const DictionaryDescription& from) {
1257   DictionaryDescription* const _this = this;
1258   // @@protoc_insertion_point(class_specific_merge_from_start:fcp.dictionary.DictionaryDescription)
1259   GOOGLE_DCHECK_NE(&from, _this);
1260   ::uint32_t cached_has_bits = 0;
1261   (void) cached_has_bits;
1262 
1263   cached_has_bits = from._impl_._has_bits_[0];
1264   if (cached_has_bits & 0x00000007u) {
1265     if (cached_has_bits & 0x00000001u) {
1266       _this->_internal_mutable_special_ids()->::fcp::dictionary::DictionaryDescription_SpecialIds::MergeFrom(
1267           from._internal_special_ids());
1268     }
1269     if (cached_has_bits & 0x00000002u) {
1270       _this->_internal_mutable_vocabulary()->::fcp::dictionary::DictionaryDescription_Vocabulary::MergeFrom(
1271           from._internal_vocabulary());
1272     }
1273     if (cached_has_bits & 0x00000004u) {
1274       _this->_internal_mutable_output_blocklist_ids()->::fcp::dictionary::DictionaryDescription_OutputBlocklistIds::MergeFrom(
1275           from._internal_output_blocklist_ids());
1276     }
1277   }
1278   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1279 }
1280 
CopyFrom(const DictionaryDescription & from)1281 void DictionaryDescription::CopyFrom(const DictionaryDescription& from) {
1282 // @@protoc_insertion_point(class_specific_copy_from_start:fcp.dictionary.DictionaryDescription)
1283   if (&from == this) return;
1284   Clear();
1285   MergeFrom(from);
1286 }
1287 
IsInitialized() const1288 bool DictionaryDescription::IsInitialized() const {
1289   return true;
1290 }
1291 
InternalSwap(DictionaryDescription * other)1292 void DictionaryDescription::InternalSwap(DictionaryDescription* other) {
1293   using std::swap;
1294   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1295   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1296   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1297       PROTOBUF_FIELD_OFFSET(DictionaryDescription, _impl_.output_blocklist_ids_)
1298       + sizeof(DictionaryDescription::_impl_.output_blocklist_ids_)  // NOLINT
1299       - PROTOBUF_FIELD_OFFSET(DictionaryDescription, _impl_.special_ids_)>(
1300           reinterpret_cast<char*>(&_impl_.special_ids_),
1301           reinterpret_cast<char*>(&other->_impl_.special_ids_));
1302 }
1303 
GetTypeName() const1304 std::string DictionaryDescription::GetTypeName() const {
1305   return "fcp.dictionary.DictionaryDescription";
1306 }
1307 
1308 
1309 // @@protoc_insertion_point(namespace_scope)
1310 }  // namespace dictionary
1311 }  // namespace fcp
1312 PROTOBUF_NAMESPACE_OPEN
1313 template<> PROTOBUF_NOINLINE ::fcp::dictionary::DictionaryDescription_SpecialIds*
CreateMaybeMessage(Arena * arena)1314 Arena::CreateMaybeMessage< ::fcp::dictionary::DictionaryDescription_SpecialIds >(Arena* arena) {
1315   return Arena::CreateMessageInternal< ::fcp::dictionary::DictionaryDescription_SpecialIds >(arena);
1316 }
1317 template<> PROTOBUF_NOINLINE ::fcp::dictionary::DictionaryDescription_OutputBlocklistIds*
CreateMaybeMessage(Arena * arena)1318 Arena::CreateMaybeMessage< ::fcp::dictionary::DictionaryDescription_OutputBlocklistIds >(Arena* arena) {
1319   return Arena::CreateMessageInternal< ::fcp::dictionary::DictionaryDescription_OutputBlocklistIds >(arena);
1320 }
1321 template<> PROTOBUF_NOINLINE ::fcp::dictionary::DictionaryDescription_Vocabulary_TokenIndex*
CreateMaybeMessage(Arena * arena)1322 Arena::CreateMaybeMessage< ::fcp::dictionary::DictionaryDescription_Vocabulary_TokenIndex >(Arena* arena) {
1323   return Arena::CreateMessageInternal< ::fcp::dictionary::DictionaryDescription_Vocabulary_TokenIndex >(arena);
1324 }
1325 template<> PROTOBUF_NOINLINE ::fcp::dictionary::DictionaryDescription_Vocabulary*
CreateMaybeMessage(Arena * arena)1326 Arena::CreateMaybeMessage< ::fcp::dictionary::DictionaryDescription_Vocabulary >(Arena* arena) {
1327   return Arena::CreateMessageInternal< ::fcp::dictionary::DictionaryDescription_Vocabulary >(arena);
1328 }
1329 template<> PROTOBUF_NOINLINE ::fcp::dictionary::DictionaryDescription*
CreateMaybeMessage(Arena * arena)1330 Arena::CreateMaybeMessage< ::fcp::dictionary::DictionaryDescription >(Arena* arena) {
1331   return Arena::CreateMessageInternal< ::fcp::dictionary::DictionaryDescription >(arena);
1332 }
1333 PROTOBUF_NAMESPACE_CLOSE
1334 
1335 // @@protoc_insertion_point(global_scope)
1336 #include <google/protobuf/port_undef.inc>
1337