1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: protos/perfetto/trace/android/camera_event.proto
3
4 #include "protos/perfetto/trace/android/camera_event.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 {
AndroidCameraFrameEvent_CameraNodeProcessingDetails(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR AndroidCameraFrameEvent_CameraNodeProcessingDetails::AndroidCameraFrameEvent_CameraNodeProcessingDetails(
24 ::_pbi::ConstantInitialized): _impl_{
25 /*decltype(_impl_._has_bits_)*/{}
26 , /*decltype(_impl_._cached_size_)*/{}
27 , /*decltype(_impl_.node_id_)*/::int64_t{0}
28 , /*decltype(_impl_.start_processing_ns_)*/::int64_t{0}
29 , /*decltype(_impl_.end_processing_ns_)*/::int64_t{0}
30 , /*decltype(_impl_.scheduling_latency_ns_)*/::int64_t{0}} {}
31 struct AndroidCameraFrameEvent_CameraNodeProcessingDetailsDefaultTypeInternal {
AndroidCameraFrameEvent_CameraNodeProcessingDetailsDefaultTypeInternalperfetto::protos::AndroidCameraFrameEvent_CameraNodeProcessingDetailsDefaultTypeInternal32 PROTOBUF_CONSTEXPR AndroidCameraFrameEvent_CameraNodeProcessingDetailsDefaultTypeInternal()
33 : _instance(::_pbi::ConstantInitialized{}) {}
~AndroidCameraFrameEvent_CameraNodeProcessingDetailsDefaultTypeInternalperfetto::protos::AndroidCameraFrameEvent_CameraNodeProcessingDetailsDefaultTypeInternal34 ~AndroidCameraFrameEvent_CameraNodeProcessingDetailsDefaultTypeInternal() {}
35 union { // NOLINT(misc-non-private-member-variables-in-classes)
36 AndroidCameraFrameEvent_CameraNodeProcessingDetails _instance;
37 };
38 };
39 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AndroidCameraFrameEvent_CameraNodeProcessingDetailsDefaultTypeInternal _AndroidCameraFrameEvent_CameraNodeProcessingDetails_default_instance_;
AndroidCameraFrameEvent(::_pbi::ConstantInitialized)40 PROTOBUF_CONSTEXPR AndroidCameraFrameEvent::AndroidCameraFrameEvent(
41 ::_pbi::ConstantInitialized): _impl_{
42 /*decltype(_impl_._has_bits_)*/{}
43 , /*decltype(_impl_._cached_size_)*/{}
44 , /*decltype(_impl_.node_processing_details_)*/{}
45 , /*decltype(_impl_.vendor_data_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
46 , /*decltype(_impl_.session_id_)*/::uint64_t{0u}
47 , /*decltype(_impl_.frame_number_)*/::int64_t{0}
48 , /*decltype(_impl_.request_id_)*/::int64_t{0}
49 , /*decltype(_impl_.request_received_ns_)*/::int64_t{0}
50 , /*decltype(_impl_.request_processing_started_ns_)*/::int64_t{0}
51 , /*decltype(_impl_.camera_id_)*/0u
52 , /*decltype(_impl_.capture_result_status_)*/0
53 , /*decltype(_impl_.start_of_exposure_ns_)*/::int64_t{0}
54 , /*decltype(_impl_.start_of_frame_ns_)*/::int64_t{0}
55 , /*decltype(_impl_.responses_all_sent_ns_)*/::int64_t{0}
56 , /*decltype(_impl_.skipped_sensor_frames_)*/0
57 , /*decltype(_impl_.capture_intent_)*/0
58 , /*decltype(_impl_.num_streams_)*/0
59 , /*decltype(_impl_.vendor_data_version_)*/0} {}
60 struct AndroidCameraFrameEventDefaultTypeInternal {
AndroidCameraFrameEventDefaultTypeInternalperfetto::protos::AndroidCameraFrameEventDefaultTypeInternal61 PROTOBUF_CONSTEXPR AndroidCameraFrameEventDefaultTypeInternal()
62 : _instance(::_pbi::ConstantInitialized{}) {}
~AndroidCameraFrameEventDefaultTypeInternalperfetto::protos::AndroidCameraFrameEventDefaultTypeInternal63 ~AndroidCameraFrameEventDefaultTypeInternal() {}
64 union { // NOLINT(misc-non-private-member-variables-in-classes)
65 AndroidCameraFrameEvent _instance;
66 };
67 };
68 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AndroidCameraFrameEventDefaultTypeInternal _AndroidCameraFrameEvent_default_instance_;
AndroidCameraSessionStats_CameraGraph_CameraNode(::_pbi::ConstantInitialized)69 PROTOBUF_CONSTEXPR AndroidCameraSessionStats_CameraGraph_CameraNode::AndroidCameraSessionStats_CameraGraph_CameraNode(
70 ::_pbi::ConstantInitialized): _impl_{
71 /*decltype(_impl_._has_bits_)*/{}
72 , /*decltype(_impl_._cached_size_)*/{}
73 , /*decltype(_impl_.input_ids_)*/{}
74 , /*decltype(_impl_.output_ids_)*/{}
75 , /*decltype(_impl_.vendor_data_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
76 , /*decltype(_impl_.node_id_)*/::int64_t{0}
77 , /*decltype(_impl_.vendor_data_version_)*/0} {}
78 struct AndroidCameraSessionStats_CameraGraph_CameraNodeDefaultTypeInternal {
AndroidCameraSessionStats_CameraGraph_CameraNodeDefaultTypeInternalperfetto::protos::AndroidCameraSessionStats_CameraGraph_CameraNodeDefaultTypeInternal79 PROTOBUF_CONSTEXPR AndroidCameraSessionStats_CameraGraph_CameraNodeDefaultTypeInternal()
80 : _instance(::_pbi::ConstantInitialized{}) {}
~AndroidCameraSessionStats_CameraGraph_CameraNodeDefaultTypeInternalperfetto::protos::AndroidCameraSessionStats_CameraGraph_CameraNodeDefaultTypeInternal81 ~AndroidCameraSessionStats_CameraGraph_CameraNodeDefaultTypeInternal() {}
82 union { // NOLINT(misc-non-private-member-variables-in-classes)
83 AndroidCameraSessionStats_CameraGraph_CameraNode _instance;
84 };
85 };
86 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AndroidCameraSessionStats_CameraGraph_CameraNodeDefaultTypeInternal _AndroidCameraSessionStats_CameraGraph_CameraNode_default_instance_;
AndroidCameraSessionStats_CameraGraph_CameraEdge(::_pbi::ConstantInitialized)87 PROTOBUF_CONSTEXPR AndroidCameraSessionStats_CameraGraph_CameraEdge::AndroidCameraSessionStats_CameraGraph_CameraEdge(
88 ::_pbi::ConstantInitialized): _impl_{
89 /*decltype(_impl_._has_bits_)*/{}
90 , /*decltype(_impl_._cached_size_)*/{}
91 , /*decltype(_impl_.vendor_data_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
92 , /*decltype(_impl_.output_node_id_)*/::int64_t{0}
93 , /*decltype(_impl_.output_id_)*/::int64_t{0}
94 , /*decltype(_impl_.input_node_id_)*/::int64_t{0}
95 , /*decltype(_impl_.input_id_)*/::int64_t{0}
96 , /*decltype(_impl_.vendor_data_version_)*/0} {}
97 struct AndroidCameraSessionStats_CameraGraph_CameraEdgeDefaultTypeInternal {
AndroidCameraSessionStats_CameraGraph_CameraEdgeDefaultTypeInternalperfetto::protos::AndroidCameraSessionStats_CameraGraph_CameraEdgeDefaultTypeInternal98 PROTOBUF_CONSTEXPR AndroidCameraSessionStats_CameraGraph_CameraEdgeDefaultTypeInternal()
99 : _instance(::_pbi::ConstantInitialized{}) {}
~AndroidCameraSessionStats_CameraGraph_CameraEdgeDefaultTypeInternalperfetto::protos::AndroidCameraSessionStats_CameraGraph_CameraEdgeDefaultTypeInternal100 ~AndroidCameraSessionStats_CameraGraph_CameraEdgeDefaultTypeInternal() {}
101 union { // NOLINT(misc-non-private-member-variables-in-classes)
102 AndroidCameraSessionStats_CameraGraph_CameraEdge _instance;
103 };
104 };
105 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AndroidCameraSessionStats_CameraGraph_CameraEdgeDefaultTypeInternal _AndroidCameraSessionStats_CameraGraph_CameraEdge_default_instance_;
AndroidCameraSessionStats_CameraGraph(::_pbi::ConstantInitialized)106 PROTOBUF_CONSTEXPR AndroidCameraSessionStats_CameraGraph::AndroidCameraSessionStats_CameraGraph(
107 ::_pbi::ConstantInitialized): _impl_{
108 /*decltype(_impl_.nodes_)*/{}
109 , /*decltype(_impl_.edges_)*/{}
110 , /*decltype(_impl_._cached_size_)*/{}} {}
111 struct AndroidCameraSessionStats_CameraGraphDefaultTypeInternal {
AndroidCameraSessionStats_CameraGraphDefaultTypeInternalperfetto::protos::AndroidCameraSessionStats_CameraGraphDefaultTypeInternal112 PROTOBUF_CONSTEXPR AndroidCameraSessionStats_CameraGraphDefaultTypeInternal()
113 : _instance(::_pbi::ConstantInitialized{}) {}
~AndroidCameraSessionStats_CameraGraphDefaultTypeInternalperfetto::protos::AndroidCameraSessionStats_CameraGraphDefaultTypeInternal114 ~AndroidCameraSessionStats_CameraGraphDefaultTypeInternal() {}
115 union { // NOLINT(misc-non-private-member-variables-in-classes)
116 AndroidCameraSessionStats_CameraGraph _instance;
117 };
118 };
119 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AndroidCameraSessionStats_CameraGraphDefaultTypeInternal _AndroidCameraSessionStats_CameraGraph_default_instance_;
AndroidCameraSessionStats(::_pbi::ConstantInitialized)120 PROTOBUF_CONSTEXPR AndroidCameraSessionStats::AndroidCameraSessionStats(
121 ::_pbi::ConstantInitialized): _impl_{
122 /*decltype(_impl_._has_bits_)*/{}
123 , /*decltype(_impl_._cached_size_)*/{}
124 , /*decltype(_impl_.graph_)*/nullptr
125 , /*decltype(_impl_.session_id_)*/::uint64_t{0u}} {}
126 struct AndroidCameraSessionStatsDefaultTypeInternal {
AndroidCameraSessionStatsDefaultTypeInternalperfetto::protos::AndroidCameraSessionStatsDefaultTypeInternal127 PROTOBUF_CONSTEXPR AndroidCameraSessionStatsDefaultTypeInternal()
128 : _instance(::_pbi::ConstantInitialized{}) {}
~AndroidCameraSessionStatsDefaultTypeInternalperfetto::protos::AndroidCameraSessionStatsDefaultTypeInternal129 ~AndroidCameraSessionStatsDefaultTypeInternal() {}
130 union { // NOLINT(misc-non-private-member-variables-in-classes)
131 AndroidCameraSessionStats _instance;
132 };
133 };
134 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AndroidCameraSessionStatsDefaultTypeInternal _AndroidCameraSessionStats_default_instance_;
135 } // namespace protos
136 } // namespace perfetto
137 namespace perfetto {
138 namespace protos {
AndroidCameraFrameEvent_CaptureResultStatus_IsValid(int value)139 bool AndroidCameraFrameEvent_CaptureResultStatus_IsValid(int value) {
140 switch (value) {
141 case 0:
142 case 1:
143 case 2:
144 case 3:
145 case 4:
146 case 5:
147 return true;
148 default:
149 return false;
150 }
151 }
152
153 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> AndroidCameraFrameEvent_CaptureResultStatus_strings[6] = {};
154
155 static const char AndroidCameraFrameEvent_CaptureResultStatus_names[] =
156 "STATUS_BUFFER_ERROR"
157 "STATUS_EARLY_METADATA_ERROR"
158 "STATUS_FINAL_METADATA_ERROR"
159 "STATUS_FLUSH_ERROR"
160 "STATUS_OK"
161 "STATUS_UNSPECIFIED";
162
163 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry AndroidCameraFrameEvent_CaptureResultStatus_entries[] = {
164 { {AndroidCameraFrameEvent_CaptureResultStatus_names + 0, 19}, 4 },
165 { {AndroidCameraFrameEvent_CaptureResultStatus_names + 19, 27}, 2 },
166 { {AndroidCameraFrameEvent_CaptureResultStatus_names + 46, 27}, 3 },
167 { {AndroidCameraFrameEvent_CaptureResultStatus_names + 73, 18}, 5 },
168 { {AndroidCameraFrameEvent_CaptureResultStatus_names + 91, 9}, 1 },
169 { {AndroidCameraFrameEvent_CaptureResultStatus_names + 100, 18}, 0 },
170 };
171
172 static const int AndroidCameraFrameEvent_CaptureResultStatus_entries_by_number[] = {
173 5, // 0 -> STATUS_UNSPECIFIED
174 4, // 1 -> STATUS_OK
175 1, // 2 -> STATUS_EARLY_METADATA_ERROR
176 2, // 3 -> STATUS_FINAL_METADATA_ERROR
177 0, // 4 -> STATUS_BUFFER_ERROR
178 3, // 5 -> STATUS_FLUSH_ERROR
179 };
180
AndroidCameraFrameEvent_CaptureResultStatus_Name(AndroidCameraFrameEvent_CaptureResultStatus value)181 const std::string& AndroidCameraFrameEvent_CaptureResultStatus_Name(
182 AndroidCameraFrameEvent_CaptureResultStatus value) {
183 static const bool dummy =
184 ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
185 AndroidCameraFrameEvent_CaptureResultStatus_entries,
186 AndroidCameraFrameEvent_CaptureResultStatus_entries_by_number,
187 6, AndroidCameraFrameEvent_CaptureResultStatus_strings);
188 (void) dummy;
189 int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
190 AndroidCameraFrameEvent_CaptureResultStatus_entries,
191 AndroidCameraFrameEvent_CaptureResultStatus_entries_by_number,
192 6, value);
193 return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
194 AndroidCameraFrameEvent_CaptureResultStatus_strings[idx].get();
195 }
AndroidCameraFrameEvent_CaptureResultStatus_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,AndroidCameraFrameEvent_CaptureResultStatus * value)196 bool AndroidCameraFrameEvent_CaptureResultStatus_Parse(
197 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AndroidCameraFrameEvent_CaptureResultStatus* value) {
198 int int_value;
199 bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
200 AndroidCameraFrameEvent_CaptureResultStatus_entries, 6, name, &int_value);
201 if (success) {
202 *value = static_cast<AndroidCameraFrameEvent_CaptureResultStatus>(int_value);
203 }
204 return success;
205 }
206 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
207 constexpr AndroidCameraFrameEvent_CaptureResultStatus AndroidCameraFrameEvent::STATUS_UNSPECIFIED;
208 constexpr AndroidCameraFrameEvent_CaptureResultStatus AndroidCameraFrameEvent::STATUS_OK;
209 constexpr AndroidCameraFrameEvent_CaptureResultStatus AndroidCameraFrameEvent::STATUS_EARLY_METADATA_ERROR;
210 constexpr AndroidCameraFrameEvent_CaptureResultStatus AndroidCameraFrameEvent::STATUS_FINAL_METADATA_ERROR;
211 constexpr AndroidCameraFrameEvent_CaptureResultStatus AndroidCameraFrameEvent::STATUS_BUFFER_ERROR;
212 constexpr AndroidCameraFrameEvent_CaptureResultStatus AndroidCameraFrameEvent::STATUS_FLUSH_ERROR;
213 constexpr AndroidCameraFrameEvent_CaptureResultStatus AndroidCameraFrameEvent::CaptureResultStatus_MIN;
214 constexpr AndroidCameraFrameEvent_CaptureResultStatus AndroidCameraFrameEvent::CaptureResultStatus_MAX;
215 constexpr int AndroidCameraFrameEvent::CaptureResultStatus_ARRAYSIZE;
216 #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
217
218 // ===================================================================
219
220 class AndroidCameraFrameEvent_CameraNodeProcessingDetails::_Internal {
221 public:
222 using HasBits = decltype(std::declval<AndroidCameraFrameEvent_CameraNodeProcessingDetails>()._impl_._has_bits_);
set_has_node_id(HasBits * has_bits)223 static void set_has_node_id(HasBits* has_bits) {
224 (*has_bits)[0] |= 1u;
225 }
set_has_start_processing_ns(HasBits * has_bits)226 static void set_has_start_processing_ns(HasBits* has_bits) {
227 (*has_bits)[0] |= 2u;
228 }
set_has_end_processing_ns(HasBits * has_bits)229 static void set_has_end_processing_ns(HasBits* has_bits) {
230 (*has_bits)[0] |= 4u;
231 }
set_has_scheduling_latency_ns(HasBits * has_bits)232 static void set_has_scheduling_latency_ns(HasBits* has_bits) {
233 (*has_bits)[0] |= 8u;
234 }
235 };
236
AndroidCameraFrameEvent_CameraNodeProcessingDetails(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)237 AndroidCameraFrameEvent_CameraNodeProcessingDetails::AndroidCameraFrameEvent_CameraNodeProcessingDetails(::PROTOBUF_NAMESPACE_ID::Arena* arena,
238 bool is_message_owned)
239 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
240 SharedCtor(arena, is_message_owned);
241 // @@protoc_insertion_point(arena_constructor:perfetto.protos.AndroidCameraFrameEvent.CameraNodeProcessingDetails)
242 }
AndroidCameraFrameEvent_CameraNodeProcessingDetails(const AndroidCameraFrameEvent_CameraNodeProcessingDetails & from)243 AndroidCameraFrameEvent_CameraNodeProcessingDetails::AndroidCameraFrameEvent_CameraNodeProcessingDetails(const AndroidCameraFrameEvent_CameraNodeProcessingDetails& from)
244 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
245 AndroidCameraFrameEvent_CameraNodeProcessingDetails* const _this = this; (void)_this;
246 new (&_impl_) Impl_{
247 decltype(_impl_._has_bits_){from._impl_._has_bits_}
248 , /*decltype(_impl_._cached_size_)*/{}
249 , decltype(_impl_.node_id_){}
250 , decltype(_impl_.start_processing_ns_){}
251 , decltype(_impl_.end_processing_ns_){}
252 , decltype(_impl_.scheduling_latency_ns_){}};
253
254 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
255 ::memcpy(&_impl_.node_id_, &from._impl_.node_id_,
256 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.scheduling_latency_ns_) -
257 reinterpret_cast<char*>(&_impl_.node_id_)) + sizeof(_impl_.scheduling_latency_ns_));
258 // @@protoc_insertion_point(copy_constructor:perfetto.protos.AndroidCameraFrameEvent.CameraNodeProcessingDetails)
259 }
260
SharedCtor(::_pb::Arena * arena,bool is_message_owned)261 inline void AndroidCameraFrameEvent_CameraNodeProcessingDetails::SharedCtor(
262 ::_pb::Arena* arena, bool is_message_owned) {
263 (void)arena;
264 (void)is_message_owned;
265 new (&_impl_) Impl_{
266 decltype(_impl_._has_bits_){}
267 , /*decltype(_impl_._cached_size_)*/{}
268 , decltype(_impl_.node_id_){::int64_t{0}}
269 , decltype(_impl_.start_processing_ns_){::int64_t{0}}
270 , decltype(_impl_.end_processing_ns_){::int64_t{0}}
271 , decltype(_impl_.scheduling_latency_ns_){::int64_t{0}}
272 };
273 }
274
~AndroidCameraFrameEvent_CameraNodeProcessingDetails()275 AndroidCameraFrameEvent_CameraNodeProcessingDetails::~AndroidCameraFrameEvent_CameraNodeProcessingDetails() {
276 // @@protoc_insertion_point(destructor:perfetto.protos.AndroidCameraFrameEvent.CameraNodeProcessingDetails)
277 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
278 (void)arena;
279 return;
280 }
281 SharedDtor();
282 }
283
SharedDtor()284 inline void AndroidCameraFrameEvent_CameraNodeProcessingDetails::SharedDtor() {
285 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
286 }
287
SetCachedSize(int size) const288 void AndroidCameraFrameEvent_CameraNodeProcessingDetails::SetCachedSize(int size) const {
289 _impl_._cached_size_.Set(size);
290 }
291
Clear()292 void AndroidCameraFrameEvent_CameraNodeProcessingDetails::Clear() {
293 // @@protoc_insertion_point(message_clear_start:perfetto.protos.AndroidCameraFrameEvent.CameraNodeProcessingDetails)
294 ::uint32_t cached_has_bits = 0;
295 // Prevent compiler warnings about cached_has_bits being unused
296 (void) cached_has_bits;
297
298 cached_has_bits = _impl_._has_bits_[0];
299 if (cached_has_bits & 0x0000000fu) {
300 ::memset(&_impl_.node_id_, 0, static_cast<size_t>(
301 reinterpret_cast<char*>(&_impl_.scheduling_latency_ns_) -
302 reinterpret_cast<char*>(&_impl_.node_id_)) + sizeof(_impl_.scheduling_latency_ns_));
303 }
304 _impl_._has_bits_.Clear();
305 _internal_metadata_.Clear<std::string>();
306 }
307
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)308 const char* AndroidCameraFrameEvent_CameraNodeProcessingDetails::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
309 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
310 _Internal::HasBits has_bits{};
311 while (!ctx->Done(&ptr)) {
312 ::uint32_t tag;
313 ptr = ::_pbi::ReadTag(ptr, &tag);
314 switch (tag >> 3) {
315 // optional int64 node_id = 1;
316 case 1:
317 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
318 _Internal::set_has_node_id(&has_bits);
319 _impl_.node_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
320 CHK_(ptr);
321 } else {
322 goto handle_unusual;
323 }
324 continue;
325 // optional int64 start_processing_ns = 2;
326 case 2:
327 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
328 _Internal::set_has_start_processing_ns(&has_bits);
329 _impl_.start_processing_ns_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
330 CHK_(ptr);
331 } else {
332 goto handle_unusual;
333 }
334 continue;
335 // optional int64 end_processing_ns = 3;
336 case 3:
337 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
338 _Internal::set_has_end_processing_ns(&has_bits);
339 _impl_.end_processing_ns_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
340 CHK_(ptr);
341 } else {
342 goto handle_unusual;
343 }
344 continue;
345 // optional int64 scheduling_latency_ns = 4;
346 case 4:
347 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
348 _Internal::set_has_scheduling_latency_ns(&has_bits);
349 _impl_.scheduling_latency_ns_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
350 CHK_(ptr);
351 } else {
352 goto handle_unusual;
353 }
354 continue;
355 default:
356 goto handle_unusual;
357 } // switch
358 handle_unusual:
359 if ((tag == 0) || ((tag & 7) == 4)) {
360 CHK_(ptr);
361 ctx->SetLastTag(tag);
362 goto message_done;
363 }
364 ptr = UnknownFieldParse(
365 tag,
366 _internal_metadata_.mutable_unknown_fields<std::string>(),
367 ptr, ctx);
368 CHK_(ptr != nullptr);
369 } // while
370 message_done:
371 _impl_._has_bits_.Or(has_bits);
372 return ptr;
373 failure:
374 ptr = nullptr;
375 goto message_done;
376 #undef CHK_
377 }
378
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const379 ::uint8_t* AndroidCameraFrameEvent_CameraNodeProcessingDetails::_InternalSerialize(
380 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
381 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.AndroidCameraFrameEvent.CameraNodeProcessingDetails)
382 ::uint32_t cached_has_bits = 0;
383 (void) cached_has_bits;
384
385 cached_has_bits = _impl_._has_bits_[0];
386 // optional int64 node_id = 1;
387 if (cached_has_bits & 0x00000001u) {
388 target = stream->EnsureSpace(target);
389 target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_node_id(), target);
390 }
391
392 // optional int64 start_processing_ns = 2;
393 if (cached_has_bits & 0x00000002u) {
394 target = stream->EnsureSpace(target);
395 target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_start_processing_ns(), target);
396 }
397
398 // optional int64 end_processing_ns = 3;
399 if (cached_has_bits & 0x00000004u) {
400 target = stream->EnsureSpace(target);
401 target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_end_processing_ns(), target);
402 }
403
404 // optional int64 scheduling_latency_ns = 4;
405 if (cached_has_bits & 0x00000008u) {
406 target = stream->EnsureSpace(target);
407 target = ::_pbi::WireFormatLite::WriteInt64ToArray(4, this->_internal_scheduling_latency_ns(), target);
408 }
409
410 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
411 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
412 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
413 }
414 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.AndroidCameraFrameEvent.CameraNodeProcessingDetails)
415 return target;
416 }
417
ByteSizeLong() const418 size_t AndroidCameraFrameEvent_CameraNodeProcessingDetails::ByteSizeLong() const {
419 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.AndroidCameraFrameEvent.CameraNodeProcessingDetails)
420 size_t total_size = 0;
421
422 ::uint32_t cached_has_bits = 0;
423 // Prevent compiler warnings about cached_has_bits being unused
424 (void) cached_has_bits;
425
426 cached_has_bits = _impl_._has_bits_[0];
427 if (cached_has_bits & 0x0000000fu) {
428 // optional int64 node_id = 1;
429 if (cached_has_bits & 0x00000001u) {
430 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_node_id());
431 }
432
433 // optional int64 start_processing_ns = 2;
434 if (cached_has_bits & 0x00000002u) {
435 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_start_processing_ns());
436 }
437
438 // optional int64 end_processing_ns = 3;
439 if (cached_has_bits & 0x00000004u) {
440 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_end_processing_ns());
441 }
442
443 // optional int64 scheduling_latency_ns = 4;
444 if (cached_has_bits & 0x00000008u) {
445 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_scheduling_latency_ns());
446 }
447
448 }
449 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
450 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
451 }
452 int cached_size = ::_pbi::ToCachedSize(total_size);
453 SetCachedSize(cached_size);
454 return total_size;
455 }
456
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)457 void AndroidCameraFrameEvent_CameraNodeProcessingDetails::CheckTypeAndMergeFrom(
458 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
459 MergeFrom(*::_pbi::DownCast<const AndroidCameraFrameEvent_CameraNodeProcessingDetails*>(
460 &from));
461 }
462
MergeFrom(const AndroidCameraFrameEvent_CameraNodeProcessingDetails & from)463 void AndroidCameraFrameEvent_CameraNodeProcessingDetails::MergeFrom(const AndroidCameraFrameEvent_CameraNodeProcessingDetails& from) {
464 AndroidCameraFrameEvent_CameraNodeProcessingDetails* const _this = this;
465 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.AndroidCameraFrameEvent.CameraNodeProcessingDetails)
466 GOOGLE_DCHECK_NE(&from, _this);
467 ::uint32_t cached_has_bits = 0;
468 (void) cached_has_bits;
469
470 cached_has_bits = from._impl_._has_bits_[0];
471 if (cached_has_bits & 0x0000000fu) {
472 if (cached_has_bits & 0x00000001u) {
473 _this->_impl_.node_id_ = from._impl_.node_id_;
474 }
475 if (cached_has_bits & 0x00000002u) {
476 _this->_impl_.start_processing_ns_ = from._impl_.start_processing_ns_;
477 }
478 if (cached_has_bits & 0x00000004u) {
479 _this->_impl_.end_processing_ns_ = from._impl_.end_processing_ns_;
480 }
481 if (cached_has_bits & 0x00000008u) {
482 _this->_impl_.scheduling_latency_ns_ = from._impl_.scheduling_latency_ns_;
483 }
484 _this->_impl_._has_bits_[0] |= cached_has_bits;
485 }
486 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
487 }
488
CopyFrom(const AndroidCameraFrameEvent_CameraNodeProcessingDetails & from)489 void AndroidCameraFrameEvent_CameraNodeProcessingDetails::CopyFrom(const AndroidCameraFrameEvent_CameraNodeProcessingDetails& from) {
490 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.AndroidCameraFrameEvent.CameraNodeProcessingDetails)
491 if (&from == this) return;
492 Clear();
493 MergeFrom(from);
494 }
495
IsInitialized() const496 bool AndroidCameraFrameEvent_CameraNodeProcessingDetails::IsInitialized() const {
497 return true;
498 }
499
InternalSwap(AndroidCameraFrameEvent_CameraNodeProcessingDetails * other)500 void AndroidCameraFrameEvent_CameraNodeProcessingDetails::InternalSwap(AndroidCameraFrameEvent_CameraNodeProcessingDetails* other) {
501 using std::swap;
502 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
503 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
504 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
505 PROTOBUF_FIELD_OFFSET(AndroidCameraFrameEvent_CameraNodeProcessingDetails, _impl_.scheduling_latency_ns_)
506 + sizeof(AndroidCameraFrameEvent_CameraNodeProcessingDetails::_impl_.scheduling_latency_ns_) // NOLINT
507 - PROTOBUF_FIELD_OFFSET(AndroidCameraFrameEvent_CameraNodeProcessingDetails, _impl_.node_id_)>(
508 reinterpret_cast<char*>(&_impl_.node_id_),
509 reinterpret_cast<char*>(&other->_impl_.node_id_));
510 }
511
GetTypeName() const512 std::string AndroidCameraFrameEvent_CameraNodeProcessingDetails::GetTypeName() const {
513 return "perfetto.protos.AndroidCameraFrameEvent.CameraNodeProcessingDetails";
514 }
515
516
517 // ===================================================================
518
519 class AndroidCameraFrameEvent::_Internal {
520 public:
521 using HasBits = decltype(std::declval<AndroidCameraFrameEvent>()._impl_._has_bits_);
set_has_session_id(HasBits * has_bits)522 static void set_has_session_id(HasBits* has_bits) {
523 (*has_bits)[0] |= 2u;
524 }
set_has_camera_id(HasBits * has_bits)525 static void set_has_camera_id(HasBits* has_bits) {
526 (*has_bits)[0] |= 64u;
527 }
set_has_frame_number(HasBits * has_bits)528 static void set_has_frame_number(HasBits* has_bits) {
529 (*has_bits)[0] |= 4u;
530 }
set_has_request_id(HasBits * has_bits)531 static void set_has_request_id(HasBits* has_bits) {
532 (*has_bits)[0] |= 8u;
533 }
set_has_request_received_ns(HasBits * has_bits)534 static void set_has_request_received_ns(HasBits* has_bits) {
535 (*has_bits)[0] |= 16u;
536 }
set_has_request_processing_started_ns(HasBits * has_bits)537 static void set_has_request_processing_started_ns(HasBits* has_bits) {
538 (*has_bits)[0] |= 32u;
539 }
set_has_start_of_exposure_ns(HasBits * has_bits)540 static void set_has_start_of_exposure_ns(HasBits* has_bits) {
541 (*has_bits)[0] |= 256u;
542 }
set_has_start_of_frame_ns(HasBits * has_bits)543 static void set_has_start_of_frame_ns(HasBits* has_bits) {
544 (*has_bits)[0] |= 512u;
545 }
set_has_responses_all_sent_ns(HasBits * has_bits)546 static void set_has_responses_all_sent_ns(HasBits* has_bits) {
547 (*has_bits)[0] |= 1024u;
548 }
set_has_capture_result_status(HasBits * has_bits)549 static void set_has_capture_result_status(HasBits* has_bits) {
550 (*has_bits)[0] |= 128u;
551 }
set_has_skipped_sensor_frames(HasBits * has_bits)552 static void set_has_skipped_sensor_frames(HasBits* has_bits) {
553 (*has_bits)[0] |= 2048u;
554 }
set_has_capture_intent(HasBits * has_bits)555 static void set_has_capture_intent(HasBits* has_bits) {
556 (*has_bits)[0] |= 4096u;
557 }
set_has_num_streams(HasBits * has_bits)558 static void set_has_num_streams(HasBits* has_bits) {
559 (*has_bits)[0] |= 8192u;
560 }
set_has_vendor_data_version(HasBits * has_bits)561 static void set_has_vendor_data_version(HasBits* has_bits) {
562 (*has_bits)[0] |= 16384u;
563 }
set_has_vendor_data(HasBits * has_bits)564 static void set_has_vendor_data(HasBits* has_bits) {
565 (*has_bits)[0] |= 1u;
566 }
567 };
568
AndroidCameraFrameEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)569 AndroidCameraFrameEvent::AndroidCameraFrameEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
570 bool is_message_owned)
571 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
572 SharedCtor(arena, is_message_owned);
573 // @@protoc_insertion_point(arena_constructor:perfetto.protos.AndroidCameraFrameEvent)
574 }
AndroidCameraFrameEvent(const AndroidCameraFrameEvent & from)575 AndroidCameraFrameEvent::AndroidCameraFrameEvent(const AndroidCameraFrameEvent& from)
576 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
577 AndroidCameraFrameEvent* const _this = this; (void)_this;
578 new (&_impl_) Impl_{
579 decltype(_impl_._has_bits_){from._impl_._has_bits_}
580 , /*decltype(_impl_._cached_size_)*/{}
581 , decltype(_impl_.node_processing_details_){from._impl_.node_processing_details_}
582 , decltype(_impl_.vendor_data_){}
583 , decltype(_impl_.session_id_){}
584 , decltype(_impl_.frame_number_){}
585 , decltype(_impl_.request_id_){}
586 , decltype(_impl_.request_received_ns_){}
587 , decltype(_impl_.request_processing_started_ns_){}
588 , decltype(_impl_.camera_id_){}
589 , decltype(_impl_.capture_result_status_){}
590 , decltype(_impl_.start_of_exposure_ns_){}
591 , decltype(_impl_.start_of_frame_ns_){}
592 , decltype(_impl_.responses_all_sent_ns_){}
593 , decltype(_impl_.skipped_sensor_frames_){}
594 , decltype(_impl_.capture_intent_){}
595 , decltype(_impl_.num_streams_){}
596 , decltype(_impl_.vendor_data_version_){}};
597
598 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
599 _impl_.vendor_data_.InitDefault();
600 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
601 _impl_.vendor_data_.Set("", GetArenaForAllocation());
602 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
603 if (from._internal_has_vendor_data()) {
604 _this->_impl_.vendor_data_.Set(from._internal_vendor_data(),
605 _this->GetArenaForAllocation());
606 }
607 ::memcpy(&_impl_.session_id_, &from._impl_.session_id_,
608 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.vendor_data_version_) -
609 reinterpret_cast<char*>(&_impl_.session_id_)) + sizeof(_impl_.vendor_data_version_));
610 // @@protoc_insertion_point(copy_constructor:perfetto.protos.AndroidCameraFrameEvent)
611 }
612
SharedCtor(::_pb::Arena * arena,bool is_message_owned)613 inline void AndroidCameraFrameEvent::SharedCtor(
614 ::_pb::Arena* arena, bool is_message_owned) {
615 (void)arena;
616 (void)is_message_owned;
617 new (&_impl_) Impl_{
618 decltype(_impl_._has_bits_){}
619 , /*decltype(_impl_._cached_size_)*/{}
620 , decltype(_impl_.node_processing_details_){arena}
621 , decltype(_impl_.vendor_data_){}
622 , decltype(_impl_.session_id_){::uint64_t{0u}}
623 , decltype(_impl_.frame_number_){::int64_t{0}}
624 , decltype(_impl_.request_id_){::int64_t{0}}
625 , decltype(_impl_.request_received_ns_){::int64_t{0}}
626 , decltype(_impl_.request_processing_started_ns_){::int64_t{0}}
627 , decltype(_impl_.camera_id_){0u}
628 , decltype(_impl_.capture_result_status_){0}
629 , decltype(_impl_.start_of_exposure_ns_){::int64_t{0}}
630 , decltype(_impl_.start_of_frame_ns_){::int64_t{0}}
631 , decltype(_impl_.responses_all_sent_ns_){::int64_t{0}}
632 , decltype(_impl_.skipped_sensor_frames_){0}
633 , decltype(_impl_.capture_intent_){0}
634 , decltype(_impl_.num_streams_){0}
635 , decltype(_impl_.vendor_data_version_){0}
636 };
637 _impl_.vendor_data_.InitDefault();
638 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
639 _impl_.vendor_data_.Set("", GetArenaForAllocation());
640 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
641 }
642
~AndroidCameraFrameEvent()643 AndroidCameraFrameEvent::~AndroidCameraFrameEvent() {
644 // @@protoc_insertion_point(destructor:perfetto.protos.AndroidCameraFrameEvent)
645 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
646 (void)arena;
647 return;
648 }
649 SharedDtor();
650 }
651
SharedDtor()652 inline void AndroidCameraFrameEvent::SharedDtor() {
653 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
654 _impl_.node_processing_details_.~RepeatedPtrField();
655 _impl_.vendor_data_.Destroy();
656 }
657
SetCachedSize(int size) const658 void AndroidCameraFrameEvent::SetCachedSize(int size) const {
659 _impl_._cached_size_.Set(size);
660 }
661
Clear()662 void AndroidCameraFrameEvent::Clear() {
663 // @@protoc_insertion_point(message_clear_start:perfetto.protos.AndroidCameraFrameEvent)
664 ::uint32_t cached_has_bits = 0;
665 // Prevent compiler warnings about cached_has_bits being unused
666 (void) cached_has_bits;
667
668 _impl_.node_processing_details_.Clear();
669 cached_has_bits = _impl_._has_bits_[0];
670 if (cached_has_bits & 0x00000001u) {
671 _impl_.vendor_data_.ClearNonDefaultToEmpty();
672 }
673 if (cached_has_bits & 0x000000feu) {
674 ::memset(&_impl_.session_id_, 0, static_cast<size_t>(
675 reinterpret_cast<char*>(&_impl_.capture_result_status_) -
676 reinterpret_cast<char*>(&_impl_.session_id_)) + sizeof(_impl_.capture_result_status_));
677 }
678 if (cached_has_bits & 0x00007f00u) {
679 ::memset(&_impl_.start_of_exposure_ns_, 0, static_cast<size_t>(
680 reinterpret_cast<char*>(&_impl_.vendor_data_version_) -
681 reinterpret_cast<char*>(&_impl_.start_of_exposure_ns_)) + sizeof(_impl_.vendor_data_version_));
682 }
683 _impl_._has_bits_.Clear();
684 _internal_metadata_.Clear<std::string>();
685 }
686
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)687 const char* AndroidCameraFrameEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
688 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
689 _Internal::HasBits has_bits{};
690 while (!ctx->Done(&ptr)) {
691 ::uint32_t tag;
692 ptr = ::_pbi::ReadTag(ptr, &tag);
693 switch (tag >> 3) {
694 // optional uint64 session_id = 1;
695 case 1:
696 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
697 _Internal::set_has_session_id(&has_bits);
698 _impl_.session_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
699 CHK_(ptr);
700 } else {
701 goto handle_unusual;
702 }
703 continue;
704 // optional uint32 camera_id = 2;
705 case 2:
706 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
707 _Internal::set_has_camera_id(&has_bits);
708 _impl_.camera_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
709 CHK_(ptr);
710 } else {
711 goto handle_unusual;
712 }
713 continue;
714 // optional int64 frame_number = 3;
715 case 3:
716 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
717 _Internal::set_has_frame_number(&has_bits);
718 _impl_.frame_number_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
719 CHK_(ptr);
720 } else {
721 goto handle_unusual;
722 }
723 continue;
724 // optional int64 request_id = 4;
725 case 4:
726 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
727 _Internal::set_has_request_id(&has_bits);
728 _impl_.request_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
729 CHK_(ptr);
730 } else {
731 goto handle_unusual;
732 }
733 continue;
734 // optional int64 request_received_ns = 5;
735 case 5:
736 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
737 _Internal::set_has_request_received_ns(&has_bits);
738 _impl_.request_received_ns_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
739 CHK_(ptr);
740 } else {
741 goto handle_unusual;
742 }
743 continue;
744 // optional int64 request_processing_started_ns = 6;
745 case 6:
746 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
747 _Internal::set_has_request_processing_started_ns(&has_bits);
748 _impl_.request_processing_started_ns_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
749 CHK_(ptr);
750 } else {
751 goto handle_unusual;
752 }
753 continue;
754 // optional int64 start_of_exposure_ns = 7;
755 case 7:
756 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
757 _Internal::set_has_start_of_exposure_ns(&has_bits);
758 _impl_.start_of_exposure_ns_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
759 CHK_(ptr);
760 } else {
761 goto handle_unusual;
762 }
763 continue;
764 // optional int64 start_of_frame_ns = 8;
765 case 8:
766 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 64)) {
767 _Internal::set_has_start_of_frame_ns(&has_bits);
768 _impl_.start_of_frame_ns_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
769 CHK_(ptr);
770 } else {
771 goto handle_unusual;
772 }
773 continue;
774 // optional int64 responses_all_sent_ns = 9;
775 case 9:
776 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 72)) {
777 _Internal::set_has_responses_all_sent_ns(&has_bits);
778 _impl_.responses_all_sent_ns_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
779 CHK_(ptr);
780 } else {
781 goto handle_unusual;
782 }
783 continue;
784 // optional .perfetto.protos.AndroidCameraFrameEvent.CaptureResultStatus capture_result_status = 10;
785 case 10:
786 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 80)) {
787 ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
788 CHK_(ptr);
789 if (PROTOBUF_PREDICT_TRUE(::perfetto::protos::AndroidCameraFrameEvent_CaptureResultStatus_IsValid(val))) {
790 _internal_set_capture_result_status(static_cast<::perfetto::protos::AndroidCameraFrameEvent_CaptureResultStatus>(val));
791 } else {
792 ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(10, val, mutable_unknown_fields());
793 }
794 } else {
795 goto handle_unusual;
796 }
797 continue;
798 // optional int32 skipped_sensor_frames = 11;
799 case 11:
800 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 88)) {
801 _Internal::set_has_skipped_sensor_frames(&has_bits);
802 _impl_.skipped_sensor_frames_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
803 CHK_(ptr);
804 } else {
805 goto handle_unusual;
806 }
807 continue;
808 // optional int32 capture_intent = 12;
809 case 12:
810 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 96)) {
811 _Internal::set_has_capture_intent(&has_bits);
812 _impl_.capture_intent_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
813 CHK_(ptr);
814 } else {
815 goto handle_unusual;
816 }
817 continue;
818 // optional int32 num_streams = 13;
819 case 13:
820 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 104)) {
821 _Internal::set_has_num_streams(&has_bits);
822 _impl_.num_streams_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
823 CHK_(ptr);
824 } else {
825 goto handle_unusual;
826 }
827 continue;
828 // repeated .perfetto.protos.AndroidCameraFrameEvent.CameraNodeProcessingDetails node_processing_details = 14;
829 case 14:
830 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 114)) {
831 ptr -= 1;
832 do {
833 ptr += 1;
834 ptr = ctx->ParseMessage(_internal_add_node_processing_details(), ptr);
835 CHK_(ptr);
836 if (!ctx->DataAvailable(ptr)) break;
837 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<114>(ptr));
838 } else {
839 goto handle_unusual;
840 }
841 continue;
842 // optional int32 vendor_data_version = 15;
843 case 15:
844 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 120)) {
845 _Internal::set_has_vendor_data_version(&has_bits);
846 _impl_.vendor_data_version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
847 CHK_(ptr);
848 } else {
849 goto handle_unusual;
850 }
851 continue;
852 // optional bytes vendor_data = 16;
853 case 16:
854 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 130)) {
855 auto str = _internal_mutable_vendor_data();
856 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
857 CHK_(ptr);
858 } else {
859 goto handle_unusual;
860 }
861 continue;
862 default:
863 goto handle_unusual;
864 } // switch
865 handle_unusual:
866 if ((tag == 0) || ((tag & 7) == 4)) {
867 CHK_(ptr);
868 ctx->SetLastTag(tag);
869 goto message_done;
870 }
871 ptr = UnknownFieldParse(
872 tag,
873 _internal_metadata_.mutable_unknown_fields<std::string>(),
874 ptr, ctx);
875 CHK_(ptr != nullptr);
876 } // while
877 message_done:
878 _impl_._has_bits_.Or(has_bits);
879 return ptr;
880 failure:
881 ptr = nullptr;
882 goto message_done;
883 #undef CHK_
884 }
885
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const886 ::uint8_t* AndroidCameraFrameEvent::_InternalSerialize(
887 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
888 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.AndroidCameraFrameEvent)
889 ::uint32_t cached_has_bits = 0;
890 (void) cached_has_bits;
891
892 cached_has_bits = _impl_._has_bits_[0];
893 // optional uint64 session_id = 1;
894 if (cached_has_bits & 0x00000002u) {
895 target = stream->EnsureSpace(target);
896 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_session_id(), target);
897 }
898
899 // optional uint32 camera_id = 2;
900 if (cached_has_bits & 0x00000040u) {
901 target = stream->EnsureSpace(target);
902 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_camera_id(), target);
903 }
904
905 // optional int64 frame_number = 3;
906 if (cached_has_bits & 0x00000004u) {
907 target = stream->EnsureSpace(target);
908 target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_frame_number(), target);
909 }
910
911 // optional int64 request_id = 4;
912 if (cached_has_bits & 0x00000008u) {
913 target = stream->EnsureSpace(target);
914 target = ::_pbi::WireFormatLite::WriteInt64ToArray(4, this->_internal_request_id(), target);
915 }
916
917 // optional int64 request_received_ns = 5;
918 if (cached_has_bits & 0x00000010u) {
919 target = stream->EnsureSpace(target);
920 target = ::_pbi::WireFormatLite::WriteInt64ToArray(5, this->_internal_request_received_ns(), target);
921 }
922
923 // optional int64 request_processing_started_ns = 6;
924 if (cached_has_bits & 0x00000020u) {
925 target = stream->EnsureSpace(target);
926 target = ::_pbi::WireFormatLite::WriteInt64ToArray(6, this->_internal_request_processing_started_ns(), target);
927 }
928
929 // optional int64 start_of_exposure_ns = 7;
930 if (cached_has_bits & 0x00000100u) {
931 target = stream->EnsureSpace(target);
932 target = ::_pbi::WireFormatLite::WriteInt64ToArray(7, this->_internal_start_of_exposure_ns(), target);
933 }
934
935 // optional int64 start_of_frame_ns = 8;
936 if (cached_has_bits & 0x00000200u) {
937 target = stream->EnsureSpace(target);
938 target = ::_pbi::WireFormatLite::WriteInt64ToArray(8, this->_internal_start_of_frame_ns(), target);
939 }
940
941 // optional int64 responses_all_sent_ns = 9;
942 if (cached_has_bits & 0x00000400u) {
943 target = stream->EnsureSpace(target);
944 target = ::_pbi::WireFormatLite::WriteInt64ToArray(9, this->_internal_responses_all_sent_ns(), target);
945 }
946
947 // optional .perfetto.protos.AndroidCameraFrameEvent.CaptureResultStatus capture_result_status = 10;
948 if (cached_has_bits & 0x00000080u) {
949 target = stream->EnsureSpace(target);
950 target = ::_pbi::WireFormatLite::WriteEnumToArray(
951 10, this->_internal_capture_result_status(), target);
952 }
953
954 // optional int32 skipped_sensor_frames = 11;
955 if (cached_has_bits & 0x00000800u) {
956 target = stream->EnsureSpace(target);
957 target = ::_pbi::WireFormatLite::WriteInt32ToArray(11, this->_internal_skipped_sensor_frames(), target);
958 }
959
960 // optional int32 capture_intent = 12;
961 if (cached_has_bits & 0x00001000u) {
962 target = stream->EnsureSpace(target);
963 target = ::_pbi::WireFormatLite::WriteInt32ToArray(12, this->_internal_capture_intent(), target);
964 }
965
966 // optional int32 num_streams = 13;
967 if (cached_has_bits & 0x00002000u) {
968 target = stream->EnsureSpace(target);
969 target = ::_pbi::WireFormatLite::WriteInt32ToArray(13, this->_internal_num_streams(), target);
970 }
971
972 // repeated .perfetto.protos.AndroidCameraFrameEvent.CameraNodeProcessingDetails node_processing_details = 14;
973 for (unsigned i = 0,
974 n = static_cast<unsigned>(this->_internal_node_processing_details_size()); i < n; i++) {
975 const auto& repfield = this->_internal_node_processing_details(i);
976 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
977 InternalWriteMessage(14, repfield, repfield.GetCachedSize(), target, stream);
978 }
979
980 // optional int32 vendor_data_version = 15;
981 if (cached_has_bits & 0x00004000u) {
982 target = stream->EnsureSpace(target);
983 target = ::_pbi::WireFormatLite::WriteInt32ToArray(15, this->_internal_vendor_data_version(), target);
984 }
985
986 // optional bytes vendor_data = 16;
987 if (cached_has_bits & 0x00000001u) {
988 target = stream->WriteBytesMaybeAliased(
989 16, this->_internal_vendor_data(), target);
990 }
991
992 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
993 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
994 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
995 }
996 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.AndroidCameraFrameEvent)
997 return target;
998 }
999
ByteSizeLong() const1000 size_t AndroidCameraFrameEvent::ByteSizeLong() const {
1001 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.AndroidCameraFrameEvent)
1002 size_t total_size = 0;
1003
1004 ::uint32_t cached_has_bits = 0;
1005 // Prevent compiler warnings about cached_has_bits being unused
1006 (void) cached_has_bits;
1007
1008 // repeated .perfetto.protos.AndroidCameraFrameEvent.CameraNodeProcessingDetails node_processing_details = 14;
1009 total_size += 1UL * this->_internal_node_processing_details_size();
1010 for (const auto& msg : this->_impl_.node_processing_details_) {
1011 total_size +=
1012 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
1013 }
1014
1015 cached_has_bits = _impl_._has_bits_[0];
1016 if (cached_has_bits & 0x000000ffu) {
1017 // optional bytes vendor_data = 16;
1018 if (cached_has_bits & 0x00000001u) {
1019 total_size += 2 +
1020 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
1021 this->_internal_vendor_data());
1022 }
1023
1024 // optional uint64 session_id = 1;
1025 if (cached_has_bits & 0x00000002u) {
1026 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_session_id());
1027 }
1028
1029 // optional int64 frame_number = 3;
1030 if (cached_has_bits & 0x00000004u) {
1031 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_frame_number());
1032 }
1033
1034 // optional int64 request_id = 4;
1035 if (cached_has_bits & 0x00000008u) {
1036 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_request_id());
1037 }
1038
1039 // optional int64 request_received_ns = 5;
1040 if (cached_has_bits & 0x00000010u) {
1041 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_request_received_ns());
1042 }
1043
1044 // optional int64 request_processing_started_ns = 6;
1045 if (cached_has_bits & 0x00000020u) {
1046 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_request_processing_started_ns());
1047 }
1048
1049 // optional uint32 camera_id = 2;
1050 if (cached_has_bits & 0x00000040u) {
1051 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_camera_id());
1052 }
1053
1054 // optional .perfetto.protos.AndroidCameraFrameEvent.CaptureResultStatus capture_result_status = 10;
1055 if (cached_has_bits & 0x00000080u) {
1056 total_size += 1 +
1057 ::_pbi::WireFormatLite::EnumSize(this->_internal_capture_result_status());
1058 }
1059
1060 }
1061 if (cached_has_bits & 0x00007f00u) {
1062 // optional int64 start_of_exposure_ns = 7;
1063 if (cached_has_bits & 0x00000100u) {
1064 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_start_of_exposure_ns());
1065 }
1066
1067 // optional int64 start_of_frame_ns = 8;
1068 if (cached_has_bits & 0x00000200u) {
1069 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_start_of_frame_ns());
1070 }
1071
1072 // optional int64 responses_all_sent_ns = 9;
1073 if (cached_has_bits & 0x00000400u) {
1074 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_responses_all_sent_ns());
1075 }
1076
1077 // optional int32 skipped_sensor_frames = 11;
1078 if (cached_has_bits & 0x00000800u) {
1079 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_skipped_sensor_frames());
1080 }
1081
1082 // optional int32 capture_intent = 12;
1083 if (cached_has_bits & 0x00001000u) {
1084 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_capture_intent());
1085 }
1086
1087 // optional int32 num_streams = 13;
1088 if (cached_has_bits & 0x00002000u) {
1089 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_num_streams());
1090 }
1091
1092 // optional int32 vendor_data_version = 15;
1093 if (cached_has_bits & 0x00004000u) {
1094 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_vendor_data_version());
1095 }
1096
1097 }
1098 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1099 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1100 }
1101 int cached_size = ::_pbi::ToCachedSize(total_size);
1102 SetCachedSize(cached_size);
1103 return total_size;
1104 }
1105
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1106 void AndroidCameraFrameEvent::CheckTypeAndMergeFrom(
1107 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1108 MergeFrom(*::_pbi::DownCast<const AndroidCameraFrameEvent*>(
1109 &from));
1110 }
1111
MergeFrom(const AndroidCameraFrameEvent & from)1112 void AndroidCameraFrameEvent::MergeFrom(const AndroidCameraFrameEvent& from) {
1113 AndroidCameraFrameEvent* const _this = this;
1114 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.AndroidCameraFrameEvent)
1115 GOOGLE_DCHECK_NE(&from, _this);
1116 ::uint32_t cached_has_bits = 0;
1117 (void) cached_has_bits;
1118
1119 _this->_impl_.node_processing_details_.MergeFrom(from._impl_.node_processing_details_);
1120 cached_has_bits = from._impl_._has_bits_[0];
1121 if (cached_has_bits & 0x000000ffu) {
1122 if (cached_has_bits & 0x00000001u) {
1123 _this->_internal_set_vendor_data(from._internal_vendor_data());
1124 }
1125 if (cached_has_bits & 0x00000002u) {
1126 _this->_impl_.session_id_ = from._impl_.session_id_;
1127 }
1128 if (cached_has_bits & 0x00000004u) {
1129 _this->_impl_.frame_number_ = from._impl_.frame_number_;
1130 }
1131 if (cached_has_bits & 0x00000008u) {
1132 _this->_impl_.request_id_ = from._impl_.request_id_;
1133 }
1134 if (cached_has_bits & 0x00000010u) {
1135 _this->_impl_.request_received_ns_ = from._impl_.request_received_ns_;
1136 }
1137 if (cached_has_bits & 0x00000020u) {
1138 _this->_impl_.request_processing_started_ns_ = from._impl_.request_processing_started_ns_;
1139 }
1140 if (cached_has_bits & 0x00000040u) {
1141 _this->_impl_.camera_id_ = from._impl_.camera_id_;
1142 }
1143 if (cached_has_bits & 0x00000080u) {
1144 _this->_impl_.capture_result_status_ = from._impl_.capture_result_status_;
1145 }
1146 _this->_impl_._has_bits_[0] |= cached_has_bits;
1147 }
1148 if (cached_has_bits & 0x00007f00u) {
1149 if (cached_has_bits & 0x00000100u) {
1150 _this->_impl_.start_of_exposure_ns_ = from._impl_.start_of_exposure_ns_;
1151 }
1152 if (cached_has_bits & 0x00000200u) {
1153 _this->_impl_.start_of_frame_ns_ = from._impl_.start_of_frame_ns_;
1154 }
1155 if (cached_has_bits & 0x00000400u) {
1156 _this->_impl_.responses_all_sent_ns_ = from._impl_.responses_all_sent_ns_;
1157 }
1158 if (cached_has_bits & 0x00000800u) {
1159 _this->_impl_.skipped_sensor_frames_ = from._impl_.skipped_sensor_frames_;
1160 }
1161 if (cached_has_bits & 0x00001000u) {
1162 _this->_impl_.capture_intent_ = from._impl_.capture_intent_;
1163 }
1164 if (cached_has_bits & 0x00002000u) {
1165 _this->_impl_.num_streams_ = from._impl_.num_streams_;
1166 }
1167 if (cached_has_bits & 0x00004000u) {
1168 _this->_impl_.vendor_data_version_ = from._impl_.vendor_data_version_;
1169 }
1170 _this->_impl_._has_bits_[0] |= cached_has_bits;
1171 }
1172 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1173 }
1174
CopyFrom(const AndroidCameraFrameEvent & from)1175 void AndroidCameraFrameEvent::CopyFrom(const AndroidCameraFrameEvent& from) {
1176 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.AndroidCameraFrameEvent)
1177 if (&from == this) return;
1178 Clear();
1179 MergeFrom(from);
1180 }
1181
IsInitialized() const1182 bool AndroidCameraFrameEvent::IsInitialized() const {
1183 return true;
1184 }
1185
InternalSwap(AndroidCameraFrameEvent * other)1186 void AndroidCameraFrameEvent::InternalSwap(AndroidCameraFrameEvent* other) {
1187 using std::swap;
1188 auto* lhs_arena = GetArenaForAllocation();
1189 auto* rhs_arena = other->GetArenaForAllocation();
1190 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1191 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1192 _impl_.node_processing_details_.InternalSwap(&other->_impl_.node_processing_details_);
1193 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1194 &_impl_.vendor_data_, lhs_arena,
1195 &other->_impl_.vendor_data_, rhs_arena
1196 );
1197 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1198 PROTOBUF_FIELD_OFFSET(AndroidCameraFrameEvent, _impl_.vendor_data_version_)
1199 + sizeof(AndroidCameraFrameEvent::_impl_.vendor_data_version_) // NOLINT
1200 - PROTOBUF_FIELD_OFFSET(AndroidCameraFrameEvent, _impl_.session_id_)>(
1201 reinterpret_cast<char*>(&_impl_.session_id_),
1202 reinterpret_cast<char*>(&other->_impl_.session_id_));
1203 }
1204
GetTypeName() const1205 std::string AndroidCameraFrameEvent::GetTypeName() const {
1206 return "perfetto.protos.AndroidCameraFrameEvent";
1207 }
1208
1209
1210 // ===================================================================
1211
1212 class AndroidCameraSessionStats_CameraGraph_CameraNode::_Internal {
1213 public:
1214 using HasBits = decltype(std::declval<AndroidCameraSessionStats_CameraGraph_CameraNode>()._impl_._has_bits_);
set_has_node_id(HasBits * has_bits)1215 static void set_has_node_id(HasBits* has_bits) {
1216 (*has_bits)[0] |= 2u;
1217 }
set_has_vendor_data_version(HasBits * has_bits)1218 static void set_has_vendor_data_version(HasBits* has_bits) {
1219 (*has_bits)[0] |= 4u;
1220 }
set_has_vendor_data(HasBits * has_bits)1221 static void set_has_vendor_data(HasBits* has_bits) {
1222 (*has_bits)[0] |= 1u;
1223 }
1224 };
1225
AndroidCameraSessionStats_CameraGraph_CameraNode(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1226 AndroidCameraSessionStats_CameraGraph_CameraNode::AndroidCameraSessionStats_CameraGraph_CameraNode(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1227 bool is_message_owned)
1228 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1229 SharedCtor(arena, is_message_owned);
1230 // @@protoc_insertion_point(arena_constructor:perfetto.protos.AndroidCameraSessionStats.CameraGraph.CameraNode)
1231 }
AndroidCameraSessionStats_CameraGraph_CameraNode(const AndroidCameraSessionStats_CameraGraph_CameraNode & from)1232 AndroidCameraSessionStats_CameraGraph_CameraNode::AndroidCameraSessionStats_CameraGraph_CameraNode(const AndroidCameraSessionStats_CameraGraph_CameraNode& from)
1233 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1234 AndroidCameraSessionStats_CameraGraph_CameraNode* const _this = this; (void)_this;
1235 new (&_impl_) Impl_{
1236 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1237 , /*decltype(_impl_._cached_size_)*/{}
1238 , decltype(_impl_.input_ids_){from._impl_.input_ids_}
1239 , decltype(_impl_.output_ids_){from._impl_.output_ids_}
1240 , decltype(_impl_.vendor_data_){}
1241 , decltype(_impl_.node_id_){}
1242 , decltype(_impl_.vendor_data_version_){}};
1243
1244 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1245 _impl_.vendor_data_.InitDefault();
1246 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1247 _impl_.vendor_data_.Set("", GetArenaForAllocation());
1248 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1249 if (from._internal_has_vendor_data()) {
1250 _this->_impl_.vendor_data_.Set(from._internal_vendor_data(),
1251 _this->GetArenaForAllocation());
1252 }
1253 ::memcpy(&_impl_.node_id_, &from._impl_.node_id_,
1254 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.vendor_data_version_) -
1255 reinterpret_cast<char*>(&_impl_.node_id_)) + sizeof(_impl_.vendor_data_version_));
1256 // @@protoc_insertion_point(copy_constructor:perfetto.protos.AndroidCameraSessionStats.CameraGraph.CameraNode)
1257 }
1258
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1259 inline void AndroidCameraSessionStats_CameraGraph_CameraNode::SharedCtor(
1260 ::_pb::Arena* arena, bool is_message_owned) {
1261 (void)arena;
1262 (void)is_message_owned;
1263 new (&_impl_) Impl_{
1264 decltype(_impl_._has_bits_){}
1265 , /*decltype(_impl_._cached_size_)*/{}
1266 , decltype(_impl_.input_ids_){arena}
1267 , decltype(_impl_.output_ids_){arena}
1268 , decltype(_impl_.vendor_data_){}
1269 , decltype(_impl_.node_id_){::int64_t{0}}
1270 , decltype(_impl_.vendor_data_version_){0}
1271 };
1272 _impl_.vendor_data_.InitDefault();
1273 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1274 _impl_.vendor_data_.Set("", GetArenaForAllocation());
1275 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1276 }
1277
~AndroidCameraSessionStats_CameraGraph_CameraNode()1278 AndroidCameraSessionStats_CameraGraph_CameraNode::~AndroidCameraSessionStats_CameraGraph_CameraNode() {
1279 // @@protoc_insertion_point(destructor:perfetto.protos.AndroidCameraSessionStats.CameraGraph.CameraNode)
1280 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1281 (void)arena;
1282 return;
1283 }
1284 SharedDtor();
1285 }
1286
SharedDtor()1287 inline void AndroidCameraSessionStats_CameraGraph_CameraNode::SharedDtor() {
1288 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1289 _impl_.input_ids_.~RepeatedField();
1290 _impl_.output_ids_.~RepeatedField();
1291 _impl_.vendor_data_.Destroy();
1292 }
1293
SetCachedSize(int size) const1294 void AndroidCameraSessionStats_CameraGraph_CameraNode::SetCachedSize(int size) const {
1295 _impl_._cached_size_.Set(size);
1296 }
1297
Clear()1298 void AndroidCameraSessionStats_CameraGraph_CameraNode::Clear() {
1299 // @@protoc_insertion_point(message_clear_start:perfetto.protos.AndroidCameraSessionStats.CameraGraph.CameraNode)
1300 ::uint32_t cached_has_bits = 0;
1301 // Prevent compiler warnings about cached_has_bits being unused
1302 (void) cached_has_bits;
1303
1304 _impl_.input_ids_.Clear();
1305 _impl_.output_ids_.Clear();
1306 cached_has_bits = _impl_._has_bits_[0];
1307 if (cached_has_bits & 0x00000001u) {
1308 _impl_.vendor_data_.ClearNonDefaultToEmpty();
1309 }
1310 if (cached_has_bits & 0x00000006u) {
1311 ::memset(&_impl_.node_id_, 0, static_cast<size_t>(
1312 reinterpret_cast<char*>(&_impl_.vendor_data_version_) -
1313 reinterpret_cast<char*>(&_impl_.node_id_)) + sizeof(_impl_.vendor_data_version_));
1314 }
1315 _impl_._has_bits_.Clear();
1316 _internal_metadata_.Clear<std::string>();
1317 }
1318
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1319 const char* AndroidCameraSessionStats_CameraGraph_CameraNode::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1320 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1321 _Internal::HasBits has_bits{};
1322 while (!ctx->Done(&ptr)) {
1323 ::uint32_t tag;
1324 ptr = ::_pbi::ReadTag(ptr, &tag);
1325 switch (tag >> 3) {
1326 // optional int64 node_id = 1;
1327 case 1:
1328 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1329 _Internal::set_has_node_id(&has_bits);
1330 _impl_.node_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1331 CHK_(ptr);
1332 } else {
1333 goto handle_unusual;
1334 }
1335 continue;
1336 // repeated int64 input_ids = 2;
1337 case 2:
1338 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1339 ptr -= 1;
1340 do {
1341 ptr += 1;
1342 _internal_add_input_ids(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
1343 CHK_(ptr);
1344 if (!ctx->DataAvailable(ptr)) break;
1345 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<16>(ptr));
1346 } else if (static_cast<::uint8_t>(tag) == 18) {
1347 ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(_internal_mutable_input_ids(), ptr, ctx);
1348 CHK_(ptr);
1349 } else {
1350 goto handle_unusual;
1351 }
1352 continue;
1353 // repeated int64 output_ids = 3;
1354 case 3:
1355 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1356 ptr -= 1;
1357 do {
1358 ptr += 1;
1359 _internal_add_output_ids(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
1360 CHK_(ptr);
1361 if (!ctx->DataAvailable(ptr)) break;
1362 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<24>(ptr));
1363 } else if (static_cast<::uint8_t>(tag) == 26) {
1364 ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(_internal_mutable_output_ids(), ptr, ctx);
1365 CHK_(ptr);
1366 } else {
1367 goto handle_unusual;
1368 }
1369 continue;
1370 // optional int32 vendor_data_version = 4;
1371 case 4:
1372 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
1373 _Internal::set_has_vendor_data_version(&has_bits);
1374 _impl_.vendor_data_version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1375 CHK_(ptr);
1376 } else {
1377 goto handle_unusual;
1378 }
1379 continue;
1380 // optional bytes vendor_data = 5;
1381 case 5:
1382 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
1383 auto str = _internal_mutable_vendor_data();
1384 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1385 CHK_(ptr);
1386 } else {
1387 goto handle_unusual;
1388 }
1389 continue;
1390 default:
1391 goto handle_unusual;
1392 } // switch
1393 handle_unusual:
1394 if ((tag == 0) || ((tag & 7) == 4)) {
1395 CHK_(ptr);
1396 ctx->SetLastTag(tag);
1397 goto message_done;
1398 }
1399 ptr = UnknownFieldParse(
1400 tag,
1401 _internal_metadata_.mutable_unknown_fields<std::string>(),
1402 ptr, ctx);
1403 CHK_(ptr != nullptr);
1404 } // while
1405 message_done:
1406 _impl_._has_bits_.Or(has_bits);
1407 return ptr;
1408 failure:
1409 ptr = nullptr;
1410 goto message_done;
1411 #undef CHK_
1412 }
1413
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1414 ::uint8_t* AndroidCameraSessionStats_CameraGraph_CameraNode::_InternalSerialize(
1415 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1416 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.AndroidCameraSessionStats.CameraGraph.CameraNode)
1417 ::uint32_t cached_has_bits = 0;
1418 (void) cached_has_bits;
1419
1420 cached_has_bits = _impl_._has_bits_[0];
1421 // optional int64 node_id = 1;
1422 if (cached_has_bits & 0x00000002u) {
1423 target = stream->EnsureSpace(target);
1424 target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_node_id(), target);
1425 }
1426
1427 // repeated int64 input_ids = 2;
1428 for (int i = 0, n = this->_internal_input_ids_size(); i < n; i++) {
1429 target = stream->EnsureSpace(target);
1430 target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_input_ids(i), target);
1431 }
1432
1433 // repeated int64 output_ids = 3;
1434 for (int i = 0, n = this->_internal_output_ids_size(); i < n; i++) {
1435 target = stream->EnsureSpace(target);
1436 target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_output_ids(i), target);
1437 }
1438
1439 // optional int32 vendor_data_version = 4;
1440 if (cached_has_bits & 0x00000004u) {
1441 target = stream->EnsureSpace(target);
1442 target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_vendor_data_version(), target);
1443 }
1444
1445 // optional bytes vendor_data = 5;
1446 if (cached_has_bits & 0x00000001u) {
1447 target = stream->WriteBytesMaybeAliased(
1448 5, this->_internal_vendor_data(), target);
1449 }
1450
1451 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1452 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1453 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1454 }
1455 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.AndroidCameraSessionStats.CameraGraph.CameraNode)
1456 return target;
1457 }
1458
ByteSizeLong() const1459 size_t AndroidCameraSessionStats_CameraGraph_CameraNode::ByteSizeLong() const {
1460 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.AndroidCameraSessionStats.CameraGraph.CameraNode)
1461 size_t total_size = 0;
1462
1463 ::uint32_t cached_has_bits = 0;
1464 // Prevent compiler warnings about cached_has_bits being unused
1465 (void) cached_has_bits;
1466
1467 // repeated int64 input_ids = 2;
1468 {
1469 size_t data_size = ::_pbi::WireFormatLite::
1470 Int64Size(this->_impl_.input_ids_);
1471 total_size += 1 *
1472 ::_pbi::FromIntSize(this->_internal_input_ids_size());
1473 total_size += data_size;
1474 }
1475
1476 // repeated int64 output_ids = 3;
1477 {
1478 size_t data_size = ::_pbi::WireFormatLite::
1479 Int64Size(this->_impl_.output_ids_);
1480 total_size += 1 *
1481 ::_pbi::FromIntSize(this->_internal_output_ids_size());
1482 total_size += data_size;
1483 }
1484
1485 cached_has_bits = _impl_._has_bits_[0];
1486 if (cached_has_bits & 0x00000007u) {
1487 // optional bytes vendor_data = 5;
1488 if (cached_has_bits & 0x00000001u) {
1489 total_size += 1 +
1490 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
1491 this->_internal_vendor_data());
1492 }
1493
1494 // optional int64 node_id = 1;
1495 if (cached_has_bits & 0x00000002u) {
1496 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_node_id());
1497 }
1498
1499 // optional int32 vendor_data_version = 4;
1500 if (cached_has_bits & 0x00000004u) {
1501 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_vendor_data_version());
1502 }
1503
1504 }
1505 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1506 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1507 }
1508 int cached_size = ::_pbi::ToCachedSize(total_size);
1509 SetCachedSize(cached_size);
1510 return total_size;
1511 }
1512
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1513 void AndroidCameraSessionStats_CameraGraph_CameraNode::CheckTypeAndMergeFrom(
1514 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1515 MergeFrom(*::_pbi::DownCast<const AndroidCameraSessionStats_CameraGraph_CameraNode*>(
1516 &from));
1517 }
1518
MergeFrom(const AndroidCameraSessionStats_CameraGraph_CameraNode & from)1519 void AndroidCameraSessionStats_CameraGraph_CameraNode::MergeFrom(const AndroidCameraSessionStats_CameraGraph_CameraNode& from) {
1520 AndroidCameraSessionStats_CameraGraph_CameraNode* const _this = this;
1521 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.AndroidCameraSessionStats.CameraGraph.CameraNode)
1522 GOOGLE_DCHECK_NE(&from, _this);
1523 ::uint32_t cached_has_bits = 0;
1524 (void) cached_has_bits;
1525
1526 _this->_impl_.input_ids_.MergeFrom(from._impl_.input_ids_);
1527 _this->_impl_.output_ids_.MergeFrom(from._impl_.output_ids_);
1528 cached_has_bits = from._impl_._has_bits_[0];
1529 if (cached_has_bits & 0x00000007u) {
1530 if (cached_has_bits & 0x00000001u) {
1531 _this->_internal_set_vendor_data(from._internal_vendor_data());
1532 }
1533 if (cached_has_bits & 0x00000002u) {
1534 _this->_impl_.node_id_ = from._impl_.node_id_;
1535 }
1536 if (cached_has_bits & 0x00000004u) {
1537 _this->_impl_.vendor_data_version_ = from._impl_.vendor_data_version_;
1538 }
1539 _this->_impl_._has_bits_[0] |= cached_has_bits;
1540 }
1541 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1542 }
1543
CopyFrom(const AndroidCameraSessionStats_CameraGraph_CameraNode & from)1544 void AndroidCameraSessionStats_CameraGraph_CameraNode::CopyFrom(const AndroidCameraSessionStats_CameraGraph_CameraNode& from) {
1545 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.AndroidCameraSessionStats.CameraGraph.CameraNode)
1546 if (&from == this) return;
1547 Clear();
1548 MergeFrom(from);
1549 }
1550
IsInitialized() const1551 bool AndroidCameraSessionStats_CameraGraph_CameraNode::IsInitialized() const {
1552 return true;
1553 }
1554
InternalSwap(AndroidCameraSessionStats_CameraGraph_CameraNode * other)1555 void AndroidCameraSessionStats_CameraGraph_CameraNode::InternalSwap(AndroidCameraSessionStats_CameraGraph_CameraNode* other) {
1556 using std::swap;
1557 auto* lhs_arena = GetArenaForAllocation();
1558 auto* rhs_arena = other->GetArenaForAllocation();
1559 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1560 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1561 _impl_.input_ids_.InternalSwap(&other->_impl_.input_ids_);
1562 _impl_.output_ids_.InternalSwap(&other->_impl_.output_ids_);
1563 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1564 &_impl_.vendor_data_, lhs_arena,
1565 &other->_impl_.vendor_data_, rhs_arena
1566 );
1567 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1568 PROTOBUF_FIELD_OFFSET(AndroidCameraSessionStats_CameraGraph_CameraNode, _impl_.vendor_data_version_)
1569 + sizeof(AndroidCameraSessionStats_CameraGraph_CameraNode::_impl_.vendor_data_version_) // NOLINT
1570 - PROTOBUF_FIELD_OFFSET(AndroidCameraSessionStats_CameraGraph_CameraNode, _impl_.node_id_)>(
1571 reinterpret_cast<char*>(&_impl_.node_id_),
1572 reinterpret_cast<char*>(&other->_impl_.node_id_));
1573 }
1574
GetTypeName() const1575 std::string AndroidCameraSessionStats_CameraGraph_CameraNode::GetTypeName() const {
1576 return "perfetto.protos.AndroidCameraSessionStats.CameraGraph.CameraNode";
1577 }
1578
1579
1580 // ===================================================================
1581
1582 class AndroidCameraSessionStats_CameraGraph_CameraEdge::_Internal {
1583 public:
1584 using HasBits = decltype(std::declval<AndroidCameraSessionStats_CameraGraph_CameraEdge>()._impl_._has_bits_);
set_has_output_node_id(HasBits * has_bits)1585 static void set_has_output_node_id(HasBits* has_bits) {
1586 (*has_bits)[0] |= 2u;
1587 }
set_has_output_id(HasBits * has_bits)1588 static void set_has_output_id(HasBits* has_bits) {
1589 (*has_bits)[0] |= 4u;
1590 }
set_has_input_node_id(HasBits * has_bits)1591 static void set_has_input_node_id(HasBits* has_bits) {
1592 (*has_bits)[0] |= 8u;
1593 }
set_has_input_id(HasBits * has_bits)1594 static void set_has_input_id(HasBits* has_bits) {
1595 (*has_bits)[0] |= 16u;
1596 }
set_has_vendor_data_version(HasBits * has_bits)1597 static void set_has_vendor_data_version(HasBits* has_bits) {
1598 (*has_bits)[0] |= 32u;
1599 }
set_has_vendor_data(HasBits * has_bits)1600 static void set_has_vendor_data(HasBits* has_bits) {
1601 (*has_bits)[0] |= 1u;
1602 }
1603 };
1604
AndroidCameraSessionStats_CameraGraph_CameraEdge(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1605 AndroidCameraSessionStats_CameraGraph_CameraEdge::AndroidCameraSessionStats_CameraGraph_CameraEdge(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1606 bool is_message_owned)
1607 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1608 SharedCtor(arena, is_message_owned);
1609 // @@protoc_insertion_point(arena_constructor:perfetto.protos.AndroidCameraSessionStats.CameraGraph.CameraEdge)
1610 }
AndroidCameraSessionStats_CameraGraph_CameraEdge(const AndroidCameraSessionStats_CameraGraph_CameraEdge & from)1611 AndroidCameraSessionStats_CameraGraph_CameraEdge::AndroidCameraSessionStats_CameraGraph_CameraEdge(const AndroidCameraSessionStats_CameraGraph_CameraEdge& from)
1612 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1613 AndroidCameraSessionStats_CameraGraph_CameraEdge* const _this = this; (void)_this;
1614 new (&_impl_) Impl_{
1615 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1616 , /*decltype(_impl_._cached_size_)*/{}
1617 , decltype(_impl_.vendor_data_){}
1618 , decltype(_impl_.output_node_id_){}
1619 , decltype(_impl_.output_id_){}
1620 , decltype(_impl_.input_node_id_){}
1621 , decltype(_impl_.input_id_){}
1622 , decltype(_impl_.vendor_data_version_){}};
1623
1624 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1625 _impl_.vendor_data_.InitDefault();
1626 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1627 _impl_.vendor_data_.Set("", GetArenaForAllocation());
1628 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1629 if (from._internal_has_vendor_data()) {
1630 _this->_impl_.vendor_data_.Set(from._internal_vendor_data(),
1631 _this->GetArenaForAllocation());
1632 }
1633 ::memcpy(&_impl_.output_node_id_, &from._impl_.output_node_id_,
1634 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.vendor_data_version_) -
1635 reinterpret_cast<char*>(&_impl_.output_node_id_)) + sizeof(_impl_.vendor_data_version_));
1636 // @@protoc_insertion_point(copy_constructor:perfetto.protos.AndroidCameraSessionStats.CameraGraph.CameraEdge)
1637 }
1638
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1639 inline void AndroidCameraSessionStats_CameraGraph_CameraEdge::SharedCtor(
1640 ::_pb::Arena* arena, bool is_message_owned) {
1641 (void)arena;
1642 (void)is_message_owned;
1643 new (&_impl_) Impl_{
1644 decltype(_impl_._has_bits_){}
1645 , /*decltype(_impl_._cached_size_)*/{}
1646 , decltype(_impl_.vendor_data_){}
1647 , decltype(_impl_.output_node_id_){::int64_t{0}}
1648 , decltype(_impl_.output_id_){::int64_t{0}}
1649 , decltype(_impl_.input_node_id_){::int64_t{0}}
1650 , decltype(_impl_.input_id_){::int64_t{0}}
1651 , decltype(_impl_.vendor_data_version_){0}
1652 };
1653 _impl_.vendor_data_.InitDefault();
1654 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1655 _impl_.vendor_data_.Set("", GetArenaForAllocation());
1656 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1657 }
1658
~AndroidCameraSessionStats_CameraGraph_CameraEdge()1659 AndroidCameraSessionStats_CameraGraph_CameraEdge::~AndroidCameraSessionStats_CameraGraph_CameraEdge() {
1660 // @@protoc_insertion_point(destructor:perfetto.protos.AndroidCameraSessionStats.CameraGraph.CameraEdge)
1661 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1662 (void)arena;
1663 return;
1664 }
1665 SharedDtor();
1666 }
1667
SharedDtor()1668 inline void AndroidCameraSessionStats_CameraGraph_CameraEdge::SharedDtor() {
1669 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1670 _impl_.vendor_data_.Destroy();
1671 }
1672
SetCachedSize(int size) const1673 void AndroidCameraSessionStats_CameraGraph_CameraEdge::SetCachedSize(int size) const {
1674 _impl_._cached_size_.Set(size);
1675 }
1676
Clear()1677 void AndroidCameraSessionStats_CameraGraph_CameraEdge::Clear() {
1678 // @@protoc_insertion_point(message_clear_start:perfetto.protos.AndroidCameraSessionStats.CameraGraph.CameraEdge)
1679 ::uint32_t cached_has_bits = 0;
1680 // Prevent compiler warnings about cached_has_bits being unused
1681 (void) cached_has_bits;
1682
1683 cached_has_bits = _impl_._has_bits_[0];
1684 if (cached_has_bits & 0x00000001u) {
1685 _impl_.vendor_data_.ClearNonDefaultToEmpty();
1686 }
1687 if (cached_has_bits & 0x0000003eu) {
1688 ::memset(&_impl_.output_node_id_, 0, static_cast<size_t>(
1689 reinterpret_cast<char*>(&_impl_.vendor_data_version_) -
1690 reinterpret_cast<char*>(&_impl_.output_node_id_)) + sizeof(_impl_.vendor_data_version_));
1691 }
1692 _impl_._has_bits_.Clear();
1693 _internal_metadata_.Clear<std::string>();
1694 }
1695
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1696 const char* AndroidCameraSessionStats_CameraGraph_CameraEdge::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1697 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1698 _Internal::HasBits has_bits{};
1699 while (!ctx->Done(&ptr)) {
1700 ::uint32_t tag;
1701 ptr = ::_pbi::ReadTag(ptr, &tag);
1702 switch (tag >> 3) {
1703 // optional int64 output_node_id = 1;
1704 case 1:
1705 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1706 _Internal::set_has_output_node_id(&has_bits);
1707 _impl_.output_node_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1708 CHK_(ptr);
1709 } else {
1710 goto handle_unusual;
1711 }
1712 continue;
1713 // optional int64 output_id = 2;
1714 case 2:
1715 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1716 _Internal::set_has_output_id(&has_bits);
1717 _impl_.output_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1718 CHK_(ptr);
1719 } else {
1720 goto handle_unusual;
1721 }
1722 continue;
1723 // optional int64 input_node_id = 3;
1724 case 3:
1725 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1726 _Internal::set_has_input_node_id(&has_bits);
1727 _impl_.input_node_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1728 CHK_(ptr);
1729 } else {
1730 goto handle_unusual;
1731 }
1732 continue;
1733 // optional int64 input_id = 4;
1734 case 4:
1735 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
1736 _Internal::set_has_input_id(&has_bits);
1737 _impl_.input_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1738 CHK_(ptr);
1739 } else {
1740 goto handle_unusual;
1741 }
1742 continue;
1743 // optional int32 vendor_data_version = 5;
1744 case 5:
1745 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
1746 _Internal::set_has_vendor_data_version(&has_bits);
1747 _impl_.vendor_data_version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1748 CHK_(ptr);
1749 } else {
1750 goto handle_unusual;
1751 }
1752 continue;
1753 // optional bytes vendor_data = 6;
1754 case 6:
1755 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
1756 auto str = _internal_mutable_vendor_data();
1757 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1758 CHK_(ptr);
1759 } else {
1760 goto handle_unusual;
1761 }
1762 continue;
1763 default:
1764 goto handle_unusual;
1765 } // switch
1766 handle_unusual:
1767 if ((tag == 0) || ((tag & 7) == 4)) {
1768 CHK_(ptr);
1769 ctx->SetLastTag(tag);
1770 goto message_done;
1771 }
1772 ptr = UnknownFieldParse(
1773 tag,
1774 _internal_metadata_.mutable_unknown_fields<std::string>(),
1775 ptr, ctx);
1776 CHK_(ptr != nullptr);
1777 } // while
1778 message_done:
1779 _impl_._has_bits_.Or(has_bits);
1780 return ptr;
1781 failure:
1782 ptr = nullptr;
1783 goto message_done;
1784 #undef CHK_
1785 }
1786
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1787 ::uint8_t* AndroidCameraSessionStats_CameraGraph_CameraEdge::_InternalSerialize(
1788 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1789 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.AndroidCameraSessionStats.CameraGraph.CameraEdge)
1790 ::uint32_t cached_has_bits = 0;
1791 (void) cached_has_bits;
1792
1793 cached_has_bits = _impl_._has_bits_[0];
1794 // optional int64 output_node_id = 1;
1795 if (cached_has_bits & 0x00000002u) {
1796 target = stream->EnsureSpace(target);
1797 target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_output_node_id(), target);
1798 }
1799
1800 // optional int64 output_id = 2;
1801 if (cached_has_bits & 0x00000004u) {
1802 target = stream->EnsureSpace(target);
1803 target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_output_id(), target);
1804 }
1805
1806 // optional int64 input_node_id = 3;
1807 if (cached_has_bits & 0x00000008u) {
1808 target = stream->EnsureSpace(target);
1809 target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_input_node_id(), target);
1810 }
1811
1812 // optional int64 input_id = 4;
1813 if (cached_has_bits & 0x00000010u) {
1814 target = stream->EnsureSpace(target);
1815 target = ::_pbi::WireFormatLite::WriteInt64ToArray(4, this->_internal_input_id(), target);
1816 }
1817
1818 // optional int32 vendor_data_version = 5;
1819 if (cached_has_bits & 0x00000020u) {
1820 target = stream->EnsureSpace(target);
1821 target = ::_pbi::WireFormatLite::WriteInt32ToArray(5, this->_internal_vendor_data_version(), target);
1822 }
1823
1824 // optional bytes vendor_data = 6;
1825 if (cached_has_bits & 0x00000001u) {
1826 target = stream->WriteBytesMaybeAliased(
1827 6, this->_internal_vendor_data(), target);
1828 }
1829
1830 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1831 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1832 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1833 }
1834 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.AndroidCameraSessionStats.CameraGraph.CameraEdge)
1835 return target;
1836 }
1837
ByteSizeLong() const1838 size_t AndroidCameraSessionStats_CameraGraph_CameraEdge::ByteSizeLong() const {
1839 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.AndroidCameraSessionStats.CameraGraph.CameraEdge)
1840 size_t total_size = 0;
1841
1842 ::uint32_t cached_has_bits = 0;
1843 // Prevent compiler warnings about cached_has_bits being unused
1844 (void) cached_has_bits;
1845
1846 cached_has_bits = _impl_._has_bits_[0];
1847 if (cached_has_bits & 0x0000003fu) {
1848 // optional bytes vendor_data = 6;
1849 if (cached_has_bits & 0x00000001u) {
1850 total_size += 1 +
1851 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
1852 this->_internal_vendor_data());
1853 }
1854
1855 // optional int64 output_node_id = 1;
1856 if (cached_has_bits & 0x00000002u) {
1857 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_output_node_id());
1858 }
1859
1860 // optional int64 output_id = 2;
1861 if (cached_has_bits & 0x00000004u) {
1862 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_output_id());
1863 }
1864
1865 // optional int64 input_node_id = 3;
1866 if (cached_has_bits & 0x00000008u) {
1867 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_input_node_id());
1868 }
1869
1870 // optional int64 input_id = 4;
1871 if (cached_has_bits & 0x00000010u) {
1872 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_input_id());
1873 }
1874
1875 // optional int32 vendor_data_version = 5;
1876 if (cached_has_bits & 0x00000020u) {
1877 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_vendor_data_version());
1878 }
1879
1880 }
1881 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1882 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1883 }
1884 int cached_size = ::_pbi::ToCachedSize(total_size);
1885 SetCachedSize(cached_size);
1886 return total_size;
1887 }
1888
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1889 void AndroidCameraSessionStats_CameraGraph_CameraEdge::CheckTypeAndMergeFrom(
1890 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1891 MergeFrom(*::_pbi::DownCast<const AndroidCameraSessionStats_CameraGraph_CameraEdge*>(
1892 &from));
1893 }
1894
MergeFrom(const AndroidCameraSessionStats_CameraGraph_CameraEdge & from)1895 void AndroidCameraSessionStats_CameraGraph_CameraEdge::MergeFrom(const AndroidCameraSessionStats_CameraGraph_CameraEdge& from) {
1896 AndroidCameraSessionStats_CameraGraph_CameraEdge* const _this = this;
1897 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.AndroidCameraSessionStats.CameraGraph.CameraEdge)
1898 GOOGLE_DCHECK_NE(&from, _this);
1899 ::uint32_t cached_has_bits = 0;
1900 (void) cached_has_bits;
1901
1902 cached_has_bits = from._impl_._has_bits_[0];
1903 if (cached_has_bits & 0x0000003fu) {
1904 if (cached_has_bits & 0x00000001u) {
1905 _this->_internal_set_vendor_data(from._internal_vendor_data());
1906 }
1907 if (cached_has_bits & 0x00000002u) {
1908 _this->_impl_.output_node_id_ = from._impl_.output_node_id_;
1909 }
1910 if (cached_has_bits & 0x00000004u) {
1911 _this->_impl_.output_id_ = from._impl_.output_id_;
1912 }
1913 if (cached_has_bits & 0x00000008u) {
1914 _this->_impl_.input_node_id_ = from._impl_.input_node_id_;
1915 }
1916 if (cached_has_bits & 0x00000010u) {
1917 _this->_impl_.input_id_ = from._impl_.input_id_;
1918 }
1919 if (cached_has_bits & 0x00000020u) {
1920 _this->_impl_.vendor_data_version_ = from._impl_.vendor_data_version_;
1921 }
1922 _this->_impl_._has_bits_[0] |= cached_has_bits;
1923 }
1924 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1925 }
1926
CopyFrom(const AndroidCameraSessionStats_CameraGraph_CameraEdge & from)1927 void AndroidCameraSessionStats_CameraGraph_CameraEdge::CopyFrom(const AndroidCameraSessionStats_CameraGraph_CameraEdge& from) {
1928 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.AndroidCameraSessionStats.CameraGraph.CameraEdge)
1929 if (&from == this) return;
1930 Clear();
1931 MergeFrom(from);
1932 }
1933
IsInitialized() const1934 bool AndroidCameraSessionStats_CameraGraph_CameraEdge::IsInitialized() const {
1935 return true;
1936 }
1937
InternalSwap(AndroidCameraSessionStats_CameraGraph_CameraEdge * other)1938 void AndroidCameraSessionStats_CameraGraph_CameraEdge::InternalSwap(AndroidCameraSessionStats_CameraGraph_CameraEdge* other) {
1939 using std::swap;
1940 auto* lhs_arena = GetArenaForAllocation();
1941 auto* rhs_arena = other->GetArenaForAllocation();
1942 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1943 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1944 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1945 &_impl_.vendor_data_, lhs_arena,
1946 &other->_impl_.vendor_data_, rhs_arena
1947 );
1948 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1949 PROTOBUF_FIELD_OFFSET(AndroidCameraSessionStats_CameraGraph_CameraEdge, _impl_.vendor_data_version_)
1950 + sizeof(AndroidCameraSessionStats_CameraGraph_CameraEdge::_impl_.vendor_data_version_) // NOLINT
1951 - PROTOBUF_FIELD_OFFSET(AndroidCameraSessionStats_CameraGraph_CameraEdge, _impl_.output_node_id_)>(
1952 reinterpret_cast<char*>(&_impl_.output_node_id_),
1953 reinterpret_cast<char*>(&other->_impl_.output_node_id_));
1954 }
1955
GetTypeName() const1956 std::string AndroidCameraSessionStats_CameraGraph_CameraEdge::GetTypeName() const {
1957 return "perfetto.protos.AndroidCameraSessionStats.CameraGraph.CameraEdge";
1958 }
1959
1960
1961 // ===================================================================
1962
1963 class AndroidCameraSessionStats_CameraGraph::_Internal {
1964 public:
1965 };
1966
AndroidCameraSessionStats_CameraGraph(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1967 AndroidCameraSessionStats_CameraGraph::AndroidCameraSessionStats_CameraGraph(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1968 bool is_message_owned)
1969 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1970 SharedCtor(arena, is_message_owned);
1971 // @@protoc_insertion_point(arena_constructor:perfetto.protos.AndroidCameraSessionStats.CameraGraph)
1972 }
AndroidCameraSessionStats_CameraGraph(const AndroidCameraSessionStats_CameraGraph & from)1973 AndroidCameraSessionStats_CameraGraph::AndroidCameraSessionStats_CameraGraph(const AndroidCameraSessionStats_CameraGraph& from)
1974 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1975 AndroidCameraSessionStats_CameraGraph* const _this = this; (void)_this;
1976 new (&_impl_) Impl_{
1977 decltype(_impl_.nodes_){from._impl_.nodes_}
1978 , decltype(_impl_.edges_){from._impl_.edges_}
1979 , /*decltype(_impl_._cached_size_)*/{}};
1980
1981 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1982 // @@protoc_insertion_point(copy_constructor:perfetto.protos.AndroidCameraSessionStats.CameraGraph)
1983 }
1984
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1985 inline void AndroidCameraSessionStats_CameraGraph::SharedCtor(
1986 ::_pb::Arena* arena, bool is_message_owned) {
1987 (void)arena;
1988 (void)is_message_owned;
1989 new (&_impl_) Impl_{
1990 decltype(_impl_.nodes_){arena}
1991 , decltype(_impl_.edges_){arena}
1992 , /*decltype(_impl_._cached_size_)*/{}
1993 };
1994 }
1995
~AndroidCameraSessionStats_CameraGraph()1996 AndroidCameraSessionStats_CameraGraph::~AndroidCameraSessionStats_CameraGraph() {
1997 // @@protoc_insertion_point(destructor:perfetto.protos.AndroidCameraSessionStats.CameraGraph)
1998 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1999 (void)arena;
2000 return;
2001 }
2002 SharedDtor();
2003 }
2004
SharedDtor()2005 inline void AndroidCameraSessionStats_CameraGraph::SharedDtor() {
2006 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2007 _impl_.nodes_.~RepeatedPtrField();
2008 _impl_.edges_.~RepeatedPtrField();
2009 }
2010
SetCachedSize(int size) const2011 void AndroidCameraSessionStats_CameraGraph::SetCachedSize(int size) const {
2012 _impl_._cached_size_.Set(size);
2013 }
2014
Clear()2015 void AndroidCameraSessionStats_CameraGraph::Clear() {
2016 // @@protoc_insertion_point(message_clear_start:perfetto.protos.AndroidCameraSessionStats.CameraGraph)
2017 ::uint32_t cached_has_bits = 0;
2018 // Prevent compiler warnings about cached_has_bits being unused
2019 (void) cached_has_bits;
2020
2021 _impl_.nodes_.Clear();
2022 _impl_.edges_.Clear();
2023 _internal_metadata_.Clear<std::string>();
2024 }
2025
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2026 const char* AndroidCameraSessionStats_CameraGraph::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2027 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2028 while (!ctx->Done(&ptr)) {
2029 ::uint32_t tag;
2030 ptr = ::_pbi::ReadTag(ptr, &tag);
2031 switch (tag >> 3) {
2032 // repeated .perfetto.protos.AndroidCameraSessionStats.CameraGraph.CameraNode nodes = 1;
2033 case 1:
2034 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
2035 ptr -= 1;
2036 do {
2037 ptr += 1;
2038 ptr = ctx->ParseMessage(_internal_add_nodes(), ptr);
2039 CHK_(ptr);
2040 if (!ctx->DataAvailable(ptr)) break;
2041 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
2042 } else {
2043 goto handle_unusual;
2044 }
2045 continue;
2046 // repeated .perfetto.protos.AndroidCameraSessionStats.CameraGraph.CameraEdge edges = 2;
2047 case 2:
2048 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
2049 ptr -= 1;
2050 do {
2051 ptr += 1;
2052 ptr = ctx->ParseMessage(_internal_add_edges(), ptr);
2053 CHK_(ptr);
2054 if (!ctx->DataAvailable(ptr)) break;
2055 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
2056 } else {
2057 goto handle_unusual;
2058 }
2059 continue;
2060 default:
2061 goto handle_unusual;
2062 } // switch
2063 handle_unusual:
2064 if ((tag == 0) || ((tag & 7) == 4)) {
2065 CHK_(ptr);
2066 ctx->SetLastTag(tag);
2067 goto message_done;
2068 }
2069 ptr = UnknownFieldParse(
2070 tag,
2071 _internal_metadata_.mutable_unknown_fields<std::string>(),
2072 ptr, ctx);
2073 CHK_(ptr != nullptr);
2074 } // while
2075 message_done:
2076 return ptr;
2077 failure:
2078 ptr = nullptr;
2079 goto message_done;
2080 #undef CHK_
2081 }
2082
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2083 ::uint8_t* AndroidCameraSessionStats_CameraGraph::_InternalSerialize(
2084 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2085 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.AndroidCameraSessionStats.CameraGraph)
2086 ::uint32_t cached_has_bits = 0;
2087 (void) cached_has_bits;
2088
2089 // repeated .perfetto.protos.AndroidCameraSessionStats.CameraGraph.CameraNode nodes = 1;
2090 for (unsigned i = 0,
2091 n = static_cast<unsigned>(this->_internal_nodes_size()); i < n; i++) {
2092 const auto& repfield = this->_internal_nodes(i);
2093 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
2094 InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
2095 }
2096
2097 // repeated .perfetto.protos.AndroidCameraSessionStats.CameraGraph.CameraEdge edges = 2;
2098 for (unsigned i = 0,
2099 n = static_cast<unsigned>(this->_internal_edges_size()); i < n; i++) {
2100 const auto& repfield = this->_internal_edges(i);
2101 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
2102 InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream);
2103 }
2104
2105 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2106 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2107 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2108 }
2109 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.AndroidCameraSessionStats.CameraGraph)
2110 return target;
2111 }
2112
ByteSizeLong() const2113 size_t AndroidCameraSessionStats_CameraGraph::ByteSizeLong() const {
2114 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.AndroidCameraSessionStats.CameraGraph)
2115 size_t total_size = 0;
2116
2117 ::uint32_t cached_has_bits = 0;
2118 // Prevent compiler warnings about cached_has_bits being unused
2119 (void) cached_has_bits;
2120
2121 // repeated .perfetto.protos.AndroidCameraSessionStats.CameraGraph.CameraNode nodes = 1;
2122 total_size += 1UL * this->_internal_nodes_size();
2123 for (const auto& msg : this->_impl_.nodes_) {
2124 total_size +=
2125 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
2126 }
2127
2128 // repeated .perfetto.protos.AndroidCameraSessionStats.CameraGraph.CameraEdge edges = 2;
2129 total_size += 1UL * this->_internal_edges_size();
2130 for (const auto& msg : this->_impl_.edges_) {
2131 total_size +=
2132 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
2133 }
2134
2135 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2136 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2137 }
2138 int cached_size = ::_pbi::ToCachedSize(total_size);
2139 SetCachedSize(cached_size);
2140 return total_size;
2141 }
2142
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2143 void AndroidCameraSessionStats_CameraGraph::CheckTypeAndMergeFrom(
2144 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2145 MergeFrom(*::_pbi::DownCast<const AndroidCameraSessionStats_CameraGraph*>(
2146 &from));
2147 }
2148
MergeFrom(const AndroidCameraSessionStats_CameraGraph & from)2149 void AndroidCameraSessionStats_CameraGraph::MergeFrom(const AndroidCameraSessionStats_CameraGraph& from) {
2150 AndroidCameraSessionStats_CameraGraph* const _this = this;
2151 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.AndroidCameraSessionStats.CameraGraph)
2152 GOOGLE_DCHECK_NE(&from, _this);
2153 ::uint32_t cached_has_bits = 0;
2154 (void) cached_has_bits;
2155
2156 _this->_impl_.nodes_.MergeFrom(from._impl_.nodes_);
2157 _this->_impl_.edges_.MergeFrom(from._impl_.edges_);
2158 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2159 }
2160
CopyFrom(const AndroidCameraSessionStats_CameraGraph & from)2161 void AndroidCameraSessionStats_CameraGraph::CopyFrom(const AndroidCameraSessionStats_CameraGraph& from) {
2162 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.AndroidCameraSessionStats.CameraGraph)
2163 if (&from == this) return;
2164 Clear();
2165 MergeFrom(from);
2166 }
2167
IsInitialized() const2168 bool AndroidCameraSessionStats_CameraGraph::IsInitialized() const {
2169 return true;
2170 }
2171
InternalSwap(AndroidCameraSessionStats_CameraGraph * other)2172 void AndroidCameraSessionStats_CameraGraph::InternalSwap(AndroidCameraSessionStats_CameraGraph* other) {
2173 using std::swap;
2174 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2175 _impl_.nodes_.InternalSwap(&other->_impl_.nodes_);
2176 _impl_.edges_.InternalSwap(&other->_impl_.edges_);
2177 }
2178
GetTypeName() const2179 std::string AndroidCameraSessionStats_CameraGraph::GetTypeName() const {
2180 return "perfetto.protos.AndroidCameraSessionStats.CameraGraph";
2181 }
2182
2183
2184 // ===================================================================
2185
2186 class AndroidCameraSessionStats::_Internal {
2187 public:
2188 using HasBits = decltype(std::declval<AndroidCameraSessionStats>()._impl_._has_bits_);
set_has_session_id(HasBits * has_bits)2189 static void set_has_session_id(HasBits* has_bits) {
2190 (*has_bits)[0] |= 2u;
2191 }
2192 static const ::perfetto::protos::AndroidCameraSessionStats_CameraGraph& graph(const AndroidCameraSessionStats* msg);
set_has_graph(HasBits * has_bits)2193 static void set_has_graph(HasBits* has_bits) {
2194 (*has_bits)[0] |= 1u;
2195 }
2196 };
2197
2198 const ::perfetto::protos::AndroidCameraSessionStats_CameraGraph&
graph(const AndroidCameraSessionStats * msg)2199 AndroidCameraSessionStats::_Internal::graph(const AndroidCameraSessionStats* msg) {
2200 return *msg->_impl_.graph_;
2201 }
AndroidCameraSessionStats(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2202 AndroidCameraSessionStats::AndroidCameraSessionStats(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2203 bool is_message_owned)
2204 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2205 SharedCtor(arena, is_message_owned);
2206 // @@protoc_insertion_point(arena_constructor:perfetto.protos.AndroidCameraSessionStats)
2207 }
AndroidCameraSessionStats(const AndroidCameraSessionStats & from)2208 AndroidCameraSessionStats::AndroidCameraSessionStats(const AndroidCameraSessionStats& from)
2209 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2210 AndroidCameraSessionStats* const _this = this; (void)_this;
2211 new (&_impl_) Impl_{
2212 decltype(_impl_._has_bits_){from._impl_._has_bits_}
2213 , /*decltype(_impl_._cached_size_)*/{}
2214 , decltype(_impl_.graph_){nullptr}
2215 , decltype(_impl_.session_id_){}};
2216
2217 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2218 if (from._internal_has_graph()) {
2219 _this->_impl_.graph_ = new ::perfetto::protos::AndroidCameraSessionStats_CameraGraph(*from._impl_.graph_);
2220 }
2221 _this->_impl_.session_id_ = from._impl_.session_id_;
2222 // @@protoc_insertion_point(copy_constructor:perfetto.protos.AndroidCameraSessionStats)
2223 }
2224
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2225 inline void AndroidCameraSessionStats::SharedCtor(
2226 ::_pb::Arena* arena, bool is_message_owned) {
2227 (void)arena;
2228 (void)is_message_owned;
2229 new (&_impl_) Impl_{
2230 decltype(_impl_._has_bits_){}
2231 , /*decltype(_impl_._cached_size_)*/{}
2232 , decltype(_impl_.graph_){nullptr}
2233 , decltype(_impl_.session_id_){::uint64_t{0u}}
2234 };
2235 }
2236
~AndroidCameraSessionStats()2237 AndroidCameraSessionStats::~AndroidCameraSessionStats() {
2238 // @@protoc_insertion_point(destructor:perfetto.protos.AndroidCameraSessionStats)
2239 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2240 (void)arena;
2241 return;
2242 }
2243 SharedDtor();
2244 }
2245
SharedDtor()2246 inline void AndroidCameraSessionStats::SharedDtor() {
2247 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2248 if (this != internal_default_instance()) delete _impl_.graph_;
2249 }
2250
SetCachedSize(int size) const2251 void AndroidCameraSessionStats::SetCachedSize(int size) const {
2252 _impl_._cached_size_.Set(size);
2253 }
2254
Clear()2255 void AndroidCameraSessionStats::Clear() {
2256 // @@protoc_insertion_point(message_clear_start:perfetto.protos.AndroidCameraSessionStats)
2257 ::uint32_t cached_has_bits = 0;
2258 // Prevent compiler warnings about cached_has_bits being unused
2259 (void) cached_has_bits;
2260
2261 cached_has_bits = _impl_._has_bits_[0];
2262 if (cached_has_bits & 0x00000001u) {
2263 GOOGLE_DCHECK(_impl_.graph_ != nullptr);
2264 _impl_.graph_->Clear();
2265 }
2266 _impl_.session_id_ = ::uint64_t{0u};
2267 _impl_._has_bits_.Clear();
2268 _internal_metadata_.Clear<std::string>();
2269 }
2270
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2271 const char* AndroidCameraSessionStats::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2272 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2273 _Internal::HasBits has_bits{};
2274 while (!ctx->Done(&ptr)) {
2275 ::uint32_t tag;
2276 ptr = ::_pbi::ReadTag(ptr, &tag);
2277 switch (tag >> 3) {
2278 // optional uint64 session_id = 1;
2279 case 1:
2280 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
2281 _Internal::set_has_session_id(&has_bits);
2282 _impl_.session_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2283 CHK_(ptr);
2284 } else {
2285 goto handle_unusual;
2286 }
2287 continue;
2288 // optional .perfetto.protos.AndroidCameraSessionStats.CameraGraph graph = 2;
2289 case 2:
2290 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
2291 ptr = ctx->ParseMessage(_internal_mutable_graph(), ptr);
2292 CHK_(ptr);
2293 } else {
2294 goto handle_unusual;
2295 }
2296 continue;
2297 default:
2298 goto handle_unusual;
2299 } // switch
2300 handle_unusual:
2301 if ((tag == 0) || ((tag & 7) == 4)) {
2302 CHK_(ptr);
2303 ctx->SetLastTag(tag);
2304 goto message_done;
2305 }
2306 ptr = UnknownFieldParse(
2307 tag,
2308 _internal_metadata_.mutable_unknown_fields<std::string>(),
2309 ptr, ctx);
2310 CHK_(ptr != nullptr);
2311 } // while
2312 message_done:
2313 _impl_._has_bits_.Or(has_bits);
2314 return ptr;
2315 failure:
2316 ptr = nullptr;
2317 goto message_done;
2318 #undef CHK_
2319 }
2320
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2321 ::uint8_t* AndroidCameraSessionStats::_InternalSerialize(
2322 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2323 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.AndroidCameraSessionStats)
2324 ::uint32_t cached_has_bits = 0;
2325 (void) cached_has_bits;
2326
2327 cached_has_bits = _impl_._has_bits_[0];
2328 // optional uint64 session_id = 1;
2329 if (cached_has_bits & 0x00000002u) {
2330 target = stream->EnsureSpace(target);
2331 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_session_id(), target);
2332 }
2333
2334 // optional .perfetto.protos.AndroidCameraSessionStats.CameraGraph graph = 2;
2335 if (cached_has_bits & 0x00000001u) {
2336 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
2337 InternalWriteMessage(2, _Internal::graph(this),
2338 _Internal::graph(this).GetCachedSize(), target, stream);
2339 }
2340
2341 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2342 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2343 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2344 }
2345 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.AndroidCameraSessionStats)
2346 return target;
2347 }
2348
ByteSizeLong() const2349 size_t AndroidCameraSessionStats::ByteSizeLong() const {
2350 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.AndroidCameraSessionStats)
2351 size_t total_size = 0;
2352
2353 ::uint32_t cached_has_bits = 0;
2354 // Prevent compiler warnings about cached_has_bits being unused
2355 (void) cached_has_bits;
2356
2357 cached_has_bits = _impl_._has_bits_[0];
2358 if (cached_has_bits & 0x00000003u) {
2359 // optional .perfetto.protos.AndroidCameraSessionStats.CameraGraph graph = 2;
2360 if (cached_has_bits & 0x00000001u) {
2361 total_size += 1 +
2362 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
2363 *_impl_.graph_);
2364 }
2365
2366 // optional uint64 session_id = 1;
2367 if (cached_has_bits & 0x00000002u) {
2368 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_session_id());
2369 }
2370
2371 }
2372 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2373 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2374 }
2375 int cached_size = ::_pbi::ToCachedSize(total_size);
2376 SetCachedSize(cached_size);
2377 return total_size;
2378 }
2379
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2380 void AndroidCameraSessionStats::CheckTypeAndMergeFrom(
2381 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2382 MergeFrom(*::_pbi::DownCast<const AndroidCameraSessionStats*>(
2383 &from));
2384 }
2385
MergeFrom(const AndroidCameraSessionStats & from)2386 void AndroidCameraSessionStats::MergeFrom(const AndroidCameraSessionStats& from) {
2387 AndroidCameraSessionStats* const _this = this;
2388 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.AndroidCameraSessionStats)
2389 GOOGLE_DCHECK_NE(&from, _this);
2390 ::uint32_t cached_has_bits = 0;
2391 (void) cached_has_bits;
2392
2393 cached_has_bits = from._impl_._has_bits_[0];
2394 if (cached_has_bits & 0x00000003u) {
2395 if (cached_has_bits & 0x00000001u) {
2396 _this->_internal_mutable_graph()->::perfetto::protos::AndroidCameraSessionStats_CameraGraph::MergeFrom(
2397 from._internal_graph());
2398 }
2399 if (cached_has_bits & 0x00000002u) {
2400 _this->_impl_.session_id_ = from._impl_.session_id_;
2401 }
2402 _this->_impl_._has_bits_[0] |= cached_has_bits;
2403 }
2404 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2405 }
2406
CopyFrom(const AndroidCameraSessionStats & from)2407 void AndroidCameraSessionStats::CopyFrom(const AndroidCameraSessionStats& from) {
2408 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.AndroidCameraSessionStats)
2409 if (&from == this) return;
2410 Clear();
2411 MergeFrom(from);
2412 }
2413
IsInitialized() const2414 bool AndroidCameraSessionStats::IsInitialized() const {
2415 return true;
2416 }
2417
InternalSwap(AndroidCameraSessionStats * other)2418 void AndroidCameraSessionStats::InternalSwap(AndroidCameraSessionStats* other) {
2419 using std::swap;
2420 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2421 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2422 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2423 PROTOBUF_FIELD_OFFSET(AndroidCameraSessionStats, _impl_.session_id_)
2424 + sizeof(AndroidCameraSessionStats::_impl_.session_id_) // NOLINT
2425 - PROTOBUF_FIELD_OFFSET(AndroidCameraSessionStats, _impl_.graph_)>(
2426 reinterpret_cast<char*>(&_impl_.graph_),
2427 reinterpret_cast<char*>(&other->_impl_.graph_));
2428 }
2429
GetTypeName() const2430 std::string AndroidCameraSessionStats::GetTypeName() const {
2431 return "perfetto.protos.AndroidCameraSessionStats";
2432 }
2433
2434
2435 // @@protoc_insertion_point(namespace_scope)
2436 } // namespace protos
2437 } // namespace perfetto
2438 PROTOBUF_NAMESPACE_OPEN
2439 template<> PROTOBUF_NOINLINE ::perfetto::protos::AndroidCameraFrameEvent_CameraNodeProcessingDetails*
CreateMaybeMessage(Arena * arena)2440 Arena::CreateMaybeMessage< ::perfetto::protos::AndroidCameraFrameEvent_CameraNodeProcessingDetails >(Arena* arena) {
2441 return Arena::CreateMessageInternal< ::perfetto::protos::AndroidCameraFrameEvent_CameraNodeProcessingDetails >(arena);
2442 }
2443 template<> PROTOBUF_NOINLINE ::perfetto::protos::AndroidCameraFrameEvent*
CreateMaybeMessage(Arena * arena)2444 Arena::CreateMaybeMessage< ::perfetto::protos::AndroidCameraFrameEvent >(Arena* arena) {
2445 return Arena::CreateMessageInternal< ::perfetto::protos::AndroidCameraFrameEvent >(arena);
2446 }
2447 template<> PROTOBUF_NOINLINE ::perfetto::protos::AndroidCameraSessionStats_CameraGraph_CameraNode*
CreateMaybeMessage(Arena * arena)2448 Arena::CreateMaybeMessage< ::perfetto::protos::AndroidCameraSessionStats_CameraGraph_CameraNode >(Arena* arena) {
2449 return Arena::CreateMessageInternal< ::perfetto::protos::AndroidCameraSessionStats_CameraGraph_CameraNode >(arena);
2450 }
2451 template<> PROTOBUF_NOINLINE ::perfetto::protos::AndroidCameraSessionStats_CameraGraph_CameraEdge*
CreateMaybeMessage(Arena * arena)2452 Arena::CreateMaybeMessage< ::perfetto::protos::AndroidCameraSessionStats_CameraGraph_CameraEdge >(Arena* arena) {
2453 return Arena::CreateMessageInternal< ::perfetto::protos::AndroidCameraSessionStats_CameraGraph_CameraEdge >(arena);
2454 }
2455 template<> PROTOBUF_NOINLINE ::perfetto::protos::AndroidCameraSessionStats_CameraGraph*
CreateMaybeMessage(Arena * arena)2456 Arena::CreateMaybeMessage< ::perfetto::protos::AndroidCameraSessionStats_CameraGraph >(Arena* arena) {
2457 return Arena::CreateMessageInternal< ::perfetto::protos::AndroidCameraSessionStats_CameraGraph >(arena);
2458 }
2459 template<> PROTOBUF_NOINLINE ::perfetto::protos::AndroidCameraSessionStats*
CreateMaybeMessage(Arena * arena)2460 Arena::CreateMaybeMessage< ::perfetto::protos::AndroidCameraSessionStats >(Arena* arena) {
2461 return Arena::CreateMessageInternal< ::perfetto::protos::AndroidCameraSessionStats >(arena);
2462 }
2463 PROTOBUF_NAMESPACE_CLOSE
2464
2465 // @@protoc_insertion_point(global_scope)
2466 #include <google/protobuf/port_undef.inc>
2467