diff options
Diffstat (limited to 'devtools/shared/heapsnapshot/CoreDump.pb.h')
| -rw-r--r-- | devtools/shared/heapsnapshot/CoreDump.pb.h | 2883 |
1 files changed, 2883 insertions, 0 deletions
diff --git a/devtools/shared/heapsnapshot/CoreDump.pb.h b/devtools/shared/heapsnapshot/CoreDump.pb.h new file mode 100644 index 0000000000..734c38c017 --- /dev/null +++ b/devtools/shared/heapsnapshot/CoreDump.pb.h @@ -0,0 +1,2883 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: CoreDump.proto + +#ifndef GOOGLE_PROTOBUF_INCLUDED_CoreDump_2eproto +#define GOOGLE_PROTOBUF_INCLUDED_CoreDump_2eproto + +#include <limits> +#include <string> + +#include <google/protobuf/port_def.inc> +#if PROTOBUF_VERSION < 3021000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 3021006 < PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include <google/protobuf/port_undef.inc> +#include <google/protobuf/io/coded_stream.h> +#include <google/protobuf/arena.h> +#include <google/protobuf/arenastring.h> +#include <google/protobuf/generated_message_util.h> +#include <google/protobuf/metadata_lite.h> +#include <google/protobuf/message_lite.h> +#include <google/protobuf/repeated_field.h> // IWYU pragma: export +#include <google/protobuf/extension_set.h> // IWYU pragma: export +// @@protoc_insertion_point(includes) +#include <google/protobuf/port_def.inc> +#define PROTOBUF_INTERNAL_EXPORT_CoreDump_2eproto +PROTOBUF_NAMESPACE_OPEN +namespace internal { +class AnyMetadata; +} // namespace internal +PROTOBUF_NAMESPACE_CLOSE + +// Internal implementation detail -- do not use these members. +struct TableStruct_CoreDump_2eproto { + static const uint32_t offsets[]; +}; +namespace mozilla { +namespace devtools { +namespace protobuf { +class Edge; +struct EdgeDefaultTypeInternal; +extern EdgeDefaultTypeInternal _Edge_default_instance_; +class Metadata; +struct MetadataDefaultTypeInternal; +extern MetadataDefaultTypeInternal _Metadata_default_instance_; +class Node; +struct NodeDefaultTypeInternal; +extern NodeDefaultTypeInternal _Node_default_instance_; +class StackFrame; +struct StackFrameDefaultTypeInternal; +extern StackFrameDefaultTypeInternal _StackFrame_default_instance_; +class StackFrame_Data; +struct StackFrame_DataDefaultTypeInternal; +extern StackFrame_DataDefaultTypeInternal _StackFrame_Data_default_instance_; +} // namespace protobuf +} // namespace devtools +} // namespace mozilla +PROTOBUF_NAMESPACE_OPEN +template<> ::mozilla::devtools::protobuf::Edge* Arena::CreateMaybeMessage<::mozilla::devtools::protobuf::Edge>(Arena*); +template<> ::mozilla::devtools::protobuf::Metadata* Arena::CreateMaybeMessage<::mozilla::devtools::protobuf::Metadata>(Arena*); +template<> ::mozilla::devtools::protobuf::Node* Arena::CreateMaybeMessage<::mozilla::devtools::protobuf::Node>(Arena*); +template<> ::mozilla::devtools::protobuf::StackFrame* Arena::CreateMaybeMessage<::mozilla::devtools::protobuf::StackFrame>(Arena*); +template<> ::mozilla::devtools::protobuf::StackFrame_Data* Arena::CreateMaybeMessage<::mozilla::devtools::protobuf::StackFrame_Data>(Arena*); +PROTOBUF_NAMESPACE_CLOSE +namespace mozilla { +namespace devtools { +namespace protobuf { + +// =================================================================== + +class Metadata final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.devtools.protobuf.Metadata) */ { + public: + inline Metadata() : Metadata(nullptr) {} + ~Metadata() override; + explicit PROTOBUF_CONSTEXPR Metadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Metadata(const Metadata& from); + Metadata(Metadata&& from) noexcept + : Metadata() { + *this = ::std::move(from); + } + + inline Metadata& operator=(const Metadata& from) { + CopyFrom(from); + return *this; + } + inline Metadata& operator=(Metadata&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<std::string>(); + } + + static const Metadata& default_instance() { + return *internal_default_instance(); + } + static inline const Metadata* internal_default_instance() { + return reinterpret_cast<const Metadata*>( + &_Metadata_default_instance_); + } + static constexpr int kIndexInFileMessages = + 0; + + friend void swap(Metadata& a, Metadata& b) { + a.Swap(&b); + } + inline void Swap(Metadata* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Metadata* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Metadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage<Metadata>(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const Metadata& from); + void MergeFrom(const Metadata& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(Metadata* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "mozilla.devtools.protobuf.Metadata"; + } + protected: + explicit Metadata(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kTimeStampFieldNumber = 1, + }; + // optional uint64 timeStamp = 1; + bool has_timestamp() const; + private: + bool _internal_has_timestamp() const; + public: + void clear_timestamp(); + uint64_t timestamp() const; + void set_timestamp(uint64_t value); + private: + uint64_t _internal_timestamp() const; + void _internal_set_timestamp(uint64_t value); + public: + + // @@protoc_insertion_point(class_scope:mozilla.devtools.protobuf.Metadata) + private: + class _Internal; + + template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + uint64_t timestamp_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_CoreDump_2eproto; +}; +// ------------------------------------------------------------------- + +class StackFrame_Data final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.devtools.protobuf.StackFrame.Data) */ { + public: + inline StackFrame_Data() : StackFrame_Data(nullptr) {} + ~StackFrame_Data() override; + explicit PROTOBUF_CONSTEXPR StackFrame_Data(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + StackFrame_Data(const StackFrame_Data& from); + StackFrame_Data(StackFrame_Data&& from) noexcept + : StackFrame_Data() { + *this = ::std::move(from); + } + + inline StackFrame_Data& operator=(const StackFrame_Data& from) { + CopyFrom(from); + return *this; + } + inline StackFrame_Data& operator=(StackFrame_Data&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<std::string>(); + } + + static const StackFrame_Data& default_instance() { + return *internal_default_instance(); + } + enum SourceOrRefCase { + kSource = 5, + kSourceRef = 6, + SOURCEORREF_NOT_SET = 0, + }; + + enum FunctionDisplayNameOrRefCase { + kFunctionDisplayName = 7, + kFunctionDisplayNameRef = 8, + FUNCTIONDISPLAYNAMEORREF_NOT_SET = 0, + }; + + static inline const StackFrame_Data* internal_default_instance() { + return reinterpret_cast<const StackFrame_Data*>( + &_StackFrame_Data_default_instance_); + } + static constexpr int kIndexInFileMessages = + 1; + + friend void swap(StackFrame_Data& a, StackFrame_Data& b) { + a.Swap(&b); + } + inline void Swap(StackFrame_Data* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(StackFrame_Data* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + StackFrame_Data* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage<StackFrame_Data>(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const StackFrame_Data& from); + void MergeFrom(const StackFrame_Data& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(StackFrame_Data* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "mozilla.devtools.protobuf.StackFrame.Data"; + } + protected: + explicit StackFrame_Data(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kParentFieldNumber = 2, + kIdFieldNumber = 1, + kLineFieldNumber = 3, + kColumnFieldNumber = 4, + kIsSystemFieldNumber = 9, + kIsSelfHostedFieldNumber = 10, + kSourceFieldNumber = 5, + kSourceRefFieldNumber = 6, + kFunctionDisplayNameFieldNumber = 7, + kFunctionDisplayNameRefFieldNumber = 8, + }; + // optional .mozilla.devtools.protobuf.StackFrame parent = 2; + bool has_parent() const; + private: + bool _internal_has_parent() const; + public: + void clear_parent(); + const ::mozilla::devtools::protobuf::StackFrame& parent() const; + PROTOBUF_NODISCARD ::mozilla::devtools::protobuf::StackFrame* release_parent(); + ::mozilla::devtools::protobuf::StackFrame* mutable_parent(); + void set_allocated_parent(::mozilla::devtools::protobuf::StackFrame* parent); + private: + const ::mozilla::devtools::protobuf::StackFrame& _internal_parent() const; + ::mozilla::devtools::protobuf::StackFrame* _internal_mutable_parent(); + public: + void unsafe_arena_set_allocated_parent( + ::mozilla::devtools::protobuf::StackFrame* parent); + ::mozilla::devtools::protobuf::StackFrame* unsafe_arena_release_parent(); + + // optional uint64 id = 1; + bool has_id() const; + private: + bool _internal_has_id() const; + public: + void clear_id(); + uint64_t id() const; + void set_id(uint64_t value); + private: + uint64_t _internal_id() const; + void _internal_set_id(uint64_t value); + public: + + // optional uint32 line = 3; + bool has_line() const; + private: + bool _internal_has_line() const; + public: + void clear_line(); + uint32_t line() const; + void set_line(uint32_t value); + private: + uint32_t _internal_line() const; + void _internal_set_line(uint32_t value); + public: + + // optional uint32 column = 4; + bool has_column() const; + private: + bool _internal_has_column() const; + public: + void clear_column(); + uint32_t column() const; + void set_column(uint32_t value); + private: + uint32_t _internal_column() const; + void _internal_set_column(uint32_t value); + public: + + // optional bool isSystem = 9; + bool has_issystem() const; + private: + bool _internal_has_issystem() const; + public: + void clear_issystem(); + bool issystem() const; + void set_issystem(bool value); + private: + bool _internal_issystem() const; + void _internal_set_issystem(bool value); + public: + + // optional bool isSelfHosted = 10; + bool has_isselfhosted() const; + private: + bool _internal_has_isselfhosted() const; + public: + void clear_isselfhosted(); + bool isselfhosted() const; + void set_isselfhosted(bool value); + private: + bool _internal_isselfhosted() const; + void _internal_set_isselfhosted(bool value); + public: + + // bytes source = 5; + bool has_source() const; + private: + bool _internal_has_source() const; + public: + void clear_source(); + const std::string& source() const; + template <typename ArgT0 = const std::string&, typename... ArgT> + void set_source(ArgT0&& arg0, ArgT... args); + std::string* mutable_source(); + PROTOBUF_NODISCARD std::string* release_source(); + void set_allocated_source(std::string* source); + private: + const std::string& _internal_source() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_source(const std::string& value); + std::string* _internal_mutable_source(); + public: + + // uint64 sourceRef = 6; + bool has_sourceref() const; + private: + bool _internal_has_sourceref() const; + public: + void clear_sourceref(); + uint64_t sourceref() const; + void set_sourceref(uint64_t value); + private: + uint64_t _internal_sourceref() const; + void _internal_set_sourceref(uint64_t value); + public: + + // bytes functionDisplayName = 7; + bool has_functiondisplayname() const; + private: + bool _internal_has_functiondisplayname() const; + public: + void clear_functiondisplayname(); + const std::string& functiondisplayname() const; + template <typename ArgT0 = const std::string&, typename... ArgT> + void set_functiondisplayname(ArgT0&& arg0, ArgT... args); + std::string* mutable_functiondisplayname(); + PROTOBUF_NODISCARD std::string* release_functiondisplayname(); + void set_allocated_functiondisplayname(std::string* functiondisplayname); + private: + const std::string& _internal_functiondisplayname() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_functiondisplayname(const std::string& value); + std::string* _internal_mutable_functiondisplayname(); + public: + + // uint64 functionDisplayNameRef = 8; + bool has_functiondisplaynameref() const; + private: + bool _internal_has_functiondisplaynameref() const; + public: + void clear_functiondisplaynameref(); + uint64_t functiondisplaynameref() const; + void set_functiondisplaynameref(uint64_t value); + private: + uint64_t _internal_functiondisplaynameref() const; + void _internal_set_functiondisplaynameref(uint64_t value); + public: + + void clear_SourceOrRef(); + SourceOrRefCase SourceOrRef_case() const; + void clear_FunctionDisplayNameOrRef(); + FunctionDisplayNameOrRefCase FunctionDisplayNameOrRef_case() const; + // @@protoc_insertion_point(class_scope:mozilla.devtools.protobuf.StackFrame.Data) + private: + class _Internal; + void set_has_source(); + void set_has_sourceref(); + void set_has_functiondisplayname(); + void set_has_functiondisplaynameref(); + + inline bool has_SourceOrRef() const; + inline void clear_has_SourceOrRef(); + + inline bool has_FunctionDisplayNameOrRef() const; + inline void clear_has_FunctionDisplayNameOrRef(); + + template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::mozilla::devtools::protobuf::StackFrame* parent_; + uint64_t id_; + uint32_t line_; + uint32_t column_; + bool issystem_; + bool isselfhosted_; + union SourceOrRefUnion { + constexpr SourceOrRefUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr source_; + uint64_t sourceref_; + } SourceOrRef_; + union FunctionDisplayNameOrRefUnion { + constexpr FunctionDisplayNameOrRefUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr functiondisplayname_; + uint64_t functiondisplaynameref_; + } FunctionDisplayNameOrRef_; + uint32_t _oneof_case_[2]; + + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_CoreDump_2eproto; +}; +// ------------------------------------------------------------------- + +class StackFrame final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.devtools.protobuf.StackFrame) */ { + public: + inline StackFrame() : StackFrame(nullptr) {} + ~StackFrame() override; + explicit PROTOBUF_CONSTEXPR StackFrame(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + StackFrame(const StackFrame& from); + StackFrame(StackFrame&& from) noexcept + : StackFrame() { + *this = ::std::move(from); + } + + inline StackFrame& operator=(const StackFrame& from) { + CopyFrom(from); + return *this; + } + inline StackFrame& operator=(StackFrame&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<std::string>(); + } + + static const StackFrame& default_instance() { + return *internal_default_instance(); + } + enum StackFrameTypeCase { + kData = 1, + kRef = 2, + STACKFRAMETYPE_NOT_SET = 0, + }; + + static inline const StackFrame* internal_default_instance() { + return reinterpret_cast<const StackFrame*>( + &_StackFrame_default_instance_); + } + static constexpr int kIndexInFileMessages = + 2; + + friend void swap(StackFrame& a, StackFrame& b) { + a.Swap(&b); + } + inline void Swap(StackFrame* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(StackFrame* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + StackFrame* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage<StackFrame>(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const StackFrame& from); + void MergeFrom(const StackFrame& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(StackFrame* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "mozilla.devtools.protobuf.StackFrame"; + } + protected: + explicit StackFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + typedef StackFrame_Data Data; + + // accessors ------------------------------------------------------- + + enum : int { + kDataFieldNumber = 1, + kRefFieldNumber = 2, + }; + // .mozilla.devtools.protobuf.StackFrame.Data data = 1; + bool has_data() const; + private: + bool _internal_has_data() const; + public: + void clear_data(); + const ::mozilla::devtools::protobuf::StackFrame_Data& data() const; + PROTOBUF_NODISCARD ::mozilla::devtools::protobuf::StackFrame_Data* release_data(); + ::mozilla::devtools::protobuf::StackFrame_Data* mutable_data(); + void set_allocated_data(::mozilla::devtools::protobuf::StackFrame_Data* data); + private: + const ::mozilla::devtools::protobuf::StackFrame_Data& _internal_data() const; + ::mozilla::devtools::protobuf::StackFrame_Data* _internal_mutable_data(); + public: + void unsafe_arena_set_allocated_data( + ::mozilla::devtools::protobuf::StackFrame_Data* data); + ::mozilla::devtools::protobuf::StackFrame_Data* unsafe_arena_release_data(); + + // uint64 ref = 2; + bool has_ref() const; + private: + bool _internal_has_ref() const; + public: + void clear_ref(); + uint64_t ref() const; + void set_ref(uint64_t value); + private: + uint64_t _internal_ref() const; + void _internal_set_ref(uint64_t value); + public: + + void clear_StackFrameType(); + StackFrameTypeCase StackFrameType_case() const; + // @@protoc_insertion_point(class_scope:mozilla.devtools.protobuf.StackFrame) + private: + class _Internal; + void set_has_data(); + void set_has_ref(); + + inline bool has_StackFrameType() const; + inline void clear_has_StackFrameType(); + + template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + union StackFrameTypeUnion { + constexpr StackFrameTypeUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::mozilla::devtools::protobuf::StackFrame_Data* data_; + uint64_t ref_; + } StackFrameType_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + uint32_t _oneof_case_[1]; + + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_CoreDump_2eproto; +}; +// ------------------------------------------------------------------- + +class Node final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.devtools.protobuf.Node) */ { + public: + inline Node() : Node(nullptr) {} + ~Node() override; + explicit PROTOBUF_CONSTEXPR Node(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Node(const Node& from); + Node(Node&& from) noexcept + : Node() { + *this = ::std::move(from); + } + + inline Node& operator=(const Node& from) { + CopyFrom(from); + return *this; + } + inline Node& operator=(Node&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<std::string>(); + } + + static const Node& default_instance() { + return *internal_default_instance(); + } + enum TypeNameOrRefCase { + kTypeName = 2, + kTypeNameRef = 3, + TYPENAMEORREF_NOT_SET = 0, + }; + + enum JSObjectClassNameOrRefCase { + kJsObjectClassName = 7, + kJsObjectClassNameRef = 8, + JSOBJECTCLASSNAMEORREF_NOT_SET = 0, + }; + + enum ScriptFilenameOrRefCase { + kScriptFilename = 10, + kScriptFilenameRef = 11, + SCRIPTFILENAMEORREF_NOT_SET = 0, + }; + + enum DescriptiveTypeNameOrRefCase { + kDescriptiveTypeName = 12, + kDescriptiveTypeNameRef = 13, + DESCRIPTIVETYPENAMEORREF_NOT_SET = 0, + }; + + static inline const Node* internal_default_instance() { + return reinterpret_cast<const Node*>( + &_Node_default_instance_); + } + static constexpr int kIndexInFileMessages = + 3; + + friend void swap(Node& a, Node& b) { + a.Swap(&b); + } + inline void Swap(Node* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Node* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Node* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage<Node>(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const Node& from); + void MergeFrom(const Node& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(Node* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "mozilla.devtools.protobuf.Node"; + } + protected: + explicit Node(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kEdgesFieldNumber = 5, + kAllocationStackFieldNumber = 6, + kIdFieldNumber = 1, + kSizeFieldNumber = 4, + kCoarseTypeFieldNumber = 9, + kTypeNameFieldNumber = 2, + kTypeNameRefFieldNumber = 3, + kJsObjectClassNameFieldNumber = 7, + kJsObjectClassNameRefFieldNumber = 8, + kScriptFilenameFieldNumber = 10, + kScriptFilenameRefFieldNumber = 11, + kDescriptiveTypeNameFieldNumber = 12, + kDescriptiveTypeNameRefFieldNumber = 13, + }; + // repeated .mozilla.devtools.protobuf.Edge edges = 5; + int edges_size() const; + private: + int _internal_edges_size() const; + public: + void clear_edges(); + ::mozilla::devtools::protobuf::Edge* mutable_edges(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::devtools::protobuf::Edge >* + mutable_edges(); + private: + const ::mozilla::devtools::protobuf::Edge& _internal_edges(int index) const; + ::mozilla::devtools::protobuf::Edge* _internal_add_edges(); + public: + const ::mozilla::devtools::protobuf::Edge& edges(int index) const; + ::mozilla::devtools::protobuf::Edge* add_edges(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::devtools::protobuf::Edge >& + edges() const; + + // optional .mozilla.devtools.protobuf.StackFrame allocationStack = 6; + bool has_allocationstack() const; + private: + bool _internal_has_allocationstack() const; + public: + void clear_allocationstack(); + const ::mozilla::devtools::protobuf::StackFrame& allocationstack() const; + PROTOBUF_NODISCARD ::mozilla::devtools::protobuf::StackFrame* release_allocationstack(); + ::mozilla::devtools::protobuf::StackFrame* mutable_allocationstack(); + void set_allocated_allocationstack(::mozilla::devtools::protobuf::StackFrame* allocationstack); + private: + const ::mozilla::devtools::protobuf::StackFrame& _internal_allocationstack() const; + ::mozilla::devtools::protobuf::StackFrame* _internal_mutable_allocationstack(); + public: + void unsafe_arena_set_allocated_allocationstack( + ::mozilla::devtools::protobuf::StackFrame* allocationstack); + ::mozilla::devtools::protobuf::StackFrame* unsafe_arena_release_allocationstack(); + + // optional uint64 id = 1; + bool has_id() const; + private: + bool _internal_has_id() const; + public: + void clear_id(); + uint64_t id() const; + void set_id(uint64_t value); + private: + uint64_t _internal_id() const; + void _internal_set_id(uint64_t value); + public: + + // optional uint64 size = 4; + bool has_size() const; + private: + bool _internal_has_size() const; + public: + void clear_size(); + uint64_t size() const; + void set_size(uint64_t value); + private: + uint64_t _internal_size() const; + void _internal_set_size(uint64_t value); + public: + + // optional uint32 coarseType = 9 [default = 0]; + bool has_coarsetype() const; + private: + bool _internal_has_coarsetype() const; + public: + void clear_coarsetype(); + uint32_t coarsetype() const; + void set_coarsetype(uint32_t value); + private: + uint32_t _internal_coarsetype() const; + void _internal_set_coarsetype(uint32_t value); + public: + + // bytes typeName = 2; + bool has_typename_() const; + private: + bool _internal_has_typename_() const; + public: + void clear_typename_(); + const std::string& typename_() const; + template <typename ArgT0 = const std::string&, typename... ArgT> + void set_typename_(ArgT0&& arg0, ArgT... args); + std::string* mutable_typename_(); + PROTOBUF_NODISCARD std::string* release_typename_(); + void set_allocated_typename_(std::string* typename_); + private: + const std::string& _internal_typename_() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_typename_(const std::string& value); + std::string* _internal_mutable_typename_(); + public: + + // uint64 typeNameRef = 3; + bool has_typenameref() const; + private: + bool _internal_has_typenameref() const; + public: + void clear_typenameref(); + uint64_t typenameref() const; + void set_typenameref(uint64_t value); + private: + uint64_t _internal_typenameref() const; + void _internal_set_typenameref(uint64_t value); + public: + + // bytes jsObjectClassName = 7; + bool has_jsobjectclassname() const; + private: + bool _internal_has_jsobjectclassname() const; + public: + void clear_jsobjectclassname(); + const std::string& jsobjectclassname() const; + template <typename ArgT0 = const std::string&, typename... ArgT> + void set_jsobjectclassname(ArgT0&& arg0, ArgT... args); + std::string* mutable_jsobjectclassname(); + PROTOBUF_NODISCARD std::string* release_jsobjectclassname(); + void set_allocated_jsobjectclassname(std::string* jsobjectclassname); + private: + const std::string& _internal_jsobjectclassname() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_jsobjectclassname(const std::string& value); + std::string* _internal_mutable_jsobjectclassname(); + public: + + // uint64 jsObjectClassNameRef = 8; + bool has_jsobjectclassnameref() const; + private: + bool _internal_has_jsobjectclassnameref() const; + public: + void clear_jsobjectclassnameref(); + uint64_t jsobjectclassnameref() const; + void set_jsobjectclassnameref(uint64_t value); + private: + uint64_t _internal_jsobjectclassnameref() const; + void _internal_set_jsobjectclassnameref(uint64_t value); + public: + + // bytes scriptFilename = 10; + bool has_scriptfilename() const; + private: + bool _internal_has_scriptfilename() const; + public: + void clear_scriptfilename(); + const std::string& scriptfilename() const; + template <typename ArgT0 = const std::string&, typename... ArgT> + void set_scriptfilename(ArgT0&& arg0, ArgT... args); + std::string* mutable_scriptfilename(); + PROTOBUF_NODISCARD std::string* release_scriptfilename(); + void set_allocated_scriptfilename(std::string* scriptfilename); + private: + const std::string& _internal_scriptfilename() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_scriptfilename(const std::string& value); + std::string* _internal_mutable_scriptfilename(); + public: + + // uint64 scriptFilenameRef = 11; + bool has_scriptfilenameref() const; + private: + bool _internal_has_scriptfilenameref() const; + public: + void clear_scriptfilenameref(); + uint64_t scriptfilenameref() const; + void set_scriptfilenameref(uint64_t value); + private: + uint64_t _internal_scriptfilenameref() const; + void _internal_set_scriptfilenameref(uint64_t value); + public: + + // bytes descriptiveTypeName = 12; + bool has_descriptivetypename() const; + private: + bool _internal_has_descriptivetypename() const; + public: + void clear_descriptivetypename(); + const std::string& descriptivetypename() const; + template <typename ArgT0 = const std::string&, typename... ArgT> + void set_descriptivetypename(ArgT0&& arg0, ArgT... args); + std::string* mutable_descriptivetypename(); + PROTOBUF_NODISCARD std::string* release_descriptivetypename(); + void set_allocated_descriptivetypename(std::string* descriptivetypename); + private: + const std::string& _internal_descriptivetypename() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_descriptivetypename(const std::string& value); + std::string* _internal_mutable_descriptivetypename(); + public: + + // uint64 descriptiveTypeNameRef = 13; + bool has_descriptivetypenameref() const; + private: + bool _internal_has_descriptivetypenameref() const; + public: + void clear_descriptivetypenameref(); + uint64_t descriptivetypenameref() const; + void set_descriptivetypenameref(uint64_t value); + private: + uint64_t _internal_descriptivetypenameref() const; + void _internal_set_descriptivetypenameref(uint64_t value); + public: + + void clear_TypeNameOrRef(); + TypeNameOrRefCase TypeNameOrRef_case() const; + void clear_JSObjectClassNameOrRef(); + JSObjectClassNameOrRefCase JSObjectClassNameOrRef_case() const; + void clear_ScriptFilenameOrRef(); + ScriptFilenameOrRefCase ScriptFilenameOrRef_case() const; + void clear_descriptiveTypeNameOrRef(); + DescriptiveTypeNameOrRefCase descriptiveTypeNameOrRef_case() const; + // @@protoc_insertion_point(class_scope:mozilla.devtools.protobuf.Node) + private: + class _Internal; + void set_has_typename_(); + void set_has_typenameref(); + void set_has_jsobjectclassname(); + void set_has_jsobjectclassnameref(); + void set_has_scriptfilename(); + void set_has_scriptfilenameref(); + void set_has_descriptivetypename(); + void set_has_descriptivetypenameref(); + + inline bool has_TypeNameOrRef() const; + inline void clear_has_TypeNameOrRef(); + + inline bool has_JSObjectClassNameOrRef() const; + inline void clear_has_JSObjectClassNameOrRef(); + + inline bool has_ScriptFilenameOrRef() const; + inline void clear_has_ScriptFilenameOrRef(); + + inline bool has_descriptiveTypeNameOrRef() const; + inline void clear_has_descriptiveTypeNameOrRef(); + + template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::devtools::protobuf::Edge > edges_; + ::mozilla::devtools::protobuf::StackFrame* allocationstack_; + uint64_t id_; + uint64_t size_; + uint32_t coarsetype_; + union TypeNameOrRefUnion { + constexpr TypeNameOrRefUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr typename__; + uint64_t typenameref_; + } TypeNameOrRef_; + union JSObjectClassNameOrRefUnion { + constexpr JSObjectClassNameOrRefUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jsobjectclassname_; + uint64_t jsobjectclassnameref_; + } JSObjectClassNameOrRef_; + union ScriptFilenameOrRefUnion { + constexpr ScriptFilenameOrRefUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr scriptfilename_; + uint64_t scriptfilenameref_; + } ScriptFilenameOrRef_; + union DescriptiveTypeNameOrRefUnion { + constexpr DescriptiveTypeNameOrRefUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr descriptivetypename_; + uint64_t descriptivetypenameref_; + } descriptiveTypeNameOrRef_; + uint32_t _oneof_case_[4]; + + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_CoreDump_2eproto; +}; +// ------------------------------------------------------------------- + +class Edge final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.devtools.protobuf.Edge) */ { + public: + inline Edge() : Edge(nullptr) {} + ~Edge() override; + explicit PROTOBUF_CONSTEXPR Edge(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Edge(const Edge& from); + Edge(Edge&& from) noexcept + : Edge() { + *this = ::std::move(from); + } + + inline Edge& operator=(const Edge& from) { + CopyFrom(from); + return *this; + } + inline Edge& operator=(Edge&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<std::string>(); + } + + static const Edge& default_instance() { + return *internal_default_instance(); + } + enum EdgeNameOrRefCase { + kName = 2, + kNameRef = 3, + EDGENAMEORREF_NOT_SET = 0, + }; + + static inline const Edge* internal_default_instance() { + return reinterpret_cast<const Edge*>( + &_Edge_default_instance_); + } + static constexpr int kIndexInFileMessages = + 4; + + friend void swap(Edge& a, Edge& b) { + a.Swap(&b); + } + inline void Swap(Edge* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Edge* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Edge* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage<Edge>(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const Edge& from); + void MergeFrom(const Edge& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(Edge* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "mozilla.devtools.protobuf.Edge"; + } + protected: + explicit Edge(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kReferentFieldNumber = 1, + kNameFieldNumber = 2, + kNameRefFieldNumber = 3, + }; + // optional uint64 referent = 1; + bool has_referent() const; + private: + bool _internal_has_referent() const; + public: + void clear_referent(); + uint64_t referent() const; + void set_referent(uint64_t value); + private: + uint64_t _internal_referent() const; + void _internal_set_referent(uint64_t value); + public: + + // bytes name = 2; + bool has_name() const; + private: + bool _internal_has_name() const; + public: + void clear_name(); + const std::string& name() const; + template <typename ArgT0 = const std::string&, typename... ArgT> + void set_name(ArgT0&& arg0, ArgT... args); + std::string* mutable_name(); + PROTOBUF_NODISCARD std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); + public: + + // uint64 nameRef = 3; + bool has_nameref() const; + private: + bool _internal_has_nameref() const; + public: + void clear_nameref(); + uint64_t nameref() const; + void set_nameref(uint64_t value); + private: + uint64_t _internal_nameref() const; + void _internal_set_nameref(uint64_t value); + public: + + void clear_EdgeNameOrRef(); + EdgeNameOrRefCase EdgeNameOrRef_case() const; + // @@protoc_insertion_point(class_scope:mozilla.devtools.protobuf.Edge) + private: + class _Internal; + void set_has_name(); + void set_has_nameref(); + + inline bool has_EdgeNameOrRef() const; + inline void clear_has_EdgeNameOrRef(); + + template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + uint64_t referent_; + union EdgeNameOrRefUnion { + constexpr EdgeNameOrRefUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + uint64_t nameref_; + } EdgeNameOrRef_; + uint32_t _oneof_case_[1]; + + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_CoreDump_2eproto; +}; +// =================================================================== + + +// =================================================================== + +#ifdef __GNUC__ + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// Metadata + +// optional uint64 timeStamp = 1; +inline bool Metadata::_internal_has_timestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Metadata::has_timestamp() const { + return _internal_has_timestamp(); +} +inline void Metadata::clear_timestamp() { + _impl_.timestamp_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline uint64_t Metadata::_internal_timestamp() const { + return _impl_.timestamp_; +} +inline uint64_t Metadata::timestamp() const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Metadata.timeStamp) + return _internal_timestamp(); +} +inline void Metadata::_internal_set_timestamp(uint64_t value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.timestamp_ = value; +} +inline void Metadata::set_timestamp(uint64_t value) { + _internal_set_timestamp(value); + // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Metadata.timeStamp) +} + +// ------------------------------------------------------------------- + +// StackFrame_Data + +// optional uint64 id = 1; +inline bool StackFrame_Data::_internal_has_id() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool StackFrame_Data::has_id() const { + return _internal_has_id(); +} +inline void StackFrame_Data::clear_id() { + _impl_.id_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline uint64_t StackFrame_Data::_internal_id() const { + return _impl_.id_; +} +inline uint64_t StackFrame_Data::id() const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.id) + return _internal_id(); +} +inline void StackFrame_Data::_internal_set_id(uint64_t value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.id_ = value; +} +inline void StackFrame_Data::set_id(uint64_t value) { + _internal_set_id(value); + // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.id) +} + +// optional .mozilla.devtools.protobuf.StackFrame parent = 2; +inline bool StackFrame_Data::_internal_has_parent() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.parent_ != nullptr); + return value; +} +inline bool StackFrame_Data::has_parent() const { + return _internal_has_parent(); +} +inline void StackFrame_Data::clear_parent() { + if (_impl_.parent_ != nullptr) _impl_.parent_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::mozilla::devtools::protobuf::StackFrame& StackFrame_Data::_internal_parent() const { + const ::mozilla::devtools::protobuf::StackFrame* p = _impl_.parent_; + return p != nullptr ? *p : reinterpret_cast<const ::mozilla::devtools::protobuf::StackFrame&>( + ::mozilla::devtools::protobuf::_StackFrame_default_instance_); +} +inline const ::mozilla::devtools::protobuf::StackFrame& StackFrame_Data::parent() const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.parent) + return _internal_parent(); +} +inline void StackFrame_Data::unsafe_arena_set_allocated_parent( + ::mozilla::devtools::protobuf::StackFrame* parent) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.parent_); + } + _impl_.parent_ = parent; + if (parent) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.devtools.protobuf.StackFrame.Data.parent) +} +inline ::mozilla::devtools::protobuf::StackFrame* StackFrame_Data::release_parent() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::mozilla::devtools::protobuf::StackFrame* temp = _impl_.parent_; + _impl_.parent_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::mozilla::devtools::protobuf::StackFrame* StackFrame_Data::unsafe_arena_release_parent() { + // @@protoc_insertion_point(field_release:mozilla.devtools.protobuf.StackFrame.Data.parent) + _impl_._has_bits_[0] &= ~0x00000001u; + ::mozilla::devtools::protobuf::StackFrame* temp = _impl_.parent_; + _impl_.parent_ = nullptr; + return temp; +} +inline ::mozilla::devtools::protobuf::StackFrame* StackFrame_Data::_internal_mutable_parent() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.parent_ == nullptr) { + auto* p = CreateMaybeMessage<::mozilla::devtools::protobuf::StackFrame>(GetArenaForAllocation()); + _impl_.parent_ = p; + } + return _impl_.parent_; +} +inline ::mozilla::devtools::protobuf::StackFrame* StackFrame_Data::mutable_parent() { + ::mozilla::devtools::protobuf::StackFrame* _msg = _internal_mutable_parent(); + // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.StackFrame.Data.parent) + return _msg; +} +inline void StackFrame_Data::set_allocated_parent(::mozilla::devtools::protobuf::StackFrame* parent) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.parent_; + } + if (parent) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(parent); + if (message_arena != submessage_arena) { + parent = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, parent, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.parent_ = parent; + // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.StackFrame.Data.parent) +} + +// optional uint32 line = 3; +inline bool StackFrame_Data::_internal_has_line() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool StackFrame_Data::has_line() const { + return _internal_has_line(); +} +inline void StackFrame_Data::clear_line() { + _impl_.line_ = 0u; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline uint32_t StackFrame_Data::_internal_line() const { + return _impl_.line_; +} +inline uint32_t StackFrame_Data::line() const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.line) + return _internal_line(); +} +inline void StackFrame_Data::_internal_set_line(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.line_ = value; +} +inline void StackFrame_Data::set_line(uint32_t value) { + _internal_set_line(value); + // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.line) +} + +// optional uint32 column = 4; +inline bool StackFrame_Data::_internal_has_column() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool StackFrame_Data::has_column() const { + return _internal_has_column(); +} +inline void StackFrame_Data::clear_column() { + _impl_.column_ = 0u; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline uint32_t StackFrame_Data::_internal_column() const { + return _impl_.column_; +} +inline uint32_t StackFrame_Data::column() const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.column) + return _internal_column(); +} +inline void StackFrame_Data::_internal_set_column(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.column_ = value; +} +inline void StackFrame_Data::set_column(uint32_t value) { + _internal_set_column(value); + // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.column) +} + +// bytes source = 5; +inline bool StackFrame_Data::_internal_has_source() const { + return SourceOrRef_case() == kSource; +} +inline bool StackFrame_Data::has_source() const { + return _internal_has_source(); +} +inline void StackFrame_Data::set_has_source() { + _impl_._oneof_case_[0] = kSource; +} +inline void StackFrame_Data::clear_source() { + if (_internal_has_source()) { + _impl_.SourceOrRef_.source_.Destroy(); + clear_has_SourceOrRef(); + } +} +inline const std::string& StackFrame_Data::source() const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.source) + return _internal_source(); +} +template <typename ArgT0, typename... ArgT> +inline void StackFrame_Data::set_source(ArgT0&& arg0, ArgT... args) { + if (!_internal_has_source()) { + clear_SourceOrRef(); + set_has_source(); + _impl_.SourceOrRef_.source_.InitDefault(); + } + _impl_.SourceOrRef_.source_.SetBytes( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.source) +} +inline std::string* StackFrame_Data::mutable_source() { + std::string* _s = _internal_mutable_source(); + // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.StackFrame.Data.source) + return _s; +} +inline const std::string& StackFrame_Data::_internal_source() const { + if (_internal_has_source()) { + return _impl_.SourceOrRef_.source_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void StackFrame_Data::_internal_set_source(const std::string& value) { + if (!_internal_has_source()) { + clear_SourceOrRef(); + set_has_source(); + _impl_.SourceOrRef_.source_.InitDefault(); + } + _impl_.SourceOrRef_.source_.Set(value, GetArenaForAllocation()); +} +inline std::string* StackFrame_Data::_internal_mutable_source() { + if (!_internal_has_source()) { + clear_SourceOrRef(); + set_has_source(); + _impl_.SourceOrRef_.source_.InitDefault(); + } + return _impl_.SourceOrRef_.source_.Mutable( GetArenaForAllocation()); +} +inline std::string* StackFrame_Data::release_source() { + // @@protoc_insertion_point(field_release:mozilla.devtools.protobuf.StackFrame.Data.source) + if (_internal_has_source()) { + clear_has_SourceOrRef(); + return _impl_.SourceOrRef_.source_.Release(); + } else { + return nullptr; + } +} +inline void StackFrame_Data::set_allocated_source(std::string* source) { + if (has_SourceOrRef()) { + clear_SourceOrRef(); + } + if (source != nullptr) { + set_has_source(); + _impl_.SourceOrRef_.source_.InitAllocated(source, GetArenaForAllocation()); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.StackFrame.Data.source) +} + +// uint64 sourceRef = 6; +inline bool StackFrame_Data::_internal_has_sourceref() const { + return SourceOrRef_case() == kSourceRef; +} +inline bool StackFrame_Data::has_sourceref() const { + return _internal_has_sourceref(); +} +inline void StackFrame_Data::set_has_sourceref() { + _impl_._oneof_case_[0] = kSourceRef; +} +inline void StackFrame_Data::clear_sourceref() { + if (_internal_has_sourceref()) { + _impl_.SourceOrRef_.sourceref_ = uint64_t{0u}; + clear_has_SourceOrRef(); + } +} +inline uint64_t StackFrame_Data::_internal_sourceref() const { + if (_internal_has_sourceref()) { + return _impl_.SourceOrRef_.sourceref_; + } + return uint64_t{0u}; +} +inline void StackFrame_Data::_internal_set_sourceref(uint64_t value) { + if (!_internal_has_sourceref()) { + clear_SourceOrRef(); + set_has_sourceref(); + } + _impl_.SourceOrRef_.sourceref_ = value; +} +inline uint64_t StackFrame_Data::sourceref() const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.sourceRef) + return _internal_sourceref(); +} +inline void StackFrame_Data::set_sourceref(uint64_t value) { + _internal_set_sourceref(value); + // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.sourceRef) +} + +// bytes functionDisplayName = 7; +inline bool StackFrame_Data::_internal_has_functiondisplayname() const { + return FunctionDisplayNameOrRef_case() == kFunctionDisplayName; +} +inline bool StackFrame_Data::has_functiondisplayname() const { + return _internal_has_functiondisplayname(); +} +inline void StackFrame_Data::set_has_functiondisplayname() { + _impl_._oneof_case_[1] = kFunctionDisplayName; +} +inline void StackFrame_Data::clear_functiondisplayname() { + if (_internal_has_functiondisplayname()) { + _impl_.FunctionDisplayNameOrRef_.functiondisplayname_.Destroy(); + clear_has_FunctionDisplayNameOrRef(); + } +} +inline const std::string& StackFrame_Data::functiondisplayname() const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.functionDisplayName) + return _internal_functiondisplayname(); +} +template <typename ArgT0, typename... ArgT> +inline void StackFrame_Data::set_functiondisplayname(ArgT0&& arg0, ArgT... args) { + if (!_internal_has_functiondisplayname()) { + clear_FunctionDisplayNameOrRef(); + set_has_functiondisplayname(); + _impl_.FunctionDisplayNameOrRef_.functiondisplayname_.InitDefault(); + } + _impl_.FunctionDisplayNameOrRef_.functiondisplayname_.SetBytes( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.functionDisplayName) +} +inline std::string* StackFrame_Data::mutable_functiondisplayname() { + std::string* _s = _internal_mutable_functiondisplayname(); + // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.StackFrame.Data.functionDisplayName) + return _s; +} +inline const std::string& StackFrame_Data::_internal_functiondisplayname() const { + if (_internal_has_functiondisplayname()) { + return _impl_.FunctionDisplayNameOrRef_.functiondisplayname_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void StackFrame_Data::_internal_set_functiondisplayname(const std::string& value) { + if (!_internal_has_functiondisplayname()) { + clear_FunctionDisplayNameOrRef(); + set_has_functiondisplayname(); + _impl_.FunctionDisplayNameOrRef_.functiondisplayname_.InitDefault(); + } + _impl_.FunctionDisplayNameOrRef_.functiondisplayname_.Set(value, GetArenaForAllocation()); +} +inline std::string* StackFrame_Data::_internal_mutable_functiondisplayname() { + if (!_internal_has_functiondisplayname()) { + clear_FunctionDisplayNameOrRef(); + set_has_functiondisplayname(); + _impl_.FunctionDisplayNameOrRef_.functiondisplayname_.InitDefault(); + } + return _impl_.FunctionDisplayNameOrRef_.functiondisplayname_.Mutable( GetArenaForAllocation()); +} +inline std::string* StackFrame_Data::release_functiondisplayname() { + // @@protoc_insertion_point(field_release:mozilla.devtools.protobuf.StackFrame.Data.functionDisplayName) + if (_internal_has_functiondisplayname()) { + clear_has_FunctionDisplayNameOrRef(); + return _impl_.FunctionDisplayNameOrRef_.functiondisplayname_.Release(); + } else { + return nullptr; + } +} +inline void StackFrame_Data::set_allocated_functiondisplayname(std::string* functiondisplayname) { + if (has_FunctionDisplayNameOrRef()) { + clear_FunctionDisplayNameOrRef(); + } + if (functiondisplayname != nullptr) { + set_has_functiondisplayname(); + _impl_.FunctionDisplayNameOrRef_.functiondisplayname_.InitAllocated(functiondisplayname, GetArenaForAllocation()); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.StackFrame.Data.functionDisplayName) +} + +// uint64 functionDisplayNameRef = 8; +inline bool StackFrame_Data::_internal_has_functiondisplaynameref() const { + return FunctionDisplayNameOrRef_case() == kFunctionDisplayNameRef; +} +inline bool StackFrame_Data::has_functiondisplaynameref() const { + return _internal_has_functiondisplaynameref(); +} +inline void StackFrame_Data::set_has_functiondisplaynameref() { + _impl_._oneof_case_[1] = kFunctionDisplayNameRef; +} +inline void StackFrame_Data::clear_functiondisplaynameref() { + if (_internal_has_functiondisplaynameref()) { + _impl_.FunctionDisplayNameOrRef_.functiondisplaynameref_ = uint64_t{0u}; + clear_has_FunctionDisplayNameOrRef(); + } +} +inline uint64_t StackFrame_Data::_internal_functiondisplaynameref() const { + if (_internal_has_functiondisplaynameref()) { + return _impl_.FunctionDisplayNameOrRef_.functiondisplaynameref_; + } + return uint64_t{0u}; +} +inline void StackFrame_Data::_internal_set_functiondisplaynameref(uint64_t value) { + if (!_internal_has_functiondisplaynameref()) { + clear_FunctionDisplayNameOrRef(); + set_has_functiondisplaynameref(); + } + _impl_.FunctionDisplayNameOrRef_.functiondisplaynameref_ = value; +} +inline uint64_t StackFrame_Data::functiondisplaynameref() const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.functionDisplayNameRef) + return _internal_functiondisplaynameref(); +} +inline void StackFrame_Data::set_functiondisplaynameref(uint64_t value) { + _internal_set_functiondisplaynameref(value); + // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.functionDisplayNameRef) +} + +// optional bool isSystem = 9; +inline bool StackFrame_Data::_internal_has_issystem() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool StackFrame_Data::has_issystem() const { + return _internal_has_issystem(); +} +inline void StackFrame_Data::clear_issystem() { + _impl_.issystem_ = false; + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline bool StackFrame_Data::_internal_issystem() const { + return _impl_.issystem_; +} +inline bool StackFrame_Data::issystem() const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.isSystem) + return _internal_issystem(); +} +inline void StackFrame_Data::_internal_set_issystem(bool value) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.issystem_ = value; +} +inline void StackFrame_Data::set_issystem(bool value) { + _internal_set_issystem(value); + // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.isSystem) +} + +// optional bool isSelfHosted = 10; +inline bool StackFrame_Data::_internal_has_isselfhosted() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool StackFrame_Data::has_isselfhosted() const { + return _internal_has_isselfhosted(); +} +inline void StackFrame_Data::clear_isselfhosted() { + _impl_.isselfhosted_ = false; + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline bool StackFrame_Data::_internal_isselfhosted() const { + return _impl_.isselfhosted_; +} +inline bool StackFrame_Data::isselfhosted() const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.isSelfHosted) + return _internal_isselfhosted(); +} +inline void StackFrame_Data::_internal_set_isselfhosted(bool value) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.isselfhosted_ = value; +} +inline void StackFrame_Data::set_isselfhosted(bool value) { + _internal_set_isselfhosted(value); + // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.isSelfHosted) +} + +inline bool StackFrame_Data::has_SourceOrRef() const { + return SourceOrRef_case() != SOURCEORREF_NOT_SET; +} +inline void StackFrame_Data::clear_has_SourceOrRef() { + _impl_._oneof_case_[0] = SOURCEORREF_NOT_SET; +} +inline bool StackFrame_Data::has_FunctionDisplayNameOrRef() const { + return FunctionDisplayNameOrRef_case() != FUNCTIONDISPLAYNAMEORREF_NOT_SET; +} +inline void StackFrame_Data::clear_has_FunctionDisplayNameOrRef() { + _impl_._oneof_case_[1] = FUNCTIONDISPLAYNAMEORREF_NOT_SET; +} +inline StackFrame_Data::SourceOrRefCase StackFrame_Data::SourceOrRef_case() const { + return StackFrame_Data::SourceOrRefCase(_impl_._oneof_case_[0]); +} +inline StackFrame_Data::FunctionDisplayNameOrRefCase StackFrame_Data::FunctionDisplayNameOrRef_case() const { + return StackFrame_Data::FunctionDisplayNameOrRefCase(_impl_._oneof_case_[1]); +} +// ------------------------------------------------------------------- + +// StackFrame + +// .mozilla.devtools.protobuf.StackFrame.Data data = 1; +inline bool StackFrame::_internal_has_data() const { + return StackFrameType_case() == kData; +} +inline bool StackFrame::has_data() const { + return _internal_has_data(); +} +inline void StackFrame::set_has_data() { + _impl_._oneof_case_[0] = kData; +} +inline void StackFrame::clear_data() { + if (_internal_has_data()) { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.StackFrameType_.data_; + } + clear_has_StackFrameType(); + } +} +inline ::mozilla::devtools::protobuf::StackFrame_Data* StackFrame::release_data() { + // @@protoc_insertion_point(field_release:mozilla.devtools.protobuf.StackFrame.data) + if (_internal_has_data()) { + clear_has_StackFrameType(); + ::mozilla::devtools::protobuf::StackFrame_Data* temp = _impl_.StackFrameType_.data_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.StackFrameType_.data_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::mozilla::devtools::protobuf::StackFrame_Data& StackFrame::_internal_data() const { + return _internal_has_data() + ? *_impl_.StackFrameType_.data_ + : reinterpret_cast< ::mozilla::devtools::protobuf::StackFrame_Data&>(::mozilla::devtools::protobuf::_StackFrame_Data_default_instance_); +} +inline const ::mozilla::devtools::protobuf::StackFrame_Data& StackFrame::data() const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.data) + return _internal_data(); +} +inline ::mozilla::devtools::protobuf::StackFrame_Data* StackFrame::unsafe_arena_release_data() { + // @@protoc_insertion_point(field_unsafe_arena_release:mozilla.devtools.protobuf.StackFrame.data) + if (_internal_has_data()) { + clear_has_StackFrameType(); + ::mozilla::devtools::protobuf::StackFrame_Data* temp = _impl_.StackFrameType_.data_; + _impl_.StackFrameType_.data_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void StackFrame::unsafe_arena_set_allocated_data(::mozilla::devtools::protobuf::StackFrame_Data* data) { + clear_StackFrameType(); + if (data) { + set_has_data(); + _impl_.StackFrameType_.data_ = data; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.devtools.protobuf.StackFrame.data) +} +inline ::mozilla::devtools::protobuf::StackFrame_Data* StackFrame::_internal_mutable_data() { + if (!_internal_has_data()) { + clear_StackFrameType(); + set_has_data(); + _impl_.StackFrameType_.data_ = CreateMaybeMessage< ::mozilla::devtools::protobuf::StackFrame_Data >(GetArenaForAllocation()); + } + return _impl_.StackFrameType_.data_; +} +inline ::mozilla::devtools::protobuf::StackFrame_Data* StackFrame::mutable_data() { + ::mozilla::devtools::protobuf::StackFrame_Data* _msg = _internal_mutable_data(); + // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.StackFrame.data) + return _msg; +} + +// uint64 ref = 2; +inline bool StackFrame::_internal_has_ref() const { + return StackFrameType_case() == kRef; +} +inline bool StackFrame::has_ref() const { + return _internal_has_ref(); +} +inline void StackFrame::set_has_ref() { + _impl_._oneof_case_[0] = kRef; +} +inline void StackFrame::clear_ref() { + if (_internal_has_ref()) { + _impl_.StackFrameType_.ref_ = uint64_t{0u}; + clear_has_StackFrameType(); + } +} +inline uint64_t StackFrame::_internal_ref() const { + if (_internal_has_ref()) { + return _impl_.StackFrameType_.ref_; + } + return uint64_t{0u}; +} +inline void StackFrame::_internal_set_ref(uint64_t value) { + if (!_internal_has_ref()) { + clear_StackFrameType(); + set_has_ref(); + } + _impl_.StackFrameType_.ref_ = value; +} +inline uint64_t StackFrame::ref() const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.ref) + return _internal_ref(); +} +inline void StackFrame::set_ref(uint64_t value) { + _internal_set_ref(value); + // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.ref) +} + +inline bool StackFrame::has_StackFrameType() const { + return StackFrameType_case() != STACKFRAMETYPE_NOT_SET; +} +inline void StackFrame::clear_has_StackFrameType() { + _impl_._oneof_case_[0] = STACKFRAMETYPE_NOT_SET; +} +inline StackFrame::StackFrameTypeCase StackFrame::StackFrameType_case() const { + return StackFrame::StackFrameTypeCase(_impl_._oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// Node + +// optional uint64 id = 1; +inline bool Node::_internal_has_id() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Node::has_id() const { + return _internal_has_id(); +} +inline void Node::clear_id() { + _impl_.id_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline uint64_t Node::_internal_id() const { + return _impl_.id_; +} +inline uint64_t Node::id() const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.id) + return _internal_id(); +} +inline void Node::_internal_set_id(uint64_t value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.id_ = value; +} +inline void Node::set_id(uint64_t value) { + _internal_set_id(value); + // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.id) +} + +// bytes typeName = 2; +inline bool Node::_internal_has_typename_() const { + return TypeNameOrRef_case() == kTypeName; +} +inline bool Node::has_typename_() const { + return _internal_has_typename_(); +} +inline void Node::set_has_typename_() { + _impl_._oneof_case_[0] = kTypeName; +} +inline void Node::clear_typename_() { + if (_internal_has_typename_()) { + _impl_.TypeNameOrRef_.typename__.Destroy(); + clear_has_TypeNameOrRef(); + } +} +inline const std::string& Node::typename_() const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.typeName) + return _internal_typename_(); +} +template <typename ArgT0, typename... ArgT> +inline void Node::set_typename_(ArgT0&& arg0, ArgT... args) { + if (!_internal_has_typename_()) { + clear_TypeNameOrRef(); + set_has_typename_(); + _impl_.TypeNameOrRef_.typename__.InitDefault(); + } + _impl_.TypeNameOrRef_.typename__.SetBytes( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.typeName) +} +inline std::string* Node::mutable_typename_() { + std::string* _s = _internal_mutable_typename_(); + // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.Node.typeName) + return _s; +} +inline const std::string& Node::_internal_typename_() const { + if (_internal_has_typename_()) { + return _impl_.TypeNameOrRef_.typename__.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void Node::_internal_set_typename_(const std::string& value) { + if (!_internal_has_typename_()) { + clear_TypeNameOrRef(); + set_has_typename_(); + _impl_.TypeNameOrRef_.typename__.InitDefault(); + } + _impl_.TypeNameOrRef_.typename__.Set(value, GetArenaForAllocation()); +} +inline std::string* Node::_internal_mutable_typename_() { + if (!_internal_has_typename_()) { + clear_TypeNameOrRef(); + set_has_typename_(); + _impl_.TypeNameOrRef_.typename__.InitDefault(); + } + return _impl_.TypeNameOrRef_.typename__.Mutable( GetArenaForAllocation()); +} +inline std::string* Node::release_typename_() { + // @@protoc_insertion_point(field_release:mozilla.devtools.protobuf.Node.typeName) + if (_internal_has_typename_()) { + clear_has_TypeNameOrRef(); + return _impl_.TypeNameOrRef_.typename__.Release(); + } else { + return nullptr; + } +} +inline void Node::set_allocated_typename_(std::string* typename_) { + if (has_TypeNameOrRef()) { + clear_TypeNameOrRef(); + } + if (typename_ != nullptr) { + set_has_typename_(); + _impl_.TypeNameOrRef_.typename__.InitAllocated(typename_, GetArenaForAllocation()); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.Node.typeName) +} + +// uint64 typeNameRef = 3; +inline bool Node::_internal_has_typenameref() const { + return TypeNameOrRef_case() == kTypeNameRef; +} +inline bool Node::has_typenameref() const { + return _internal_has_typenameref(); +} +inline void Node::set_has_typenameref() { + _impl_._oneof_case_[0] = kTypeNameRef; +} +inline void Node::clear_typenameref() { + if (_internal_has_typenameref()) { + _impl_.TypeNameOrRef_.typenameref_ = uint64_t{0u}; + clear_has_TypeNameOrRef(); + } +} +inline uint64_t Node::_internal_typenameref() const { + if (_internal_has_typenameref()) { + return _impl_.TypeNameOrRef_.typenameref_; + } + return uint64_t{0u}; +} +inline void Node::_internal_set_typenameref(uint64_t value) { + if (!_internal_has_typenameref()) { + clear_TypeNameOrRef(); + set_has_typenameref(); + } + _impl_.TypeNameOrRef_.typenameref_ = value; +} +inline uint64_t Node::typenameref() const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.typeNameRef) + return _internal_typenameref(); +} +inline void Node::set_typenameref(uint64_t value) { + _internal_set_typenameref(value); + // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.typeNameRef) +} + +// optional uint64 size = 4; +inline bool Node::_internal_has_size() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool Node::has_size() const { + return _internal_has_size(); +} +inline void Node::clear_size() { + _impl_.size_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline uint64_t Node::_internal_size() const { + return _impl_.size_; +} +inline uint64_t Node::size() const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.size) + return _internal_size(); +} +inline void Node::_internal_set_size(uint64_t value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.size_ = value; +} +inline void Node::set_size(uint64_t value) { + _internal_set_size(value); + // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.size) +} + +// repeated .mozilla.devtools.protobuf.Edge edges = 5; +inline int Node::_internal_edges_size() const { + return _impl_.edges_.size(); +} +inline int Node::edges_size() const { + return _internal_edges_size(); +} +inline void Node::clear_edges() { + _impl_.edges_.Clear(); +} +inline ::mozilla::devtools::protobuf::Edge* Node::mutable_edges(int index) { + // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.Node.edges) + return _impl_.edges_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::devtools::protobuf::Edge >* +Node::mutable_edges() { + // @@protoc_insertion_point(field_mutable_list:mozilla.devtools.protobuf.Node.edges) + return &_impl_.edges_; +} +inline const ::mozilla::devtools::protobuf::Edge& Node::_internal_edges(int index) const { + return _impl_.edges_.Get(index); +} +inline const ::mozilla::devtools::protobuf::Edge& Node::edges(int index) const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.edges) + return _internal_edges(index); +} +inline ::mozilla::devtools::protobuf::Edge* Node::_internal_add_edges() { + return _impl_.edges_.Add(); +} +inline ::mozilla::devtools::protobuf::Edge* Node::add_edges() { + ::mozilla::devtools::protobuf::Edge* _add = _internal_add_edges(); + // @@protoc_insertion_point(field_add:mozilla.devtools.protobuf.Node.edges) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::devtools::protobuf::Edge >& +Node::edges() const { + // @@protoc_insertion_point(field_list:mozilla.devtools.protobuf.Node.edges) + return _impl_.edges_; +} + +// optional .mozilla.devtools.protobuf.StackFrame allocationStack = 6; +inline bool Node::_internal_has_allocationstack() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.allocationstack_ != nullptr); + return value; +} +inline bool Node::has_allocationstack() const { + return _internal_has_allocationstack(); +} +inline void Node::clear_allocationstack() { + if (_impl_.allocationstack_ != nullptr) _impl_.allocationstack_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::mozilla::devtools::protobuf::StackFrame& Node::_internal_allocationstack() const { + const ::mozilla::devtools::protobuf::StackFrame* p = _impl_.allocationstack_; + return p != nullptr ? *p : reinterpret_cast<const ::mozilla::devtools::protobuf::StackFrame&>( + ::mozilla::devtools::protobuf::_StackFrame_default_instance_); +} +inline const ::mozilla::devtools::protobuf::StackFrame& Node::allocationstack() const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.allocationStack) + return _internal_allocationstack(); +} +inline void Node::unsafe_arena_set_allocated_allocationstack( + ::mozilla::devtools::protobuf::StackFrame* allocationstack) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.allocationstack_); + } + _impl_.allocationstack_ = allocationstack; + if (allocationstack) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.devtools.protobuf.Node.allocationStack) +} +inline ::mozilla::devtools::protobuf::StackFrame* Node::release_allocationstack() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::mozilla::devtools::protobuf::StackFrame* temp = _impl_.allocationstack_; + _impl_.allocationstack_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::mozilla::devtools::protobuf::StackFrame* Node::unsafe_arena_release_allocationstack() { + // @@protoc_insertion_point(field_release:mozilla.devtools.protobuf.Node.allocationStack) + _impl_._has_bits_[0] &= ~0x00000001u; + ::mozilla::devtools::protobuf::StackFrame* temp = _impl_.allocationstack_; + _impl_.allocationstack_ = nullptr; + return temp; +} +inline ::mozilla::devtools::protobuf::StackFrame* Node::_internal_mutable_allocationstack() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.allocationstack_ == nullptr) { + auto* p = CreateMaybeMessage<::mozilla::devtools::protobuf::StackFrame>(GetArenaForAllocation()); + _impl_.allocationstack_ = p; + } + return _impl_.allocationstack_; +} +inline ::mozilla::devtools::protobuf::StackFrame* Node::mutable_allocationstack() { + ::mozilla::devtools::protobuf::StackFrame* _msg = _internal_mutable_allocationstack(); + // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.Node.allocationStack) + return _msg; +} +inline void Node::set_allocated_allocationstack(::mozilla::devtools::protobuf::StackFrame* allocationstack) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.allocationstack_; + } + if (allocationstack) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(allocationstack); + if (message_arena != submessage_arena) { + allocationstack = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, allocationstack, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.allocationstack_ = allocationstack; + // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.Node.allocationStack) +} + +// bytes jsObjectClassName = 7; +inline bool Node::_internal_has_jsobjectclassname() const { + return JSObjectClassNameOrRef_case() == kJsObjectClassName; +} +inline bool Node::has_jsobjectclassname() const { + return _internal_has_jsobjectclassname(); +} +inline void Node::set_has_jsobjectclassname() { + _impl_._oneof_case_[1] = kJsObjectClassName; +} +inline void Node::clear_jsobjectclassname() { + if (_internal_has_jsobjectclassname()) { + _impl_.JSObjectClassNameOrRef_.jsobjectclassname_.Destroy(); + clear_has_JSObjectClassNameOrRef(); + } +} +inline const std::string& Node::jsobjectclassname() const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.jsObjectClassName) + return _internal_jsobjectclassname(); +} +template <typename ArgT0, typename... ArgT> +inline void Node::set_jsobjectclassname(ArgT0&& arg0, ArgT... args) { + if (!_internal_has_jsobjectclassname()) { + clear_JSObjectClassNameOrRef(); + set_has_jsobjectclassname(); + _impl_.JSObjectClassNameOrRef_.jsobjectclassname_.InitDefault(); + } + _impl_.JSObjectClassNameOrRef_.jsobjectclassname_.SetBytes( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.jsObjectClassName) +} +inline std::string* Node::mutable_jsobjectclassname() { + std::string* _s = _internal_mutable_jsobjectclassname(); + // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.Node.jsObjectClassName) + return _s; +} +inline const std::string& Node::_internal_jsobjectclassname() const { + if (_internal_has_jsobjectclassname()) { + return _impl_.JSObjectClassNameOrRef_.jsobjectclassname_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void Node::_internal_set_jsobjectclassname(const std::string& value) { + if (!_internal_has_jsobjectclassname()) { + clear_JSObjectClassNameOrRef(); + set_has_jsobjectclassname(); + _impl_.JSObjectClassNameOrRef_.jsobjectclassname_.InitDefault(); + } + _impl_.JSObjectClassNameOrRef_.jsobjectclassname_.Set(value, GetArenaForAllocation()); +} +inline std::string* Node::_internal_mutable_jsobjectclassname() { + if (!_internal_has_jsobjectclassname()) { + clear_JSObjectClassNameOrRef(); + set_has_jsobjectclassname(); + _impl_.JSObjectClassNameOrRef_.jsobjectclassname_.InitDefault(); + } + return _impl_.JSObjectClassNameOrRef_.jsobjectclassname_.Mutable( GetArenaForAllocation()); +} +inline std::string* Node::release_jsobjectclassname() { + // @@protoc_insertion_point(field_release:mozilla.devtools.protobuf.Node.jsObjectClassName) + if (_internal_has_jsobjectclassname()) { + clear_has_JSObjectClassNameOrRef(); + return _impl_.JSObjectClassNameOrRef_.jsobjectclassname_.Release(); + } else { + return nullptr; + } +} +inline void Node::set_allocated_jsobjectclassname(std::string* jsobjectclassname) { + if (has_JSObjectClassNameOrRef()) { + clear_JSObjectClassNameOrRef(); + } + if (jsobjectclassname != nullptr) { + set_has_jsobjectclassname(); + _impl_.JSObjectClassNameOrRef_.jsobjectclassname_.InitAllocated(jsobjectclassname, GetArenaForAllocation()); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.Node.jsObjectClassName) +} + +// uint64 jsObjectClassNameRef = 8; +inline bool Node::_internal_has_jsobjectclassnameref() const { + return JSObjectClassNameOrRef_case() == kJsObjectClassNameRef; +} +inline bool Node::has_jsobjectclassnameref() const { + return _internal_has_jsobjectclassnameref(); +} +inline void Node::set_has_jsobjectclassnameref() { + _impl_._oneof_case_[1] = kJsObjectClassNameRef; +} +inline void Node::clear_jsobjectclassnameref() { + if (_internal_has_jsobjectclassnameref()) { + _impl_.JSObjectClassNameOrRef_.jsobjectclassnameref_ = uint64_t{0u}; + clear_has_JSObjectClassNameOrRef(); + } +} +inline uint64_t Node::_internal_jsobjectclassnameref() const { + if (_internal_has_jsobjectclassnameref()) { + return _impl_.JSObjectClassNameOrRef_.jsobjectclassnameref_; + } + return uint64_t{0u}; +} +inline void Node::_internal_set_jsobjectclassnameref(uint64_t value) { + if (!_internal_has_jsobjectclassnameref()) { + clear_JSObjectClassNameOrRef(); + set_has_jsobjectclassnameref(); + } + _impl_.JSObjectClassNameOrRef_.jsobjectclassnameref_ = value; +} +inline uint64_t Node::jsobjectclassnameref() const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.jsObjectClassNameRef) + return _internal_jsobjectclassnameref(); +} +inline void Node::set_jsobjectclassnameref(uint64_t value) { + _internal_set_jsobjectclassnameref(value); + // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.jsObjectClassNameRef) +} + +// optional uint32 coarseType = 9 [default = 0]; +inline bool Node::_internal_has_coarsetype() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool Node::has_coarsetype() const { + return _internal_has_coarsetype(); +} +inline void Node::clear_coarsetype() { + _impl_.coarsetype_ = 0u; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline uint32_t Node::_internal_coarsetype() const { + return _impl_.coarsetype_; +} +inline uint32_t Node::coarsetype() const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.coarseType) + return _internal_coarsetype(); +} +inline void Node::_internal_set_coarsetype(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.coarsetype_ = value; +} +inline void Node::set_coarsetype(uint32_t value) { + _internal_set_coarsetype(value); + // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.coarseType) +} + +// bytes scriptFilename = 10; +inline bool Node::_internal_has_scriptfilename() const { + return ScriptFilenameOrRef_case() == kScriptFilename; +} +inline bool Node::has_scriptfilename() const { + return _internal_has_scriptfilename(); +} +inline void Node::set_has_scriptfilename() { + _impl_._oneof_case_[2] = kScriptFilename; +} +inline void Node::clear_scriptfilename() { + if (_internal_has_scriptfilename()) { + _impl_.ScriptFilenameOrRef_.scriptfilename_.Destroy(); + clear_has_ScriptFilenameOrRef(); + } +} +inline const std::string& Node::scriptfilename() const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.scriptFilename) + return _internal_scriptfilename(); +} +template <typename ArgT0, typename... ArgT> +inline void Node::set_scriptfilename(ArgT0&& arg0, ArgT... args) { + if (!_internal_has_scriptfilename()) { + clear_ScriptFilenameOrRef(); + set_has_scriptfilename(); + _impl_.ScriptFilenameOrRef_.scriptfilename_.InitDefault(); + } + _impl_.ScriptFilenameOrRef_.scriptfilename_.SetBytes( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.scriptFilename) +} +inline std::string* Node::mutable_scriptfilename() { + std::string* _s = _internal_mutable_scriptfilename(); + // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.Node.scriptFilename) + return _s; +} +inline const std::string& Node::_internal_scriptfilename() const { + if (_internal_has_scriptfilename()) { + return _impl_.ScriptFilenameOrRef_.scriptfilename_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void Node::_internal_set_scriptfilename(const std::string& value) { + if (!_internal_has_scriptfilename()) { + clear_ScriptFilenameOrRef(); + set_has_scriptfilename(); + _impl_.ScriptFilenameOrRef_.scriptfilename_.InitDefault(); + } + _impl_.ScriptFilenameOrRef_.scriptfilename_.Set(value, GetArenaForAllocation()); +} +inline std::string* Node::_internal_mutable_scriptfilename() { + if (!_internal_has_scriptfilename()) { + clear_ScriptFilenameOrRef(); + set_has_scriptfilename(); + _impl_.ScriptFilenameOrRef_.scriptfilename_.InitDefault(); + } + return _impl_.ScriptFilenameOrRef_.scriptfilename_.Mutable( GetArenaForAllocation()); +} +inline std::string* Node::release_scriptfilename() { + // @@protoc_insertion_point(field_release:mozilla.devtools.protobuf.Node.scriptFilename) + if (_internal_has_scriptfilename()) { + clear_has_ScriptFilenameOrRef(); + return _impl_.ScriptFilenameOrRef_.scriptfilename_.Release(); + } else { + return nullptr; + } +} +inline void Node::set_allocated_scriptfilename(std::string* scriptfilename) { + if (has_ScriptFilenameOrRef()) { + clear_ScriptFilenameOrRef(); + } + if (scriptfilename != nullptr) { + set_has_scriptfilename(); + _impl_.ScriptFilenameOrRef_.scriptfilename_.InitAllocated(scriptfilename, GetArenaForAllocation()); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.Node.scriptFilename) +} + +// uint64 scriptFilenameRef = 11; +inline bool Node::_internal_has_scriptfilenameref() const { + return ScriptFilenameOrRef_case() == kScriptFilenameRef; +} +inline bool Node::has_scriptfilenameref() const { + return _internal_has_scriptfilenameref(); +} +inline void Node::set_has_scriptfilenameref() { + _impl_._oneof_case_[2] = kScriptFilenameRef; +} +inline void Node::clear_scriptfilenameref() { + if (_internal_has_scriptfilenameref()) { + _impl_.ScriptFilenameOrRef_.scriptfilenameref_ = uint64_t{0u}; + clear_has_ScriptFilenameOrRef(); + } +} +inline uint64_t Node::_internal_scriptfilenameref() const { + if (_internal_has_scriptfilenameref()) { + return _impl_.ScriptFilenameOrRef_.scriptfilenameref_; + } + return uint64_t{0u}; +} +inline void Node::_internal_set_scriptfilenameref(uint64_t value) { + if (!_internal_has_scriptfilenameref()) { + clear_ScriptFilenameOrRef(); + set_has_scriptfilenameref(); + } + _impl_.ScriptFilenameOrRef_.scriptfilenameref_ = value; +} +inline uint64_t Node::scriptfilenameref() const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.scriptFilenameRef) + return _internal_scriptfilenameref(); +} +inline void Node::set_scriptfilenameref(uint64_t value) { + _internal_set_scriptfilenameref(value); + // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.scriptFilenameRef) +} + +// bytes descriptiveTypeName = 12; +inline bool Node::_internal_has_descriptivetypename() const { + return descriptiveTypeNameOrRef_case() == kDescriptiveTypeName; +} +inline bool Node::has_descriptivetypename() const { + return _internal_has_descriptivetypename(); +} +inline void Node::set_has_descriptivetypename() { + _impl_._oneof_case_[3] = kDescriptiveTypeName; +} +inline void Node::clear_descriptivetypename() { + if (_internal_has_descriptivetypename()) { + _impl_.descriptiveTypeNameOrRef_.descriptivetypename_.Destroy(); + clear_has_descriptiveTypeNameOrRef(); + } +} +inline const std::string& Node::descriptivetypename() const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.descriptiveTypeName) + return _internal_descriptivetypename(); +} +template <typename ArgT0, typename... ArgT> +inline void Node::set_descriptivetypename(ArgT0&& arg0, ArgT... args) { + if (!_internal_has_descriptivetypename()) { + clear_descriptiveTypeNameOrRef(); + set_has_descriptivetypename(); + _impl_.descriptiveTypeNameOrRef_.descriptivetypename_.InitDefault(); + } + _impl_.descriptiveTypeNameOrRef_.descriptivetypename_.SetBytes( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.descriptiveTypeName) +} +inline std::string* Node::mutable_descriptivetypename() { + std::string* _s = _internal_mutable_descriptivetypename(); + // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.Node.descriptiveTypeName) + return _s; +} +inline const std::string& Node::_internal_descriptivetypename() const { + if (_internal_has_descriptivetypename()) { + return _impl_.descriptiveTypeNameOrRef_.descriptivetypename_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void Node::_internal_set_descriptivetypename(const std::string& value) { + if (!_internal_has_descriptivetypename()) { + clear_descriptiveTypeNameOrRef(); + set_has_descriptivetypename(); + _impl_.descriptiveTypeNameOrRef_.descriptivetypename_.InitDefault(); + } + _impl_.descriptiveTypeNameOrRef_.descriptivetypename_.Set(value, GetArenaForAllocation()); +} +inline std::string* Node::_internal_mutable_descriptivetypename() { + if (!_internal_has_descriptivetypename()) { + clear_descriptiveTypeNameOrRef(); + set_has_descriptivetypename(); + _impl_.descriptiveTypeNameOrRef_.descriptivetypename_.InitDefault(); + } + return _impl_.descriptiveTypeNameOrRef_.descriptivetypename_.Mutable( GetArenaForAllocation()); +} +inline std::string* Node::release_descriptivetypename() { + // @@protoc_insertion_point(field_release:mozilla.devtools.protobuf.Node.descriptiveTypeName) + if (_internal_has_descriptivetypename()) { + clear_has_descriptiveTypeNameOrRef(); + return _impl_.descriptiveTypeNameOrRef_.descriptivetypename_.Release(); + } else { + return nullptr; + } +} +inline void Node::set_allocated_descriptivetypename(std::string* descriptivetypename) { + if (has_descriptiveTypeNameOrRef()) { + clear_descriptiveTypeNameOrRef(); + } + if (descriptivetypename != nullptr) { + set_has_descriptivetypename(); + _impl_.descriptiveTypeNameOrRef_.descriptivetypename_.InitAllocated(descriptivetypename, GetArenaForAllocation()); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.Node.descriptiveTypeName) +} + +// uint64 descriptiveTypeNameRef = 13; +inline bool Node::_internal_has_descriptivetypenameref() const { + return descriptiveTypeNameOrRef_case() == kDescriptiveTypeNameRef; +} +inline bool Node::has_descriptivetypenameref() const { + return _internal_has_descriptivetypenameref(); +} +inline void Node::set_has_descriptivetypenameref() { + _impl_._oneof_case_[3] = kDescriptiveTypeNameRef; +} +inline void Node::clear_descriptivetypenameref() { + if (_internal_has_descriptivetypenameref()) { + _impl_.descriptiveTypeNameOrRef_.descriptivetypenameref_ = uint64_t{0u}; + clear_has_descriptiveTypeNameOrRef(); + } +} +inline uint64_t Node::_internal_descriptivetypenameref() const { + if (_internal_has_descriptivetypenameref()) { + return _impl_.descriptiveTypeNameOrRef_.descriptivetypenameref_; + } + return uint64_t{0u}; +} +inline void Node::_internal_set_descriptivetypenameref(uint64_t value) { + if (!_internal_has_descriptivetypenameref()) { + clear_descriptiveTypeNameOrRef(); + set_has_descriptivetypenameref(); + } + _impl_.descriptiveTypeNameOrRef_.descriptivetypenameref_ = value; +} +inline uint64_t Node::descriptivetypenameref() const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.descriptiveTypeNameRef) + return _internal_descriptivetypenameref(); +} +inline void Node::set_descriptivetypenameref(uint64_t value) { + _internal_set_descriptivetypenameref(value); + // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.descriptiveTypeNameRef) +} + +inline bool Node::has_TypeNameOrRef() const { + return TypeNameOrRef_case() != TYPENAMEORREF_NOT_SET; +} +inline void Node::clear_has_TypeNameOrRef() { + _impl_._oneof_case_[0] = TYPENAMEORREF_NOT_SET; +} +inline bool Node::has_JSObjectClassNameOrRef() const { + return JSObjectClassNameOrRef_case() != JSOBJECTCLASSNAMEORREF_NOT_SET; +} +inline void Node::clear_has_JSObjectClassNameOrRef() { + _impl_._oneof_case_[1] = JSOBJECTCLASSNAMEORREF_NOT_SET; +} +inline bool Node::has_ScriptFilenameOrRef() const { + return ScriptFilenameOrRef_case() != SCRIPTFILENAMEORREF_NOT_SET; +} +inline void Node::clear_has_ScriptFilenameOrRef() { + _impl_._oneof_case_[2] = SCRIPTFILENAMEORREF_NOT_SET; +} +inline bool Node::has_descriptiveTypeNameOrRef() const { + return descriptiveTypeNameOrRef_case() != DESCRIPTIVETYPENAMEORREF_NOT_SET; +} +inline void Node::clear_has_descriptiveTypeNameOrRef() { + _impl_._oneof_case_[3] = DESCRIPTIVETYPENAMEORREF_NOT_SET; +} +inline Node::TypeNameOrRefCase Node::TypeNameOrRef_case() const { + return Node::TypeNameOrRefCase(_impl_._oneof_case_[0]); +} +inline Node::JSObjectClassNameOrRefCase Node::JSObjectClassNameOrRef_case() const { + return Node::JSObjectClassNameOrRefCase(_impl_._oneof_case_[1]); +} +inline Node::ScriptFilenameOrRefCase Node::ScriptFilenameOrRef_case() const { + return Node::ScriptFilenameOrRefCase(_impl_._oneof_case_[2]); +} +inline Node::DescriptiveTypeNameOrRefCase Node::descriptiveTypeNameOrRef_case() const { + return Node::DescriptiveTypeNameOrRefCase(_impl_._oneof_case_[3]); +} +// ------------------------------------------------------------------- + +// Edge + +// optional uint64 referent = 1; +inline bool Edge::_internal_has_referent() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Edge::has_referent() const { + return _internal_has_referent(); +} +inline void Edge::clear_referent() { + _impl_.referent_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline uint64_t Edge::_internal_referent() const { + return _impl_.referent_; +} +inline uint64_t Edge::referent() const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Edge.referent) + return _internal_referent(); +} +inline void Edge::_internal_set_referent(uint64_t value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.referent_ = value; +} +inline void Edge::set_referent(uint64_t value) { + _internal_set_referent(value); + // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Edge.referent) +} + +// bytes name = 2; +inline bool Edge::_internal_has_name() const { + return EdgeNameOrRef_case() == kName; +} +inline bool Edge::has_name() const { + return _internal_has_name(); +} +inline void Edge::set_has_name() { + _impl_._oneof_case_[0] = kName; +} +inline void Edge::clear_name() { + if (_internal_has_name()) { + _impl_.EdgeNameOrRef_.name_.Destroy(); + clear_has_EdgeNameOrRef(); + } +} +inline const std::string& Edge::name() const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Edge.name) + return _internal_name(); +} +template <typename ArgT0, typename... ArgT> +inline void Edge::set_name(ArgT0&& arg0, ArgT... args) { + if (!_internal_has_name()) { + clear_EdgeNameOrRef(); + set_has_name(); + _impl_.EdgeNameOrRef_.name_.InitDefault(); + } + _impl_.EdgeNameOrRef_.name_.SetBytes( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Edge.name) +} +inline std::string* Edge::mutable_name() { + std::string* _s = _internal_mutable_name(); + // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.Edge.name) + return _s; +} +inline const std::string& Edge::_internal_name() const { + if (_internal_has_name()) { + return _impl_.EdgeNameOrRef_.name_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void Edge::_internal_set_name(const std::string& value) { + if (!_internal_has_name()) { + clear_EdgeNameOrRef(); + set_has_name(); + _impl_.EdgeNameOrRef_.name_.InitDefault(); + } + _impl_.EdgeNameOrRef_.name_.Set(value, GetArenaForAllocation()); +} +inline std::string* Edge::_internal_mutable_name() { + if (!_internal_has_name()) { + clear_EdgeNameOrRef(); + set_has_name(); + _impl_.EdgeNameOrRef_.name_.InitDefault(); + } + return _impl_.EdgeNameOrRef_.name_.Mutable( GetArenaForAllocation()); +} +inline std::string* Edge::release_name() { + // @@protoc_insertion_point(field_release:mozilla.devtools.protobuf.Edge.name) + if (_internal_has_name()) { + clear_has_EdgeNameOrRef(); + return _impl_.EdgeNameOrRef_.name_.Release(); + } else { + return nullptr; + } +} +inline void Edge::set_allocated_name(std::string* name) { + if (has_EdgeNameOrRef()) { + clear_EdgeNameOrRef(); + } + if (name != nullptr) { + set_has_name(); + _impl_.EdgeNameOrRef_.name_.InitAllocated(name, GetArenaForAllocation()); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.Edge.name) +} + +// uint64 nameRef = 3; +inline bool Edge::_internal_has_nameref() const { + return EdgeNameOrRef_case() == kNameRef; +} +inline bool Edge::has_nameref() const { + return _internal_has_nameref(); +} +inline void Edge::set_has_nameref() { + _impl_._oneof_case_[0] = kNameRef; +} +inline void Edge::clear_nameref() { + if (_internal_has_nameref()) { + _impl_.EdgeNameOrRef_.nameref_ = uint64_t{0u}; + clear_has_EdgeNameOrRef(); + } +} +inline uint64_t Edge::_internal_nameref() const { + if (_internal_has_nameref()) { + return _impl_.EdgeNameOrRef_.nameref_; + } + return uint64_t{0u}; +} +inline void Edge::_internal_set_nameref(uint64_t value) { + if (!_internal_has_nameref()) { + clear_EdgeNameOrRef(); + set_has_nameref(); + } + _impl_.EdgeNameOrRef_.nameref_ = value; +} +inline uint64_t Edge::nameref() const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Edge.nameRef) + return _internal_nameref(); +} +inline void Edge::set_nameref(uint64_t value) { + _internal_set_nameref(value); + // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Edge.nameRef) +} + +inline bool Edge::has_EdgeNameOrRef() const { + return EdgeNameOrRef_case() != EDGENAMEORREF_NOT_SET; +} +inline void Edge::clear_has_EdgeNameOrRef() { + _impl_._oneof_case_[0] = EDGENAMEORREF_NOT_SET; +} +inline Edge::EdgeNameOrRefCase Edge::EdgeNameOrRef_case() const { + return Edge::EdgeNameOrRefCase(_impl_._oneof_case_[0]); +} +#ifdef __GNUC__ + #pragma GCC diagnostic pop +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace protobuf +} // namespace devtools +} // namespace mozilla + +// @@protoc_insertion_point(global_scope) + +#include <google/protobuf/port_undef.inc> +#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_CoreDump_2eproto |