CoreDump.pb.h (103215B)
1 // Generated by the protocol buffer compiler. DO NOT EDIT! 2 // source: CoreDump.proto 3 4 #ifndef GOOGLE_PROTOBUF_INCLUDED_CoreDump_2eproto 5 #define GOOGLE_PROTOBUF_INCLUDED_CoreDump_2eproto 6 7 #include <limits> 8 #include <string> 9 10 #include <google/protobuf/port_def.inc> 11 #if PROTOBUF_VERSION < 3021000 12 #error This file was generated by a newer version of protoc which is 13 #error incompatible with your Protocol Buffer headers. Please update 14 #error your headers. 15 #endif 16 #if 3021006 < PROTOBUF_MIN_PROTOC_VERSION 17 #error This file was generated by an older version of protoc which is 18 #error incompatible with your Protocol Buffer headers. Please 19 #error regenerate this file with a newer version of protoc. 20 #endif 21 22 #include <google/protobuf/port_undef.inc> 23 #include <google/protobuf/io/coded_stream.h> 24 #include <google/protobuf/arena.h> 25 #include <google/protobuf/arenastring.h> 26 #include <google/protobuf/generated_message_util.h> 27 #include <google/protobuf/metadata_lite.h> 28 #include <google/protobuf/message_lite.h> 29 #include <google/protobuf/repeated_field.h> // IWYU pragma: export 30 #include <google/protobuf/extension_set.h> // IWYU pragma: export 31 // @@protoc_insertion_point(includes) 32 #include <google/protobuf/port_def.inc> 33 #define PROTOBUF_INTERNAL_EXPORT_CoreDump_2eproto 34 PROTOBUF_NAMESPACE_OPEN 35 namespace internal { 36 class AnyMetadata; 37 } // namespace internal 38 PROTOBUF_NAMESPACE_CLOSE 39 40 // Internal implementation detail -- do not use these members. 41 struct TableStruct_CoreDump_2eproto { 42 static const uint32_t offsets[]; 43 }; 44 namespace mozilla { 45 namespace devtools { 46 namespace protobuf { 47 class Edge; 48 struct EdgeDefaultTypeInternal; 49 extern EdgeDefaultTypeInternal _Edge_default_instance_; 50 class Metadata; 51 struct MetadataDefaultTypeInternal; 52 extern MetadataDefaultTypeInternal _Metadata_default_instance_; 53 class Node; 54 struct NodeDefaultTypeInternal; 55 extern NodeDefaultTypeInternal _Node_default_instance_; 56 class StackFrame; 57 struct StackFrameDefaultTypeInternal; 58 extern StackFrameDefaultTypeInternal _StackFrame_default_instance_; 59 class StackFrame_Data; 60 struct StackFrame_DataDefaultTypeInternal; 61 extern StackFrame_DataDefaultTypeInternal _StackFrame_Data_default_instance_; 62 } // namespace protobuf 63 } // namespace devtools 64 } // namespace mozilla 65 PROTOBUF_NAMESPACE_OPEN 66 template<> ::mozilla::devtools::protobuf::Edge* Arena::CreateMaybeMessage<::mozilla::devtools::protobuf::Edge>(Arena*); 67 template<> ::mozilla::devtools::protobuf::Metadata* Arena::CreateMaybeMessage<::mozilla::devtools::protobuf::Metadata>(Arena*); 68 template<> ::mozilla::devtools::protobuf::Node* Arena::CreateMaybeMessage<::mozilla::devtools::protobuf::Node>(Arena*); 69 template<> ::mozilla::devtools::protobuf::StackFrame* Arena::CreateMaybeMessage<::mozilla::devtools::protobuf::StackFrame>(Arena*); 70 template<> ::mozilla::devtools::protobuf::StackFrame_Data* Arena::CreateMaybeMessage<::mozilla::devtools::protobuf::StackFrame_Data>(Arena*); 71 PROTOBUF_NAMESPACE_CLOSE 72 namespace mozilla { 73 namespace devtools { 74 namespace protobuf { 75 76 // =================================================================== 77 78 class Metadata final : 79 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.devtools.protobuf.Metadata) */ { 80 public: 81 inline Metadata() : Metadata(nullptr) {} 82 ~Metadata() override; 83 explicit PROTOBUF_CONSTEXPR Metadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); 84 85 Metadata(const Metadata& from); 86 Metadata(Metadata&& from) noexcept 87 : Metadata() { 88 *this = ::std::move(from); 89 } 90 91 inline Metadata& operator=(const Metadata& from) { 92 CopyFrom(from); 93 return *this; 94 } 95 inline Metadata& operator=(Metadata&& from) noexcept { 96 if (this == &from) return *this; 97 if (GetOwningArena() == from.GetOwningArena() 98 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE 99 && GetOwningArena() != nullptr 100 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE 101 ) { 102 InternalSwap(&from); 103 } else { 104 CopyFrom(from); 105 } 106 return *this; 107 } 108 109 inline const std::string& unknown_fields() const { 110 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); 111 } 112 inline std::string* mutable_unknown_fields() { 113 return _internal_metadata_.mutable_unknown_fields<std::string>(); 114 } 115 116 static const Metadata& default_instance() { 117 return *internal_default_instance(); 118 } 119 static inline const Metadata* internal_default_instance() { 120 return reinterpret_cast<const Metadata*>( 121 &_Metadata_default_instance_); 122 } 123 static constexpr int kIndexInFileMessages = 124 0; 125 126 friend void swap(Metadata& a, Metadata& b) { 127 a.Swap(&b); 128 } 129 inline void Swap(Metadata* other) { 130 if (other == this) return; 131 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP 132 if (GetOwningArena() != nullptr && 133 GetOwningArena() == other->GetOwningArena()) { 134 #else // PROTOBUF_FORCE_COPY_IN_SWAP 135 if (GetOwningArena() == other->GetOwningArena()) { 136 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP 137 InternalSwap(other); 138 } else { 139 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); 140 } 141 } 142 void UnsafeArenaSwap(Metadata* other) { 143 if (other == this) return; 144 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); 145 InternalSwap(other); 146 } 147 148 // implements Message ---------------------------------------------- 149 150 Metadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { 151 return CreateMaybeMessage<Metadata>(arena); 152 } 153 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; 154 void CopyFrom(const Metadata& from); 155 void MergeFrom(const Metadata& from); 156 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; 157 bool IsInitialized() const final; 158 159 size_t ByteSizeLong() const final; 160 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; 161 uint8_t* _InternalSerialize( 162 uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; 163 int GetCachedSize() const final { return _impl_._cached_size_.Get(); } 164 165 private: 166 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); 167 void SharedDtor(); 168 void SetCachedSize(int size) const; 169 void InternalSwap(Metadata* other); 170 171 private: 172 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; 173 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { 174 return "mozilla.devtools.protobuf.Metadata"; 175 } 176 protected: 177 explicit Metadata(::PROTOBUF_NAMESPACE_ID::Arena* arena, 178 bool is_message_owned = false); 179 public: 180 181 std::string GetTypeName() const final; 182 183 // nested types ---------------------------------------------------- 184 185 // accessors ------------------------------------------------------- 186 187 enum : int { 188 kTimeStampFieldNumber = 1, 189 }; 190 // optional uint64 timeStamp = 1; 191 bool has_timestamp() const; 192 private: 193 bool _internal_has_timestamp() const; 194 public: 195 void clear_timestamp(); 196 uint64_t timestamp() const; 197 void set_timestamp(uint64_t value); 198 private: 199 uint64_t _internal_timestamp() const; 200 void _internal_set_timestamp(uint64_t value); 201 public: 202 203 // @@protoc_insertion_point(class_scope:mozilla.devtools.protobuf.Metadata) 204 private: 205 class _Internal; 206 207 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; 208 typedef void InternalArenaConstructable_; 209 typedef void DestructorSkippable_; 210 struct Impl_ { 211 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; 212 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; 213 uint64_t timestamp_; 214 }; 215 union { Impl_ _impl_; }; 216 friend struct ::TableStruct_CoreDump_2eproto; 217 }; 218 // ------------------------------------------------------------------- 219 220 class StackFrame_Data final : 221 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.devtools.protobuf.StackFrame.Data) */ { 222 public: 223 inline StackFrame_Data() : StackFrame_Data(nullptr) {} 224 ~StackFrame_Data() override; 225 explicit PROTOBUF_CONSTEXPR StackFrame_Data(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); 226 227 StackFrame_Data(const StackFrame_Data& from); 228 StackFrame_Data(StackFrame_Data&& from) noexcept 229 : StackFrame_Data() { 230 *this = ::std::move(from); 231 } 232 233 inline StackFrame_Data& operator=(const StackFrame_Data& from) { 234 CopyFrom(from); 235 return *this; 236 } 237 inline StackFrame_Data& operator=(StackFrame_Data&& from) noexcept { 238 if (this == &from) return *this; 239 if (GetOwningArena() == from.GetOwningArena() 240 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE 241 && GetOwningArena() != nullptr 242 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE 243 ) { 244 InternalSwap(&from); 245 } else { 246 CopyFrom(from); 247 } 248 return *this; 249 } 250 251 inline const std::string& unknown_fields() const { 252 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); 253 } 254 inline std::string* mutable_unknown_fields() { 255 return _internal_metadata_.mutable_unknown_fields<std::string>(); 256 } 257 258 static const StackFrame_Data& default_instance() { 259 return *internal_default_instance(); 260 } 261 enum SourceOrRefCase { 262 kSource = 5, 263 kSourceRef = 6, 264 SOURCEORREF_NOT_SET = 0, 265 }; 266 267 enum FunctionDisplayNameOrRefCase { 268 kFunctionDisplayName = 7, 269 kFunctionDisplayNameRef = 8, 270 FUNCTIONDISPLAYNAMEORREF_NOT_SET = 0, 271 }; 272 273 static inline const StackFrame_Data* internal_default_instance() { 274 return reinterpret_cast<const StackFrame_Data*>( 275 &_StackFrame_Data_default_instance_); 276 } 277 static constexpr int kIndexInFileMessages = 278 1; 279 280 friend void swap(StackFrame_Data& a, StackFrame_Data& b) { 281 a.Swap(&b); 282 } 283 inline void Swap(StackFrame_Data* other) { 284 if (other == this) return; 285 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP 286 if (GetOwningArena() != nullptr && 287 GetOwningArena() == other->GetOwningArena()) { 288 #else // PROTOBUF_FORCE_COPY_IN_SWAP 289 if (GetOwningArena() == other->GetOwningArena()) { 290 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP 291 InternalSwap(other); 292 } else { 293 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); 294 } 295 } 296 void UnsafeArenaSwap(StackFrame_Data* other) { 297 if (other == this) return; 298 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); 299 InternalSwap(other); 300 } 301 302 // implements Message ---------------------------------------------- 303 304 StackFrame_Data* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { 305 return CreateMaybeMessage<StackFrame_Data>(arena); 306 } 307 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; 308 void CopyFrom(const StackFrame_Data& from); 309 void MergeFrom(const StackFrame_Data& from); 310 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; 311 bool IsInitialized() const final; 312 313 size_t ByteSizeLong() const final; 314 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; 315 uint8_t* _InternalSerialize( 316 uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; 317 int GetCachedSize() const final { return _impl_._cached_size_.Get(); } 318 319 private: 320 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); 321 void SharedDtor(); 322 void SetCachedSize(int size) const; 323 void InternalSwap(StackFrame_Data* other); 324 325 private: 326 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; 327 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { 328 return "mozilla.devtools.protobuf.StackFrame.Data"; 329 } 330 protected: 331 explicit StackFrame_Data(::PROTOBUF_NAMESPACE_ID::Arena* arena, 332 bool is_message_owned = false); 333 public: 334 335 std::string GetTypeName() const final; 336 337 // nested types ---------------------------------------------------- 338 339 // accessors ------------------------------------------------------- 340 341 enum : int { 342 kParentFieldNumber = 2, 343 kIdFieldNumber = 1, 344 kLineFieldNumber = 3, 345 kColumnFieldNumber = 4, 346 kIsSystemFieldNumber = 9, 347 kIsSelfHostedFieldNumber = 10, 348 kSourceFieldNumber = 5, 349 kSourceRefFieldNumber = 6, 350 kFunctionDisplayNameFieldNumber = 7, 351 kFunctionDisplayNameRefFieldNumber = 8, 352 }; 353 // optional .mozilla.devtools.protobuf.StackFrame parent = 2; 354 bool has_parent() const; 355 private: 356 bool _internal_has_parent() const; 357 public: 358 void clear_parent(); 359 const ::mozilla::devtools::protobuf::StackFrame& parent() const; 360 PROTOBUF_NODISCARD ::mozilla::devtools::protobuf::StackFrame* release_parent(); 361 ::mozilla::devtools::protobuf::StackFrame* mutable_parent(); 362 void set_allocated_parent(::mozilla::devtools::protobuf::StackFrame* parent); 363 private: 364 const ::mozilla::devtools::protobuf::StackFrame& _internal_parent() const; 365 ::mozilla::devtools::protobuf::StackFrame* _internal_mutable_parent(); 366 public: 367 void unsafe_arena_set_allocated_parent( 368 ::mozilla::devtools::protobuf::StackFrame* parent); 369 ::mozilla::devtools::protobuf::StackFrame* unsafe_arena_release_parent(); 370 371 // optional uint64 id = 1; 372 bool has_id() const; 373 private: 374 bool _internal_has_id() const; 375 public: 376 void clear_id(); 377 uint64_t id() const; 378 void set_id(uint64_t value); 379 private: 380 uint64_t _internal_id() const; 381 void _internal_set_id(uint64_t value); 382 public: 383 384 // optional uint32 line = 3; 385 bool has_line() const; 386 private: 387 bool _internal_has_line() const; 388 public: 389 void clear_line(); 390 uint32_t line() const; 391 void set_line(uint32_t value); 392 private: 393 uint32_t _internal_line() const; 394 void _internal_set_line(uint32_t value); 395 public: 396 397 // optional uint32 column = 4; 398 bool has_column() const; 399 private: 400 bool _internal_has_column() const; 401 public: 402 void clear_column(); 403 uint32_t column() const; 404 void set_column(uint32_t value); 405 private: 406 uint32_t _internal_column() const; 407 void _internal_set_column(uint32_t value); 408 public: 409 410 // optional bool isSystem = 9; 411 bool has_issystem() const; 412 private: 413 bool _internal_has_issystem() const; 414 public: 415 void clear_issystem(); 416 bool issystem() const; 417 void set_issystem(bool value); 418 private: 419 bool _internal_issystem() const; 420 void _internal_set_issystem(bool value); 421 public: 422 423 // optional bool isSelfHosted = 10; 424 bool has_isselfhosted() const; 425 private: 426 bool _internal_has_isselfhosted() const; 427 public: 428 void clear_isselfhosted(); 429 bool isselfhosted() const; 430 void set_isselfhosted(bool value); 431 private: 432 bool _internal_isselfhosted() const; 433 void _internal_set_isselfhosted(bool value); 434 public: 435 436 // bytes source = 5; 437 bool has_source() const; 438 private: 439 bool _internal_has_source() const; 440 public: 441 void clear_source(); 442 const std::string& source() const; 443 template <typename ArgT0 = const std::string&, typename... ArgT> 444 void set_source(ArgT0&& arg0, ArgT... args); 445 std::string* mutable_source(); 446 PROTOBUF_NODISCARD std::string* release_source(); 447 void set_allocated_source(std::string* source); 448 private: 449 const std::string& _internal_source() const; 450 inline PROTOBUF_ALWAYS_INLINE void _internal_set_source(const std::string& value); 451 std::string* _internal_mutable_source(); 452 public: 453 454 // uint64 sourceRef = 6; 455 bool has_sourceref() const; 456 private: 457 bool _internal_has_sourceref() const; 458 public: 459 void clear_sourceref(); 460 uint64_t sourceref() const; 461 void set_sourceref(uint64_t value); 462 private: 463 uint64_t _internal_sourceref() const; 464 void _internal_set_sourceref(uint64_t value); 465 public: 466 467 // bytes functionDisplayName = 7; 468 bool has_functiondisplayname() const; 469 private: 470 bool _internal_has_functiondisplayname() const; 471 public: 472 void clear_functiondisplayname(); 473 const std::string& functiondisplayname() const; 474 template <typename ArgT0 = const std::string&, typename... ArgT> 475 void set_functiondisplayname(ArgT0&& arg0, ArgT... args); 476 std::string* mutable_functiondisplayname(); 477 PROTOBUF_NODISCARD std::string* release_functiondisplayname(); 478 void set_allocated_functiondisplayname(std::string* functiondisplayname); 479 private: 480 const std::string& _internal_functiondisplayname() const; 481 inline PROTOBUF_ALWAYS_INLINE void _internal_set_functiondisplayname(const std::string& value); 482 std::string* _internal_mutable_functiondisplayname(); 483 public: 484 485 // uint64 functionDisplayNameRef = 8; 486 bool has_functiondisplaynameref() const; 487 private: 488 bool _internal_has_functiondisplaynameref() const; 489 public: 490 void clear_functiondisplaynameref(); 491 uint64_t functiondisplaynameref() const; 492 void set_functiondisplaynameref(uint64_t value); 493 private: 494 uint64_t _internal_functiondisplaynameref() const; 495 void _internal_set_functiondisplaynameref(uint64_t value); 496 public: 497 498 void clear_SourceOrRef(); 499 SourceOrRefCase SourceOrRef_case() const; 500 void clear_FunctionDisplayNameOrRef(); 501 FunctionDisplayNameOrRefCase FunctionDisplayNameOrRef_case() const; 502 // @@protoc_insertion_point(class_scope:mozilla.devtools.protobuf.StackFrame.Data) 503 private: 504 class _Internal; 505 void set_has_source(); 506 void set_has_sourceref(); 507 void set_has_functiondisplayname(); 508 void set_has_functiondisplaynameref(); 509 510 inline bool has_SourceOrRef() const; 511 inline void clear_has_SourceOrRef(); 512 513 inline bool has_FunctionDisplayNameOrRef() const; 514 inline void clear_has_FunctionDisplayNameOrRef(); 515 516 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; 517 typedef void InternalArenaConstructable_; 518 typedef void DestructorSkippable_; 519 struct Impl_ { 520 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; 521 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; 522 ::mozilla::devtools::protobuf::StackFrame* parent_; 523 uint64_t id_; 524 uint32_t line_; 525 uint32_t column_; 526 bool issystem_; 527 bool isselfhosted_; 528 union SourceOrRefUnion { 529 constexpr SourceOrRefUnion() : _constinit_{} {} 530 ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; 531 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr source_; 532 uint64_t sourceref_; 533 } SourceOrRef_; 534 union FunctionDisplayNameOrRefUnion { 535 constexpr FunctionDisplayNameOrRefUnion() : _constinit_{} {} 536 ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; 537 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr functiondisplayname_; 538 uint64_t functiondisplaynameref_; 539 } FunctionDisplayNameOrRef_; 540 uint32_t _oneof_case_[2]; 541 542 }; 543 union { Impl_ _impl_; }; 544 friend struct ::TableStruct_CoreDump_2eproto; 545 }; 546 // ------------------------------------------------------------------- 547 548 class StackFrame final : 549 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.devtools.protobuf.StackFrame) */ { 550 public: 551 inline StackFrame() : StackFrame(nullptr) {} 552 ~StackFrame() override; 553 explicit PROTOBUF_CONSTEXPR StackFrame(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); 554 555 StackFrame(const StackFrame& from); 556 StackFrame(StackFrame&& from) noexcept 557 : StackFrame() { 558 *this = ::std::move(from); 559 } 560 561 inline StackFrame& operator=(const StackFrame& from) { 562 CopyFrom(from); 563 return *this; 564 } 565 inline StackFrame& operator=(StackFrame&& from) noexcept { 566 if (this == &from) return *this; 567 if (GetOwningArena() == from.GetOwningArena() 568 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE 569 && GetOwningArena() != nullptr 570 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE 571 ) { 572 InternalSwap(&from); 573 } else { 574 CopyFrom(from); 575 } 576 return *this; 577 } 578 579 inline const std::string& unknown_fields() const { 580 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); 581 } 582 inline std::string* mutable_unknown_fields() { 583 return _internal_metadata_.mutable_unknown_fields<std::string>(); 584 } 585 586 static const StackFrame& default_instance() { 587 return *internal_default_instance(); 588 } 589 enum StackFrameTypeCase { 590 kData = 1, 591 kRef = 2, 592 STACKFRAMETYPE_NOT_SET = 0, 593 }; 594 595 static inline const StackFrame* internal_default_instance() { 596 return reinterpret_cast<const StackFrame*>( 597 &_StackFrame_default_instance_); 598 } 599 static constexpr int kIndexInFileMessages = 600 2; 601 602 friend void swap(StackFrame& a, StackFrame& b) { 603 a.Swap(&b); 604 } 605 inline void Swap(StackFrame* other) { 606 if (other == this) return; 607 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP 608 if (GetOwningArena() != nullptr && 609 GetOwningArena() == other->GetOwningArena()) { 610 #else // PROTOBUF_FORCE_COPY_IN_SWAP 611 if (GetOwningArena() == other->GetOwningArena()) { 612 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP 613 InternalSwap(other); 614 } else { 615 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); 616 } 617 } 618 void UnsafeArenaSwap(StackFrame* other) { 619 if (other == this) return; 620 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); 621 InternalSwap(other); 622 } 623 624 // implements Message ---------------------------------------------- 625 626 StackFrame* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { 627 return CreateMaybeMessage<StackFrame>(arena); 628 } 629 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; 630 void CopyFrom(const StackFrame& from); 631 void MergeFrom(const StackFrame& from); 632 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; 633 bool IsInitialized() const final; 634 635 size_t ByteSizeLong() const final; 636 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; 637 uint8_t* _InternalSerialize( 638 uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; 639 int GetCachedSize() const final { return _impl_._cached_size_.Get(); } 640 641 private: 642 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); 643 void SharedDtor(); 644 void SetCachedSize(int size) const; 645 void InternalSwap(StackFrame* other); 646 647 private: 648 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; 649 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { 650 return "mozilla.devtools.protobuf.StackFrame"; 651 } 652 protected: 653 explicit StackFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena, 654 bool is_message_owned = false); 655 public: 656 657 std::string GetTypeName() const final; 658 659 // nested types ---------------------------------------------------- 660 661 typedef StackFrame_Data Data; 662 663 // accessors ------------------------------------------------------- 664 665 enum : int { 666 kDataFieldNumber = 1, 667 kRefFieldNumber = 2, 668 }; 669 // .mozilla.devtools.protobuf.StackFrame.Data data = 1; 670 bool has_data() const; 671 private: 672 bool _internal_has_data() const; 673 public: 674 void clear_data(); 675 const ::mozilla::devtools::protobuf::StackFrame_Data& data() const; 676 PROTOBUF_NODISCARD ::mozilla::devtools::protobuf::StackFrame_Data* release_data(); 677 ::mozilla::devtools::protobuf::StackFrame_Data* mutable_data(); 678 void set_allocated_data(::mozilla::devtools::protobuf::StackFrame_Data* data); 679 private: 680 const ::mozilla::devtools::protobuf::StackFrame_Data& _internal_data() const; 681 ::mozilla::devtools::protobuf::StackFrame_Data* _internal_mutable_data(); 682 public: 683 void unsafe_arena_set_allocated_data( 684 ::mozilla::devtools::protobuf::StackFrame_Data* data); 685 ::mozilla::devtools::protobuf::StackFrame_Data* unsafe_arena_release_data(); 686 687 // uint64 ref = 2; 688 bool has_ref() const; 689 private: 690 bool _internal_has_ref() const; 691 public: 692 void clear_ref(); 693 uint64_t ref() const; 694 void set_ref(uint64_t value); 695 private: 696 uint64_t _internal_ref() const; 697 void _internal_set_ref(uint64_t value); 698 public: 699 700 void clear_StackFrameType(); 701 StackFrameTypeCase StackFrameType_case() const; 702 // @@protoc_insertion_point(class_scope:mozilla.devtools.protobuf.StackFrame) 703 private: 704 class _Internal; 705 void set_has_data(); 706 void set_has_ref(); 707 708 inline bool has_StackFrameType() const; 709 inline void clear_has_StackFrameType(); 710 711 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; 712 typedef void InternalArenaConstructable_; 713 typedef void DestructorSkippable_; 714 struct Impl_ { 715 union StackFrameTypeUnion { 716 constexpr StackFrameTypeUnion() : _constinit_{} {} 717 ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; 718 ::mozilla::devtools::protobuf::StackFrame_Data* data_; 719 uint64_t ref_; 720 } StackFrameType_; 721 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; 722 uint32_t _oneof_case_[1]; 723 724 }; 725 union { Impl_ _impl_; }; 726 friend struct ::TableStruct_CoreDump_2eproto; 727 }; 728 // ------------------------------------------------------------------- 729 730 class Node final : 731 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.devtools.protobuf.Node) */ { 732 public: 733 inline Node() : Node(nullptr) {} 734 ~Node() override; 735 explicit PROTOBUF_CONSTEXPR Node(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); 736 737 Node(const Node& from); 738 Node(Node&& from) noexcept 739 : Node() { 740 *this = ::std::move(from); 741 } 742 743 inline Node& operator=(const Node& from) { 744 CopyFrom(from); 745 return *this; 746 } 747 inline Node& operator=(Node&& from) noexcept { 748 if (this == &from) return *this; 749 if (GetOwningArena() == from.GetOwningArena() 750 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE 751 && GetOwningArena() != nullptr 752 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE 753 ) { 754 InternalSwap(&from); 755 } else { 756 CopyFrom(from); 757 } 758 return *this; 759 } 760 761 inline const std::string& unknown_fields() const { 762 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); 763 } 764 inline std::string* mutable_unknown_fields() { 765 return _internal_metadata_.mutable_unknown_fields<std::string>(); 766 } 767 768 static const Node& default_instance() { 769 return *internal_default_instance(); 770 } 771 enum TypeNameOrRefCase { 772 kTypeName = 2, 773 kTypeNameRef = 3, 774 TYPENAMEORREF_NOT_SET = 0, 775 }; 776 777 enum JSObjectClassNameOrRefCase { 778 kJsObjectClassName = 7, 779 kJsObjectClassNameRef = 8, 780 JSOBJECTCLASSNAMEORREF_NOT_SET = 0, 781 }; 782 783 enum ScriptFilenameOrRefCase { 784 kScriptFilename = 10, 785 kScriptFilenameRef = 11, 786 SCRIPTFILENAMEORREF_NOT_SET = 0, 787 }; 788 789 enum DescriptiveTypeNameOrRefCase { 790 kDescriptiveTypeName = 12, 791 kDescriptiveTypeNameRef = 13, 792 DESCRIPTIVETYPENAMEORREF_NOT_SET = 0, 793 }; 794 795 static inline const Node* internal_default_instance() { 796 return reinterpret_cast<const Node*>( 797 &_Node_default_instance_); 798 } 799 static constexpr int kIndexInFileMessages = 800 3; 801 802 friend void swap(Node& a, Node& b) { 803 a.Swap(&b); 804 } 805 inline void Swap(Node* other) { 806 if (other == this) return; 807 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP 808 if (GetOwningArena() != nullptr && 809 GetOwningArena() == other->GetOwningArena()) { 810 #else // PROTOBUF_FORCE_COPY_IN_SWAP 811 if (GetOwningArena() == other->GetOwningArena()) { 812 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP 813 InternalSwap(other); 814 } else { 815 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); 816 } 817 } 818 void UnsafeArenaSwap(Node* other) { 819 if (other == this) return; 820 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); 821 InternalSwap(other); 822 } 823 824 // implements Message ---------------------------------------------- 825 826 Node* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { 827 return CreateMaybeMessage<Node>(arena); 828 } 829 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; 830 void CopyFrom(const Node& from); 831 void MergeFrom(const Node& from); 832 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; 833 bool IsInitialized() const final; 834 835 size_t ByteSizeLong() const final; 836 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; 837 uint8_t* _InternalSerialize( 838 uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; 839 int GetCachedSize() const final { return _impl_._cached_size_.Get(); } 840 841 private: 842 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); 843 void SharedDtor(); 844 void SetCachedSize(int size) const; 845 void InternalSwap(Node* other); 846 847 private: 848 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; 849 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { 850 return "mozilla.devtools.protobuf.Node"; 851 } 852 protected: 853 explicit Node(::PROTOBUF_NAMESPACE_ID::Arena* arena, 854 bool is_message_owned = false); 855 public: 856 857 std::string GetTypeName() const final; 858 859 // nested types ---------------------------------------------------- 860 861 // accessors ------------------------------------------------------- 862 863 enum : int { 864 kEdgesFieldNumber = 5, 865 kAllocationStackFieldNumber = 6, 866 kIdFieldNumber = 1, 867 kSizeFieldNumber = 4, 868 kCoarseTypeFieldNumber = 9, 869 kTypeNameFieldNumber = 2, 870 kTypeNameRefFieldNumber = 3, 871 kJsObjectClassNameFieldNumber = 7, 872 kJsObjectClassNameRefFieldNumber = 8, 873 kScriptFilenameFieldNumber = 10, 874 kScriptFilenameRefFieldNumber = 11, 875 kDescriptiveTypeNameFieldNumber = 12, 876 kDescriptiveTypeNameRefFieldNumber = 13, 877 }; 878 // repeated .mozilla.devtools.protobuf.Edge edges = 5; 879 int edges_size() const; 880 private: 881 int _internal_edges_size() const; 882 public: 883 void clear_edges(); 884 ::mozilla::devtools::protobuf::Edge* mutable_edges(int index); 885 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::devtools::protobuf::Edge >* 886 mutable_edges(); 887 private: 888 const ::mozilla::devtools::protobuf::Edge& _internal_edges(int index) const; 889 ::mozilla::devtools::protobuf::Edge* _internal_add_edges(); 890 public: 891 const ::mozilla::devtools::protobuf::Edge& edges(int index) const; 892 ::mozilla::devtools::protobuf::Edge* add_edges(); 893 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::devtools::protobuf::Edge >& 894 edges() const; 895 896 // optional .mozilla.devtools.protobuf.StackFrame allocationStack = 6; 897 bool has_allocationstack() const; 898 private: 899 bool _internal_has_allocationstack() const; 900 public: 901 void clear_allocationstack(); 902 const ::mozilla::devtools::protobuf::StackFrame& allocationstack() const; 903 PROTOBUF_NODISCARD ::mozilla::devtools::protobuf::StackFrame* release_allocationstack(); 904 ::mozilla::devtools::protobuf::StackFrame* mutable_allocationstack(); 905 void set_allocated_allocationstack(::mozilla::devtools::protobuf::StackFrame* allocationstack); 906 private: 907 const ::mozilla::devtools::protobuf::StackFrame& _internal_allocationstack() const; 908 ::mozilla::devtools::protobuf::StackFrame* _internal_mutable_allocationstack(); 909 public: 910 void unsafe_arena_set_allocated_allocationstack( 911 ::mozilla::devtools::protobuf::StackFrame* allocationstack); 912 ::mozilla::devtools::protobuf::StackFrame* unsafe_arena_release_allocationstack(); 913 914 // optional uint64 id = 1; 915 bool has_id() const; 916 private: 917 bool _internal_has_id() const; 918 public: 919 void clear_id(); 920 uint64_t id() const; 921 void set_id(uint64_t value); 922 private: 923 uint64_t _internal_id() const; 924 void _internal_set_id(uint64_t value); 925 public: 926 927 // optional uint64 size = 4; 928 bool has_size() const; 929 private: 930 bool _internal_has_size() const; 931 public: 932 void clear_size(); 933 uint64_t size() const; 934 void set_size(uint64_t value); 935 private: 936 uint64_t _internal_size() const; 937 void _internal_set_size(uint64_t value); 938 public: 939 940 // optional uint32 coarseType = 9 [default = 0]; 941 bool has_coarsetype() const; 942 private: 943 bool _internal_has_coarsetype() const; 944 public: 945 void clear_coarsetype(); 946 uint32_t coarsetype() const; 947 void set_coarsetype(uint32_t value); 948 private: 949 uint32_t _internal_coarsetype() const; 950 void _internal_set_coarsetype(uint32_t value); 951 public: 952 953 // bytes typeName = 2; 954 bool has_typename_() const; 955 private: 956 bool _internal_has_typename_() const; 957 public: 958 void clear_typename_(); 959 const std::string& typename_() const; 960 template <typename ArgT0 = const std::string&, typename... ArgT> 961 void set_typename_(ArgT0&& arg0, ArgT... args); 962 std::string* mutable_typename_(); 963 PROTOBUF_NODISCARD std::string* release_typename_(); 964 void set_allocated_typename_(std::string* typename_); 965 private: 966 const std::string& _internal_typename_() const; 967 inline PROTOBUF_ALWAYS_INLINE void _internal_set_typename_(const std::string& value); 968 std::string* _internal_mutable_typename_(); 969 public: 970 971 // uint64 typeNameRef = 3; 972 bool has_typenameref() const; 973 private: 974 bool _internal_has_typenameref() const; 975 public: 976 void clear_typenameref(); 977 uint64_t typenameref() const; 978 void set_typenameref(uint64_t value); 979 private: 980 uint64_t _internal_typenameref() const; 981 void _internal_set_typenameref(uint64_t value); 982 public: 983 984 // bytes jsObjectClassName = 7; 985 bool has_jsobjectclassname() const; 986 private: 987 bool _internal_has_jsobjectclassname() const; 988 public: 989 void clear_jsobjectclassname(); 990 const std::string& jsobjectclassname() const; 991 template <typename ArgT0 = const std::string&, typename... ArgT> 992 void set_jsobjectclassname(ArgT0&& arg0, ArgT... args); 993 std::string* mutable_jsobjectclassname(); 994 PROTOBUF_NODISCARD std::string* release_jsobjectclassname(); 995 void set_allocated_jsobjectclassname(std::string* jsobjectclassname); 996 private: 997 const std::string& _internal_jsobjectclassname() const; 998 inline PROTOBUF_ALWAYS_INLINE void _internal_set_jsobjectclassname(const std::string& value); 999 std::string* _internal_mutable_jsobjectclassname(); 1000 public: 1001 1002 // uint64 jsObjectClassNameRef = 8; 1003 bool has_jsobjectclassnameref() const; 1004 private: 1005 bool _internal_has_jsobjectclassnameref() const; 1006 public: 1007 void clear_jsobjectclassnameref(); 1008 uint64_t jsobjectclassnameref() const; 1009 void set_jsobjectclassnameref(uint64_t value); 1010 private: 1011 uint64_t _internal_jsobjectclassnameref() const; 1012 void _internal_set_jsobjectclassnameref(uint64_t value); 1013 public: 1014 1015 // bytes scriptFilename = 10; 1016 bool has_scriptfilename() const; 1017 private: 1018 bool _internal_has_scriptfilename() const; 1019 public: 1020 void clear_scriptfilename(); 1021 const std::string& scriptfilename() const; 1022 template <typename ArgT0 = const std::string&, typename... ArgT> 1023 void set_scriptfilename(ArgT0&& arg0, ArgT... args); 1024 std::string* mutable_scriptfilename(); 1025 PROTOBUF_NODISCARD std::string* release_scriptfilename(); 1026 void set_allocated_scriptfilename(std::string* scriptfilename); 1027 private: 1028 const std::string& _internal_scriptfilename() const; 1029 inline PROTOBUF_ALWAYS_INLINE void _internal_set_scriptfilename(const std::string& value); 1030 std::string* _internal_mutable_scriptfilename(); 1031 public: 1032 1033 // uint64 scriptFilenameRef = 11; 1034 bool has_scriptfilenameref() const; 1035 private: 1036 bool _internal_has_scriptfilenameref() const; 1037 public: 1038 void clear_scriptfilenameref(); 1039 uint64_t scriptfilenameref() const; 1040 void set_scriptfilenameref(uint64_t value); 1041 private: 1042 uint64_t _internal_scriptfilenameref() const; 1043 void _internal_set_scriptfilenameref(uint64_t value); 1044 public: 1045 1046 // bytes descriptiveTypeName = 12; 1047 bool has_descriptivetypename() const; 1048 private: 1049 bool _internal_has_descriptivetypename() const; 1050 public: 1051 void clear_descriptivetypename(); 1052 const std::string& descriptivetypename() const; 1053 template <typename ArgT0 = const std::string&, typename... ArgT> 1054 void set_descriptivetypename(ArgT0&& arg0, ArgT... args); 1055 std::string* mutable_descriptivetypename(); 1056 PROTOBUF_NODISCARD std::string* release_descriptivetypename(); 1057 void set_allocated_descriptivetypename(std::string* descriptivetypename); 1058 private: 1059 const std::string& _internal_descriptivetypename() const; 1060 inline PROTOBUF_ALWAYS_INLINE void _internal_set_descriptivetypename(const std::string& value); 1061 std::string* _internal_mutable_descriptivetypename(); 1062 public: 1063 1064 // uint64 descriptiveTypeNameRef = 13; 1065 bool has_descriptivetypenameref() const; 1066 private: 1067 bool _internal_has_descriptivetypenameref() const; 1068 public: 1069 void clear_descriptivetypenameref(); 1070 uint64_t descriptivetypenameref() const; 1071 void set_descriptivetypenameref(uint64_t value); 1072 private: 1073 uint64_t _internal_descriptivetypenameref() const; 1074 void _internal_set_descriptivetypenameref(uint64_t value); 1075 public: 1076 1077 void clear_TypeNameOrRef(); 1078 TypeNameOrRefCase TypeNameOrRef_case() const; 1079 void clear_JSObjectClassNameOrRef(); 1080 JSObjectClassNameOrRefCase JSObjectClassNameOrRef_case() const; 1081 void clear_ScriptFilenameOrRef(); 1082 ScriptFilenameOrRefCase ScriptFilenameOrRef_case() const; 1083 void clear_descriptiveTypeNameOrRef(); 1084 DescriptiveTypeNameOrRefCase descriptiveTypeNameOrRef_case() const; 1085 // @@protoc_insertion_point(class_scope:mozilla.devtools.protobuf.Node) 1086 private: 1087 class _Internal; 1088 void set_has_typename_(); 1089 void set_has_typenameref(); 1090 void set_has_jsobjectclassname(); 1091 void set_has_jsobjectclassnameref(); 1092 void set_has_scriptfilename(); 1093 void set_has_scriptfilenameref(); 1094 void set_has_descriptivetypename(); 1095 void set_has_descriptivetypenameref(); 1096 1097 inline bool has_TypeNameOrRef() const; 1098 inline void clear_has_TypeNameOrRef(); 1099 1100 inline bool has_JSObjectClassNameOrRef() const; 1101 inline void clear_has_JSObjectClassNameOrRef(); 1102 1103 inline bool has_ScriptFilenameOrRef() const; 1104 inline void clear_has_ScriptFilenameOrRef(); 1105 1106 inline bool has_descriptiveTypeNameOrRef() const; 1107 inline void clear_has_descriptiveTypeNameOrRef(); 1108 1109 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; 1110 typedef void InternalArenaConstructable_; 1111 typedef void DestructorSkippable_; 1112 struct Impl_ { 1113 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; 1114 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; 1115 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::devtools::protobuf::Edge > edges_; 1116 ::mozilla::devtools::protobuf::StackFrame* allocationstack_; 1117 uint64_t id_; 1118 uint64_t size_; 1119 uint32_t coarsetype_; 1120 union TypeNameOrRefUnion { 1121 constexpr TypeNameOrRefUnion() : _constinit_{} {} 1122 ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; 1123 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr typename__; 1124 uint64_t typenameref_; 1125 } TypeNameOrRef_; 1126 union JSObjectClassNameOrRefUnion { 1127 constexpr JSObjectClassNameOrRefUnion() : _constinit_{} {} 1128 ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; 1129 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jsobjectclassname_; 1130 uint64_t jsobjectclassnameref_; 1131 } JSObjectClassNameOrRef_; 1132 union ScriptFilenameOrRefUnion { 1133 constexpr ScriptFilenameOrRefUnion() : _constinit_{} {} 1134 ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; 1135 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr scriptfilename_; 1136 uint64_t scriptfilenameref_; 1137 } ScriptFilenameOrRef_; 1138 union DescriptiveTypeNameOrRefUnion { 1139 constexpr DescriptiveTypeNameOrRefUnion() : _constinit_{} {} 1140 ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; 1141 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr descriptivetypename_; 1142 uint64_t descriptivetypenameref_; 1143 } descriptiveTypeNameOrRef_; 1144 uint32_t _oneof_case_[4]; 1145 1146 }; 1147 union { Impl_ _impl_; }; 1148 friend struct ::TableStruct_CoreDump_2eproto; 1149 }; 1150 // ------------------------------------------------------------------- 1151 1152 class Edge final : 1153 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.devtools.protobuf.Edge) */ { 1154 public: 1155 inline Edge() : Edge(nullptr) {} 1156 ~Edge() override; 1157 explicit PROTOBUF_CONSTEXPR Edge(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); 1158 1159 Edge(const Edge& from); 1160 Edge(Edge&& from) noexcept 1161 : Edge() { 1162 *this = ::std::move(from); 1163 } 1164 1165 inline Edge& operator=(const Edge& from) { 1166 CopyFrom(from); 1167 return *this; 1168 } 1169 inline Edge& operator=(Edge&& from) noexcept { 1170 if (this == &from) return *this; 1171 if (GetOwningArena() == from.GetOwningArena() 1172 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE 1173 && GetOwningArena() != nullptr 1174 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE 1175 ) { 1176 InternalSwap(&from); 1177 } else { 1178 CopyFrom(from); 1179 } 1180 return *this; 1181 } 1182 1183 inline const std::string& unknown_fields() const { 1184 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); 1185 } 1186 inline std::string* mutable_unknown_fields() { 1187 return _internal_metadata_.mutable_unknown_fields<std::string>(); 1188 } 1189 1190 static const Edge& default_instance() { 1191 return *internal_default_instance(); 1192 } 1193 enum EdgeNameOrRefCase { 1194 kName = 2, 1195 kNameRef = 3, 1196 EDGENAMEORREF_NOT_SET = 0, 1197 }; 1198 1199 static inline const Edge* internal_default_instance() { 1200 return reinterpret_cast<const Edge*>( 1201 &_Edge_default_instance_); 1202 } 1203 static constexpr int kIndexInFileMessages = 1204 4; 1205 1206 friend void swap(Edge& a, Edge& b) { 1207 a.Swap(&b); 1208 } 1209 inline void Swap(Edge* other) { 1210 if (other == this) return; 1211 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP 1212 if (GetOwningArena() != nullptr && 1213 GetOwningArena() == other->GetOwningArena()) { 1214 #else // PROTOBUF_FORCE_COPY_IN_SWAP 1215 if (GetOwningArena() == other->GetOwningArena()) { 1216 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP 1217 InternalSwap(other); 1218 } else { 1219 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); 1220 } 1221 } 1222 void UnsafeArenaSwap(Edge* other) { 1223 if (other == this) return; 1224 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); 1225 InternalSwap(other); 1226 } 1227 1228 // implements Message ---------------------------------------------- 1229 1230 Edge* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { 1231 return CreateMaybeMessage<Edge>(arena); 1232 } 1233 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; 1234 void CopyFrom(const Edge& from); 1235 void MergeFrom(const Edge& from); 1236 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; 1237 bool IsInitialized() const final; 1238 1239 size_t ByteSizeLong() const final; 1240 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; 1241 uint8_t* _InternalSerialize( 1242 uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; 1243 int GetCachedSize() const final { return _impl_._cached_size_.Get(); } 1244 1245 private: 1246 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); 1247 void SharedDtor(); 1248 void SetCachedSize(int size) const; 1249 void InternalSwap(Edge* other); 1250 1251 private: 1252 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; 1253 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { 1254 return "mozilla.devtools.protobuf.Edge"; 1255 } 1256 protected: 1257 explicit Edge(::PROTOBUF_NAMESPACE_ID::Arena* arena, 1258 bool is_message_owned = false); 1259 public: 1260 1261 std::string GetTypeName() const final; 1262 1263 // nested types ---------------------------------------------------- 1264 1265 // accessors ------------------------------------------------------- 1266 1267 enum : int { 1268 kReferentFieldNumber = 1, 1269 kNameFieldNumber = 2, 1270 kNameRefFieldNumber = 3, 1271 }; 1272 // optional uint64 referent = 1; 1273 bool has_referent() const; 1274 private: 1275 bool _internal_has_referent() const; 1276 public: 1277 void clear_referent(); 1278 uint64_t referent() const; 1279 void set_referent(uint64_t value); 1280 private: 1281 uint64_t _internal_referent() const; 1282 void _internal_set_referent(uint64_t value); 1283 public: 1284 1285 // bytes name = 2; 1286 bool has_name() const; 1287 private: 1288 bool _internal_has_name() const; 1289 public: 1290 void clear_name(); 1291 const std::string& name() const; 1292 template <typename ArgT0 = const std::string&, typename... ArgT> 1293 void set_name(ArgT0&& arg0, ArgT... args); 1294 std::string* mutable_name(); 1295 PROTOBUF_NODISCARD std::string* release_name(); 1296 void set_allocated_name(std::string* name); 1297 private: 1298 const std::string& _internal_name() const; 1299 inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); 1300 std::string* _internal_mutable_name(); 1301 public: 1302 1303 // uint64 nameRef = 3; 1304 bool has_nameref() const; 1305 private: 1306 bool _internal_has_nameref() const; 1307 public: 1308 void clear_nameref(); 1309 uint64_t nameref() const; 1310 void set_nameref(uint64_t value); 1311 private: 1312 uint64_t _internal_nameref() const; 1313 void _internal_set_nameref(uint64_t value); 1314 public: 1315 1316 void clear_EdgeNameOrRef(); 1317 EdgeNameOrRefCase EdgeNameOrRef_case() const; 1318 // @@protoc_insertion_point(class_scope:mozilla.devtools.protobuf.Edge) 1319 private: 1320 class _Internal; 1321 void set_has_name(); 1322 void set_has_nameref(); 1323 1324 inline bool has_EdgeNameOrRef() const; 1325 inline void clear_has_EdgeNameOrRef(); 1326 1327 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; 1328 typedef void InternalArenaConstructable_; 1329 typedef void DestructorSkippable_; 1330 struct Impl_ { 1331 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; 1332 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; 1333 uint64_t referent_; 1334 union EdgeNameOrRefUnion { 1335 constexpr EdgeNameOrRefUnion() : _constinit_{} {} 1336 ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; 1337 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; 1338 uint64_t nameref_; 1339 } EdgeNameOrRef_; 1340 uint32_t _oneof_case_[1]; 1341 1342 }; 1343 union { Impl_ _impl_; }; 1344 friend struct ::TableStruct_CoreDump_2eproto; 1345 }; 1346 // =================================================================== 1347 1348 1349 // =================================================================== 1350 1351 #ifdef __GNUC__ 1352 #pragma GCC diagnostic push 1353 #pragma GCC diagnostic ignored "-Wstrict-aliasing" 1354 #endif // __GNUC__ 1355 // Metadata 1356 1357 // optional uint64 timeStamp = 1; 1358 inline bool Metadata::_internal_has_timestamp() const { 1359 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; 1360 return value; 1361 } 1362 inline bool Metadata::has_timestamp() const { 1363 return _internal_has_timestamp(); 1364 } 1365 inline void Metadata::clear_timestamp() { 1366 _impl_.timestamp_ = uint64_t{0u}; 1367 _impl_._has_bits_[0] &= ~0x00000001u; 1368 } 1369 inline uint64_t Metadata::_internal_timestamp() const { 1370 return _impl_.timestamp_; 1371 } 1372 inline uint64_t Metadata::timestamp() const { 1373 // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Metadata.timeStamp) 1374 return _internal_timestamp(); 1375 } 1376 inline void Metadata::_internal_set_timestamp(uint64_t value) { 1377 _impl_._has_bits_[0] |= 0x00000001u; 1378 _impl_.timestamp_ = value; 1379 } 1380 inline void Metadata::set_timestamp(uint64_t value) { 1381 _internal_set_timestamp(value); 1382 // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Metadata.timeStamp) 1383 } 1384 1385 // ------------------------------------------------------------------- 1386 1387 // StackFrame_Data 1388 1389 // optional uint64 id = 1; 1390 inline bool StackFrame_Data::_internal_has_id() const { 1391 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; 1392 return value; 1393 } 1394 inline bool StackFrame_Data::has_id() const { 1395 return _internal_has_id(); 1396 } 1397 inline void StackFrame_Data::clear_id() { 1398 _impl_.id_ = uint64_t{0u}; 1399 _impl_._has_bits_[0] &= ~0x00000002u; 1400 } 1401 inline uint64_t StackFrame_Data::_internal_id() const { 1402 return _impl_.id_; 1403 } 1404 inline uint64_t StackFrame_Data::id() const { 1405 // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.id) 1406 return _internal_id(); 1407 } 1408 inline void StackFrame_Data::_internal_set_id(uint64_t value) { 1409 _impl_._has_bits_[0] |= 0x00000002u; 1410 _impl_.id_ = value; 1411 } 1412 inline void StackFrame_Data::set_id(uint64_t value) { 1413 _internal_set_id(value); 1414 // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.id) 1415 } 1416 1417 // optional .mozilla.devtools.protobuf.StackFrame parent = 2; 1418 inline bool StackFrame_Data::_internal_has_parent() const { 1419 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; 1420 PROTOBUF_ASSUME(!value || _impl_.parent_ != nullptr); 1421 return value; 1422 } 1423 inline bool StackFrame_Data::has_parent() const { 1424 return _internal_has_parent(); 1425 } 1426 inline void StackFrame_Data::clear_parent() { 1427 if (_impl_.parent_ != nullptr) _impl_.parent_->Clear(); 1428 _impl_._has_bits_[0] &= ~0x00000001u; 1429 } 1430 inline const ::mozilla::devtools::protobuf::StackFrame& StackFrame_Data::_internal_parent() const { 1431 const ::mozilla::devtools::protobuf::StackFrame* p = _impl_.parent_; 1432 return p != nullptr ? *p : reinterpret_cast<const ::mozilla::devtools::protobuf::StackFrame&>( 1433 ::mozilla::devtools::protobuf::_StackFrame_default_instance_); 1434 } 1435 inline const ::mozilla::devtools::protobuf::StackFrame& StackFrame_Data::parent() const { 1436 // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.parent) 1437 return _internal_parent(); 1438 } 1439 inline void StackFrame_Data::unsafe_arena_set_allocated_parent( 1440 ::mozilla::devtools::protobuf::StackFrame* parent) { 1441 if (GetArenaForAllocation() == nullptr) { 1442 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.parent_); 1443 } 1444 _impl_.parent_ = parent; 1445 if (parent) { 1446 _impl_._has_bits_[0] |= 0x00000001u; 1447 } else { 1448 _impl_._has_bits_[0] &= ~0x00000001u; 1449 } 1450 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.devtools.protobuf.StackFrame.Data.parent) 1451 } 1452 inline ::mozilla::devtools::protobuf::StackFrame* StackFrame_Data::release_parent() { 1453 _impl_._has_bits_[0] &= ~0x00000001u; 1454 ::mozilla::devtools::protobuf::StackFrame* temp = _impl_.parent_; 1455 _impl_.parent_ = nullptr; 1456 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE 1457 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); 1458 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); 1459 if (GetArenaForAllocation() == nullptr) { delete old; } 1460 #else // PROTOBUF_FORCE_COPY_IN_RELEASE 1461 if (GetArenaForAllocation() != nullptr) { 1462 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); 1463 } 1464 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE 1465 return temp; 1466 } 1467 inline ::mozilla::devtools::protobuf::StackFrame* StackFrame_Data::unsafe_arena_release_parent() { 1468 // @@protoc_insertion_point(field_release:mozilla.devtools.protobuf.StackFrame.Data.parent) 1469 _impl_._has_bits_[0] &= ~0x00000001u; 1470 ::mozilla::devtools::protobuf::StackFrame* temp = _impl_.parent_; 1471 _impl_.parent_ = nullptr; 1472 return temp; 1473 } 1474 inline ::mozilla::devtools::protobuf::StackFrame* StackFrame_Data::_internal_mutable_parent() { 1475 _impl_._has_bits_[0] |= 0x00000001u; 1476 if (_impl_.parent_ == nullptr) { 1477 auto* p = CreateMaybeMessage<::mozilla::devtools::protobuf::StackFrame>(GetArenaForAllocation()); 1478 _impl_.parent_ = p; 1479 } 1480 return _impl_.parent_; 1481 } 1482 inline ::mozilla::devtools::protobuf::StackFrame* StackFrame_Data::mutable_parent() { 1483 ::mozilla::devtools::protobuf::StackFrame* _msg = _internal_mutable_parent(); 1484 // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.StackFrame.Data.parent) 1485 return _msg; 1486 } 1487 inline void StackFrame_Data::set_allocated_parent(::mozilla::devtools::protobuf::StackFrame* parent) { 1488 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); 1489 if (message_arena == nullptr) { 1490 delete _impl_.parent_; 1491 } 1492 if (parent) { 1493 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = 1494 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(parent); 1495 if (message_arena != submessage_arena) { 1496 parent = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( 1497 message_arena, parent, submessage_arena); 1498 } 1499 _impl_._has_bits_[0] |= 0x00000001u; 1500 } else { 1501 _impl_._has_bits_[0] &= ~0x00000001u; 1502 } 1503 _impl_.parent_ = parent; 1504 // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.StackFrame.Data.parent) 1505 } 1506 1507 // optional uint32 line = 3; 1508 inline bool StackFrame_Data::_internal_has_line() const { 1509 bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; 1510 return value; 1511 } 1512 inline bool StackFrame_Data::has_line() const { 1513 return _internal_has_line(); 1514 } 1515 inline void StackFrame_Data::clear_line() { 1516 _impl_.line_ = 0u; 1517 _impl_._has_bits_[0] &= ~0x00000004u; 1518 } 1519 inline uint32_t StackFrame_Data::_internal_line() const { 1520 return _impl_.line_; 1521 } 1522 inline uint32_t StackFrame_Data::line() const { 1523 // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.line) 1524 return _internal_line(); 1525 } 1526 inline void StackFrame_Data::_internal_set_line(uint32_t value) { 1527 _impl_._has_bits_[0] |= 0x00000004u; 1528 _impl_.line_ = value; 1529 } 1530 inline void StackFrame_Data::set_line(uint32_t value) { 1531 _internal_set_line(value); 1532 // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.line) 1533 } 1534 1535 // optional uint32 column = 4; 1536 inline bool StackFrame_Data::_internal_has_column() const { 1537 bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; 1538 return value; 1539 } 1540 inline bool StackFrame_Data::has_column() const { 1541 return _internal_has_column(); 1542 } 1543 inline void StackFrame_Data::clear_column() { 1544 _impl_.column_ = 0u; 1545 _impl_._has_bits_[0] &= ~0x00000008u; 1546 } 1547 inline uint32_t StackFrame_Data::_internal_column() const { 1548 return _impl_.column_; 1549 } 1550 inline uint32_t StackFrame_Data::column() const { 1551 // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.column) 1552 return _internal_column(); 1553 } 1554 inline void StackFrame_Data::_internal_set_column(uint32_t value) { 1555 _impl_._has_bits_[0] |= 0x00000008u; 1556 _impl_.column_ = value; 1557 } 1558 inline void StackFrame_Data::set_column(uint32_t value) { 1559 _internal_set_column(value); 1560 // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.column) 1561 } 1562 1563 // bytes source = 5; 1564 inline bool StackFrame_Data::_internal_has_source() const { 1565 return SourceOrRef_case() == kSource; 1566 } 1567 inline bool StackFrame_Data::has_source() const { 1568 return _internal_has_source(); 1569 } 1570 inline void StackFrame_Data::set_has_source() { 1571 _impl_._oneof_case_[0] = kSource; 1572 } 1573 inline void StackFrame_Data::clear_source() { 1574 if (_internal_has_source()) { 1575 _impl_.SourceOrRef_.source_.Destroy(); 1576 clear_has_SourceOrRef(); 1577 } 1578 } 1579 inline const std::string& StackFrame_Data::source() const { 1580 // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.source) 1581 return _internal_source(); 1582 } 1583 template <typename ArgT0, typename... ArgT> 1584 inline void StackFrame_Data::set_source(ArgT0&& arg0, ArgT... args) { 1585 if (!_internal_has_source()) { 1586 clear_SourceOrRef(); 1587 set_has_source(); 1588 _impl_.SourceOrRef_.source_.InitDefault(); 1589 } 1590 _impl_.SourceOrRef_.source_.SetBytes( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation()); 1591 // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.source) 1592 } 1593 inline std::string* StackFrame_Data::mutable_source() { 1594 std::string* _s = _internal_mutable_source(); 1595 // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.StackFrame.Data.source) 1596 return _s; 1597 } 1598 inline const std::string& StackFrame_Data::_internal_source() const { 1599 if (_internal_has_source()) { 1600 return _impl_.SourceOrRef_.source_.Get(); 1601 } 1602 return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); 1603 } 1604 inline void StackFrame_Data::_internal_set_source(const std::string& value) { 1605 if (!_internal_has_source()) { 1606 clear_SourceOrRef(); 1607 set_has_source(); 1608 _impl_.SourceOrRef_.source_.InitDefault(); 1609 } 1610 _impl_.SourceOrRef_.source_.Set(value, GetArenaForAllocation()); 1611 } 1612 inline std::string* StackFrame_Data::_internal_mutable_source() { 1613 if (!_internal_has_source()) { 1614 clear_SourceOrRef(); 1615 set_has_source(); 1616 _impl_.SourceOrRef_.source_.InitDefault(); 1617 } 1618 return _impl_.SourceOrRef_.source_.Mutable( GetArenaForAllocation()); 1619 } 1620 inline std::string* StackFrame_Data::release_source() { 1621 // @@protoc_insertion_point(field_release:mozilla.devtools.protobuf.StackFrame.Data.source) 1622 if (_internal_has_source()) { 1623 clear_has_SourceOrRef(); 1624 return _impl_.SourceOrRef_.source_.Release(); 1625 } else { 1626 return nullptr; 1627 } 1628 } 1629 inline void StackFrame_Data::set_allocated_source(std::string* source) { 1630 if (has_SourceOrRef()) { 1631 clear_SourceOrRef(); 1632 } 1633 if (source != nullptr) { 1634 set_has_source(); 1635 _impl_.SourceOrRef_.source_.InitAllocated(source, GetArenaForAllocation()); 1636 } 1637 // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.StackFrame.Data.source) 1638 } 1639 1640 // uint64 sourceRef = 6; 1641 inline bool StackFrame_Data::_internal_has_sourceref() const { 1642 return SourceOrRef_case() == kSourceRef; 1643 } 1644 inline bool StackFrame_Data::has_sourceref() const { 1645 return _internal_has_sourceref(); 1646 } 1647 inline void StackFrame_Data::set_has_sourceref() { 1648 _impl_._oneof_case_[0] = kSourceRef; 1649 } 1650 inline void StackFrame_Data::clear_sourceref() { 1651 if (_internal_has_sourceref()) { 1652 _impl_.SourceOrRef_.sourceref_ = uint64_t{0u}; 1653 clear_has_SourceOrRef(); 1654 } 1655 } 1656 inline uint64_t StackFrame_Data::_internal_sourceref() const { 1657 if (_internal_has_sourceref()) { 1658 return _impl_.SourceOrRef_.sourceref_; 1659 } 1660 return uint64_t{0u}; 1661 } 1662 inline void StackFrame_Data::_internal_set_sourceref(uint64_t value) { 1663 if (!_internal_has_sourceref()) { 1664 clear_SourceOrRef(); 1665 set_has_sourceref(); 1666 } 1667 _impl_.SourceOrRef_.sourceref_ = value; 1668 } 1669 inline uint64_t StackFrame_Data::sourceref() const { 1670 // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.sourceRef) 1671 return _internal_sourceref(); 1672 } 1673 inline void StackFrame_Data::set_sourceref(uint64_t value) { 1674 _internal_set_sourceref(value); 1675 // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.sourceRef) 1676 } 1677 1678 // bytes functionDisplayName = 7; 1679 inline bool StackFrame_Data::_internal_has_functiondisplayname() const { 1680 return FunctionDisplayNameOrRef_case() == kFunctionDisplayName; 1681 } 1682 inline bool StackFrame_Data::has_functiondisplayname() const { 1683 return _internal_has_functiondisplayname(); 1684 } 1685 inline void StackFrame_Data::set_has_functiondisplayname() { 1686 _impl_._oneof_case_[1] = kFunctionDisplayName; 1687 } 1688 inline void StackFrame_Data::clear_functiondisplayname() { 1689 if (_internal_has_functiondisplayname()) { 1690 _impl_.FunctionDisplayNameOrRef_.functiondisplayname_.Destroy(); 1691 clear_has_FunctionDisplayNameOrRef(); 1692 } 1693 } 1694 inline const std::string& StackFrame_Data::functiondisplayname() const { 1695 // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.functionDisplayName) 1696 return _internal_functiondisplayname(); 1697 } 1698 template <typename ArgT0, typename... ArgT> 1699 inline void StackFrame_Data::set_functiondisplayname(ArgT0&& arg0, ArgT... args) { 1700 if (!_internal_has_functiondisplayname()) { 1701 clear_FunctionDisplayNameOrRef(); 1702 set_has_functiondisplayname(); 1703 _impl_.FunctionDisplayNameOrRef_.functiondisplayname_.InitDefault(); 1704 } 1705 _impl_.FunctionDisplayNameOrRef_.functiondisplayname_.SetBytes( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation()); 1706 // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.functionDisplayName) 1707 } 1708 inline std::string* StackFrame_Data::mutable_functiondisplayname() { 1709 std::string* _s = _internal_mutable_functiondisplayname(); 1710 // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.StackFrame.Data.functionDisplayName) 1711 return _s; 1712 } 1713 inline const std::string& StackFrame_Data::_internal_functiondisplayname() const { 1714 if (_internal_has_functiondisplayname()) { 1715 return _impl_.FunctionDisplayNameOrRef_.functiondisplayname_.Get(); 1716 } 1717 return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); 1718 } 1719 inline void StackFrame_Data::_internal_set_functiondisplayname(const std::string& value) { 1720 if (!_internal_has_functiondisplayname()) { 1721 clear_FunctionDisplayNameOrRef(); 1722 set_has_functiondisplayname(); 1723 _impl_.FunctionDisplayNameOrRef_.functiondisplayname_.InitDefault(); 1724 } 1725 _impl_.FunctionDisplayNameOrRef_.functiondisplayname_.Set(value, GetArenaForAllocation()); 1726 } 1727 inline std::string* StackFrame_Data::_internal_mutable_functiondisplayname() { 1728 if (!_internal_has_functiondisplayname()) { 1729 clear_FunctionDisplayNameOrRef(); 1730 set_has_functiondisplayname(); 1731 _impl_.FunctionDisplayNameOrRef_.functiondisplayname_.InitDefault(); 1732 } 1733 return _impl_.FunctionDisplayNameOrRef_.functiondisplayname_.Mutable( GetArenaForAllocation()); 1734 } 1735 inline std::string* StackFrame_Data::release_functiondisplayname() { 1736 // @@protoc_insertion_point(field_release:mozilla.devtools.protobuf.StackFrame.Data.functionDisplayName) 1737 if (_internal_has_functiondisplayname()) { 1738 clear_has_FunctionDisplayNameOrRef(); 1739 return _impl_.FunctionDisplayNameOrRef_.functiondisplayname_.Release(); 1740 } else { 1741 return nullptr; 1742 } 1743 } 1744 inline void StackFrame_Data::set_allocated_functiondisplayname(std::string* functiondisplayname) { 1745 if (has_FunctionDisplayNameOrRef()) { 1746 clear_FunctionDisplayNameOrRef(); 1747 } 1748 if (functiondisplayname != nullptr) { 1749 set_has_functiondisplayname(); 1750 _impl_.FunctionDisplayNameOrRef_.functiondisplayname_.InitAllocated(functiondisplayname, GetArenaForAllocation()); 1751 } 1752 // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.StackFrame.Data.functionDisplayName) 1753 } 1754 1755 // uint64 functionDisplayNameRef = 8; 1756 inline bool StackFrame_Data::_internal_has_functiondisplaynameref() const { 1757 return FunctionDisplayNameOrRef_case() == kFunctionDisplayNameRef; 1758 } 1759 inline bool StackFrame_Data::has_functiondisplaynameref() const { 1760 return _internal_has_functiondisplaynameref(); 1761 } 1762 inline void StackFrame_Data::set_has_functiondisplaynameref() { 1763 _impl_._oneof_case_[1] = kFunctionDisplayNameRef; 1764 } 1765 inline void StackFrame_Data::clear_functiondisplaynameref() { 1766 if (_internal_has_functiondisplaynameref()) { 1767 _impl_.FunctionDisplayNameOrRef_.functiondisplaynameref_ = uint64_t{0u}; 1768 clear_has_FunctionDisplayNameOrRef(); 1769 } 1770 } 1771 inline uint64_t StackFrame_Data::_internal_functiondisplaynameref() const { 1772 if (_internal_has_functiondisplaynameref()) { 1773 return _impl_.FunctionDisplayNameOrRef_.functiondisplaynameref_; 1774 } 1775 return uint64_t{0u}; 1776 } 1777 inline void StackFrame_Data::_internal_set_functiondisplaynameref(uint64_t value) { 1778 if (!_internal_has_functiondisplaynameref()) { 1779 clear_FunctionDisplayNameOrRef(); 1780 set_has_functiondisplaynameref(); 1781 } 1782 _impl_.FunctionDisplayNameOrRef_.functiondisplaynameref_ = value; 1783 } 1784 inline uint64_t StackFrame_Data::functiondisplaynameref() const { 1785 // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.functionDisplayNameRef) 1786 return _internal_functiondisplaynameref(); 1787 } 1788 inline void StackFrame_Data::set_functiondisplaynameref(uint64_t value) { 1789 _internal_set_functiondisplaynameref(value); 1790 // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.functionDisplayNameRef) 1791 } 1792 1793 // optional bool isSystem = 9; 1794 inline bool StackFrame_Data::_internal_has_issystem() const { 1795 bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; 1796 return value; 1797 } 1798 inline bool StackFrame_Data::has_issystem() const { 1799 return _internal_has_issystem(); 1800 } 1801 inline void StackFrame_Data::clear_issystem() { 1802 _impl_.issystem_ = false; 1803 _impl_._has_bits_[0] &= ~0x00000010u; 1804 } 1805 inline bool StackFrame_Data::_internal_issystem() const { 1806 return _impl_.issystem_; 1807 } 1808 inline bool StackFrame_Data::issystem() const { 1809 // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.isSystem) 1810 return _internal_issystem(); 1811 } 1812 inline void StackFrame_Data::_internal_set_issystem(bool value) { 1813 _impl_._has_bits_[0] |= 0x00000010u; 1814 _impl_.issystem_ = value; 1815 } 1816 inline void StackFrame_Data::set_issystem(bool value) { 1817 _internal_set_issystem(value); 1818 // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.isSystem) 1819 } 1820 1821 // optional bool isSelfHosted = 10; 1822 inline bool StackFrame_Data::_internal_has_isselfhosted() const { 1823 bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; 1824 return value; 1825 } 1826 inline bool StackFrame_Data::has_isselfhosted() const { 1827 return _internal_has_isselfhosted(); 1828 } 1829 inline void StackFrame_Data::clear_isselfhosted() { 1830 _impl_.isselfhosted_ = false; 1831 _impl_._has_bits_[0] &= ~0x00000020u; 1832 } 1833 inline bool StackFrame_Data::_internal_isselfhosted() const { 1834 return _impl_.isselfhosted_; 1835 } 1836 inline bool StackFrame_Data::isselfhosted() const { 1837 // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.isSelfHosted) 1838 return _internal_isselfhosted(); 1839 } 1840 inline void StackFrame_Data::_internal_set_isselfhosted(bool value) { 1841 _impl_._has_bits_[0] |= 0x00000020u; 1842 _impl_.isselfhosted_ = value; 1843 } 1844 inline void StackFrame_Data::set_isselfhosted(bool value) { 1845 _internal_set_isselfhosted(value); 1846 // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.isSelfHosted) 1847 } 1848 1849 inline bool StackFrame_Data::has_SourceOrRef() const { 1850 return SourceOrRef_case() != SOURCEORREF_NOT_SET; 1851 } 1852 inline void StackFrame_Data::clear_has_SourceOrRef() { 1853 _impl_._oneof_case_[0] = SOURCEORREF_NOT_SET; 1854 } 1855 inline bool StackFrame_Data::has_FunctionDisplayNameOrRef() const { 1856 return FunctionDisplayNameOrRef_case() != FUNCTIONDISPLAYNAMEORREF_NOT_SET; 1857 } 1858 inline void StackFrame_Data::clear_has_FunctionDisplayNameOrRef() { 1859 _impl_._oneof_case_[1] = FUNCTIONDISPLAYNAMEORREF_NOT_SET; 1860 } 1861 inline StackFrame_Data::SourceOrRefCase StackFrame_Data::SourceOrRef_case() const { 1862 return StackFrame_Data::SourceOrRefCase(_impl_._oneof_case_[0]); 1863 } 1864 inline StackFrame_Data::FunctionDisplayNameOrRefCase StackFrame_Data::FunctionDisplayNameOrRef_case() const { 1865 return StackFrame_Data::FunctionDisplayNameOrRefCase(_impl_._oneof_case_[1]); 1866 } 1867 // ------------------------------------------------------------------- 1868 1869 // StackFrame 1870 1871 // .mozilla.devtools.protobuf.StackFrame.Data data = 1; 1872 inline bool StackFrame::_internal_has_data() const { 1873 return StackFrameType_case() == kData; 1874 } 1875 inline bool StackFrame::has_data() const { 1876 return _internal_has_data(); 1877 } 1878 inline void StackFrame::set_has_data() { 1879 _impl_._oneof_case_[0] = kData; 1880 } 1881 inline void StackFrame::clear_data() { 1882 if (_internal_has_data()) { 1883 if (GetArenaForAllocation() == nullptr) { 1884 delete _impl_.StackFrameType_.data_; 1885 } 1886 clear_has_StackFrameType(); 1887 } 1888 } 1889 inline ::mozilla::devtools::protobuf::StackFrame_Data* StackFrame::release_data() { 1890 // @@protoc_insertion_point(field_release:mozilla.devtools.protobuf.StackFrame.data) 1891 if (_internal_has_data()) { 1892 clear_has_StackFrameType(); 1893 ::mozilla::devtools::protobuf::StackFrame_Data* temp = _impl_.StackFrameType_.data_; 1894 if (GetArenaForAllocation() != nullptr) { 1895 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); 1896 } 1897 _impl_.StackFrameType_.data_ = nullptr; 1898 return temp; 1899 } else { 1900 return nullptr; 1901 } 1902 } 1903 inline const ::mozilla::devtools::protobuf::StackFrame_Data& StackFrame::_internal_data() const { 1904 return _internal_has_data() 1905 ? *_impl_.StackFrameType_.data_ 1906 : reinterpret_cast< ::mozilla::devtools::protobuf::StackFrame_Data&>(::mozilla::devtools::protobuf::_StackFrame_Data_default_instance_); 1907 } 1908 inline const ::mozilla::devtools::protobuf::StackFrame_Data& StackFrame::data() const { 1909 // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.data) 1910 return _internal_data(); 1911 } 1912 inline ::mozilla::devtools::protobuf::StackFrame_Data* StackFrame::unsafe_arena_release_data() { 1913 // @@protoc_insertion_point(field_unsafe_arena_release:mozilla.devtools.protobuf.StackFrame.data) 1914 if (_internal_has_data()) { 1915 clear_has_StackFrameType(); 1916 ::mozilla::devtools::protobuf::StackFrame_Data* temp = _impl_.StackFrameType_.data_; 1917 _impl_.StackFrameType_.data_ = nullptr; 1918 return temp; 1919 } else { 1920 return nullptr; 1921 } 1922 } 1923 inline void StackFrame::unsafe_arena_set_allocated_data(::mozilla::devtools::protobuf::StackFrame_Data* data) { 1924 clear_StackFrameType(); 1925 if (data) { 1926 set_has_data(); 1927 _impl_.StackFrameType_.data_ = data; 1928 } 1929 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.devtools.protobuf.StackFrame.data) 1930 } 1931 inline ::mozilla::devtools::protobuf::StackFrame_Data* StackFrame::_internal_mutable_data() { 1932 if (!_internal_has_data()) { 1933 clear_StackFrameType(); 1934 set_has_data(); 1935 _impl_.StackFrameType_.data_ = CreateMaybeMessage< ::mozilla::devtools::protobuf::StackFrame_Data >(GetArenaForAllocation()); 1936 } 1937 return _impl_.StackFrameType_.data_; 1938 } 1939 inline ::mozilla::devtools::protobuf::StackFrame_Data* StackFrame::mutable_data() { 1940 ::mozilla::devtools::protobuf::StackFrame_Data* _msg = _internal_mutable_data(); 1941 // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.StackFrame.data) 1942 return _msg; 1943 } 1944 1945 // uint64 ref = 2; 1946 inline bool StackFrame::_internal_has_ref() const { 1947 return StackFrameType_case() == kRef; 1948 } 1949 inline bool StackFrame::has_ref() const { 1950 return _internal_has_ref(); 1951 } 1952 inline void StackFrame::set_has_ref() { 1953 _impl_._oneof_case_[0] = kRef; 1954 } 1955 inline void StackFrame::clear_ref() { 1956 if (_internal_has_ref()) { 1957 _impl_.StackFrameType_.ref_ = uint64_t{0u}; 1958 clear_has_StackFrameType(); 1959 } 1960 } 1961 inline uint64_t StackFrame::_internal_ref() const { 1962 if (_internal_has_ref()) { 1963 return _impl_.StackFrameType_.ref_; 1964 } 1965 return uint64_t{0u}; 1966 } 1967 inline void StackFrame::_internal_set_ref(uint64_t value) { 1968 if (!_internal_has_ref()) { 1969 clear_StackFrameType(); 1970 set_has_ref(); 1971 } 1972 _impl_.StackFrameType_.ref_ = value; 1973 } 1974 inline uint64_t StackFrame::ref() const { 1975 // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.ref) 1976 return _internal_ref(); 1977 } 1978 inline void StackFrame::set_ref(uint64_t value) { 1979 _internal_set_ref(value); 1980 // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.ref) 1981 } 1982 1983 inline bool StackFrame::has_StackFrameType() const { 1984 return StackFrameType_case() != STACKFRAMETYPE_NOT_SET; 1985 } 1986 inline void StackFrame::clear_has_StackFrameType() { 1987 _impl_._oneof_case_[0] = STACKFRAMETYPE_NOT_SET; 1988 } 1989 inline StackFrame::StackFrameTypeCase StackFrame::StackFrameType_case() const { 1990 return StackFrame::StackFrameTypeCase(_impl_._oneof_case_[0]); 1991 } 1992 // ------------------------------------------------------------------- 1993 1994 // Node 1995 1996 // optional uint64 id = 1; 1997 inline bool Node::_internal_has_id() const { 1998 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; 1999 return value; 2000 } 2001 inline bool Node::has_id() const { 2002 return _internal_has_id(); 2003 } 2004 inline void Node::clear_id() { 2005 _impl_.id_ = uint64_t{0u}; 2006 _impl_._has_bits_[0] &= ~0x00000002u; 2007 } 2008 inline uint64_t Node::_internal_id() const { 2009 return _impl_.id_; 2010 } 2011 inline uint64_t Node::id() const { 2012 // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.id) 2013 return _internal_id(); 2014 } 2015 inline void Node::_internal_set_id(uint64_t value) { 2016 _impl_._has_bits_[0] |= 0x00000002u; 2017 _impl_.id_ = value; 2018 } 2019 inline void Node::set_id(uint64_t value) { 2020 _internal_set_id(value); 2021 // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.id) 2022 } 2023 2024 // bytes typeName = 2; 2025 inline bool Node::_internal_has_typename_() const { 2026 return TypeNameOrRef_case() == kTypeName; 2027 } 2028 inline bool Node::has_typename_() const { 2029 return _internal_has_typename_(); 2030 } 2031 inline void Node::set_has_typename_() { 2032 _impl_._oneof_case_[0] = kTypeName; 2033 } 2034 inline void Node::clear_typename_() { 2035 if (_internal_has_typename_()) { 2036 _impl_.TypeNameOrRef_.typename__.Destroy(); 2037 clear_has_TypeNameOrRef(); 2038 } 2039 } 2040 inline const std::string& Node::typename_() const { 2041 // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.typeName) 2042 return _internal_typename_(); 2043 } 2044 template <typename ArgT0, typename... ArgT> 2045 inline void Node::set_typename_(ArgT0&& arg0, ArgT... args) { 2046 if (!_internal_has_typename_()) { 2047 clear_TypeNameOrRef(); 2048 set_has_typename_(); 2049 _impl_.TypeNameOrRef_.typename__.InitDefault(); 2050 } 2051 _impl_.TypeNameOrRef_.typename__.SetBytes( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation()); 2052 // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.typeName) 2053 } 2054 inline std::string* Node::mutable_typename_() { 2055 std::string* _s = _internal_mutable_typename_(); 2056 // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.Node.typeName) 2057 return _s; 2058 } 2059 inline const std::string& Node::_internal_typename_() const { 2060 if (_internal_has_typename_()) { 2061 return _impl_.TypeNameOrRef_.typename__.Get(); 2062 } 2063 return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); 2064 } 2065 inline void Node::_internal_set_typename_(const std::string& value) { 2066 if (!_internal_has_typename_()) { 2067 clear_TypeNameOrRef(); 2068 set_has_typename_(); 2069 _impl_.TypeNameOrRef_.typename__.InitDefault(); 2070 } 2071 _impl_.TypeNameOrRef_.typename__.Set(value, GetArenaForAllocation()); 2072 } 2073 inline std::string* Node::_internal_mutable_typename_() { 2074 if (!_internal_has_typename_()) { 2075 clear_TypeNameOrRef(); 2076 set_has_typename_(); 2077 _impl_.TypeNameOrRef_.typename__.InitDefault(); 2078 } 2079 return _impl_.TypeNameOrRef_.typename__.Mutable( GetArenaForAllocation()); 2080 } 2081 inline std::string* Node::release_typename_() { 2082 // @@protoc_insertion_point(field_release:mozilla.devtools.protobuf.Node.typeName) 2083 if (_internal_has_typename_()) { 2084 clear_has_TypeNameOrRef(); 2085 return _impl_.TypeNameOrRef_.typename__.Release(); 2086 } else { 2087 return nullptr; 2088 } 2089 } 2090 inline void Node::set_allocated_typename_(std::string* typename_) { 2091 if (has_TypeNameOrRef()) { 2092 clear_TypeNameOrRef(); 2093 } 2094 if (typename_ != nullptr) { 2095 set_has_typename_(); 2096 _impl_.TypeNameOrRef_.typename__.InitAllocated(typename_, GetArenaForAllocation()); 2097 } 2098 // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.Node.typeName) 2099 } 2100 2101 // uint64 typeNameRef = 3; 2102 inline bool Node::_internal_has_typenameref() const { 2103 return TypeNameOrRef_case() == kTypeNameRef; 2104 } 2105 inline bool Node::has_typenameref() const { 2106 return _internal_has_typenameref(); 2107 } 2108 inline void Node::set_has_typenameref() { 2109 _impl_._oneof_case_[0] = kTypeNameRef; 2110 } 2111 inline void Node::clear_typenameref() { 2112 if (_internal_has_typenameref()) { 2113 _impl_.TypeNameOrRef_.typenameref_ = uint64_t{0u}; 2114 clear_has_TypeNameOrRef(); 2115 } 2116 } 2117 inline uint64_t Node::_internal_typenameref() const { 2118 if (_internal_has_typenameref()) { 2119 return _impl_.TypeNameOrRef_.typenameref_; 2120 } 2121 return uint64_t{0u}; 2122 } 2123 inline void Node::_internal_set_typenameref(uint64_t value) { 2124 if (!_internal_has_typenameref()) { 2125 clear_TypeNameOrRef(); 2126 set_has_typenameref(); 2127 } 2128 _impl_.TypeNameOrRef_.typenameref_ = value; 2129 } 2130 inline uint64_t Node::typenameref() const { 2131 // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.typeNameRef) 2132 return _internal_typenameref(); 2133 } 2134 inline void Node::set_typenameref(uint64_t value) { 2135 _internal_set_typenameref(value); 2136 // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.typeNameRef) 2137 } 2138 2139 // optional uint64 size = 4; 2140 inline bool Node::_internal_has_size() const { 2141 bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; 2142 return value; 2143 } 2144 inline bool Node::has_size() const { 2145 return _internal_has_size(); 2146 } 2147 inline void Node::clear_size() { 2148 _impl_.size_ = uint64_t{0u}; 2149 _impl_._has_bits_[0] &= ~0x00000004u; 2150 } 2151 inline uint64_t Node::_internal_size() const { 2152 return _impl_.size_; 2153 } 2154 inline uint64_t Node::size() const { 2155 // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.size) 2156 return _internal_size(); 2157 } 2158 inline void Node::_internal_set_size(uint64_t value) { 2159 _impl_._has_bits_[0] |= 0x00000004u; 2160 _impl_.size_ = value; 2161 } 2162 inline void Node::set_size(uint64_t value) { 2163 _internal_set_size(value); 2164 // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.size) 2165 } 2166 2167 // repeated .mozilla.devtools.protobuf.Edge edges = 5; 2168 inline int Node::_internal_edges_size() const { 2169 return _impl_.edges_.size(); 2170 } 2171 inline int Node::edges_size() const { 2172 return _internal_edges_size(); 2173 } 2174 inline void Node::clear_edges() { 2175 _impl_.edges_.Clear(); 2176 } 2177 inline ::mozilla::devtools::protobuf::Edge* Node::mutable_edges(int index) { 2178 // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.Node.edges) 2179 return _impl_.edges_.Mutable(index); 2180 } 2181 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::devtools::protobuf::Edge >* 2182 Node::mutable_edges() { 2183 // @@protoc_insertion_point(field_mutable_list:mozilla.devtools.protobuf.Node.edges) 2184 return &_impl_.edges_; 2185 } 2186 inline const ::mozilla::devtools::protobuf::Edge& Node::_internal_edges(int index) const { 2187 return _impl_.edges_.Get(index); 2188 } 2189 inline const ::mozilla::devtools::protobuf::Edge& Node::edges(int index) const { 2190 // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.edges) 2191 return _internal_edges(index); 2192 } 2193 inline ::mozilla::devtools::protobuf::Edge* Node::_internal_add_edges() { 2194 return _impl_.edges_.Add(); 2195 } 2196 inline ::mozilla::devtools::protobuf::Edge* Node::add_edges() { 2197 ::mozilla::devtools::protobuf::Edge* _add = _internal_add_edges(); 2198 // @@protoc_insertion_point(field_add:mozilla.devtools.protobuf.Node.edges) 2199 return _add; 2200 } 2201 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::devtools::protobuf::Edge >& 2202 Node::edges() const { 2203 // @@protoc_insertion_point(field_list:mozilla.devtools.protobuf.Node.edges) 2204 return _impl_.edges_; 2205 } 2206 2207 // optional .mozilla.devtools.protobuf.StackFrame allocationStack = 6; 2208 inline bool Node::_internal_has_allocationstack() const { 2209 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; 2210 PROTOBUF_ASSUME(!value || _impl_.allocationstack_ != nullptr); 2211 return value; 2212 } 2213 inline bool Node::has_allocationstack() const { 2214 return _internal_has_allocationstack(); 2215 } 2216 inline void Node::clear_allocationstack() { 2217 if (_impl_.allocationstack_ != nullptr) _impl_.allocationstack_->Clear(); 2218 _impl_._has_bits_[0] &= ~0x00000001u; 2219 } 2220 inline const ::mozilla::devtools::protobuf::StackFrame& Node::_internal_allocationstack() const { 2221 const ::mozilla::devtools::protobuf::StackFrame* p = _impl_.allocationstack_; 2222 return p != nullptr ? *p : reinterpret_cast<const ::mozilla::devtools::protobuf::StackFrame&>( 2223 ::mozilla::devtools::protobuf::_StackFrame_default_instance_); 2224 } 2225 inline const ::mozilla::devtools::protobuf::StackFrame& Node::allocationstack() const { 2226 // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.allocationStack) 2227 return _internal_allocationstack(); 2228 } 2229 inline void Node::unsafe_arena_set_allocated_allocationstack( 2230 ::mozilla::devtools::protobuf::StackFrame* allocationstack) { 2231 if (GetArenaForAllocation() == nullptr) { 2232 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.allocationstack_); 2233 } 2234 _impl_.allocationstack_ = allocationstack; 2235 if (allocationstack) { 2236 _impl_._has_bits_[0] |= 0x00000001u; 2237 } else { 2238 _impl_._has_bits_[0] &= ~0x00000001u; 2239 } 2240 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.devtools.protobuf.Node.allocationStack) 2241 } 2242 inline ::mozilla::devtools::protobuf::StackFrame* Node::release_allocationstack() { 2243 _impl_._has_bits_[0] &= ~0x00000001u; 2244 ::mozilla::devtools::protobuf::StackFrame* temp = _impl_.allocationstack_; 2245 _impl_.allocationstack_ = nullptr; 2246 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE 2247 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); 2248 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); 2249 if (GetArenaForAllocation() == nullptr) { delete old; } 2250 #else // PROTOBUF_FORCE_COPY_IN_RELEASE 2251 if (GetArenaForAllocation() != nullptr) { 2252 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); 2253 } 2254 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE 2255 return temp; 2256 } 2257 inline ::mozilla::devtools::protobuf::StackFrame* Node::unsafe_arena_release_allocationstack() { 2258 // @@protoc_insertion_point(field_release:mozilla.devtools.protobuf.Node.allocationStack) 2259 _impl_._has_bits_[0] &= ~0x00000001u; 2260 ::mozilla::devtools::protobuf::StackFrame* temp = _impl_.allocationstack_; 2261 _impl_.allocationstack_ = nullptr; 2262 return temp; 2263 } 2264 inline ::mozilla::devtools::protobuf::StackFrame* Node::_internal_mutable_allocationstack() { 2265 _impl_._has_bits_[0] |= 0x00000001u; 2266 if (_impl_.allocationstack_ == nullptr) { 2267 auto* p = CreateMaybeMessage<::mozilla::devtools::protobuf::StackFrame>(GetArenaForAllocation()); 2268 _impl_.allocationstack_ = p; 2269 } 2270 return _impl_.allocationstack_; 2271 } 2272 inline ::mozilla::devtools::protobuf::StackFrame* Node::mutable_allocationstack() { 2273 ::mozilla::devtools::protobuf::StackFrame* _msg = _internal_mutable_allocationstack(); 2274 // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.Node.allocationStack) 2275 return _msg; 2276 } 2277 inline void Node::set_allocated_allocationstack(::mozilla::devtools::protobuf::StackFrame* allocationstack) { 2278 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); 2279 if (message_arena == nullptr) { 2280 delete _impl_.allocationstack_; 2281 } 2282 if (allocationstack) { 2283 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = 2284 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(allocationstack); 2285 if (message_arena != submessage_arena) { 2286 allocationstack = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( 2287 message_arena, allocationstack, submessage_arena); 2288 } 2289 _impl_._has_bits_[0] |= 0x00000001u; 2290 } else { 2291 _impl_._has_bits_[0] &= ~0x00000001u; 2292 } 2293 _impl_.allocationstack_ = allocationstack; 2294 // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.Node.allocationStack) 2295 } 2296 2297 // bytes jsObjectClassName = 7; 2298 inline bool Node::_internal_has_jsobjectclassname() const { 2299 return JSObjectClassNameOrRef_case() == kJsObjectClassName; 2300 } 2301 inline bool Node::has_jsobjectclassname() const { 2302 return _internal_has_jsobjectclassname(); 2303 } 2304 inline void Node::set_has_jsobjectclassname() { 2305 _impl_._oneof_case_[1] = kJsObjectClassName; 2306 } 2307 inline void Node::clear_jsobjectclassname() { 2308 if (_internal_has_jsobjectclassname()) { 2309 _impl_.JSObjectClassNameOrRef_.jsobjectclassname_.Destroy(); 2310 clear_has_JSObjectClassNameOrRef(); 2311 } 2312 } 2313 inline const std::string& Node::jsobjectclassname() const { 2314 // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.jsObjectClassName) 2315 return _internal_jsobjectclassname(); 2316 } 2317 template <typename ArgT0, typename... ArgT> 2318 inline void Node::set_jsobjectclassname(ArgT0&& arg0, ArgT... args) { 2319 if (!_internal_has_jsobjectclassname()) { 2320 clear_JSObjectClassNameOrRef(); 2321 set_has_jsobjectclassname(); 2322 _impl_.JSObjectClassNameOrRef_.jsobjectclassname_.InitDefault(); 2323 } 2324 _impl_.JSObjectClassNameOrRef_.jsobjectclassname_.SetBytes( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation()); 2325 // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.jsObjectClassName) 2326 } 2327 inline std::string* Node::mutable_jsobjectclassname() { 2328 std::string* _s = _internal_mutable_jsobjectclassname(); 2329 // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.Node.jsObjectClassName) 2330 return _s; 2331 } 2332 inline const std::string& Node::_internal_jsobjectclassname() const { 2333 if (_internal_has_jsobjectclassname()) { 2334 return _impl_.JSObjectClassNameOrRef_.jsobjectclassname_.Get(); 2335 } 2336 return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); 2337 } 2338 inline void Node::_internal_set_jsobjectclassname(const std::string& value) { 2339 if (!_internal_has_jsobjectclassname()) { 2340 clear_JSObjectClassNameOrRef(); 2341 set_has_jsobjectclassname(); 2342 _impl_.JSObjectClassNameOrRef_.jsobjectclassname_.InitDefault(); 2343 } 2344 _impl_.JSObjectClassNameOrRef_.jsobjectclassname_.Set(value, GetArenaForAllocation()); 2345 } 2346 inline std::string* Node::_internal_mutable_jsobjectclassname() { 2347 if (!_internal_has_jsobjectclassname()) { 2348 clear_JSObjectClassNameOrRef(); 2349 set_has_jsobjectclassname(); 2350 _impl_.JSObjectClassNameOrRef_.jsobjectclassname_.InitDefault(); 2351 } 2352 return _impl_.JSObjectClassNameOrRef_.jsobjectclassname_.Mutable( GetArenaForAllocation()); 2353 } 2354 inline std::string* Node::release_jsobjectclassname() { 2355 // @@protoc_insertion_point(field_release:mozilla.devtools.protobuf.Node.jsObjectClassName) 2356 if (_internal_has_jsobjectclassname()) { 2357 clear_has_JSObjectClassNameOrRef(); 2358 return _impl_.JSObjectClassNameOrRef_.jsobjectclassname_.Release(); 2359 } else { 2360 return nullptr; 2361 } 2362 } 2363 inline void Node::set_allocated_jsobjectclassname(std::string* jsobjectclassname) { 2364 if (has_JSObjectClassNameOrRef()) { 2365 clear_JSObjectClassNameOrRef(); 2366 } 2367 if (jsobjectclassname != nullptr) { 2368 set_has_jsobjectclassname(); 2369 _impl_.JSObjectClassNameOrRef_.jsobjectclassname_.InitAllocated(jsobjectclassname, GetArenaForAllocation()); 2370 } 2371 // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.Node.jsObjectClassName) 2372 } 2373 2374 // uint64 jsObjectClassNameRef = 8; 2375 inline bool Node::_internal_has_jsobjectclassnameref() const { 2376 return JSObjectClassNameOrRef_case() == kJsObjectClassNameRef; 2377 } 2378 inline bool Node::has_jsobjectclassnameref() const { 2379 return _internal_has_jsobjectclassnameref(); 2380 } 2381 inline void Node::set_has_jsobjectclassnameref() { 2382 _impl_._oneof_case_[1] = kJsObjectClassNameRef; 2383 } 2384 inline void Node::clear_jsobjectclassnameref() { 2385 if (_internal_has_jsobjectclassnameref()) { 2386 _impl_.JSObjectClassNameOrRef_.jsobjectclassnameref_ = uint64_t{0u}; 2387 clear_has_JSObjectClassNameOrRef(); 2388 } 2389 } 2390 inline uint64_t Node::_internal_jsobjectclassnameref() const { 2391 if (_internal_has_jsobjectclassnameref()) { 2392 return _impl_.JSObjectClassNameOrRef_.jsobjectclassnameref_; 2393 } 2394 return uint64_t{0u}; 2395 } 2396 inline void Node::_internal_set_jsobjectclassnameref(uint64_t value) { 2397 if (!_internal_has_jsobjectclassnameref()) { 2398 clear_JSObjectClassNameOrRef(); 2399 set_has_jsobjectclassnameref(); 2400 } 2401 _impl_.JSObjectClassNameOrRef_.jsobjectclassnameref_ = value; 2402 } 2403 inline uint64_t Node::jsobjectclassnameref() const { 2404 // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.jsObjectClassNameRef) 2405 return _internal_jsobjectclassnameref(); 2406 } 2407 inline void Node::set_jsobjectclassnameref(uint64_t value) { 2408 _internal_set_jsobjectclassnameref(value); 2409 // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.jsObjectClassNameRef) 2410 } 2411 2412 // optional uint32 coarseType = 9 [default = 0]; 2413 inline bool Node::_internal_has_coarsetype() const { 2414 bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; 2415 return value; 2416 } 2417 inline bool Node::has_coarsetype() const { 2418 return _internal_has_coarsetype(); 2419 } 2420 inline void Node::clear_coarsetype() { 2421 _impl_.coarsetype_ = 0u; 2422 _impl_._has_bits_[0] &= ~0x00000008u; 2423 } 2424 inline uint32_t Node::_internal_coarsetype() const { 2425 return _impl_.coarsetype_; 2426 } 2427 inline uint32_t Node::coarsetype() const { 2428 // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.coarseType) 2429 return _internal_coarsetype(); 2430 } 2431 inline void Node::_internal_set_coarsetype(uint32_t value) { 2432 _impl_._has_bits_[0] |= 0x00000008u; 2433 _impl_.coarsetype_ = value; 2434 } 2435 inline void Node::set_coarsetype(uint32_t value) { 2436 _internal_set_coarsetype(value); 2437 // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.coarseType) 2438 } 2439 2440 // bytes scriptFilename = 10; 2441 inline bool Node::_internal_has_scriptfilename() const { 2442 return ScriptFilenameOrRef_case() == kScriptFilename; 2443 } 2444 inline bool Node::has_scriptfilename() const { 2445 return _internal_has_scriptfilename(); 2446 } 2447 inline void Node::set_has_scriptfilename() { 2448 _impl_._oneof_case_[2] = kScriptFilename; 2449 } 2450 inline void Node::clear_scriptfilename() { 2451 if (_internal_has_scriptfilename()) { 2452 _impl_.ScriptFilenameOrRef_.scriptfilename_.Destroy(); 2453 clear_has_ScriptFilenameOrRef(); 2454 } 2455 } 2456 inline const std::string& Node::scriptfilename() const { 2457 // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.scriptFilename) 2458 return _internal_scriptfilename(); 2459 } 2460 template <typename ArgT0, typename... ArgT> 2461 inline void Node::set_scriptfilename(ArgT0&& arg0, ArgT... args) { 2462 if (!_internal_has_scriptfilename()) { 2463 clear_ScriptFilenameOrRef(); 2464 set_has_scriptfilename(); 2465 _impl_.ScriptFilenameOrRef_.scriptfilename_.InitDefault(); 2466 } 2467 _impl_.ScriptFilenameOrRef_.scriptfilename_.SetBytes( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation()); 2468 // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.scriptFilename) 2469 } 2470 inline std::string* Node::mutable_scriptfilename() { 2471 std::string* _s = _internal_mutable_scriptfilename(); 2472 // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.Node.scriptFilename) 2473 return _s; 2474 } 2475 inline const std::string& Node::_internal_scriptfilename() const { 2476 if (_internal_has_scriptfilename()) { 2477 return _impl_.ScriptFilenameOrRef_.scriptfilename_.Get(); 2478 } 2479 return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); 2480 } 2481 inline void Node::_internal_set_scriptfilename(const std::string& value) { 2482 if (!_internal_has_scriptfilename()) { 2483 clear_ScriptFilenameOrRef(); 2484 set_has_scriptfilename(); 2485 _impl_.ScriptFilenameOrRef_.scriptfilename_.InitDefault(); 2486 } 2487 _impl_.ScriptFilenameOrRef_.scriptfilename_.Set(value, GetArenaForAllocation()); 2488 } 2489 inline std::string* Node::_internal_mutable_scriptfilename() { 2490 if (!_internal_has_scriptfilename()) { 2491 clear_ScriptFilenameOrRef(); 2492 set_has_scriptfilename(); 2493 _impl_.ScriptFilenameOrRef_.scriptfilename_.InitDefault(); 2494 } 2495 return _impl_.ScriptFilenameOrRef_.scriptfilename_.Mutable( GetArenaForAllocation()); 2496 } 2497 inline std::string* Node::release_scriptfilename() { 2498 // @@protoc_insertion_point(field_release:mozilla.devtools.protobuf.Node.scriptFilename) 2499 if (_internal_has_scriptfilename()) { 2500 clear_has_ScriptFilenameOrRef(); 2501 return _impl_.ScriptFilenameOrRef_.scriptfilename_.Release(); 2502 } else { 2503 return nullptr; 2504 } 2505 } 2506 inline void Node::set_allocated_scriptfilename(std::string* scriptfilename) { 2507 if (has_ScriptFilenameOrRef()) { 2508 clear_ScriptFilenameOrRef(); 2509 } 2510 if (scriptfilename != nullptr) { 2511 set_has_scriptfilename(); 2512 _impl_.ScriptFilenameOrRef_.scriptfilename_.InitAllocated(scriptfilename, GetArenaForAllocation()); 2513 } 2514 // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.Node.scriptFilename) 2515 } 2516 2517 // uint64 scriptFilenameRef = 11; 2518 inline bool Node::_internal_has_scriptfilenameref() const { 2519 return ScriptFilenameOrRef_case() == kScriptFilenameRef; 2520 } 2521 inline bool Node::has_scriptfilenameref() const { 2522 return _internal_has_scriptfilenameref(); 2523 } 2524 inline void Node::set_has_scriptfilenameref() { 2525 _impl_._oneof_case_[2] = kScriptFilenameRef; 2526 } 2527 inline void Node::clear_scriptfilenameref() { 2528 if (_internal_has_scriptfilenameref()) { 2529 _impl_.ScriptFilenameOrRef_.scriptfilenameref_ = uint64_t{0u}; 2530 clear_has_ScriptFilenameOrRef(); 2531 } 2532 } 2533 inline uint64_t Node::_internal_scriptfilenameref() const { 2534 if (_internal_has_scriptfilenameref()) { 2535 return _impl_.ScriptFilenameOrRef_.scriptfilenameref_; 2536 } 2537 return uint64_t{0u}; 2538 } 2539 inline void Node::_internal_set_scriptfilenameref(uint64_t value) { 2540 if (!_internal_has_scriptfilenameref()) { 2541 clear_ScriptFilenameOrRef(); 2542 set_has_scriptfilenameref(); 2543 } 2544 _impl_.ScriptFilenameOrRef_.scriptfilenameref_ = value; 2545 } 2546 inline uint64_t Node::scriptfilenameref() const { 2547 // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.scriptFilenameRef) 2548 return _internal_scriptfilenameref(); 2549 } 2550 inline void Node::set_scriptfilenameref(uint64_t value) { 2551 _internal_set_scriptfilenameref(value); 2552 // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.scriptFilenameRef) 2553 } 2554 2555 // bytes descriptiveTypeName = 12; 2556 inline bool Node::_internal_has_descriptivetypename() const { 2557 return descriptiveTypeNameOrRef_case() == kDescriptiveTypeName; 2558 } 2559 inline bool Node::has_descriptivetypename() const { 2560 return _internal_has_descriptivetypename(); 2561 } 2562 inline void Node::set_has_descriptivetypename() { 2563 _impl_._oneof_case_[3] = kDescriptiveTypeName; 2564 } 2565 inline void Node::clear_descriptivetypename() { 2566 if (_internal_has_descriptivetypename()) { 2567 _impl_.descriptiveTypeNameOrRef_.descriptivetypename_.Destroy(); 2568 clear_has_descriptiveTypeNameOrRef(); 2569 } 2570 } 2571 inline const std::string& Node::descriptivetypename() const { 2572 // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.descriptiveTypeName) 2573 return _internal_descriptivetypename(); 2574 } 2575 template <typename ArgT0, typename... ArgT> 2576 inline void Node::set_descriptivetypename(ArgT0&& arg0, ArgT... args) { 2577 if (!_internal_has_descriptivetypename()) { 2578 clear_descriptiveTypeNameOrRef(); 2579 set_has_descriptivetypename(); 2580 _impl_.descriptiveTypeNameOrRef_.descriptivetypename_.InitDefault(); 2581 } 2582 _impl_.descriptiveTypeNameOrRef_.descriptivetypename_.SetBytes( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation()); 2583 // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.descriptiveTypeName) 2584 } 2585 inline std::string* Node::mutable_descriptivetypename() { 2586 std::string* _s = _internal_mutable_descriptivetypename(); 2587 // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.Node.descriptiveTypeName) 2588 return _s; 2589 } 2590 inline const std::string& Node::_internal_descriptivetypename() const { 2591 if (_internal_has_descriptivetypename()) { 2592 return _impl_.descriptiveTypeNameOrRef_.descriptivetypename_.Get(); 2593 } 2594 return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); 2595 } 2596 inline void Node::_internal_set_descriptivetypename(const std::string& value) { 2597 if (!_internal_has_descriptivetypename()) { 2598 clear_descriptiveTypeNameOrRef(); 2599 set_has_descriptivetypename(); 2600 _impl_.descriptiveTypeNameOrRef_.descriptivetypename_.InitDefault(); 2601 } 2602 _impl_.descriptiveTypeNameOrRef_.descriptivetypename_.Set(value, GetArenaForAllocation()); 2603 } 2604 inline std::string* Node::_internal_mutable_descriptivetypename() { 2605 if (!_internal_has_descriptivetypename()) { 2606 clear_descriptiveTypeNameOrRef(); 2607 set_has_descriptivetypename(); 2608 _impl_.descriptiveTypeNameOrRef_.descriptivetypename_.InitDefault(); 2609 } 2610 return _impl_.descriptiveTypeNameOrRef_.descriptivetypename_.Mutable( GetArenaForAllocation()); 2611 } 2612 inline std::string* Node::release_descriptivetypename() { 2613 // @@protoc_insertion_point(field_release:mozilla.devtools.protobuf.Node.descriptiveTypeName) 2614 if (_internal_has_descriptivetypename()) { 2615 clear_has_descriptiveTypeNameOrRef(); 2616 return _impl_.descriptiveTypeNameOrRef_.descriptivetypename_.Release(); 2617 } else { 2618 return nullptr; 2619 } 2620 } 2621 inline void Node::set_allocated_descriptivetypename(std::string* descriptivetypename) { 2622 if (has_descriptiveTypeNameOrRef()) { 2623 clear_descriptiveTypeNameOrRef(); 2624 } 2625 if (descriptivetypename != nullptr) { 2626 set_has_descriptivetypename(); 2627 _impl_.descriptiveTypeNameOrRef_.descriptivetypename_.InitAllocated(descriptivetypename, GetArenaForAllocation()); 2628 } 2629 // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.Node.descriptiveTypeName) 2630 } 2631 2632 // uint64 descriptiveTypeNameRef = 13; 2633 inline bool Node::_internal_has_descriptivetypenameref() const { 2634 return descriptiveTypeNameOrRef_case() == kDescriptiveTypeNameRef; 2635 } 2636 inline bool Node::has_descriptivetypenameref() const { 2637 return _internal_has_descriptivetypenameref(); 2638 } 2639 inline void Node::set_has_descriptivetypenameref() { 2640 _impl_._oneof_case_[3] = kDescriptiveTypeNameRef; 2641 } 2642 inline void Node::clear_descriptivetypenameref() { 2643 if (_internal_has_descriptivetypenameref()) { 2644 _impl_.descriptiveTypeNameOrRef_.descriptivetypenameref_ = uint64_t{0u}; 2645 clear_has_descriptiveTypeNameOrRef(); 2646 } 2647 } 2648 inline uint64_t Node::_internal_descriptivetypenameref() const { 2649 if (_internal_has_descriptivetypenameref()) { 2650 return _impl_.descriptiveTypeNameOrRef_.descriptivetypenameref_; 2651 } 2652 return uint64_t{0u}; 2653 } 2654 inline void Node::_internal_set_descriptivetypenameref(uint64_t value) { 2655 if (!_internal_has_descriptivetypenameref()) { 2656 clear_descriptiveTypeNameOrRef(); 2657 set_has_descriptivetypenameref(); 2658 } 2659 _impl_.descriptiveTypeNameOrRef_.descriptivetypenameref_ = value; 2660 } 2661 inline uint64_t Node::descriptivetypenameref() const { 2662 // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.descriptiveTypeNameRef) 2663 return _internal_descriptivetypenameref(); 2664 } 2665 inline void Node::set_descriptivetypenameref(uint64_t value) { 2666 _internal_set_descriptivetypenameref(value); 2667 // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.descriptiveTypeNameRef) 2668 } 2669 2670 inline bool Node::has_TypeNameOrRef() const { 2671 return TypeNameOrRef_case() != TYPENAMEORREF_NOT_SET; 2672 } 2673 inline void Node::clear_has_TypeNameOrRef() { 2674 _impl_._oneof_case_[0] = TYPENAMEORREF_NOT_SET; 2675 } 2676 inline bool Node::has_JSObjectClassNameOrRef() const { 2677 return JSObjectClassNameOrRef_case() != JSOBJECTCLASSNAMEORREF_NOT_SET; 2678 } 2679 inline void Node::clear_has_JSObjectClassNameOrRef() { 2680 _impl_._oneof_case_[1] = JSOBJECTCLASSNAMEORREF_NOT_SET; 2681 } 2682 inline bool Node::has_ScriptFilenameOrRef() const { 2683 return ScriptFilenameOrRef_case() != SCRIPTFILENAMEORREF_NOT_SET; 2684 } 2685 inline void Node::clear_has_ScriptFilenameOrRef() { 2686 _impl_._oneof_case_[2] = SCRIPTFILENAMEORREF_NOT_SET; 2687 } 2688 inline bool Node::has_descriptiveTypeNameOrRef() const { 2689 return descriptiveTypeNameOrRef_case() != DESCRIPTIVETYPENAMEORREF_NOT_SET; 2690 } 2691 inline void Node::clear_has_descriptiveTypeNameOrRef() { 2692 _impl_._oneof_case_[3] = DESCRIPTIVETYPENAMEORREF_NOT_SET; 2693 } 2694 inline Node::TypeNameOrRefCase Node::TypeNameOrRef_case() const { 2695 return Node::TypeNameOrRefCase(_impl_._oneof_case_[0]); 2696 } 2697 inline Node::JSObjectClassNameOrRefCase Node::JSObjectClassNameOrRef_case() const { 2698 return Node::JSObjectClassNameOrRefCase(_impl_._oneof_case_[1]); 2699 } 2700 inline Node::ScriptFilenameOrRefCase Node::ScriptFilenameOrRef_case() const { 2701 return Node::ScriptFilenameOrRefCase(_impl_._oneof_case_[2]); 2702 } 2703 inline Node::DescriptiveTypeNameOrRefCase Node::descriptiveTypeNameOrRef_case() const { 2704 return Node::DescriptiveTypeNameOrRefCase(_impl_._oneof_case_[3]); 2705 } 2706 // ------------------------------------------------------------------- 2707 2708 // Edge 2709 2710 // optional uint64 referent = 1; 2711 inline bool Edge::_internal_has_referent() const { 2712 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; 2713 return value; 2714 } 2715 inline bool Edge::has_referent() const { 2716 return _internal_has_referent(); 2717 } 2718 inline void Edge::clear_referent() { 2719 _impl_.referent_ = uint64_t{0u}; 2720 _impl_._has_bits_[0] &= ~0x00000001u; 2721 } 2722 inline uint64_t Edge::_internal_referent() const { 2723 return _impl_.referent_; 2724 } 2725 inline uint64_t Edge::referent() const { 2726 // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Edge.referent) 2727 return _internal_referent(); 2728 } 2729 inline void Edge::_internal_set_referent(uint64_t value) { 2730 _impl_._has_bits_[0] |= 0x00000001u; 2731 _impl_.referent_ = value; 2732 } 2733 inline void Edge::set_referent(uint64_t value) { 2734 _internal_set_referent(value); 2735 // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Edge.referent) 2736 } 2737 2738 // bytes name = 2; 2739 inline bool Edge::_internal_has_name() const { 2740 return EdgeNameOrRef_case() == kName; 2741 } 2742 inline bool Edge::has_name() const { 2743 return _internal_has_name(); 2744 } 2745 inline void Edge::set_has_name() { 2746 _impl_._oneof_case_[0] = kName; 2747 } 2748 inline void Edge::clear_name() { 2749 if (_internal_has_name()) { 2750 _impl_.EdgeNameOrRef_.name_.Destroy(); 2751 clear_has_EdgeNameOrRef(); 2752 } 2753 } 2754 inline const std::string& Edge::name() const { 2755 // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Edge.name) 2756 return _internal_name(); 2757 } 2758 template <typename ArgT0, typename... ArgT> 2759 inline void Edge::set_name(ArgT0&& arg0, ArgT... args) { 2760 if (!_internal_has_name()) { 2761 clear_EdgeNameOrRef(); 2762 set_has_name(); 2763 _impl_.EdgeNameOrRef_.name_.InitDefault(); 2764 } 2765 _impl_.EdgeNameOrRef_.name_.SetBytes( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation()); 2766 // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Edge.name) 2767 } 2768 inline std::string* Edge::mutable_name() { 2769 std::string* _s = _internal_mutable_name(); 2770 // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.Edge.name) 2771 return _s; 2772 } 2773 inline const std::string& Edge::_internal_name() const { 2774 if (_internal_has_name()) { 2775 return _impl_.EdgeNameOrRef_.name_.Get(); 2776 } 2777 return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); 2778 } 2779 inline void Edge::_internal_set_name(const std::string& value) { 2780 if (!_internal_has_name()) { 2781 clear_EdgeNameOrRef(); 2782 set_has_name(); 2783 _impl_.EdgeNameOrRef_.name_.InitDefault(); 2784 } 2785 _impl_.EdgeNameOrRef_.name_.Set(value, GetArenaForAllocation()); 2786 } 2787 inline std::string* Edge::_internal_mutable_name() { 2788 if (!_internal_has_name()) { 2789 clear_EdgeNameOrRef(); 2790 set_has_name(); 2791 _impl_.EdgeNameOrRef_.name_.InitDefault(); 2792 } 2793 return _impl_.EdgeNameOrRef_.name_.Mutable( GetArenaForAllocation()); 2794 } 2795 inline std::string* Edge::release_name() { 2796 // @@protoc_insertion_point(field_release:mozilla.devtools.protobuf.Edge.name) 2797 if (_internal_has_name()) { 2798 clear_has_EdgeNameOrRef(); 2799 return _impl_.EdgeNameOrRef_.name_.Release(); 2800 } else { 2801 return nullptr; 2802 } 2803 } 2804 inline void Edge::set_allocated_name(std::string* name) { 2805 if (has_EdgeNameOrRef()) { 2806 clear_EdgeNameOrRef(); 2807 } 2808 if (name != nullptr) { 2809 set_has_name(); 2810 _impl_.EdgeNameOrRef_.name_.InitAllocated(name, GetArenaForAllocation()); 2811 } 2812 // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.Edge.name) 2813 } 2814 2815 // uint64 nameRef = 3; 2816 inline bool Edge::_internal_has_nameref() const { 2817 return EdgeNameOrRef_case() == kNameRef; 2818 } 2819 inline bool Edge::has_nameref() const { 2820 return _internal_has_nameref(); 2821 } 2822 inline void Edge::set_has_nameref() { 2823 _impl_._oneof_case_[0] = kNameRef; 2824 } 2825 inline void Edge::clear_nameref() { 2826 if (_internal_has_nameref()) { 2827 _impl_.EdgeNameOrRef_.nameref_ = uint64_t{0u}; 2828 clear_has_EdgeNameOrRef(); 2829 } 2830 } 2831 inline uint64_t Edge::_internal_nameref() const { 2832 if (_internal_has_nameref()) { 2833 return _impl_.EdgeNameOrRef_.nameref_; 2834 } 2835 return uint64_t{0u}; 2836 } 2837 inline void Edge::_internal_set_nameref(uint64_t value) { 2838 if (!_internal_has_nameref()) { 2839 clear_EdgeNameOrRef(); 2840 set_has_nameref(); 2841 } 2842 _impl_.EdgeNameOrRef_.nameref_ = value; 2843 } 2844 inline uint64_t Edge::nameref() const { 2845 // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Edge.nameRef) 2846 return _internal_nameref(); 2847 } 2848 inline void Edge::set_nameref(uint64_t value) { 2849 _internal_set_nameref(value); 2850 // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Edge.nameRef) 2851 } 2852 2853 inline bool Edge::has_EdgeNameOrRef() const { 2854 return EdgeNameOrRef_case() != EDGENAMEORREF_NOT_SET; 2855 } 2856 inline void Edge::clear_has_EdgeNameOrRef() { 2857 _impl_._oneof_case_[0] = EDGENAMEORREF_NOT_SET; 2858 } 2859 inline Edge::EdgeNameOrRefCase Edge::EdgeNameOrRef_case() const { 2860 return Edge::EdgeNameOrRefCase(_impl_._oneof_case_[0]); 2861 } 2862 #ifdef __GNUC__ 2863 #pragma GCC diagnostic pop 2864 #endif // __GNUC__ 2865 // ------------------------------------------------------------------- 2866 2867 // ------------------------------------------------------------------- 2868 2869 // ------------------------------------------------------------------- 2870 2871 // ------------------------------------------------------------------- 2872 2873 2874 // @@protoc_insertion_point(namespace_scope) 2875 2876 } // namespace protobuf 2877 } // namespace devtools 2878 } // namespace mozilla 2879 2880 // @@protoc_insertion_point(global_scope) 2881 2882 #include <google/protobuf/port_undef.inc> 2883 #endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_CoreDump_2eproto