1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: protos/perfetto/trace/ftrace/sock.proto
3
4 #include "protos/perfetto/trace/ftrace/sock.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 perfetto {
22 namespace protos {
InetSockSetStateFtraceEvent(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR InetSockSetStateFtraceEvent::InetSockSetStateFtraceEvent(
24 ::_pbi::ConstantInitialized): _impl_{
25 /*decltype(_impl_._has_bits_)*/{}
26 , /*decltype(_impl_._cached_size_)*/{}
27 , /*decltype(_impl_.daddr_)*/0u
28 , /*decltype(_impl_.dport_)*/0u
29 , /*decltype(_impl_.family_)*/0u
30 , /*decltype(_impl_.newstate_)*/0
31 , /*decltype(_impl_.oldstate_)*/0
32 , /*decltype(_impl_.protocol_)*/0u
33 , /*decltype(_impl_.skaddr_)*/::uint64_t{0u}
34 , /*decltype(_impl_.saddr_)*/0u
35 , /*decltype(_impl_.sport_)*/0u} {}
36 struct InetSockSetStateFtraceEventDefaultTypeInternal {
InetSockSetStateFtraceEventDefaultTypeInternalperfetto::protos::InetSockSetStateFtraceEventDefaultTypeInternal37 PROTOBUF_CONSTEXPR InetSockSetStateFtraceEventDefaultTypeInternal()
38 : _instance(::_pbi::ConstantInitialized{}) {}
~InetSockSetStateFtraceEventDefaultTypeInternalperfetto::protos::InetSockSetStateFtraceEventDefaultTypeInternal39 ~InetSockSetStateFtraceEventDefaultTypeInternal() {}
40 union { // NOLINT(misc-non-private-member-variables-in-classes)
41 InetSockSetStateFtraceEvent _instance;
42 };
43 };
44 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 InetSockSetStateFtraceEventDefaultTypeInternal _InetSockSetStateFtraceEvent_default_instance_;
45 } // namespace protos
46 } // namespace perfetto
47 namespace perfetto {
48 namespace protos {
49
50 // ===================================================================
51
52 class InetSockSetStateFtraceEvent::_Internal {
53 public:
54 using HasBits = decltype(std::declval<InetSockSetStateFtraceEvent>()._impl_._has_bits_);
set_has_daddr(HasBits * has_bits)55 static void set_has_daddr(HasBits* has_bits) {
56 (*has_bits)[0] |= 1u;
57 }
set_has_dport(HasBits * has_bits)58 static void set_has_dport(HasBits* has_bits) {
59 (*has_bits)[0] |= 2u;
60 }
set_has_family(HasBits * has_bits)61 static void set_has_family(HasBits* has_bits) {
62 (*has_bits)[0] |= 4u;
63 }
set_has_newstate(HasBits * has_bits)64 static void set_has_newstate(HasBits* has_bits) {
65 (*has_bits)[0] |= 8u;
66 }
set_has_oldstate(HasBits * has_bits)67 static void set_has_oldstate(HasBits* has_bits) {
68 (*has_bits)[0] |= 16u;
69 }
set_has_protocol(HasBits * has_bits)70 static void set_has_protocol(HasBits* has_bits) {
71 (*has_bits)[0] |= 32u;
72 }
set_has_saddr(HasBits * has_bits)73 static void set_has_saddr(HasBits* has_bits) {
74 (*has_bits)[0] |= 128u;
75 }
set_has_skaddr(HasBits * has_bits)76 static void set_has_skaddr(HasBits* has_bits) {
77 (*has_bits)[0] |= 64u;
78 }
set_has_sport(HasBits * has_bits)79 static void set_has_sport(HasBits* has_bits) {
80 (*has_bits)[0] |= 256u;
81 }
82 };
83
InetSockSetStateFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)84 InetSockSetStateFtraceEvent::InetSockSetStateFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
85 bool is_message_owned)
86 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
87 SharedCtor(arena, is_message_owned);
88 // @@protoc_insertion_point(arena_constructor:perfetto.protos.InetSockSetStateFtraceEvent)
89 }
InetSockSetStateFtraceEvent(const InetSockSetStateFtraceEvent & from)90 InetSockSetStateFtraceEvent::InetSockSetStateFtraceEvent(const InetSockSetStateFtraceEvent& from)
91 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
92 InetSockSetStateFtraceEvent* const _this = this; (void)_this;
93 new (&_impl_) Impl_{
94 decltype(_impl_._has_bits_){from._impl_._has_bits_}
95 , /*decltype(_impl_._cached_size_)*/{}
96 , decltype(_impl_.daddr_){}
97 , decltype(_impl_.dport_){}
98 , decltype(_impl_.family_){}
99 , decltype(_impl_.newstate_){}
100 , decltype(_impl_.oldstate_){}
101 , decltype(_impl_.protocol_){}
102 , decltype(_impl_.skaddr_){}
103 , decltype(_impl_.saddr_){}
104 , decltype(_impl_.sport_){}};
105
106 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
107 ::memcpy(&_impl_.daddr_, &from._impl_.daddr_,
108 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.sport_) -
109 reinterpret_cast<char*>(&_impl_.daddr_)) + sizeof(_impl_.sport_));
110 // @@protoc_insertion_point(copy_constructor:perfetto.protos.InetSockSetStateFtraceEvent)
111 }
112
SharedCtor(::_pb::Arena * arena,bool is_message_owned)113 inline void InetSockSetStateFtraceEvent::SharedCtor(
114 ::_pb::Arena* arena, bool is_message_owned) {
115 (void)arena;
116 (void)is_message_owned;
117 new (&_impl_) Impl_{
118 decltype(_impl_._has_bits_){}
119 , /*decltype(_impl_._cached_size_)*/{}
120 , decltype(_impl_.daddr_){0u}
121 , decltype(_impl_.dport_){0u}
122 , decltype(_impl_.family_){0u}
123 , decltype(_impl_.newstate_){0}
124 , decltype(_impl_.oldstate_){0}
125 , decltype(_impl_.protocol_){0u}
126 , decltype(_impl_.skaddr_){::uint64_t{0u}}
127 , decltype(_impl_.saddr_){0u}
128 , decltype(_impl_.sport_){0u}
129 };
130 }
131
~InetSockSetStateFtraceEvent()132 InetSockSetStateFtraceEvent::~InetSockSetStateFtraceEvent() {
133 // @@protoc_insertion_point(destructor:perfetto.protos.InetSockSetStateFtraceEvent)
134 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
135 (void)arena;
136 return;
137 }
138 SharedDtor();
139 }
140
SharedDtor()141 inline void InetSockSetStateFtraceEvent::SharedDtor() {
142 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
143 }
144
SetCachedSize(int size) const145 void InetSockSetStateFtraceEvent::SetCachedSize(int size) const {
146 _impl_._cached_size_.Set(size);
147 }
148
Clear()149 void InetSockSetStateFtraceEvent::Clear() {
150 // @@protoc_insertion_point(message_clear_start:perfetto.protos.InetSockSetStateFtraceEvent)
151 ::uint32_t cached_has_bits = 0;
152 // Prevent compiler warnings about cached_has_bits being unused
153 (void) cached_has_bits;
154
155 cached_has_bits = _impl_._has_bits_[0];
156 if (cached_has_bits & 0x000000ffu) {
157 ::memset(&_impl_.daddr_, 0, static_cast<size_t>(
158 reinterpret_cast<char*>(&_impl_.saddr_) -
159 reinterpret_cast<char*>(&_impl_.daddr_)) + sizeof(_impl_.saddr_));
160 }
161 _impl_.sport_ = 0u;
162 _impl_._has_bits_.Clear();
163 _internal_metadata_.Clear<std::string>();
164 }
165
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)166 const char* InetSockSetStateFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
167 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
168 _Internal::HasBits has_bits{};
169 while (!ctx->Done(&ptr)) {
170 ::uint32_t tag;
171 ptr = ::_pbi::ReadTag(ptr, &tag);
172 switch (tag >> 3) {
173 // optional uint32 daddr = 1;
174 case 1:
175 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
176 _Internal::set_has_daddr(&has_bits);
177 _impl_.daddr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
178 CHK_(ptr);
179 } else {
180 goto handle_unusual;
181 }
182 continue;
183 // optional uint32 dport = 2;
184 case 2:
185 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
186 _Internal::set_has_dport(&has_bits);
187 _impl_.dport_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
188 CHK_(ptr);
189 } else {
190 goto handle_unusual;
191 }
192 continue;
193 // optional uint32 family = 3;
194 case 3:
195 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
196 _Internal::set_has_family(&has_bits);
197 _impl_.family_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
198 CHK_(ptr);
199 } else {
200 goto handle_unusual;
201 }
202 continue;
203 // optional int32 newstate = 4;
204 case 4:
205 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
206 _Internal::set_has_newstate(&has_bits);
207 _impl_.newstate_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
208 CHK_(ptr);
209 } else {
210 goto handle_unusual;
211 }
212 continue;
213 // optional int32 oldstate = 5;
214 case 5:
215 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
216 _Internal::set_has_oldstate(&has_bits);
217 _impl_.oldstate_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
218 CHK_(ptr);
219 } else {
220 goto handle_unusual;
221 }
222 continue;
223 // optional uint32 protocol = 6;
224 case 6:
225 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
226 _Internal::set_has_protocol(&has_bits);
227 _impl_.protocol_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
228 CHK_(ptr);
229 } else {
230 goto handle_unusual;
231 }
232 continue;
233 // optional uint32 saddr = 7;
234 case 7:
235 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
236 _Internal::set_has_saddr(&has_bits);
237 _impl_.saddr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
238 CHK_(ptr);
239 } else {
240 goto handle_unusual;
241 }
242 continue;
243 // optional uint64 skaddr = 8;
244 case 8:
245 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 64)) {
246 _Internal::set_has_skaddr(&has_bits);
247 _impl_.skaddr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
248 CHK_(ptr);
249 } else {
250 goto handle_unusual;
251 }
252 continue;
253 // optional uint32 sport = 9;
254 case 9:
255 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 72)) {
256 _Internal::set_has_sport(&has_bits);
257 _impl_.sport_ = ::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 _impl_._has_bits_.Or(has_bits);
280 return ptr;
281 failure:
282 ptr = nullptr;
283 goto message_done;
284 #undef CHK_
285 }
286
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const287 ::uint8_t* InetSockSetStateFtraceEvent::_InternalSerialize(
288 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
289 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.InetSockSetStateFtraceEvent)
290 ::uint32_t cached_has_bits = 0;
291 (void) cached_has_bits;
292
293 cached_has_bits = _impl_._has_bits_[0];
294 // optional uint32 daddr = 1;
295 if (cached_has_bits & 0x00000001u) {
296 target = stream->EnsureSpace(target);
297 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_daddr(), target);
298 }
299
300 // optional uint32 dport = 2;
301 if (cached_has_bits & 0x00000002u) {
302 target = stream->EnsureSpace(target);
303 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_dport(), target);
304 }
305
306 // optional uint32 family = 3;
307 if (cached_has_bits & 0x00000004u) {
308 target = stream->EnsureSpace(target);
309 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_family(), target);
310 }
311
312 // optional int32 newstate = 4;
313 if (cached_has_bits & 0x00000008u) {
314 target = stream->EnsureSpace(target);
315 target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_newstate(), target);
316 }
317
318 // optional int32 oldstate = 5;
319 if (cached_has_bits & 0x00000010u) {
320 target = stream->EnsureSpace(target);
321 target = ::_pbi::WireFormatLite::WriteInt32ToArray(5, this->_internal_oldstate(), target);
322 }
323
324 // optional uint32 protocol = 6;
325 if (cached_has_bits & 0x00000020u) {
326 target = stream->EnsureSpace(target);
327 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_protocol(), target);
328 }
329
330 // optional uint32 saddr = 7;
331 if (cached_has_bits & 0x00000080u) {
332 target = stream->EnsureSpace(target);
333 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(7, this->_internal_saddr(), target);
334 }
335
336 // optional uint64 skaddr = 8;
337 if (cached_has_bits & 0x00000040u) {
338 target = stream->EnsureSpace(target);
339 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(8, this->_internal_skaddr(), target);
340 }
341
342 // optional uint32 sport = 9;
343 if (cached_has_bits & 0x00000100u) {
344 target = stream->EnsureSpace(target);
345 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(9, this->_internal_sport(), target);
346 }
347
348 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
349 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
350 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
351 }
352 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.InetSockSetStateFtraceEvent)
353 return target;
354 }
355
ByteSizeLong() const356 size_t InetSockSetStateFtraceEvent::ByteSizeLong() const {
357 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.InetSockSetStateFtraceEvent)
358 size_t total_size = 0;
359
360 ::uint32_t cached_has_bits = 0;
361 // Prevent compiler warnings about cached_has_bits being unused
362 (void) cached_has_bits;
363
364 cached_has_bits = _impl_._has_bits_[0];
365 if (cached_has_bits & 0x000000ffu) {
366 // optional uint32 daddr = 1;
367 if (cached_has_bits & 0x00000001u) {
368 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_daddr());
369 }
370
371 // optional uint32 dport = 2;
372 if (cached_has_bits & 0x00000002u) {
373 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_dport());
374 }
375
376 // optional uint32 family = 3;
377 if (cached_has_bits & 0x00000004u) {
378 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_family());
379 }
380
381 // optional int32 newstate = 4;
382 if (cached_has_bits & 0x00000008u) {
383 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_newstate());
384 }
385
386 // optional int32 oldstate = 5;
387 if (cached_has_bits & 0x00000010u) {
388 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_oldstate());
389 }
390
391 // optional uint32 protocol = 6;
392 if (cached_has_bits & 0x00000020u) {
393 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_protocol());
394 }
395
396 // optional uint64 skaddr = 8;
397 if (cached_has_bits & 0x00000040u) {
398 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_skaddr());
399 }
400
401 // optional uint32 saddr = 7;
402 if (cached_has_bits & 0x00000080u) {
403 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_saddr());
404 }
405
406 }
407 // optional uint32 sport = 9;
408 if (cached_has_bits & 0x00000100u) {
409 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_sport());
410 }
411
412 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
413 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
414 }
415 int cached_size = ::_pbi::ToCachedSize(total_size);
416 SetCachedSize(cached_size);
417 return total_size;
418 }
419
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)420 void InetSockSetStateFtraceEvent::CheckTypeAndMergeFrom(
421 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
422 MergeFrom(*::_pbi::DownCast<const InetSockSetStateFtraceEvent*>(
423 &from));
424 }
425
MergeFrom(const InetSockSetStateFtraceEvent & from)426 void InetSockSetStateFtraceEvent::MergeFrom(const InetSockSetStateFtraceEvent& from) {
427 InetSockSetStateFtraceEvent* const _this = this;
428 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.InetSockSetStateFtraceEvent)
429 GOOGLE_DCHECK_NE(&from, _this);
430 ::uint32_t cached_has_bits = 0;
431 (void) cached_has_bits;
432
433 cached_has_bits = from._impl_._has_bits_[0];
434 if (cached_has_bits & 0x000000ffu) {
435 if (cached_has_bits & 0x00000001u) {
436 _this->_impl_.daddr_ = from._impl_.daddr_;
437 }
438 if (cached_has_bits & 0x00000002u) {
439 _this->_impl_.dport_ = from._impl_.dport_;
440 }
441 if (cached_has_bits & 0x00000004u) {
442 _this->_impl_.family_ = from._impl_.family_;
443 }
444 if (cached_has_bits & 0x00000008u) {
445 _this->_impl_.newstate_ = from._impl_.newstate_;
446 }
447 if (cached_has_bits & 0x00000010u) {
448 _this->_impl_.oldstate_ = from._impl_.oldstate_;
449 }
450 if (cached_has_bits & 0x00000020u) {
451 _this->_impl_.protocol_ = from._impl_.protocol_;
452 }
453 if (cached_has_bits & 0x00000040u) {
454 _this->_impl_.skaddr_ = from._impl_.skaddr_;
455 }
456 if (cached_has_bits & 0x00000080u) {
457 _this->_impl_.saddr_ = from._impl_.saddr_;
458 }
459 _this->_impl_._has_bits_[0] |= cached_has_bits;
460 }
461 if (cached_has_bits & 0x00000100u) {
462 _this->_internal_set_sport(from._internal_sport());
463 }
464 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
465 }
466
CopyFrom(const InetSockSetStateFtraceEvent & from)467 void InetSockSetStateFtraceEvent::CopyFrom(const InetSockSetStateFtraceEvent& from) {
468 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.InetSockSetStateFtraceEvent)
469 if (&from == this) return;
470 Clear();
471 MergeFrom(from);
472 }
473
IsInitialized() const474 bool InetSockSetStateFtraceEvent::IsInitialized() const {
475 return true;
476 }
477
InternalSwap(InetSockSetStateFtraceEvent * other)478 void InetSockSetStateFtraceEvent::InternalSwap(InetSockSetStateFtraceEvent* other) {
479 using std::swap;
480 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
481 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
482 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
483 PROTOBUF_FIELD_OFFSET(InetSockSetStateFtraceEvent, _impl_.sport_)
484 + sizeof(InetSockSetStateFtraceEvent::_impl_.sport_) // NOLINT
485 - PROTOBUF_FIELD_OFFSET(InetSockSetStateFtraceEvent, _impl_.daddr_)>(
486 reinterpret_cast<char*>(&_impl_.daddr_),
487 reinterpret_cast<char*>(&other->_impl_.daddr_));
488 }
489
GetTypeName() const490 std::string InetSockSetStateFtraceEvent::GetTypeName() const {
491 return "perfetto.protos.InetSockSetStateFtraceEvent";
492 }
493
494
495 // @@protoc_insertion_point(namespace_scope)
496 } // namespace protos
497 } // namespace perfetto
498 PROTOBUF_NAMESPACE_OPEN
499 template<> PROTOBUF_NOINLINE ::perfetto::protos::InetSockSetStateFtraceEvent*
CreateMaybeMessage(Arena * arena)500 Arena::CreateMaybeMessage< ::perfetto::protos::InetSockSetStateFtraceEvent >(Arena* arena) {
501 return Arena::CreateMessageInternal< ::perfetto::protos::InetSockSetStateFtraceEvent >(arena);
502 }
503 PROTOBUF_NAMESPACE_CLOSE
504
505 // @@protoc_insertion_point(global_scope)
506 #include <google/protobuf/port_undef.inc>
507