1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: protos/perfetto/config/profiling/java_hprof_config.proto
3 
4 #include "protos/perfetto/config/profiling/java_hprof_config.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 {
JavaHprofConfig_ContinuousDumpConfig(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR JavaHprofConfig_ContinuousDumpConfig::JavaHprofConfig_ContinuousDumpConfig(
24     ::_pbi::ConstantInitialized): _impl_{
25     /*decltype(_impl_._has_bits_)*/{}
26   , /*decltype(_impl_._cached_size_)*/{}
27   , /*decltype(_impl_.dump_phase_ms_)*/0u
28   , /*decltype(_impl_.dump_interval_ms_)*/0u
29   , /*decltype(_impl_.scan_pids_only_on_start_)*/false} {}
30 struct JavaHprofConfig_ContinuousDumpConfigDefaultTypeInternal {
JavaHprofConfig_ContinuousDumpConfigDefaultTypeInternalperfetto::protos::JavaHprofConfig_ContinuousDumpConfigDefaultTypeInternal31   PROTOBUF_CONSTEXPR JavaHprofConfig_ContinuousDumpConfigDefaultTypeInternal()
32       : _instance(::_pbi::ConstantInitialized{}) {}
~JavaHprofConfig_ContinuousDumpConfigDefaultTypeInternalperfetto::protos::JavaHprofConfig_ContinuousDumpConfigDefaultTypeInternal33   ~JavaHprofConfig_ContinuousDumpConfigDefaultTypeInternal() {}
34   union {  // NOLINT(misc-non-private-member-variables-in-classes)
35     JavaHprofConfig_ContinuousDumpConfig _instance;
36   };
37 };
38 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 JavaHprofConfig_ContinuousDumpConfigDefaultTypeInternal _JavaHprofConfig_ContinuousDumpConfig_default_instance_;
JavaHprofConfig(::_pbi::ConstantInitialized)39 PROTOBUF_CONSTEXPR JavaHprofConfig::JavaHprofConfig(
40     ::_pbi::ConstantInitialized): _impl_{
41     /*decltype(_impl_._has_bits_)*/{}
42   , /*decltype(_impl_._cached_size_)*/{}
43   , /*decltype(_impl_.process_cmdline_)*/{}
44   , /*decltype(_impl_.pid_)*/{}
45   , /*decltype(_impl_.ignored_types_)*/{}
46   , /*decltype(_impl_.target_installed_by_)*/{}
47   , /*decltype(_impl_.continuous_dump_config_)*/nullptr
48   , /*decltype(_impl_.min_anonymous_memory_kb_)*/0u
49   , /*decltype(_impl_.dump_smaps_)*/false} {}
50 struct JavaHprofConfigDefaultTypeInternal {
JavaHprofConfigDefaultTypeInternalperfetto::protos::JavaHprofConfigDefaultTypeInternal51   PROTOBUF_CONSTEXPR JavaHprofConfigDefaultTypeInternal()
52       : _instance(::_pbi::ConstantInitialized{}) {}
~JavaHprofConfigDefaultTypeInternalperfetto::protos::JavaHprofConfigDefaultTypeInternal53   ~JavaHprofConfigDefaultTypeInternal() {}
54   union {  // NOLINT(misc-non-private-member-variables-in-classes)
55     JavaHprofConfig _instance;
56   };
57 };
58 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 JavaHprofConfigDefaultTypeInternal _JavaHprofConfig_default_instance_;
59 }  // namespace protos
60 }  // namespace perfetto
61 namespace perfetto {
62 namespace protos {
63 
64 // ===================================================================
65 
66 class JavaHprofConfig_ContinuousDumpConfig::_Internal {
67  public:
68   using HasBits = decltype(std::declval<JavaHprofConfig_ContinuousDumpConfig>()._impl_._has_bits_);
set_has_dump_phase_ms(HasBits * has_bits)69   static void set_has_dump_phase_ms(HasBits* has_bits) {
70     (*has_bits)[0] |= 1u;
71   }
set_has_dump_interval_ms(HasBits * has_bits)72   static void set_has_dump_interval_ms(HasBits* has_bits) {
73     (*has_bits)[0] |= 2u;
74   }
set_has_scan_pids_only_on_start(HasBits * has_bits)75   static void set_has_scan_pids_only_on_start(HasBits* has_bits) {
76     (*has_bits)[0] |= 4u;
77   }
78 };
79 
JavaHprofConfig_ContinuousDumpConfig(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)80 JavaHprofConfig_ContinuousDumpConfig::JavaHprofConfig_ContinuousDumpConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
81                          bool is_message_owned)
82   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
83   SharedCtor(arena, is_message_owned);
84   // @@protoc_insertion_point(arena_constructor:perfetto.protos.JavaHprofConfig.ContinuousDumpConfig)
85 }
JavaHprofConfig_ContinuousDumpConfig(const JavaHprofConfig_ContinuousDumpConfig & from)86 JavaHprofConfig_ContinuousDumpConfig::JavaHprofConfig_ContinuousDumpConfig(const JavaHprofConfig_ContinuousDumpConfig& from)
87   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
88   JavaHprofConfig_ContinuousDumpConfig* const _this = this; (void)_this;
89   new (&_impl_) Impl_{
90       decltype(_impl_._has_bits_){from._impl_._has_bits_}
91     , /*decltype(_impl_._cached_size_)*/{}
92     , decltype(_impl_.dump_phase_ms_){}
93     , decltype(_impl_.dump_interval_ms_){}
94     , decltype(_impl_.scan_pids_only_on_start_){}};
95 
96   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
97   ::memcpy(&_impl_.dump_phase_ms_, &from._impl_.dump_phase_ms_,
98     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.scan_pids_only_on_start_) -
99     reinterpret_cast<char*>(&_impl_.dump_phase_ms_)) + sizeof(_impl_.scan_pids_only_on_start_));
100   // @@protoc_insertion_point(copy_constructor:perfetto.protos.JavaHprofConfig.ContinuousDumpConfig)
101 }
102 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)103 inline void JavaHprofConfig_ContinuousDumpConfig::SharedCtor(
104     ::_pb::Arena* arena, bool is_message_owned) {
105   (void)arena;
106   (void)is_message_owned;
107   new (&_impl_) Impl_{
108       decltype(_impl_._has_bits_){}
109     , /*decltype(_impl_._cached_size_)*/{}
110     , decltype(_impl_.dump_phase_ms_){0u}
111     , decltype(_impl_.dump_interval_ms_){0u}
112     , decltype(_impl_.scan_pids_only_on_start_){false}
113   };
114 }
115 
~JavaHprofConfig_ContinuousDumpConfig()116 JavaHprofConfig_ContinuousDumpConfig::~JavaHprofConfig_ContinuousDumpConfig() {
117   // @@protoc_insertion_point(destructor:perfetto.protos.JavaHprofConfig.ContinuousDumpConfig)
118   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
119   (void)arena;
120     return;
121   }
122   SharedDtor();
123 }
124 
SharedDtor()125 inline void JavaHprofConfig_ContinuousDumpConfig::SharedDtor() {
126   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
127 }
128 
SetCachedSize(int size) const129 void JavaHprofConfig_ContinuousDumpConfig::SetCachedSize(int size) const {
130   _impl_._cached_size_.Set(size);
131 }
132 
Clear()133 void JavaHprofConfig_ContinuousDumpConfig::Clear() {
134 // @@protoc_insertion_point(message_clear_start:perfetto.protos.JavaHprofConfig.ContinuousDumpConfig)
135   ::uint32_t cached_has_bits = 0;
136   // Prevent compiler warnings about cached_has_bits being unused
137   (void) cached_has_bits;
138 
139   cached_has_bits = _impl_._has_bits_[0];
140   if (cached_has_bits & 0x00000007u) {
141     ::memset(&_impl_.dump_phase_ms_, 0, static_cast<size_t>(
142         reinterpret_cast<char*>(&_impl_.scan_pids_only_on_start_) -
143         reinterpret_cast<char*>(&_impl_.dump_phase_ms_)) + sizeof(_impl_.scan_pids_only_on_start_));
144   }
145   _impl_._has_bits_.Clear();
146   _internal_metadata_.Clear<std::string>();
147 }
148 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)149 const char* JavaHprofConfig_ContinuousDumpConfig::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
150 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
151   _Internal::HasBits has_bits{};
152   while (!ctx->Done(&ptr)) {
153     ::uint32_t tag;
154     ptr = ::_pbi::ReadTag(ptr, &tag);
155     switch (tag >> 3) {
156       // optional uint32 dump_phase_ms = 1;
157       case 1:
158         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
159           _Internal::set_has_dump_phase_ms(&has_bits);
160           _impl_.dump_phase_ms_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
161           CHK_(ptr);
162         } else {
163           goto handle_unusual;
164         }
165         continue;
166       // optional uint32 dump_interval_ms = 2;
167       case 2:
168         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
169           _Internal::set_has_dump_interval_ms(&has_bits);
170           _impl_.dump_interval_ms_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
171           CHK_(ptr);
172         } else {
173           goto handle_unusual;
174         }
175         continue;
176       // optional bool scan_pids_only_on_start = 3;
177       case 3:
178         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
179           _Internal::set_has_scan_pids_only_on_start(&has_bits);
180           _impl_.scan_pids_only_on_start_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
181           CHK_(ptr);
182         } else {
183           goto handle_unusual;
184         }
185         continue;
186       default:
187         goto handle_unusual;
188     }  // switch
189   handle_unusual:
190     if ((tag == 0) || ((tag & 7) == 4)) {
191       CHK_(ptr);
192       ctx->SetLastTag(tag);
193       goto message_done;
194     }
195     ptr = UnknownFieldParse(
196         tag,
197         _internal_metadata_.mutable_unknown_fields<std::string>(),
198         ptr, ctx);
199     CHK_(ptr != nullptr);
200   }  // while
201 message_done:
202   _impl_._has_bits_.Or(has_bits);
203   return ptr;
204 failure:
205   ptr = nullptr;
206   goto message_done;
207 #undef CHK_
208 }
209 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const210 ::uint8_t* JavaHprofConfig_ContinuousDumpConfig::_InternalSerialize(
211     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
212   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.JavaHprofConfig.ContinuousDumpConfig)
213   ::uint32_t cached_has_bits = 0;
214   (void) cached_has_bits;
215 
216   cached_has_bits = _impl_._has_bits_[0];
217   // optional uint32 dump_phase_ms = 1;
218   if (cached_has_bits & 0x00000001u) {
219     target = stream->EnsureSpace(target);
220     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_dump_phase_ms(), target);
221   }
222 
223   // optional uint32 dump_interval_ms = 2;
224   if (cached_has_bits & 0x00000002u) {
225     target = stream->EnsureSpace(target);
226     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_dump_interval_ms(), target);
227   }
228 
229   // optional bool scan_pids_only_on_start = 3;
230   if (cached_has_bits & 0x00000004u) {
231     target = stream->EnsureSpace(target);
232     target = ::_pbi::WireFormatLite::WriteBoolToArray(3, this->_internal_scan_pids_only_on_start(), target);
233   }
234 
235   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
236     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
237         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
238   }
239   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.JavaHprofConfig.ContinuousDumpConfig)
240   return target;
241 }
242 
ByteSizeLong() const243 size_t JavaHprofConfig_ContinuousDumpConfig::ByteSizeLong() const {
244 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.JavaHprofConfig.ContinuousDumpConfig)
245   size_t total_size = 0;
246 
247   ::uint32_t cached_has_bits = 0;
248   // Prevent compiler warnings about cached_has_bits being unused
249   (void) cached_has_bits;
250 
251   cached_has_bits = _impl_._has_bits_[0];
252   if (cached_has_bits & 0x00000007u) {
253     // optional uint32 dump_phase_ms = 1;
254     if (cached_has_bits & 0x00000001u) {
255       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_dump_phase_ms());
256     }
257 
258     // optional uint32 dump_interval_ms = 2;
259     if (cached_has_bits & 0x00000002u) {
260       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_dump_interval_ms());
261     }
262 
263     // optional bool scan_pids_only_on_start = 3;
264     if (cached_has_bits & 0x00000004u) {
265       total_size += 1 + 1;
266     }
267 
268   }
269   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
270     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
271   }
272   int cached_size = ::_pbi::ToCachedSize(total_size);
273   SetCachedSize(cached_size);
274   return total_size;
275 }
276 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)277 void JavaHprofConfig_ContinuousDumpConfig::CheckTypeAndMergeFrom(
278     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
279   MergeFrom(*::_pbi::DownCast<const JavaHprofConfig_ContinuousDumpConfig*>(
280       &from));
281 }
282 
MergeFrom(const JavaHprofConfig_ContinuousDumpConfig & from)283 void JavaHprofConfig_ContinuousDumpConfig::MergeFrom(const JavaHprofConfig_ContinuousDumpConfig& from) {
284   JavaHprofConfig_ContinuousDumpConfig* const _this = this;
285   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.JavaHprofConfig.ContinuousDumpConfig)
286   GOOGLE_DCHECK_NE(&from, _this);
287   ::uint32_t cached_has_bits = 0;
288   (void) cached_has_bits;
289 
290   cached_has_bits = from._impl_._has_bits_[0];
291   if (cached_has_bits & 0x00000007u) {
292     if (cached_has_bits & 0x00000001u) {
293       _this->_impl_.dump_phase_ms_ = from._impl_.dump_phase_ms_;
294     }
295     if (cached_has_bits & 0x00000002u) {
296       _this->_impl_.dump_interval_ms_ = from._impl_.dump_interval_ms_;
297     }
298     if (cached_has_bits & 0x00000004u) {
299       _this->_impl_.scan_pids_only_on_start_ = from._impl_.scan_pids_only_on_start_;
300     }
301     _this->_impl_._has_bits_[0] |= cached_has_bits;
302   }
303   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
304 }
305 
CopyFrom(const JavaHprofConfig_ContinuousDumpConfig & from)306 void JavaHprofConfig_ContinuousDumpConfig::CopyFrom(const JavaHprofConfig_ContinuousDumpConfig& from) {
307 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.JavaHprofConfig.ContinuousDumpConfig)
308   if (&from == this) return;
309   Clear();
310   MergeFrom(from);
311 }
312 
IsInitialized() const313 bool JavaHprofConfig_ContinuousDumpConfig::IsInitialized() const {
314   return true;
315 }
316 
InternalSwap(JavaHprofConfig_ContinuousDumpConfig * other)317 void JavaHprofConfig_ContinuousDumpConfig::InternalSwap(JavaHprofConfig_ContinuousDumpConfig* other) {
318   using std::swap;
319   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
320   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
321   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
322       PROTOBUF_FIELD_OFFSET(JavaHprofConfig_ContinuousDumpConfig, _impl_.scan_pids_only_on_start_)
323       + sizeof(JavaHprofConfig_ContinuousDumpConfig::_impl_.scan_pids_only_on_start_)  // NOLINT
324       - PROTOBUF_FIELD_OFFSET(JavaHprofConfig_ContinuousDumpConfig, _impl_.dump_phase_ms_)>(
325           reinterpret_cast<char*>(&_impl_.dump_phase_ms_),
326           reinterpret_cast<char*>(&other->_impl_.dump_phase_ms_));
327 }
328 
GetTypeName() const329 std::string JavaHprofConfig_ContinuousDumpConfig::GetTypeName() const {
330   return "perfetto.protos.JavaHprofConfig.ContinuousDumpConfig";
331 }
332 
333 
334 // ===================================================================
335 
336 class JavaHprofConfig::_Internal {
337  public:
338   using HasBits = decltype(std::declval<JavaHprofConfig>()._impl_._has_bits_);
339   static const ::perfetto::protos::JavaHprofConfig_ContinuousDumpConfig& continuous_dump_config(const JavaHprofConfig* msg);
set_has_continuous_dump_config(HasBits * has_bits)340   static void set_has_continuous_dump_config(HasBits* has_bits) {
341     (*has_bits)[0] |= 1u;
342   }
set_has_min_anonymous_memory_kb(HasBits * has_bits)343   static void set_has_min_anonymous_memory_kb(HasBits* has_bits) {
344     (*has_bits)[0] |= 2u;
345   }
set_has_dump_smaps(HasBits * has_bits)346   static void set_has_dump_smaps(HasBits* has_bits) {
347     (*has_bits)[0] |= 4u;
348   }
349 };
350 
351 const ::perfetto::protos::JavaHprofConfig_ContinuousDumpConfig&
continuous_dump_config(const JavaHprofConfig * msg)352 JavaHprofConfig::_Internal::continuous_dump_config(const JavaHprofConfig* msg) {
353   return *msg->_impl_.continuous_dump_config_;
354 }
JavaHprofConfig(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)355 JavaHprofConfig::JavaHprofConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
356                          bool is_message_owned)
357   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
358   SharedCtor(arena, is_message_owned);
359   // @@protoc_insertion_point(arena_constructor:perfetto.protos.JavaHprofConfig)
360 }
JavaHprofConfig(const JavaHprofConfig & from)361 JavaHprofConfig::JavaHprofConfig(const JavaHprofConfig& from)
362   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
363   JavaHprofConfig* const _this = this; (void)_this;
364   new (&_impl_) Impl_{
365       decltype(_impl_._has_bits_){from._impl_._has_bits_}
366     , /*decltype(_impl_._cached_size_)*/{}
367     , decltype(_impl_.process_cmdline_){from._impl_.process_cmdline_}
368     , decltype(_impl_.pid_){from._impl_.pid_}
369     , decltype(_impl_.ignored_types_){from._impl_.ignored_types_}
370     , decltype(_impl_.target_installed_by_){from._impl_.target_installed_by_}
371     , decltype(_impl_.continuous_dump_config_){nullptr}
372     , decltype(_impl_.min_anonymous_memory_kb_){}
373     , decltype(_impl_.dump_smaps_){}};
374 
375   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
376   if (from._internal_has_continuous_dump_config()) {
377     _this->_impl_.continuous_dump_config_ = new ::perfetto::protos::JavaHprofConfig_ContinuousDumpConfig(*from._impl_.continuous_dump_config_);
378   }
379   ::memcpy(&_impl_.min_anonymous_memory_kb_, &from._impl_.min_anonymous_memory_kb_,
380     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.dump_smaps_) -
381     reinterpret_cast<char*>(&_impl_.min_anonymous_memory_kb_)) + sizeof(_impl_.dump_smaps_));
382   // @@protoc_insertion_point(copy_constructor:perfetto.protos.JavaHprofConfig)
383 }
384 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)385 inline void JavaHprofConfig::SharedCtor(
386     ::_pb::Arena* arena, bool is_message_owned) {
387   (void)arena;
388   (void)is_message_owned;
389   new (&_impl_) Impl_{
390       decltype(_impl_._has_bits_){}
391     , /*decltype(_impl_._cached_size_)*/{}
392     , decltype(_impl_.process_cmdline_){arena}
393     , decltype(_impl_.pid_){arena}
394     , decltype(_impl_.ignored_types_){arena}
395     , decltype(_impl_.target_installed_by_){arena}
396     , decltype(_impl_.continuous_dump_config_){nullptr}
397     , decltype(_impl_.min_anonymous_memory_kb_){0u}
398     , decltype(_impl_.dump_smaps_){false}
399   };
400 }
401 
~JavaHprofConfig()402 JavaHprofConfig::~JavaHprofConfig() {
403   // @@protoc_insertion_point(destructor:perfetto.protos.JavaHprofConfig)
404   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
405   (void)arena;
406     return;
407   }
408   SharedDtor();
409 }
410 
SharedDtor()411 inline void JavaHprofConfig::SharedDtor() {
412   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
413   _impl_.process_cmdline_.~RepeatedPtrField();
414   _impl_.pid_.~RepeatedField();
415   _impl_.ignored_types_.~RepeatedPtrField();
416   _impl_.target_installed_by_.~RepeatedPtrField();
417   if (this != internal_default_instance()) delete _impl_.continuous_dump_config_;
418 }
419 
SetCachedSize(int size) const420 void JavaHprofConfig::SetCachedSize(int size) const {
421   _impl_._cached_size_.Set(size);
422 }
423 
Clear()424 void JavaHprofConfig::Clear() {
425 // @@protoc_insertion_point(message_clear_start:perfetto.protos.JavaHprofConfig)
426   ::uint32_t cached_has_bits = 0;
427   // Prevent compiler warnings about cached_has_bits being unused
428   (void) cached_has_bits;
429 
430   _impl_.process_cmdline_.Clear();
431   _impl_.pid_.Clear();
432   _impl_.ignored_types_.Clear();
433   _impl_.target_installed_by_.Clear();
434   cached_has_bits = _impl_._has_bits_[0];
435   if (cached_has_bits & 0x00000001u) {
436     GOOGLE_DCHECK(_impl_.continuous_dump_config_ != nullptr);
437     _impl_.continuous_dump_config_->Clear();
438   }
439   if (cached_has_bits & 0x00000006u) {
440     ::memset(&_impl_.min_anonymous_memory_kb_, 0, static_cast<size_t>(
441         reinterpret_cast<char*>(&_impl_.dump_smaps_) -
442         reinterpret_cast<char*>(&_impl_.min_anonymous_memory_kb_)) + sizeof(_impl_.dump_smaps_));
443   }
444   _impl_._has_bits_.Clear();
445   _internal_metadata_.Clear<std::string>();
446 }
447 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)448 const char* JavaHprofConfig::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
449 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
450   _Internal::HasBits has_bits{};
451   while (!ctx->Done(&ptr)) {
452     ::uint32_t tag;
453     ptr = ::_pbi::ReadTag(ptr, &tag);
454     switch (tag >> 3) {
455       // repeated string process_cmdline = 1;
456       case 1:
457         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
458           ptr -= 1;
459           do {
460             ptr += 1;
461             auto str = _internal_add_process_cmdline();
462             ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
463             CHK_(ptr);
464             if (!ctx->DataAvailable(ptr)) break;
465           } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
466         } else {
467           goto handle_unusual;
468         }
469         continue;
470       // repeated uint64 pid = 2;
471       case 2:
472         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
473           ptr -= 1;
474           do {
475             ptr += 1;
476             _internal_add_pid(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
477             CHK_(ptr);
478             if (!ctx->DataAvailable(ptr)) break;
479           } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<16>(ptr));
480         } else if (static_cast<::uint8_t>(tag) == 18) {
481           ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt64Parser(_internal_mutable_pid(), ptr, ctx);
482           CHK_(ptr);
483         } else {
484           goto handle_unusual;
485         }
486         continue;
487       // optional .perfetto.protos.JavaHprofConfig.ContinuousDumpConfig continuous_dump_config = 3;
488       case 3:
489         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
490           ptr = ctx->ParseMessage(_internal_mutable_continuous_dump_config(), ptr);
491           CHK_(ptr);
492         } else {
493           goto handle_unusual;
494         }
495         continue;
496       // optional uint32 min_anonymous_memory_kb = 4;
497       case 4:
498         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
499           _Internal::set_has_min_anonymous_memory_kb(&has_bits);
500           _impl_.min_anonymous_memory_kb_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
501           CHK_(ptr);
502         } else {
503           goto handle_unusual;
504         }
505         continue;
506       // optional bool dump_smaps = 5;
507       case 5:
508         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
509           _Internal::set_has_dump_smaps(&has_bits);
510           _impl_.dump_smaps_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
511           CHK_(ptr);
512         } else {
513           goto handle_unusual;
514         }
515         continue;
516       // repeated string ignored_types = 6;
517       case 6:
518         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
519           ptr -= 1;
520           do {
521             ptr += 1;
522             auto str = _internal_add_ignored_types();
523             ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
524             CHK_(ptr);
525             if (!ctx->DataAvailable(ptr)) break;
526           } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr));
527         } else {
528           goto handle_unusual;
529         }
530         continue;
531       // repeated string target_installed_by = 7;
532       case 7:
533         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 58)) {
534           ptr -= 1;
535           do {
536             ptr += 1;
537             auto str = _internal_add_target_installed_by();
538             ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
539             CHK_(ptr);
540             if (!ctx->DataAvailable(ptr)) break;
541           } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<58>(ptr));
542         } else {
543           goto handle_unusual;
544         }
545         continue;
546       default:
547         goto handle_unusual;
548     }  // switch
549   handle_unusual:
550     if ((tag == 0) || ((tag & 7) == 4)) {
551       CHK_(ptr);
552       ctx->SetLastTag(tag);
553       goto message_done;
554     }
555     ptr = UnknownFieldParse(
556         tag,
557         _internal_metadata_.mutable_unknown_fields<std::string>(),
558         ptr, ctx);
559     CHK_(ptr != nullptr);
560   }  // while
561 message_done:
562   _impl_._has_bits_.Or(has_bits);
563   return ptr;
564 failure:
565   ptr = nullptr;
566   goto message_done;
567 #undef CHK_
568 }
569 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const570 ::uint8_t* JavaHprofConfig::_InternalSerialize(
571     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
572   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.JavaHprofConfig)
573   ::uint32_t cached_has_bits = 0;
574   (void) cached_has_bits;
575 
576   // repeated string process_cmdline = 1;
577   for (int i = 0, n = this->_internal_process_cmdline_size(); i < n; i++) {
578     const auto& s = this->_internal_process_cmdline(i);
579     target = stream->WriteString(1, s, target);
580   }
581 
582   // repeated uint64 pid = 2;
583   for (int i = 0, n = this->_internal_pid_size(); i < n; i++) {
584     target = stream->EnsureSpace(target);
585     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_pid(i), target);
586   }
587 
588   cached_has_bits = _impl_._has_bits_[0];
589   // optional .perfetto.protos.JavaHprofConfig.ContinuousDumpConfig continuous_dump_config = 3;
590   if (cached_has_bits & 0x00000001u) {
591     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
592       InternalWriteMessage(3, _Internal::continuous_dump_config(this),
593         _Internal::continuous_dump_config(this).GetCachedSize(), target, stream);
594   }
595 
596   // optional uint32 min_anonymous_memory_kb = 4;
597   if (cached_has_bits & 0x00000002u) {
598     target = stream->EnsureSpace(target);
599     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_min_anonymous_memory_kb(), target);
600   }
601 
602   // optional bool dump_smaps = 5;
603   if (cached_has_bits & 0x00000004u) {
604     target = stream->EnsureSpace(target);
605     target = ::_pbi::WireFormatLite::WriteBoolToArray(5, this->_internal_dump_smaps(), target);
606   }
607 
608   // repeated string ignored_types = 6;
609   for (int i = 0, n = this->_internal_ignored_types_size(); i < n; i++) {
610     const auto& s = this->_internal_ignored_types(i);
611     target = stream->WriteString(6, s, target);
612   }
613 
614   // repeated string target_installed_by = 7;
615   for (int i = 0, n = this->_internal_target_installed_by_size(); i < n; i++) {
616     const auto& s = this->_internal_target_installed_by(i);
617     target = stream->WriteString(7, s, target);
618   }
619 
620   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
621     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
622         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
623   }
624   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.JavaHprofConfig)
625   return target;
626 }
627 
ByteSizeLong() const628 size_t JavaHprofConfig::ByteSizeLong() const {
629 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.JavaHprofConfig)
630   size_t total_size = 0;
631 
632   ::uint32_t cached_has_bits = 0;
633   // Prevent compiler warnings about cached_has_bits being unused
634   (void) cached_has_bits;
635 
636   // repeated string process_cmdline = 1;
637   total_size += 1 *
638       ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.process_cmdline_.size());
639   for (int i = 0, n = _impl_.process_cmdline_.size(); i < n; i++) {
640     total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
641       _impl_.process_cmdline_.Get(i));
642   }
643 
644   // repeated uint64 pid = 2;
645   {
646     size_t data_size = ::_pbi::WireFormatLite::
647       UInt64Size(this->_impl_.pid_);
648     total_size += 1 *
649                   ::_pbi::FromIntSize(this->_internal_pid_size());
650     total_size += data_size;
651   }
652 
653   // repeated string ignored_types = 6;
654   total_size += 1 *
655       ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.ignored_types_.size());
656   for (int i = 0, n = _impl_.ignored_types_.size(); i < n; i++) {
657     total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
658       _impl_.ignored_types_.Get(i));
659   }
660 
661   // repeated string target_installed_by = 7;
662   total_size += 1 *
663       ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.target_installed_by_.size());
664   for (int i = 0, n = _impl_.target_installed_by_.size(); i < n; i++) {
665     total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
666       _impl_.target_installed_by_.Get(i));
667   }
668 
669   cached_has_bits = _impl_._has_bits_[0];
670   if (cached_has_bits & 0x00000007u) {
671     // optional .perfetto.protos.JavaHprofConfig.ContinuousDumpConfig continuous_dump_config = 3;
672     if (cached_has_bits & 0x00000001u) {
673       total_size += 1 +
674         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
675           *_impl_.continuous_dump_config_);
676     }
677 
678     // optional uint32 min_anonymous_memory_kb = 4;
679     if (cached_has_bits & 0x00000002u) {
680       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_min_anonymous_memory_kb());
681     }
682 
683     // optional bool dump_smaps = 5;
684     if (cached_has_bits & 0x00000004u) {
685       total_size += 1 + 1;
686     }
687 
688   }
689   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
690     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
691   }
692   int cached_size = ::_pbi::ToCachedSize(total_size);
693   SetCachedSize(cached_size);
694   return total_size;
695 }
696 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)697 void JavaHprofConfig::CheckTypeAndMergeFrom(
698     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
699   MergeFrom(*::_pbi::DownCast<const JavaHprofConfig*>(
700       &from));
701 }
702 
MergeFrom(const JavaHprofConfig & from)703 void JavaHprofConfig::MergeFrom(const JavaHprofConfig& from) {
704   JavaHprofConfig* const _this = this;
705   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.JavaHprofConfig)
706   GOOGLE_DCHECK_NE(&from, _this);
707   ::uint32_t cached_has_bits = 0;
708   (void) cached_has_bits;
709 
710   _this->_impl_.process_cmdline_.MergeFrom(from._impl_.process_cmdline_);
711   _this->_impl_.pid_.MergeFrom(from._impl_.pid_);
712   _this->_impl_.ignored_types_.MergeFrom(from._impl_.ignored_types_);
713   _this->_impl_.target_installed_by_.MergeFrom(from._impl_.target_installed_by_);
714   cached_has_bits = from._impl_._has_bits_[0];
715   if (cached_has_bits & 0x00000007u) {
716     if (cached_has_bits & 0x00000001u) {
717       _this->_internal_mutable_continuous_dump_config()->::perfetto::protos::JavaHprofConfig_ContinuousDumpConfig::MergeFrom(
718           from._internal_continuous_dump_config());
719     }
720     if (cached_has_bits & 0x00000002u) {
721       _this->_impl_.min_anonymous_memory_kb_ = from._impl_.min_anonymous_memory_kb_;
722     }
723     if (cached_has_bits & 0x00000004u) {
724       _this->_impl_.dump_smaps_ = from._impl_.dump_smaps_;
725     }
726     _this->_impl_._has_bits_[0] |= cached_has_bits;
727   }
728   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
729 }
730 
CopyFrom(const JavaHprofConfig & from)731 void JavaHprofConfig::CopyFrom(const JavaHprofConfig& from) {
732 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.JavaHprofConfig)
733   if (&from == this) return;
734   Clear();
735   MergeFrom(from);
736 }
737 
IsInitialized() const738 bool JavaHprofConfig::IsInitialized() const {
739   return true;
740 }
741 
InternalSwap(JavaHprofConfig * other)742 void JavaHprofConfig::InternalSwap(JavaHprofConfig* other) {
743   using std::swap;
744   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
745   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
746   _impl_.process_cmdline_.InternalSwap(&other->_impl_.process_cmdline_);
747   _impl_.pid_.InternalSwap(&other->_impl_.pid_);
748   _impl_.ignored_types_.InternalSwap(&other->_impl_.ignored_types_);
749   _impl_.target_installed_by_.InternalSwap(&other->_impl_.target_installed_by_);
750   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
751       PROTOBUF_FIELD_OFFSET(JavaHprofConfig, _impl_.dump_smaps_)
752       + sizeof(JavaHprofConfig::_impl_.dump_smaps_)  // NOLINT
753       - PROTOBUF_FIELD_OFFSET(JavaHprofConfig, _impl_.continuous_dump_config_)>(
754           reinterpret_cast<char*>(&_impl_.continuous_dump_config_),
755           reinterpret_cast<char*>(&other->_impl_.continuous_dump_config_));
756 }
757 
GetTypeName() const758 std::string JavaHprofConfig::GetTypeName() const {
759   return "perfetto.protos.JavaHprofConfig";
760 }
761 
762 
763 // @@protoc_insertion_point(namespace_scope)
764 }  // namespace protos
765 }  // namespace perfetto
766 PROTOBUF_NAMESPACE_OPEN
767 template<> PROTOBUF_NOINLINE ::perfetto::protos::JavaHprofConfig_ContinuousDumpConfig*
CreateMaybeMessage(Arena * arena)768 Arena::CreateMaybeMessage< ::perfetto::protos::JavaHprofConfig_ContinuousDumpConfig >(Arena* arena) {
769   return Arena::CreateMessageInternal< ::perfetto::protos::JavaHprofConfig_ContinuousDumpConfig >(arena);
770 }
771 template<> PROTOBUF_NOINLINE ::perfetto::protos::JavaHprofConfig*
CreateMaybeMessage(Arena * arena)772 Arena::CreateMaybeMessage< ::perfetto::protos::JavaHprofConfig >(Arena* arena) {
773   return Arena::CreateMessageInternal< ::perfetto::protos::JavaHprofConfig >(arena);
774 }
775 PROTOBUF_NAMESPACE_CLOSE
776 
777 // @@protoc_insertion_point(global_scope)
778 #include <google/protobuf/port_undef.inc>
779