1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: packages/modules/common/proto/sdk.proto
3 
4 #include "packages/modules/common/proto/sdk.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 
SdkVersion(::_pbi::ConstantInitialized)21 PROTOBUF_CONSTEXPR SdkVersion::SdkVersion(
22     ::_pbi::ConstantInitialized): _impl_{
23     /*decltype(_impl_.version_)*/0
24   , /*decltype(_impl_._cached_size_)*/{}} {}
25 struct SdkVersionDefaultTypeInternal {
SdkVersionDefaultTypeInternalSdkVersionDefaultTypeInternal26   PROTOBUF_CONSTEXPR SdkVersionDefaultTypeInternal()
27       : _instance(::_pbi::ConstantInitialized{}) {}
~SdkVersionDefaultTypeInternalSdkVersionDefaultTypeInternal28   ~SdkVersionDefaultTypeInternal() {}
29   union {  // NOLINT(misc-non-private-member-variables-in-classes)
30     SdkVersion _instance;
31   };
32 };
33 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SdkVersionDefaultTypeInternal _SdkVersion_default_instance_;
ExtensionVersion_ModuleRequirement(::_pbi::ConstantInitialized)34 PROTOBUF_CONSTEXPR ExtensionVersion_ModuleRequirement::ExtensionVersion_ModuleRequirement(
35     ::_pbi::ConstantInitialized): _impl_{
36     /*decltype(_impl_.version_)*/nullptr
37   , /*decltype(_impl_.module_)*/0
38   , /*decltype(_impl_._cached_size_)*/{}} {}
39 struct ExtensionVersion_ModuleRequirementDefaultTypeInternal {
ExtensionVersion_ModuleRequirementDefaultTypeInternalExtensionVersion_ModuleRequirementDefaultTypeInternal40   PROTOBUF_CONSTEXPR ExtensionVersion_ModuleRequirementDefaultTypeInternal()
41       : _instance(::_pbi::ConstantInitialized{}) {}
~ExtensionVersion_ModuleRequirementDefaultTypeInternalExtensionVersion_ModuleRequirementDefaultTypeInternal42   ~ExtensionVersion_ModuleRequirementDefaultTypeInternal() {}
43   union {  // NOLINT(misc-non-private-member-variables-in-classes)
44     ExtensionVersion_ModuleRequirement _instance;
45   };
46 };
47 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ExtensionVersion_ModuleRequirementDefaultTypeInternal _ExtensionVersion_ModuleRequirement_default_instance_;
ExtensionVersion(::_pbi::ConstantInitialized)48 PROTOBUF_CONSTEXPR ExtensionVersion::ExtensionVersion(
49     ::_pbi::ConstantInitialized): _impl_{
50     /*decltype(_impl_.requirements_)*/{}
51   , /*decltype(_impl_.version_)*/0
52   , /*decltype(_impl_._cached_size_)*/{}} {}
53 struct ExtensionVersionDefaultTypeInternal {
ExtensionVersionDefaultTypeInternalExtensionVersionDefaultTypeInternal54   PROTOBUF_CONSTEXPR ExtensionVersionDefaultTypeInternal()
55       : _instance(::_pbi::ConstantInitialized{}) {}
~ExtensionVersionDefaultTypeInternalExtensionVersionDefaultTypeInternal56   ~ExtensionVersionDefaultTypeInternal() {}
57   union {  // NOLINT(misc-non-private-member-variables-in-classes)
58     ExtensionVersion _instance;
59   };
60 };
61 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ExtensionVersionDefaultTypeInternal _ExtensionVersion_default_instance_;
ExtensionDatabase(::_pbi::ConstantInitialized)62 PROTOBUF_CONSTEXPR ExtensionDatabase::ExtensionDatabase(
63     ::_pbi::ConstantInitialized): _impl_{
64     /*decltype(_impl_.versions_)*/{}
65   , /*decltype(_impl_._cached_size_)*/{}} {}
66 struct ExtensionDatabaseDefaultTypeInternal {
ExtensionDatabaseDefaultTypeInternalExtensionDatabaseDefaultTypeInternal67   PROTOBUF_CONSTEXPR ExtensionDatabaseDefaultTypeInternal()
68       : _instance(::_pbi::ConstantInitialized{}) {}
~ExtensionDatabaseDefaultTypeInternalExtensionDatabaseDefaultTypeInternal69   ~ExtensionDatabaseDefaultTypeInternal() {}
70   union {  // NOLINT(misc-non-private-member-variables-in-classes)
71     ExtensionDatabase _instance;
72   };
73 };
74 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ExtensionDatabaseDefaultTypeInternal _ExtensionDatabase_default_instance_;
SdkModule_IsValid(int value)75 bool SdkModule_IsValid(int value) {
76   switch (value) {
77     case 0:
78     case 1:
79     case 2:
80     case 3:
81     case 4:
82     case 5:
83     case 6:
84     case 7:
85     case 8:
86     case 9:
87     case 10:
88     case 11:
89     case 12:
90     case 13:
91     case 14:
92     case 15:
93     case 16:
94       return true;
95     default:
96       return false;
97   }
98 }
99 
100 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> SdkModule_strings[17] = {};
101 
102 static const char SdkModule_names[] =
103   "AD_SERVICES"
104   "APPSEARCH"
105   "ART"
106   "CONFIG_INFRASTRUCTURE"
107   "CONSCRYPT"
108   "EXT_SERVICES"
109   "HEALTH_FITNESS"
110   "IPSEC"
111   "MEDIA"
112   "MEDIA_PROVIDER"
113   "ON_DEVICE_PERSONALIZATION"
114   "PERMISSIONS"
115   "SCHEDULING"
116   "SDK_EXTENSIONS"
117   "STATSD"
118   "TETHERING"
119   "UNKNOWN";
120 
121 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry SdkModule_entries[] = {
122   { {SdkModule_names + 0, 11}, 11 },
123   { {SdkModule_names + 11, 9}, 12 },
124   { {SdkModule_names + 20, 3}, 8 },
125   { {SdkModule_names + 23, 21}, 15 },
126   { {SdkModule_names + 44, 9}, 10 },
127   { {SdkModule_names + 53, 12}, 14 },
128   { {SdkModule_names + 65, 14}, 16 },
129   { {SdkModule_names + 79, 5}, 1 },
130   { {SdkModule_names + 84, 5}, 2 },
131   { {SdkModule_names + 89, 14}, 3 },
132   { {SdkModule_names + 103, 25}, 13 },
133   { {SdkModule_names + 128, 11}, 4 },
134   { {SdkModule_names + 139, 10}, 9 },
135   { {SdkModule_names + 149, 14}, 5 },
136   { {SdkModule_names + 163, 6}, 6 },
137   { {SdkModule_names + 169, 9}, 7 },
138   { {SdkModule_names + 178, 7}, 0 },
139 };
140 
141 static const int SdkModule_entries_by_number[] = {
142   16, // 0 -> UNKNOWN
143   7, // 1 -> IPSEC
144   8, // 2 -> MEDIA
145   9, // 3 -> MEDIA_PROVIDER
146   11, // 4 -> PERMISSIONS
147   13, // 5 -> SDK_EXTENSIONS
148   14, // 6 -> STATSD
149   15, // 7 -> TETHERING
150   2, // 8 -> ART
151   12, // 9 -> SCHEDULING
152   4, // 10 -> CONSCRYPT
153   0, // 11 -> AD_SERVICES
154   1, // 12 -> APPSEARCH
155   10, // 13 -> ON_DEVICE_PERSONALIZATION
156   5, // 14 -> EXT_SERVICES
157   3, // 15 -> CONFIG_INFRASTRUCTURE
158   6, // 16 -> HEALTH_FITNESS
159 };
160 
SdkModule_Name(SdkModule value)161 const std::string& SdkModule_Name(
162     SdkModule value) {
163   static const bool dummy =
164       ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
165           SdkModule_entries,
166           SdkModule_entries_by_number,
167           17, SdkModule_strings);
168   (void) dummy;
169   int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
170       SdkModule_entries,
171       SdkModule_entries_by_number,
172       17, value);
173   return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
174                      SdkModule_strings[idx].get();
175 }
SdkModule_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,SdkModule * value)176 bool SdkModule_Parse(
177     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SdkModule* value) {
178   int int_value;
179   bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
180       SdkModule_entries, 17, name, &int_value);
181   if (success) {
182     *value = static_cast<SdkModule>(int_value);
183   }
184   return success;
185 }
186 
187 // ===================================================================
188 
189 class SdkVersion::_Internal {
190  public:
191 };
192 
SdkVersion(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)193 SdkVersion::SdkVersion(::PROTOBUF_NAMESPACE_ID::Arena* arena,
194                          bool is_message_owned)
195   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
196   SharedCtor(arena, is_message_owned);
197   // @@protoc_insertion_point(arena_constructor:SdkVersion)
198 }
SdkVersion(const SdkVersion & from)199 SdkVersion::SdkVersion(const SdkVersion& from)
200   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
201   SdkVersion* const _this = this; (void)_this;
202   new (&_impl_) Impl_{
203       decltype(_impl_.version_){}
204     , /*decltype(_impl_._cached_size_)*/{}};
205 
206   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
207   _this->_impl_.version_ = from._impl_.version_;
208   // @@protoc_insertion_point(copy_constructor:SdkVersion)
209 }
210 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)211 inline void SdkVersion::SharedCtor(
212     ::_pb::Arena* arena, bool is_message_owned) {
213   (void)arena;
214   (void)is_message_owned;
215   new (&_impl_) Impl_{
216       decltype(_impl_.version_){0}
217     , /*decltype(_impl_._cached_size_)*/{}
218   };
219 }
220 
~SdkVersion()221 SdkVersion::~SdkVersion() {
222   // @@protoc_insertion_point(destructor:SdkVersion)
223   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
224   (void)arena;
225     return;
226   }
227   SharedDtor();
228 }
229 
SharedDtor()230 inline void SdkVersion::SharedDtor() {
231   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
232 }
233 
SetCachedSize(int size) const234 void SdkVersion::SetCachedSize(int size) const {
235   _impl_._cached_size_.Set(size);
236 }
237 
Clear()238 void SdkVersion::Clear() {
239 // @@protoc_insertion_point(message_clear_start:SdkVersion)
240   ::uint32_t cached_has_bits = 0;
241   // Prevent compiler warnings about cached_has_bits being unused
242   (void) cached_has_bits;
243 
244   _impl_.version_ = 0;
245   _internal_metadata_.Clear<std::string>();
246 }
247 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)248 const char* SdkVersion::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
249 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
250   while (!ctx->Done(&ptr)) {
251     ::uint32_t tag;
252     ptr = ::_pbi::ReadTag(ptr, &tag);
253     switch (tag >> 3) {
254       // int32 version = 1;
255       case 1:
256         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
257           _impl_.version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
258           CHK_(ptr);
259         } else {
260           goto handle_unusual;
261         }
262         continue;
263       default:
264         goto handle_unusual;
265     }  // switch
266   handle_unusual:
267     if ((tag == 0) || ((tag & 7) == 4)) {
268       CHK_(ptr);
269       ctx->SetLastTag(tag);
270       goto message_done;
271     }
272     ptr = UnknownFieldParse(
273         tag,
274         _internal_metadata_.mutable_unknown_fields<std::string>(),
275         ptr, ctx);
276     CHK_(ptr != nullptr);
277   }  // while
278 message_done:
279   return ptr;
280 failure:
281   ptr = nullptr;
282   goto message_done;
283 #undef CHK_
284 }
285 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const286 ::uint8_t* SdkVersion::_InternalSerialize(
287     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
288   // @@protoc_insertion_point(serialize_to_array_start:SdkVersion)
289   ::uint32_t cached_has_bits = 0;
290   (void) cached_has_bits;
291 
292   // int32 version = 1;
293   if (this->_internal_version() != 0) {
294     target = stream->EnsureSpace(target);
295     target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_version(), target);
296   }
297 
298   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
299     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
300         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
301   }
302   // @@protoc_insertion_point(serialize_to_array_end:SdkVersion)
303   return target;
304 }
305 
ByteSizeLong() const306 size_t SdkVersion::ByteSizeLong() const {
307 // @@protoc_insertion_point(message_byte_size_start:SdkVersion)
308   size_t total_size = 0;
309 
310   ::uint32_t cached_has_bits = 0;
311   // Prevent compiler warnings about cached_has_bits being unused
312   (void) cached_has_bits;
313 
314   // int32 version = 1;
315   if (this->_internal_version() != 0) {
316     total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_version());
317   }
318 
319   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
320     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
321   }
322   int cached_size = ::_pbi::ToCachedSize(total_size);
323   SetCachedSize(cached_size);
324   return total_size;
325 }
326 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)327 void SdkVersion::CheckTypeAndMergeFrom(
328     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
329   MergeFrom(*::_pbi::DownCast<const SdkVersion*>(
330       &from));
331 }
332 
MergeFrom(const SdkVersion & from)333 void SdkVersion::MergeFrom(const SdkVersion& from) {
334   SdkVersion* const _this = this;
335   // @@protoc_insertion_point(class_specific_merge_from_start:SdkVersion)
336   GOOGLE_DCHECK_NE(&from, _this);
337   ::uint32_t cached_has_bits = 0;
338   (void) cached_has_bits;
339 
340   if (from._internal_version() != 0) {
341     _this->_internal_set_version(from._internal_version());
342   }
343   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
344 }
345 
CopyFrom(const SdkVersion & from)346 void SdkVersion::CopyFrom(const SdkVersion& from) {
347 // @@protoc_insertion_point(class_specific_copy_from_start:SdkVersion)
348   if (&from == this) return;
349   Clear();
350   MergeFrom(from);
351 }
352 
IsInitialized() const353 bool SdkVersion::IsInitialized() const {
354   return true;
355 }
356 
InternalSwap(SdkVersion * other)357 void SdkVersion::InternalSwap(SdkVersion* other) {
358   using std::swap;
359   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
360   swap(_impl_.version_, other->_impl_.version_);
361 }
362 
GetTypeName() const363 std::string SdkVersion::GetTypeName() const {
364   return "SdkVersion";
365 }
366 
367 
368 // ===================================================================
369 
370 class ExtensionVersion_ModuleRequirement::_Internal {
371  public:
372   static const ::SdkVersion& version(const ExtensionVersion_ModuleRequirement* msg);
373 };
374 
375 const ::SdkVersion&
version(const ExtensionVersion_ModuleRequirement * msg)376 ExtensionVersion_ModuleRequirement::_Internal::version(const ExtensionVersion_ModuleRequirement* msg) {
377   return *msg->_impl_.version_;
378 }
ExtensionVersion_ModuleRequirement(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)379 ExtensionVersion_ModuleRequirement::ExtensionVersion_ModuleRequirement(::PROTOBUF_NAMESPACE_ID::Arena* arena,
380                          bool is_message_owned)
381   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
382   SharedCtor(arena, is_message_owned);
383   // @@protoc_insertion_point(arena_constructor:ExtensionVersion.ModuleRequirement)
384 }
ExtensionVersion_ModuleRequirement(const ExtensionVersion_ModuleRequirement & from)385 ExtensionVersion_ModuleRequirement::ExtensionVersion_ModuleRequirement(const ExtensionVersion_ModuleRequirement& from)
386   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
387   ExtensionVersion_ModuleRequirement* const _this = this; (void)_this;
388   new (&_impl_) Impl_{
389       decltype(_impl_.version_){nullptr}
390     , decltype(_impl_.module_){}
391     , /*decltype(_impl_._cached_size_)*/{}};
392 
393   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
394   if (from._internal_has_version()) {
395     _this->_impl_.version_ = new ::SdkVersion(*from._impl_.version_);
396   }
397   _this->_impl_.module_ = from._impl_.module_;
398   // @@protoc_insertion_point(copy_constructor:ExtensionVersion.ModuleRequirement)
399 }
400 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)401 inline void ExtensionVersion_ModuleRequirement::SharedCtor(
402     ::_pb::Arena* arena, bool is_message_owned) {
403   (void)arena;
404   (void)is_message_owned;
405   new (&_impl_) Impl_{
406       decltype(_impl_.version_){nullptr}
407     , decltype(_impl_.module_){0}
408     , /*decltype(_impl_._cached_size_)*/{}
409   };
410 }
411 
~ExtensionVersion_ModuleRequirement()412 ExtensionVersion_ModuleRequirement::~ExtensionVersion_ModuleRequirement() {
413   // @@protoc_insertion_point(destructor:ExtensionVersion.ModuleRequirement)
414   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
415   (void)arena;
416     return;
417   }
418   SharedDtor();
419 }
420 
SharedDtor()421 inline void ExtensionVersion_ModuleRequirement::SharedDtor() {
422   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
423   if (this != internal_default_instance()) delete _impl_.version_;
424 }
425 
SetCachedSize(int size) const426 void ExtensionVersion_ModuleRequirement::SetCachedSize(int size) const {
427   _impl_._cached_size_.Set(size);
428 }
429 
Clear()430 void ExtensionVersion_ModuleRequirement::Clear() {
431 // @@protoc_insertion_point(message_clear_start:ExtensionVersion.ModuleRequirement)
432   ::uint32_t cached_has_bits = 0;
433   // Prevent compiler warnings about cached_has_bits being unused
434   (void) cached_has_bits;
435 
436   if (GetArenaForAllocation() == nullptr && _impl_.version_ != nullptr) {
437     delete _impl_.version_;
438   }
439   _impl_.version_ = nullptr;
440   _impl_.module_ = 0;
441   _internal_metadata_.Clear<std::string>();
442 }
443 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)444 const char* ExtensionVersion_ModuleRequirement::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
445 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
446   while (!ctx->Done(&ptr)) {
447     ::uint32_t tag;
448     ptr = ::_pbi::ReadTag(ptr, &tag);
449     switch (tag >> 3) {
450       // .SdkModule module = 1;
451       case 1:
452         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
453           ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
454           CHK_(ptr);
455           _internal_set_module(static_cast<::SdkModule>(val));
456         } else {
457           goto handle_unusual;
458         }
459         continue;
460       // .SdkVersion version = 2;
461       case 2:
462         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
463           ptr = ctx->ParseMessage(_internal_mutable_version(), ptr);
464           CHK_(ptr);
465         } else {
466           goto handle_unusual;
467         }
468         continue;
469       default:
470         goto handle_unusual;
471     }  // switch
472   handle_unusual:
473     if ((tag == 0) || ((tag & 7) == 4)) {
474       CHK_(ptr);
475       ctx->SetLastTag(tag);
476       goto message_done;
477     }
478     ptr = UnknownFieldParse(
479         tag,
480         _internal_metadata_.mutable_unknown_fields<std::string>(),
481         ptr, ctx);
482     CHK_(ptr != nullptr);
483   }  // while
484 message_done:
485   return ptr;
486 failure:
487   ptr = nullptr;
488   goto message_done;
489 #undef CHK_
490 }
491 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const492 ::uint8_t* ExtensionVersion_ModuleRequirement::_InternalSerialize(
493     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
494   // @@protoc_insertion_point(serialize_to_array_start:ExtensionVersion.ModuleRequirement)
495   ::uint32_t cached_has_bits = 0;
496   (void) cached_has_bits;
497 
498   // .SdkModule module = 1;
499   if (this->_internal_module() != 0) {
500     target = stream->EnsureSpace(target);
501     target = ::_pbi::WireFormatLite::WriteEnumToArray(
502       1, this->_internal_module(), target);
503   }
504 
505   // .SdkVersion version = 2;
506   if (this->_internal_has_version()) {
507     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
508       InternalWriteMessage(2, _Internal::version(this),
509         _Internal::version(this).GetCachedSize(), target, stream);
510   }
511 
512   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
513     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
514         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
515   }
516   // @@protoc_insertion_point(serialize_to_array_end:ExtensionVersion.ModuleRequirement)
517   return target;
518 }
519 
ByteSizeLong() const520 size_t ExtensionVersion_ModuleRequirement::ByteSizeLong() const {
521 // @@protoc_insertion_point(message_byte_size_start:ExtensionVersion.ModuleRequirement)
522   size_t total_size = 0;
523 
524   ::uint32_t cached_has_bits = 0;
525   // Prevent compiler warnings about cached_has_bits being unused
526   (void) cached_has_bits;
527 
528   // .SdkVersion version = 2;
529   if (this->_internal_has_version()) {
530     total_size += 1 +
531       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
532         *_impl_.version_);
533   }
534 
535   // .SdkModule module = 1;
536   if (this->_internal_module() != 0) {
537     total_size += 1 +
538       ::_pbi::WireFormatLite::EnumSize(this->_internal_module());
539   }
540 
541   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
542     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
543   }
544   int cached_size = ::_pbi::ToCachedSize(total_size);
545   SetCachedSize(cached_size);
546   return total_size;
547 }
548 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)549 void ExtensionVersion_ModuleRequirement::CheckTypeAndMergeFrom(
550     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
551   MergeFrom(*::_pbi::DownCast<const ExtensionVersion_ModuleRequirement*>(
552       &from));
553 }
554 
MergeFrom(const ExtensionVersion_ModuleRequirement & from)555 void ExtensionVersion_ModuleRequirement::MergeFrom(const ExtensionVersion_ModuleRequirement& from) {
556   ExtensionVersion_ModuleRequirement* const _this = this;
557   // @@protoc_insertion_point(class_specific_merge_from_start:ExtensionVersion.ModuleRequirement)
558   GOOGLE_DCHECK_NE(&from, _this);
559   ::uint32_t cached_has_bits = 0;
560   (void) cached_has_bits;
561 
562   if (from._internal_has_version()) {
563     _this->_internal_mutable_version()->::SdkVersion::MergeFrom(
564         from._internal_version());
565   }
566   if (from._internal_module() != 0) {
567     _this->_internal_set_module(from._internal_module());
568   }
569   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
570 }
571 
CopyFrom(const ExtensionVersion_ModuleRequirement & from)572 void ExtensionVersion_ModuleRequirement::CopyFrom(const ExtensionVersion_ModuleRequirement& from) {
573 // @@protoc_insertion_point(class_specific_copy_from_start:ExtensionVersion.ModuleRequirement)
574   if (&from == this) return;
575   Clear();
576   MergeFrom(from);
577 }
578 
IsInitialized() const579 bool ExtensionVersion_ModuleRequirement::IsInitialized() const {
580   return true;
581 }
582 
InternalSwap(ExtensionVersion_ModuleRequirement * other)583 void ExtensionVersion_ModuleRequirement::InternalSwap(ExtensionVersion_ModuleRequirement* other) {
584   using std::swap;
585   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
586   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
587       PROTOBUF_FIELD_OFFSET(ExtensionVersion_ModuleRequirement, _impl_.module_)
588       + sizeof(ExtensionVersion_ModuleRequirement::_impl_.module_)  // NOLINT
589       - PROTOBUF_FIELD_OFFSET(ExtensionVersion_ModuleRequirement, _impl_.version_)>(
590           reinterpret_cast<char*>(&_impl_.version_),
591           reinterpret_cast<char*>(&other->_impl_.version_));
592 }
593 
GetTypeName() const594 std::string ExtensionVersion_ModuleRequirement::GetTypeName() const {
595   return "ExtensionVersion.ModuleRequirement";
596 }
597 
598 
599 // ===================================================================
600 
601 class ExtensionVersion::_Internal {
602  public:
603 };
604 
ExtensionVersion(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)605 ExtensionVersion::ExtensionVersion(::PROTOBUF_NAMESPACE_ID::Arena* arena,
606                          bool is_message_owned)
607   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
608   SharedCtor(arena, is_message_owned);
609   // @@protoc_insertion_point(arena_constructor:ExtensionVersion)
610 }
ExtensionVersion(const ExtensionVersion & from)611 ExtensionVersion::ExtensionVersion(const ExtensionVersion& from)
612   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
613   ExtensionVersion* const _this = this; (void)_this;
614   new (&_impl_) Impl_{
615       decltype(_impl_.requirements_){from._impl_.requirements_}
616     , decltype(_impl_.version_){}
617     , /*decltype(_impl_._cached_size_)*/{}};
618 
619   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
620   _this->_impl_.version_ = from._impl_.version_;
621   // @@protoc_insertion_point(copy_constructor:ExtensionVersion)
622 }
623 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)624 inline void ExtensionVersion::SharedCtor(
625     ::_pb::Arena* arena, bool is_message_owned) {
626   (void)arena;
627   (void)is_message_owned;
628   new (&_impl_) Impl_{
629       decltype(_impl_.requirements_){arena}
630     , decltype(_impl_.version_){0}
631     , /*decltype(_impl_._cached_size_)*/{}
632   };
633 }
634 
~ExtensionVersion()635 ExtensionVersion::~ExtensionVersion() {
636   // @@protoc_insertion_point(destructor:ExtensionVersion)
637   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
638   (void)arena;
639     return;
640   }
641   SharedDtor();
642 }
643 
SharedDtor()644 inline void ExtensionVersion::SharedDtor() {
645   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
646   _impl_.requirements_.~RepeatedPtrField();
647 }
648 
SetCachedSize(int size) const649 void ExtensionVersion::SetCachedSize(int size) const {
650   _impl_._cached_size_.Set(size);
651 }
652 
Clear()653 void ExtensionVersion::Clear() {
654 // @@protoc_insertion_point(message_clear_start:ExtensionVersion)
655   ::uint32_t cached_has_bits = 0;
656   // Prevent compiler warnings about cached_has_bits being unused
657   (void) cached_has_bits;
658 
659   _impl_.requirements_.Clear();
660   _impl_.version_ = 0;
661   _internal_metadata_.Clear<std::string>();
662 }
663 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)664 const char* ExtensionVersion::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
665 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
666   while (!ctx->Done(&ptr)) {
667     ::uint32_t tag;
668     ptr = ::_pbi::ReadTag(ptr, &tag);
669     switch (tag >> 3) {
670       // int32 version = 1;
671       case 1:
672         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
673           _impl_.version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
674           CHK_(ptr);
675         } else {
676           goto handle_unusual;
677         }
678         continue;
679       // repeated .ExtensionVersion.ModuleRequirement requirements = 2;
680       case 2:
681         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
682           ptr -= 1;
683           do {
684             ptr += 1;
685             ptr = ctx->ParseMessage(_internal_add_requirements(), ptr);
686             CHK_(ptr);
687             if (!ctx->DataAvailable(ptr)) break;
688           } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
689         } else {
690           goto handle_unusual;
691         }
692         continue;
693       default:
694         goto handle_unusual;
695     }  // switch
696   handle_unusual:
697     if ((tag == 0) || ((tag & 7) == 4)) {
698       CHK_(ptr);
699       ctx->SetLastTag(tag);
700       goto message_done;
701     }
702     ptr = UnknownFieldParse(
703         tag,
704         _internal_metadata_.mutable_unknown_fields<std::string>(),
705         ptr, ctx);
706     CHK_(ptr != nullptr);
707   }  // while
708 message_done:
709   return ptr;
710 failure:
711   ptr = nullptr;
712   goto message_done;
713 #undef CHK_
714 }
715 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const716 ::uint8_t* ExtensionVersion::_InternalSerialize(
717     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
718   // @@protoc_insertion_point(serialize_to_array_start:ExtensionVersion)
719   ::uint32_t cached_has_bits = 0;
720   (void) cached_has_bits;
721 
722   // int32 version = 1;
723   if (this->_internal_version() != 0) {
724     target = stream->EnsureSpace(target);
725     target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_version(), target);
726   }
727 
728   // repeated .ExtensionVersion.ModuleRequirement requirements = 2;
729   for (unsigned i = 0,
730       n = static_cast<unsigned>(this->_internal_requirements_size()); i < n; i++) {
731     const auto& repfield = this->_internal_requirements(i);
732     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
733         InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream);
734   }
735 
736   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
737     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
738         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
739   }
740   // @@protoc_insertion_point(serialize_to_array_end:ExtensionVersion)
741   return target;
742 }
743 
ByteSizeLong() const744 size_t ExtensionVersion::ByteSizeLong() const {
745 // @@protoc_insertion_point(message_byte_size_start:ExtensionVersion)
746   size_t total_size = 0;
747 
748   ::uint32_t cached_has_bits = 0;
749   // Prevent compiler warnings about cached_has_bits being unused
750   (void) cached_has_bits;
751 
752   // repeated .ExtensionVersion.ModuleRequirement requirements = 2;
753   total_size += 1UL * this->_internal_requirements_size();
754   for (const auto& msg : this->_impl_.requirements_) {
755     total_size +=
756       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
757   }
758 
759   // int32 version = 1;
760   if (this->_internal_version() != 0) {
761     total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_version());
762   }
763 
764   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
765     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
766   }
767   int cached_size = ::_pbi::ToCachedSize(total_size);
768   SetCachedSize(cached_size);
769   return total_size;
770 }
771 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)772 void ExtensionVersion::CheckTypeAndMergeFrom(
773     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
774   MergeFrom(*::_pbi::DownCast<const ExtensionVersion*>(
775       &from));
776 }
777 
MergeFrom(const ExtensionVersion & from)778 void ExtensionVersion::MergeFrom(const ExtensionVersion& from) {
779   ExtensionVersion* const _this = this;
780   // @@protoc_insertion_point(class_specific_merge_from_start:ExtensionVersion)
781   GOOGLE_DCHECK_NE(&from, _this);
782   ::uint32_t cached_has_bits = 0;
783   (void) cached_has_bits;
784 
785   _this->_impl_.requirements_.MergeFrom(from._impl_.requirements_);
786   if (from._internal_version() != 0) {
787     _this->_internal_set_version(from._internal_version());
788   }
789   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
790 }
791 
CopyFrom(const ExtensionVersion & from)792 void ExtensionVersion::CopyFrom(const ExtensionVersion& from) {
793 // @@protoc_insertion_point(class_specific_copy_from_start:ExtensionVersion)
794   if (&from == this) return;
795   Clear();
796   MergeFrom(from);
797 }
798 
IsInitialized() const799 bool ExtensionVersion::IsInitialized() const {
800   return true;
801 }
802 
InternalSwap(ExtensionVersion * other)803 void ExtensionVersion::InternalSwap(ExtensionVersion* other) {
804   using std::swap;
805   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
806   _impl_.requirements_.InternalSwap(&other->_impl_.requirements_);
807   swap(_impl_.version_, other->_impl_.version_);
808 }
809 
GetTypeName() const810 std::string ExtensionVersion::GetTypeName() const {
811   return "ExtensionVersion";
812 }
813 
814 
815 // ===================================================================
816 
817 class ExtensionDatabase::_Internal {
818  public:
819 };
820 
ExtensionDatabase(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)821 ExtensionDatabase::ExtensionDatabase(::PROTOBUF_NAMESPACE_ID::Arena* arena,
822                          bool is_message_owned)
823   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
824   SharedCtor(arena, is_message_owned);
825   // @@protoc_insertion_point(arena_constructor:ExtensionDatabase)
826 }
ExtensionDatabase(const ExtensionDatabase & from)827 ExtensionDatabase::ExtensionDatabase(const ExtensionDatabase& from)
828   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
829   ExtensionDatabase* const _this = this; (void)_this;
830   new (&_impl_) Impl_{
831       decltype(_impl_.versions_){from._impl_.versions_}
832     , /*decltype(_impl_._cached_size_)*/{}};
833 
834   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
835   // @@protoc_insertion_point(copy_constructor:ExtensionDatabase)
836 }
837 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)838 inline void ExtensionDatabase::SharedCtor(
839     ::_pb::Arena* arena, bool is_message_owned) {
840   (void)arena;
841   (void)is_message_owned;
842   new (&_impl_) Impl_{
843       decltype(_impl_.versions_){arena}
844     , /*decltype(_impl_._cached_size_)*/{}
845   };
846 }
847 
~ExtensionDatabase()848 ExtensionDatabase::~ExtensionDatabase() {
849   // @@protoc_insertion_point(destructor:ExtensionDatabase)
850   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
851   (void)arena;
852     return;
853   }
854   SharedDtor();
855 }
856 
SharedDtor()857 inline void ExtensionDatabase::SharedDtor() {
858   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
859   _impl_.versions_.~RepeatedPtrField();
860 }
861 
SetCachedSize(int size) const862 void ExtensionDatabase::SetCachedSize(int size) const {
863   _impl_._cached_size_.Set(size);
864 }
865 
Clear()866 void ExtensionDatabase::Clear() {
867 // @@protoc_insertion_point(message_clear_start:ExtensionDatabase)
868   ::uint32_t cached_has_bits = 0;
869   // Prevent compiler warnings about cached_has_bits being unused
870   (void) cached_has_bits;
871 
872   _impl_.versions_.Clear();
873   _internal_metadata_.Clear<std::string>();
874 }
875 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)876 const char* ExtensionDatabase::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
877 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
878   while (!ctx->Done(&ptr)) {
879     ::uint32_t tag;
880     ptr = ::_pbi::ReadTag(ptr, &tag);
881     switch (tag >> 3) {
882       // repeated .ExtensionVersion versions = 1;
883       case 1:
884         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
885           ptr -= 1;
886           do {
887             ptr += 1;
888             ptr = ctx->ParseMessage(_internal_add_versions(), ptr);
889             CHK_(ptr);
890             if (!ctx->DataAvailable(ptr)) break;
891           } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
892         } else {
893           goto handle_unusual;
894         }
895         continue;
896       default:
897         goto handle_unusual;
898     }  // switch
899   handle_unusual:
900     if ((tag == 0) || ((tag & 7) == 4)) {
901       CHK_(ptr);
902       ctx->SetLastTag(tag);
903       goto message_done;
904     }
905     ptr = UnknownFieldParse(
906         tag,
907         _internal_metadata_.mutable_unknown_fields<std::string>(),
908         ptr, ctx);
909     CHK_(ptr != nullptr);
910   }  // while
911 message_done:
912   return ptr;
913 failure:
914   ptr = nullptr;
915   goto message_done;
916 #undef CHK_
917 }
918 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const919 ::uint8_t* ExtensionDatabase::_InternalSerialize(
920     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
921   // @@protoc_insertion_point(serialize_to_array_start:ExtensionDatabase)
922   ::uint32_t cached_has_bits = 0;
923   (void) cached_has_bits;
924 
925   // repeated .ExtensionVersion versions = 1;
926   for (unsigned i = 0,
927       n = static_cast<unsigned>(this->_internal_versions_size()); i < n; i++) {
928     const auto& repfield = this->_internal_versions(i);
929     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
930         InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
931   }
932 
933   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
934     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
935         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
936   }
937   // @@protoc_insertion_point(serialize_to_array_end:ExtensionDatabase)
938   return target;
939 }
940 
ByteSizeLong() const941 size_t ExtensionDatabase::ByteSizeLong() const {
942 // @@protoc_insertion_point(message_byte_size_start:ExtensionDatabase)
943   size_t total_size = 0;
944 
945   ::uint32_t cached_has_bits = 0;
946   // Prevent compiler warnings about cached_has_bits being unused
947   (void) cached_has_bits;
948 
949   // repeated .ExtensionVersion versions = 1;
950   total_size += 1UL * this->_internal_versions_size();
951   for (const auto& msg : this->_impl_.versions_) {
952     total_size +=
953       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
954   }
955 
956   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
957     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
958   }
959   int cached_size = ::_pbi::ToCachedSize(total_size);
960   SetCachedSize(cached_size);
961   return total_size;
962 }
963 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)964 void ExtensionDatabase::CheckTypeAndMergeFrom(
965     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
966   MergeFrom(*::_pbi::DownCast<const ExtensionDatabase*>(
967       &from));
968 }
969 
MergeFrom(const ExtensionDatabase & from)970 void ExtensionDatabase::MergeFrom(const ExtensionDatabase& from) {
971   ExtensionDatabase* const _this = this;
972   // @@protoc_insertion_point(class_specific_merge_from_start:ExtensionDatabase)
973   GOOGLE_DCHECK_NE(&from, _this);
974   ::uint32_t cached_has_bits = 0;
975   (void) cached_has_bits;
976 
977   _this->_impl_.versions_.MergeFrom(from._impl_.versions_);
978   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
979 }
980 
CopyFrom(const ExtensionDatabase & from)981 void ExtensionDatabase::CopyFrom(const ExtensionDatabase& from) {
982 // @@protoc_insertion_point(class_specific_copy_from_start:ExtensionDatabase)
983   if (&from == this) return;
984   Clear();
985   MergeFrom(from);
986 }
987 
IsInitialized() const988 bool ExtensionDatabase::IsInitialized() const {
989   return true;
990 }
991 
InternalSwap(ExtensionDatabase * other)992 void ExtensionDatabase::InternalSwap(ExtensionDatabase* other) {
993   using std::swap;
994   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
995   _impl_.versions_.InternalSwap(&other->_impl_.versions_);
996 }
997 
GetTypeName() const998 std::string ExtensionDatabase::GetTypeName() const {
999   return "ExtensionDatabase";
1000 }
1001 
1002 
1003 // @@protoc_insertion_point(namespace_scope)
1004 PROTOBUF_NAMESPACE_OPEN
1005 template<> PROTOBUF_NOINLINE ::SdkVersion*
CreateMaybeMessage(Arena * arena)1006 Arena::CreateMaybeMessage< ::SdkVersion >(Arena* arena) {
1007   return Arena::CreateMessageInternal< ::SdkVersion >(arena);
1008 }
1009 template<> PROTOBUF_NOINLINE ::ExtensionVersion_ModuleRequirement*
CreateMaybeMessage(Arena * arena)1010 Arena::CreateMaybeMessage< ::ExtensionVersion_ModuleRequirement >(Arena* arena) {
1011   return Arena::CreateMessageInternal< ::ExtensionVersion_ModuleRequirement >(arena);
1012 }
1013 template<> PROTOBUF_NOINLINE ::ExtensionVersion*
CreateMaybeMessage(Arena * arena)1014 Arena::CreateMaybeMessage< ::ExtensionVersion >(Arena* arena) {
1015   return Arena::CreateMessageInternal< ::ExtensionVersion >(arena);
1016 }
1017 template<> PROTOBUF_NOINLINE ::ExtensionDatabase*
CreateMaybeMessage(Arena * arena)1018 Arena::CreateMaybeMessage< ::ExtensionDatabase >(Arena* arena) {
1019   return Arena::CreateMessageInternal< ::ExtensionDatabase >(arena);
1020 }
1021 PROTOBUF_NAMESPACE_CLOSE
1022 
1023 // @@protoc_insertion_point(global_scope)
1024 #include <google/protobuf/port_undef.inc>
1025