From 4e2e9be6abed3225406b466099e397acc0f914d2 Mon Sep 17 00:00:00 2001 From: "Matt A. Tobin" Date: Sat, 22 Feb 2020 17:32:39 -0500 Subject: Reclassify heapsnapshot and nsJSInspector as not part of devtools This resolves Issue #316 --- dom/heapsnapshot/CoreDump.pb.h | 1893 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1893 insertions(+) create mode 100644 dom/heapsnapshot/CoreDump.pb.h (limited to 'dom/heapsnapshot/CoreDump.pb.h') diff --git a/dom/heapsnapshot/CoreDump.pb.h b/dom/heapsnapshot/CoreDump.pb.h new file mode 100644 index 000000000..584c2e379 --- /dev/null +++ b/dom/heapsnapshot/CoreDump.pb.h @@ -0,0 +1,1893 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: CoreDump.proto + +#ifndef PROTOBUF_CoreDump_2eproto__INCLUDED +#define PROTOBUF_CoreDump_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2006000 +#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 2006001 < GOOGLE_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 +#include +#include +#include +#include +// @@protoc_insertion_point(includes) + +namespace mozilla { +namespace devtools { +namespace protobuf { + +// Internal implementation detail -- do not call these. +void protobuf_AddDesc_CoreDump_2eproto(); +void protobuf_AssignDesc_CoreDump_2eproto(); +void protobuf_ShutdownFile_CoreDump_2eproto(); + +class Metadata; +class StackFrame; +class StackFrame_Data; +class Node; +class Edge; + +// =================================================================== + +class Metadata : public ::google::protobuf::Message { + public: + Metadata(); + virtual ~Metadata(); + + Metadata(const Metadata& from); + + inline Metadata& operator=(const Metadata& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const Metadata& default_instance(); + + void Swap(Metadata* other); + + // implements Message ---------------------------------------------- + + Metadata* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const Metadata& from); + void MergeFrom(const Metadata& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional uint64 timeStamp = 1; + inline bool has_timestamp() const; + inline void clear_timestamp(); + static const int kTimeStampFieldNumber = 1; + inline ::google::protobuf::uint64 timestamp() const; + inline void set_timestamp(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:mozilla.devtools.protobuf.Metadata) + private: + inline void set_has_timestamp(); + inline void clear_has_timestamp(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint64 timestamp_; + friend void protobuf_AddDesc_CoreDump_2eproto(); + friend void protobuf_AssignDesc_CoreDump_2eproto(); + friend void protobuf_ShutdownFile_CoreDump_2eproto(); + + void InitAsDefaultInstance(); + static Metadata* default_instance_; +}; +// ------------------------------------------------------------------- + +class StackFrame_Data : public ::google::protobuf::Message { + public: + StackFrame_Data(); + virtual ~StackFrame_Data(); + + StackFrame_Data(const StackFrame_Data& from); + + inline StackFrame_Data& operator=(const StackFrame_Data& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const StackFrame_Data& default_instance(); + + enum SourceOrRefCase { + kSource = 5, + kSourceRef = 6, + SOURCEORREF_NOT_SET = 0, + }; + + enum FunctionDisplayNameOrRefCase { + kFunctionDisplayName = 7, + kFunctionDisplayNameRef = 8, + FUNCTIONDISPLAYNAMEORREF_NOT_SET = 0, + }; + + void Swap(StackFrame_Data* other); + + // implements Message ---------------------------------------------- + + StackFrame_Data* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const StackFrame_Data& from); + void MergeFrom(const StackFrame_Data& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional uint64 id = 1; + inline bool has_id() const; + inline void clear_id(); + static const int kIdFieldNumber = 1; + inline ::google::protobuf::uint64 id() const; + inline void set_id(::google::protobuf::uint64 value); + + // optional .mozilla.devtools.protobuf.StackFrame parent = 2; + inline bool has_parent() const; + inline void clear_parent(); + static const int kParentFieldNumber = 2; + inline const ::mozilla::devtools::protobuf::StackFrame& parent() const; + inline ::mozilla::devtools::protobuf::StackFrame* mutable_parent(); + inline ::mozilla::devtools::protobuf::StackFrame* release_parent(); + inline void set_allocated_parent(::mozilla::devtools::protobuf::StackFrame* parent); + + // optional uint32 line = 3; + inline bool has_line() const; + inline void clear_line(); + static const int kLineFieldNumber = 3; + inline ::google::protobuf::uint32 line() const; + inline void set_line(::google::protobuf::uint32 value); + + // optional uint32 column = 4; + inline bool has_column() const; + inline void clear_column(); + static const int kColumnFieldNumber = 4; + inline ::google::protobuf::uint32 column() const; + inline void set_column(::google::protobuf::uint32 value); + + // optional bytes source = 5; + inline bool has_source() const; + inline void clear_source(); + static const int kSourceFieldNumber = 5; + inline const ::std::string& source() const; + inline void set_source(const ::std::string& value); + inline void set_source(const char* value); + inline void set_source(const void* value, size_t size); + inline ::std::string* mutable_source(); + inline ::std::string* release_source(); + inline void set_allocated_source(::std::string* source); + + // optional uint64 sourceRef = 6; + inline bool has_sourceref() const; + inline void clear_sourceref(); + static const int kSourceRefFieldNumber = 6; + inline ::google::protobuf::uint64 sourceref() const; + inline void set_sourceref(::google::protobuf::uint64 value); + + // optional bytes functionDisplayName = 7; + inline bool has_functiondisplayname() const; + inline void clear_functiondisplayname(); + static const int kFunctionDisplayNameFieldNumber = 7; + inline const ::std::string& functiondisplayname() const; + inline void set_functiondisplayname(const ::std::string& value); + inline void set_functiondisplayname(const char* value); + inline void set_functiondisplayname(const void* value, size_t size); + inline ::std::string* mutable_functiondisplayname(); + inline ::std::string* release_functiondisplayname(); + inline void set_allocated_functiondisplayname(::std::string* functiondisplayname); + + // optional uint64 functionDisplayNameRef = 8; + inline bool has_functiondisplaynameref() const; + inline void clear_functiondisplaynameref(); + static const int kFunctionDisplayNameRefFieldNumber = 8; + inline ::google::protobuf::uint64 functiondisplaynameref() const; + inline void set_functiondisplaynameref(::google::protobuf::uint64 value); + + // optional bool isSystem = 9; + inline bool has_issystem() const; + inline void clear_issystem(); + static const int kIsSystemFieldNumber = 9; + inline bool issystem() const; + inline void set_issystem(bool value); + + // optional bool isSelfHosted = 10; + inline bool has_isselfhosted() const; + inline void clear_isselfhosted(); + static const int kIsSelfHostedFieldNumber = 10; + inline bool isselfhosted() const; + inline void set_isselfhosted(bool value); + + inline SourceOrRefCase SourceOrRef_case() const; + inline FunctionDisplayNameOrRefCase FunctionDisplayNameOrRef_case() const; + // @@protoc_insertion_point(class_scope:mozilla.devtools.protobuf.StackFrame.Data) + private: + inline void set_has_id(); + inline void clear_has_id(); + inline void set_has_parent(); + inline void clear_has_parent(); + inline void set_has_line(); + inline void clear_has_line(); + inline void set_has_column(); + inline void clear_has_column(); + inline void set_has_source(); + inline void set_has_sourceref(); + inline void set_has_functiondisplayname(); + inline void set_has_functiondisplaynameref(); + inline void set_has_issystem(); + inline void clear_has_issystem(); + inline void set_has_isselfhosted(); + inline void clear_has_isselfhosted(); + + inline bool has_SourceOrRef(); + void clear_SourceOrRef(); + inline void clear_has_SourceOrRef(); + + inline bool has_FunctionDisplayNameOrRef(); + void clear_FunctionDisplayNameOrRef(); + inline void clear_has_FunctionDisplayNameOrRef(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint64 id_; + ::mozilla::devtools::protobuf::StackFrame* parent_; + ::google::protobuf::uint32 line_; + ::google::protobuf::uint32 column_; + bool issystem_; + bool isselfhosted_; + union SourceOrRefUnion { + ::std::string* source_; + ::google::protobuf::uint64 sourceref_; + } SourceOrRef_; + union FunctionDisplayNameOrRefUnion { + ::std::string* functiondisplayname_; + ::google::protobuf::uint64 functiondisplaynameref_; + } FunctionDisplayNameOrRef_; + ::google::protobuf::uint32 _oneof_case_[2]; + + friend void protobuf_AddDesc_CoreDump_2eproto(); + friend void protobuf_AssignDesc_CoreDump_2eproto(); + friend void protobuf_ShutdownFile_CoreDump_2eproto(); + + void InitAsDefaultInstance(); + static StackFrame_Data* default_instance_; +}; +// ------------------------------------------------------------------- + +class StackFrame : public ::google::protobuf::Message { + public: + StackFrame(); + virtual ~StackFrame(); + + StackFrame(const StackFrame& from); + + inline StackFrame& operator=(const StackFrame& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const StackFrame& default_instance(); + + enum StackFrameTypeCase { + kData = 1, + kRef = 2, + STACKFRAMETYPE_NOT_SET = 0, + }; + + void Swap(StackFrame* other); + + // implements Message ---------------------------------------------- + + StackFrame* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const StackFrame& from); + void MergeFrom(const StackFrame& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + typedef StackFrame_Data Data; + + // accessors ------------------------------------------------------- + + // optional .mozilla.devtools.protobuf.StackFrame.Data data = 1; + inline bool has_data() const; + inline void clear_data(); + static const int kDataFieldNumber = 1; + inline const ::mozilla::devtools::protobuf::StackFrame_Data& data() const; + inline ::mozilla::devtools::protobuf::StackFrame_Data* mutable_data(); + inline ::mozilla::devtools::protobuf::StackFrame_Data* release_data(); + inline void set_allocated_data(::mozilla::devtools::protobuf::StackFrame_Data* data); + + // optional uint64 ref = 2; + inline bool has_ref() const; + inline void clear_ref(); + static const int kRefFieldNumber = 2; + inline ::google::protobuf::uint64 ref() const; + inline void set_ref(::google::protobuf::uint64 value); + + inline StackFrameTypeCase StackFrameType_case() const; + // @@protoc_insertion_point(class_scope:mozilla.devtools.protobuf.StackFrame) + private: + inline void set_has_data(); + inline void set_has_ref(); + + inline bool has_StackFrameType(); + void clear_StackFrameType(); + inline void clear_has_StackFrameType(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + union StackFrameTypeUnion { + ::mozilla::devtools::protobuf::StackFrame_Data* data_; + ::google::protobuf::uint64 ref_; + } StackFrameType_; + ::google::protobuf::uint32 _oneof_case_[1]; + + friend void protobuf_AddDesc_CoreDump_2eproto(); + friend void protobuf_AssignDesc_CoreDump_2eproto(); + friend void protobuf_ShutdownFile_CoreDump_2eproto(); + + void InitAsDefaultInstance(); + static StackFrame* default_instance_; +}; +// ------------------------------------------------------------------- + +class Node : public ::google::protobuf::Message { + public: + Node(); + virtual ~Node(); + + Node(const Node& from); + + inline Node& operator=(const Node& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const Node& 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, + }; + + void Swap(Node* other); + + // implements Message ---------------------------------------------- + + Node* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const Node& from); + void MergeFrom(const Node& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional uint64 id = 1; + inline bool has_id() const; + inline void clear_id(); + static const int kIdFieldNumber = 1; + inline ::google::protobuf::uint64 id() const; + inline void set_id(::google::protobuf::uint64 value); + + // optional bytes typeName = 2; + inline bool has_typename_() const; + inline void clear_typename_(); + static const int kTypeNameFieldNumber = 2; + inline const ::std::string& typename_() const; + inline void set_typename_(const ::std::string& value); + inline void set_typename_(const char* value); + inline void set_typename_(const void* value, size_t size); + inline ::std::string* mutable_typename_(); + inline ::std::string* release_typename_(); + inline void set_allocated_typename_(::std::string* typename_); + + // optional uint64 typeNameRef = 3; + inline bool has_typenameref() const; + inline void clear_typenameref(); + static const int kTypeNameRefFieldNumber = 3; + inline ::google::protobuf::uint64 typenameref() const; + inline void set_typenameref(::google::protobuf::uint64 value); + + // optional uint64 size = 4; + inline bool has_size() const; + inline void clear_size(); + static const int kSizeFieldNumber = 4; + inline ::google::protobuf::uint64 size() const; + inline void set_size(::google::protobuf::uint64 value); + + // repeated .mozilla.devtools.protobuf.Edge edges = 5; + inline int edges_size() const; + inline void clear_edges(); + static const int kEdgesFieldNumber = 5; + inline const ::mozilla::devtools::protobuf::Edge& edges(int index) const; + inline ::mozilla::devtools::protobuf::Edge* mutable_edges(int index); + inline ::mozilla::devtools::protobuf::Edge* add_edges(); + inline const ::google::protobuf::RepeatedPtrField< ::mozilla::devtools::protobuf::Edge >& + edges() const; + inline ::google::protobuf::RepeatedPtrField< ::mozilla::devtools::protobuf::Edge >* + mutable_edges(); + + // optional .mozilla.devtools.protobuf.StackFrame allocationStack = 6; + inline bool has_allocationstack() const; + inline void clear_allocationstack(); + static const int kAllocationStackFieldNumber = 6; + inline const ::mozilla::devtools::protobuf::StackFrame& allocationstack() const; + inline ::mozilla::devtools::protobuf::StackFrame* mutable_allocationstack(); + inline ::mozilla::devtools::protobuf::StackFrame* release_allocationstack(); + inline void set_allocated_allocationstack(::mozilla::devtools::protobuf::StackFrame* allocationstack); + + // optional bytes jsObjectClassName = 7; + inline bool has_jsobjectclassname() const; + inline void clear_jsobjectclassname(); + static const int kJsObjectClassNameFieldNumber = 7; + inline const ::std::string& jsobjectclassname() const; + inline void set_jsobjectclassname(const ::std::string& value); + inline void set_jsobjectclassname(const char* value); + inline void set_jsobjectclassname(const void* value, size_t size); + inline ::std::string* mutable_jsobjectclassname(); + inline ::std::string* release_jsobjectclassname(); + inline void set_allocated_jsobjectclassname(::std::string* jsobjectclassname); + + // optional uint64 jsObjectClassNameRef = 8; + inline bool has_jsobjectclassnameref() const; + inline void clear_jsobjectclassnameref(); + static const int kJsObjectClassNameRefFieldNumber = 8; + inline ::google::protobuf::uint64 jsobjectclassnameref() const; + inline void set_jsobjectclassnameref(::google::protobuf::uint64 value); + + // optional uint32 coarseType = 9 [default = 0]; + inline bool has_coarsetype() const; + inline void clear_coarsetype(); + static const int kCoarseTypeFieldNumber = 9; + inline ::google::protobuf::uint32 coarsetype() const; + inline void set_coarsetype(::google::protobuf::uint32 value); + + // optional bytes scriptFilename = 10; + inline bool has_scriptfilename() const; + inline void clear_scriptfilename(); + static const int kScriptFilenameFieldNumber = 10; + inline const ::std::string& scriptfilename() const; + inline void set_scriptfilename(const ::std::string& value); + inline void set_scriptfilename(const char* value); + inline void set_scriptfilename(const void* value, size_t size); + inline ::std::string* mutable_scriptfilename(); + inline ::std::string* release_scriptfilename(); + inline void set_allocated_scriptfilename(::std::string* scriptfilename); + + // optional uint64 scriptFilenameRef = 11; + inline bool has_scriptfilenameref() const; + inline void clear_scriptfilenameref(); + static const int kScriptFilenameRefFieldNumber = 11; + inline ::google::protobuf::uint64 scriptfilenameref() const; + inline void set_scriptfilenameref(::google::protobuf::uint64 value); + + inline TypeNameOrRefCase TypeNameOrRef_case() const; + inline JSObjectClassNameOrRefCase JSObjectClassNameOrRef_case() const; + inline ScriptFilenameOrRefCase ScriptFilenameOrRef_case() const; + // @@protoc_insertion_point(class_scope:mozilla.devtools.protobuf.Node) + private: + inline void set_has_id(); + inline void clear_has_id(); + inline void set_has_typename_(); + inline void set_has_typenameref(); + inline void set_has_size(); + inline void clear_has_size(); + inline void set_has_allocationstack(); + inline void clear_has_allocationstack(); + inline void set_has_jsobjectclassname(); + inline void set_has_jsobjectclassnameref(); + inline void set_has_coarsetype(); + inline void clear_has_coarsetype(); + inline void set_has_scriptfilename(); + inline void set_has_scriptfilenameref(); + + inline bool has_TypeNameOrRef(); + void clear_TypeNameOrRef(); + inline void clear_has_TypeNameOrRef(); + + inline bool has_JSObjectClassNameOrRef(); + void clear_JSObjectClassNameOrRef(); + inline void clear_has_JSObjectClassNameOrRef(); + + inline bool has_ScriptFilenameOrRef(); + void clear_ScriptFilenameOrRef(); + inline void clear_has_ScriptFilenameOrRef(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint64 id_; + ::google::protobuf::uint64 size_; + ::google::protobuf::RepeatedPtrField< ::mozilla::devtools::protobuf::Edge > edges_; + ::mozilla::devtools::protobuf::StackFrame* allocationstack_; + ::google::protobuf::uint32 coarsetype_; + union TypeNameOrRefUnion { + ::std::string* typename__; + ::google::protobuf::uint64 typenameref_; + } TypeNameOrRef_; + union JSObjectClassNameOrRefUnion { + ::std::string* jsobjectclassname_; + ::google::protobuf::uint64 jsobjectclassnameref_; + } JSObjectClassNameOrRef_; + union ScriptFilenameOrRefUnion { + ::std::string* scriptfilename_; + ::google::protobuf::uint64 scriptfilenameref_; + } ScriptFilenameOrRef_; + ::google::protobuf::uint32 _oneof_case_[3]; + + friend void protobuf_AddDesc_CoreDump_2eproto(); + friend void protobuf_AssignDesc_CoreDump_2eproto(); + friend void protobuf_ShutdownFile_CoreDump_2eproto(); + + void InitAsDefaultInstance(); + static Node* default_instance_; +}; +// ------------------------------------------------------------------- + +class Edge : public ::google::protobuf::Message { + public: + Edge(); + virtual ~Edge(); + + Edge(const Edge& from); + + inline Edge& operator=(const Edge& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const Edge& default_instance(); + + enum EdgeNameOrRefCase { + kName = 2, + kNameRef = 3, + EDGENAMEORREF_NOT_SET = 0, + }; + + void Swap(Edge* other); + + // implements Message ---------------------------------------------- + + Edge* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const Edge& from); + void MergeFrom(const Edge& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional uint64 referent = 1; + inline bool has_referent() const; + inline void clear_referent(); + static const int kReferentFieldNumber = 1; + inline ::google::protobuf::uint64 referent() const; + inline void set_referent(::google::protobuf::uint64 value); + + // optional bytes name = 2; + inline bool has_name() const; + inline void clear_name(); + static const int kNameFieldNumber = 2; + inline const ::std::string& name() const; + inline void set_name(const ::std::string& value); + inline void set_name(const char* value); + inline void set_name(const void* value, size_t size); + inline ::std::string* mutable_name(); + inline ::std::string* release_name(); + inline void set_allocated_name(::std::string* name); + + // optional uint64 nameRef = 3; + inline bool has_nameref() const; + inline void clear_nameref(); + static const int kNameRefFieldNumber = 3; + inline ::google::protobuf::uint64 nameref() const; + inline void set_nameref(::google::protobuf::uint64 value); + + inline EdgeNameOrRefCase EdgeNameOrRef_case() const; + // @@protoc_insertion_point(class_scope:mozilla.devtools.protobuf.Edge) + private: + inline void set_has_referent(); + inline void clear_has_referent(); + inline void set_has_name(); + inline void set_has_nameref(); + + inline bool has_EdgeNameOrRef(); + void clear_EdgeNameOrRef(); + inline void clear_has_EdgeNameOrRef(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint64 referent_; + union EdgeNameOrRefUnion { + ::std::string* name_; + ::google::protobuf::uint64 nameref_; + } EdgeNameOrRef_; + ::google::protobuf::uint32 _oneof_case_[1]; + + friend void protobuf_AddDesc_CoreDump_2eproto(); + friend void protobuf_AssignDesc_CoreDump_2eproto(); + friend void protobuf_ShutdownFile_CoreDump_2eproto(); + + void InitAsDefaultInstance(); + static Edge* default_instance_; +}; +// =================================================================== + + +// =================================================================== + +// Metadata + +// optional uint64 timeStamp = 1; +inline bool Metadata::has_timestamp() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void Metadata::set_has_timestamp() { + _has_bits_[0] |= 0x00000001u; +} +inline void Metadata::clear_has_timestamp() { + _has_bits_[0] &= ~0x00000001u; +} +inline void Metadata::clear_timestamp() { + timestamp_ = GOOGLE_ULONGLONG(0); + clear_has_timestamp(); +} +inline ::google::protobuf::uint64 Metadata::timestamp() const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Metadata.timeStamp) + return timestamp_; +} +inline void Metadata::set_timestamp(::google::protobuf::uint64 value) { + set_has_timestamp(); + timestamp_ = value; + // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Metadata.timeStamp) +} + +// ------------------------------------------------------------------- + +// StackFrame_Data + +// optional uint64 id = 1; +inline bool StackFrame_Data::has_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void StackFrame_Data::set_has_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void StackFrame_Data::clear_has_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void StackFrame_Data::clear_id() { + id_ = GOOGLE_ULONGLONG(0); + clear_has_id(); +} +inline ::google::protobuf::uint64 StackFrame_Data::id() const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.id) + return id_; +} +inline void StackFrame_Data::set_id(::google::protobuf::uint64 value) { + set_has_id(); + id_ = value; + // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.id) +} + +// optional .mozilla.devtools.protobuf.StackFrame parent = 2; +inline bool StackFrame_Data::has_parent() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void StackFrame_Data::set_has_parent() { + _has_bits_[0] |= 0x00000002u; +} +inline void StackFrame_Data::clear_has_parent() { + _has_bits_[0] &= ~0x00000002u; +} +inline void StackFrame_Data::clear_parent() { + if (parent_ != NULL) parent_->::mozilla::devtools::protobuf::StackFrame::Clear(); + clear_has_parent(); +} +inline const ::mozilla::devtools::protobuf::StackFrame& StackFrame_Data::parent() const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.parent) + return parent_ != NULL ? *parent_ : *default_instance_->parent_; +} +inline ::mozilla::devtools::protobuf::StackFrame* StackFrame_Data::mutable_parent() { + set_has_parent(); + if (parent_ == NULL) parent_ = new ::mozilla::devtools::protobuf::StackFrame; + // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.StackFrame.Data.parent) + return parent_; +} +inline ::mozilla::devtools::protobuf::StackFrame* StackFrame_Data::release_parent() { + clear_has_parent(); + ::mozilla::devtools::protobuf::StackFrame* temp = parent_; + parent_ = NULL; + return temp; +} +inline void StackFrame_Data::set_allocated_parent(::mozilla::devtools::protobuf::StackFrame* parent) { + delete parent_; + parent_ = parent; + if (parent) { + set_has_parent(); + } else { + clear_has_parent(); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.StackFrame.Data.parent) +} + +// optional uint32 line = 3; +inline bool StackFrame_Data::has_line() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void StackFrame_Data::set_has_line() { + _has_bits_[0] |= 0x00000004u; +} +inline void StackFrame_Data::clear_has_line() { + _has_bits_[0] &= ~0x00000004u; +} +inline void StackFrame_Data::clear_line() { + line_ = 0u; + clear_has_line(); +} +inline ::google::protobuf::uint32 StackFrame_Data::line() const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.line) + return line_; +} +inline void StackFrame_Data::set_line(::google::protobuf::uint32 value) { + set_has_line(); + line_ = value; + // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.line) +} + +// optional uint32 column = 4; +inline bool StackFrame_Data::has_column() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void StackFrame_Data::set_has_column() { + _has_bits_[0] |= 0x00000008u; +} +inline void StackFrame_Data::clear_has_column() { + _has_bits_[0] &= ~0x00000008u; +} +inline void StackFrame_Data::clear_column() { + column_ = 0u; + clear_has_column(); +} +inline ::google::protobuf::uint32 StackFrame_Data::column() const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.column) + return column_; +} +inline void StackFrame_Data::set_column(::google::protobuf::uint32 value) { + set_has_column(); + column_ = value; + // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.column) +} + +// optional bytes source = 5; +inline bool StackFrame_Data::has_source() const { + return SourceOrRef_case() == kSource; +} +inline void StackFrame_Data::set_has_source() { + _oneof_case_[0] = kSource; +} +inline void StackFrame_Data::clear_source() { + if (has_source()) { + delete SourceOrRef_.source_; + clear_has_SourceOrRef(); + } +} +inline const ::std::string& StackFrame_Data::source() const { + if (has_source()) { + return *SourceOrRef_.source_; + } + return ::google::protobuf::internal::GetEmptyStringAlreadyInited(); +} +inline void StackFrame_Data::set_source(const ::std::string& value) { + if (!has_source()) { + clear_SourceOrRef(); + set_has_source(); + SourceOrRef_.source_ = new ::std::string; + } + SourceOrRef_.source_->assign(value); +} +inline void StackFrame_Data::set_source(const char* value) { + if (!has_source()) { + clear_SourceOrRef(); + set_has_source(); + SourceOrRef_.source_ = new ::std::string; + } + SourceOrRef_.source_->assign(value); +} +inline void StackFrame_Data::set_source(const void* value, size_t size) { + if (!has_source()) { + clear_SourceOrRef(); + set_has_source(); + SourceOrRef_.source_ = new ::std::string; + } + SourceOrRef_.source_->assign( + reinterpret_cast(value), size); +} +inline ::std::string* StackFrame_Data::mutable_source() { + if (!has_source()) { + clear_SourceOrRef(); + set_has_source(); + SourceOrRef_.source_ = new ::std::string; + } + return SourceOrRef_.source_; +} +inline ::std::string* StackFrame_Data::release_source() { + if (has_source()) { + clear_has_SourceOrRef(); + ::std::string* temp = SourceOrRef_.source_; + SourceOrRef_.source_ = NULL; + return temp; + } else { + return NULL; + } +} +inline void StackFrame_Data::set_allocated_source(::std::string* source) { + clear_SourceOrRef(); + if (source) { + set_has_source(); + SourceOrRef_.source_ = source; + } +} + +// optional uint64 sourceRef = 6; +inline bool StackFrame_Data::has_sourceref() const { + return SourceOrRef_case() == kSourceRef; +} +inline void StackFrame_Data::set_has_sourceref() { + _oneof_case_[0] = kSourceRef; +} +inline void StackFrame_Data::clear_sourceref() { + if (has_sourceref()) { + SourceOrRef_.sourceref_ = GOOGLE_ULONGLONG(0); + clear_has_SourceOrRef(); + } +} +inline ::google::protobuf::uint64 StackFrame_Data::sourceref() const { + if (has_sourceref()) { + return SourceOrRef_.sourceref_; + } + return GOOGLE_ULONGLONG(0); +} +inline void StackFrame_Data::set_sourceref(::google::protobuf::uint64 value) { + if (!has_sourceref()) { + clear_SourceOrRef(); + set_has_sourceref(); + } + SourceOrRef_.sourceref_ = value; +} + +// optional bytes functionDisplayName = 7; +inline bool StackFrame_Data::has_functiondisplayname() const { + return FunctionDisplayNameOrRef_case() == kFunctionDisplayName; +} +inline void StackFrame_Data::set_has_functiondisplayname() { + _oneof_case_[1] = kFunctionDisplayName; +} +inline void StackFrame_Data::clear_functiondisplayname() { + if (has_functiondisplayname()) { + delete FunctionDisplayNameOrRef_.functiondisplayname_; + clear_has_FunctionDisplayNameOrRef(); + } +} +inline const ::std::string& StackFrame_Data::functiondisplayname() const { + if (has_functiondisplayname()) { + return *FunctionDisplayNameOrRef_.functiondisplayname_; + } + return ::google::protobuf::internal::GetEmptyStringAlreadyInited(); +} +inline void StackFrame_Data::set_functiondisplayname(const ::std::string& value) { + if (!has_functiondisplayname()) { + clear_FunctionDisplayNameOrRef(); + set_has_functiondisplayname(); + FunctionDisplayNameOrRef_.functiondisplayname_ = new ::std::string; + } + FunctionDisplayNameOrRef_.functiondisplayname_->assign(value); +} +inline void StackFrame_Data::set_functiondisplayname(const char* value) { + if (!has_functiondisplayname()) { + clear_FunctionDisplayNameOrRef(); + set_has_functiondisplayname(); + FunctionDisplayNameOrRef_.functiondisplayname_ = new ::std::string; + } + FunctionDisplayNameOrRef_.functiondisplayname_->assign(value); +} +inline void StackFrame_Data::set_functiondisplayname(const void* value, size_t size) { + if (!has_functiondisplayname()) { + clear_FunctionDisplayNameOrRef(); + set_has_functiondisplayname(); + FunctionDisplayNameOrRef_.functiondisplayname_ = new ::std::string; + } + FunctionDisplayNameOrRef_.functiondisplayname_->assign( + reinterpret_cast(value), size); +} +inline ::std::string* StackFrame_Data::mutable_functiondisplayname() { + if (!has_functiondisplayname()) { + clear_FunctionDisplayNameOrRef(); + set_has_functiondisplayname(); + FunctionDisplayNameOrRef_.functiondisplayname_ = new ::std::string; + } + return FunctionDisplayNameOrRef_.functiondisplayname_; +} +inline ::std::string* StackFrame_Data::release_functiondisplayname() { + if (has_functiondisplayname()) { + clear_has_FunctionDisplayNameOrRef(); + ::std::string* temp = FunctionDisplayNameOrRef_.functiondisplayname_; + FunctionDisplayNameOrRef_.functiondisplayname_ = NULL; + return temp; + } else { + return NULL; + } +} +inline void StackFrame_Data::set_allocated_functiondisplayname(::std::string* functiondisplayname) { + clear_FunctionDisplayNameOrRef(); + if (functiondisplayname) { + set_has_functiondisplayname(); + FunctionDisplayNameOrRef_.functiondisplayname_ = functiondisplayname; + } +} + +// optional uint64 functionDisplayNameRef = 8; +inline bool StackFrame_Data::has_functiondisplaynameref() const { + return FunctionDisplayNameOrRef_case() == kFunctionDisplayNameRef; +} +inline void StackFrame_Data::set_has_functiondisplaynameref() { + _oneof_case_[1] = kFunctionDisplayNameRef; +} +inline void StackFrame_Data::clear_functiondisplaynameref() { + if (has_functiondisplaynameref()) { + FunctionDisplayNameOrRef_.functiondisplaynameref_ = GOOGLE_ULONGLONG(0); + clear_has_FunctionDisplayNameOrRef(); + } +} +inline ::google::protobuf::uint64 StackFrame_Data::functiondisplaynameref() const { + if (has_functiondisplaynameref()) { + return FunctionDisplayNameOrRef_.functiondisplaynameref_; + } + return GOOGLE_ULONGLONG(0); +} +inline void StackFrame_Data::set_functiondisplaynameref(::google::protobuf::uint64 value) { + if (!has_functiondisplaynameref()) { + clear_FunctionDisplayNameOrRef(); + set_has_functiondisplaynameref(); + } + FunctionDisplayNameOrRef_.functiondisplaynameref_ = value; +} + +// optional bool isSystem = 9; +inline bool StackFrame_Data::has_issystem() const { + return (_has_bits_[0] & 0x00000100u) != 0; +} +inline void StackFrame_Data::set_has_issystem() { + _has_bits_[0] |= 0x00000100u; +} +inline void StackFrame_Data::clear_has_issystem() { + _has_bits_[0] &= ~0x00000100u; +} +inline void StackFrame_Data::clear_issystem() { + issystem_ = false; + clear_has_issystem(); +} +inline bool StackFrame_Data::issystem() const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.isSystem) + return issystem_; +} +inline void StackFrame_Data::set_issystem(bool value) { + set_has_issystem(); + issystem_ = value; + // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.isSystem) +} + +// optional bool isSelfHosted = 10; +inline bool StackFrame_Data::has_isselfhosted() const { + return (_has_bits_[0] & 0x00000200u) != 0; +} +inline void StackFrame_Data::set_has_isselfhosted() { + _has_bits_[0] |= 0x00000200u; +} +inline void StackFrame_Data::clear_has_isselfhosted() { + _has_bits_[0] &= ~0x00000200u; +} +inline void StackFrame_Data::clear_isselfhosted() { + isselfhosted_ = false; + clear_has_isselfhosted(); +} +inline bool StackFrame_Data::isselfhosted() const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.isSelfHosted) + return isselfhosted_; +} +inline void StackFrame_Data::set_isselfhosted(bool value) { + set_has_isselfhosted(); + isselfhosted_ = value; + // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.isSelfHosted) +} + +inline bool StackFrame_Data::has_SourceOrRef() { + return SourceOrRef_case() != SOURCEORREF_NOT_SET; +} +inline void StackFrame_Data::clear_has_SourceOrRef() { + _oneof_case_[0] = SOURCEORREF_NOT_SET; +} +inline bool StackFrame_Data::has_FunctionDisplayNameOrRef() { + return FunctionDisplayNameOrRef_case() != FUNCTIONDISPLAYNAMEORREF_NOT_SET; +} +inline void StackFrame_Data::clear_has_FunctionDisplayNameOrRef() { + _oneof_case_[1] = FUNCTIONDISPLAYNAMEORREF_NOT_SET; +} +inline StackFrame_Data::SourceOrRefCase StackFrame_Data::SourceOrRef_case() const { + return StackFrame_Data::SourceOrRefCase(_oneof_case_[0]); +} +inline StackFrame_Data::FunctionDisplayNameOrRefCase StackFrame_Data::FunctionDisplayNameOrRef_case() const { + return StackFrame_Data::FunctionDisplayNameOrRefCase(_oneof_case_[1]); +} +// ------------------------------------------------------------------- + +// StackFrame + +// optional .mozilla.devtools.protobuf.StackFrame.Data data = 1; +inline bool StackFrame::has_data() const { + return StackFrameType_case() == kData; +} +inline void StackFrame::set_has_data() { + _oneof_case_[0] = kData; +} +inline void StackFrame::clear_data() { + if (has_data()) { + delete StackFrameType_.data_; + clear_has_StackFrameType(); + } +} +inline const ::mozilla::devtools::protobuf::StackFrame_Data& StackFrame::data() const { + return has_data() ? *StackFrameType_.data_ + : ::mozilla::devtools::protobuf::StackFrame_Data::default_instance(); +} +inline ::mozilla::devtools::protobuf::StackFrame_Data* StackFrame::mutable_data() { + if (!has_data()) { + clear_StackFrameType(); + set_has_data(); + StackFrameType_.data_ = new ::mozilla::devtools::protobuf::StackFrame_Data; + } + return StackFrameType_.data_; +} +inline ::mozilla::devtools::protobuf::StackFrame_Data* StackFrame::release_data() { + if (has_data()) { + clear_has_StackFrameType(); + ::mozilla::devtools::protobuf::StackFrame_Data* temp = StackFrameType_.data_; + StackFrameType_.data_ = NULL; + return temp; + } else { + return NULL; + } +} +inline void StackFrame::set_allocated_data(::mozilla::devtools::protobuf::StackFrame_Data* data) { + clear_StackFrameType(); + if (data) { + set_has_data(); + StackFrameType_.data_ = data; + } +} + +// optional uint64 ref = 2; +inline bool StackFrame::has_ref() const { + return StackFrameType_case() == kRef; +} +inline void StackFrame::set_has_ref() { + _oneof_case_[0] = kRef; +} +inline void StackFrame::clear_ref() { + if (has_ref()) { + StackFrameType_.ref_ = GOOGLE_ULONGLONG(0); + clear_has_StackFrameType(); + } +} +inline ::google::protobuf::uint64 StackFrame::ref() const { + if (has_ref()) { + return StackFrameType_.ref_; + } + return GOOGLE_ULONGLONG(0); +} +inline void StackFrame::set_ref(::google::protobuf::uint64 value) { + if (!has_ref()) { + clear_StackFrameType(); + set_has_ref(); + } + StackFrameType_.ref_ = value; +} + +inline bool StackFrame::has_StackFrameType() { + return StackFrameType_case() != STACKFRAMETYPE_NOT_SET; +} +inline void StackFrame::clear_has_StackFrameType() { + _oneof_case_[0] = STACKFRAMETYPE_NOT_SET; +} +inline StackFrame::StackFrameTypeCase StackFrame::StackFrameType_case() const { + return StackFrame::StackFrameTypeCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// Node + +// optional uint64 id = 1; +inline bool Node::has_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void Node::set_has_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void Node::clear_has_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void Node::clear_id() { + id_ = GOOGLE_ULONGLONG(0); + clear_has_id(); +} +inline ::google::protobuf::uint64 Node::id() const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.id) + return id_; +} +inline void Node::set_id(::google::protobuf::uint64 value) { + set_has_id(); + id_ = value; + // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.id) +} + +// optional bytes typeName = 2; +inline bool Node::has_typename_() const { + return TypeNameOrRef_case() == kTypeName; +} +inline void Node::set_has_typename_() { + _oneof_case_[0] = kTypeName; +} +inline void Node::clear_typename_() { + if (has_typename_()) { + delete TypeNameOrRef_.typename__; + clear_has_TypeNameOrRef(); + } +} +inline const ::std::string& Node::typename_() const { + if (has_typename_()) { + return *TypeNameOrRef_.typename__; + } + return ::google::protobuf::internal::GetEmptyStringAlreadyInited(); +} +inline void Node::set_typename_(const ::std::string& value) { + if (!has_typename_()) { + clear_TypeNameOrRef(); + set_has_typename_(); + TypeNameOrRef_.typename__ = new ::std::string; + } + TypeNameOrRef_.typename__->assign(value); +} +inline void Node::set_typename_(const char* value) { + if (!has_typename_()) { + clear_TypeNameOrRef(); + set_has_typename_(); + TypeNameOrRef_.typename__ = new ::std::string; + } + TypeNameOrRef_.typename__->assign(value); +} +inline void Node::set_typename_(const void* value, size_t size) { + if (!has_typename_()) { + clear_TypeNameOrRef(); + set_has_typename_(); + TypeNameOrRef_.typename__ = new ::std::string; + } + TypeNameOrRef_.typename__->assign( + reinterpret_cast(value), size); +} +inline ::std::string* Node::mutable_typename_() { + if (!has_typename_()) { + clear_TypeNameOrRef(); + set_has_typename_(); + TypeNameOrRef_.typename__ = new ::std::string; + } + return TypeNameOrRef_.typename__; +} +inline ::std::string* Node::release_typename_() { + if (has_typename_()) { + clear_has_TypeNameOrRef(); + ::std::string* temp = TypeNameOrRef_.typename__; + TypeNameOrRef_.typename__ = NULL; + return temp; + } else { + return NULL; + } +} +inline void Node::set_allocated_typename_(::std::string* typename_) { + clear_TypeNameOrRef(); + if (typename_) { + set_has_typename_(); + TypeNameOrRef_.typename__ = typename_; + } +} + +// optional uint64 typeNameRef = 3; +inline bool Node::has_typenameref() const { + return TypeNameOrRef_case() == kTypeNameRef; +} +inline void Node::set_has_typenameref() { + _oneof_case_[0] = kTypeNameRef; +} +inline void Node::clear_typenameref() { + if (has_typenameref()) { + TypeNameOrRef_.typenameref_ = GOOGLE_ULONGLONG(0); + clear_has_TypeNameOrRef(); + } +} +inline ::google::protobuf::uint64 Node::typenameref() const { + if (has_typenameref()) { + return TypeNameOrRef_.typenameref_; + } + return GOOGLE_ULONGLONG(0); +} +inline void Node::set_typenameref(::google::protobuf::uint64 value) { + if (!has_typenameref()) { + clear_TypeNameOrRef(); + set_has_typenameref(); + } + TypeNameOrRef_.typenameref_ = value; +} + +// optional uint64 size = 4; +inline bool Node::has_size() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void Node::set_has_size() { + _has_bits_[0] |= 0x00000008u; +} +inline void Node::clear_has_size() { + _has_bits_[0] &= ~0x00000008u; +} +inline void Node::clear_size() { + size_ = GOOGLE_ULONGLONG(0); + clear_has_size(); +} +inline ::google::protobuf::uint64 Node::size() const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.size) + return size_; +} +inline void Node::set_size(::google::protobuf::uint64 value) { + set_has_size(); + size_ = value; + // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.size) +} + +// repeated .mozilla.devtools.protobuf.Edge edges = 5; +inline int Node::edges_size() const { + return edges_.size(); +} +inline void Node::clear_edges() { + edges_.Clear(); +} +inline const ::mozilla::devtools::protobuf::Edge& Node::edges(int index) const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.edges) + return edges_.Get(index); +} +inline ::mozilla::devtools::protobuf::Edge* Node::mutable_edges(int index) { + // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.Node.edges) + return edges_.Mutable(index); +} +inline ::mozilla::devtools::protobuf::Edge* Node::add_edges() { + // @@protoc_insertion_point(field_add:mozilla.devtools.protobuf.Node.edges) + return edges_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::mozilla::devtools::protobuf::Edge >& +Node::edges() const { + // @@protoc_insertion_point(field_list:mozilla.devtools.protobuf.Node.edges) + return edges_; +} +inline ::google::protobuf::RepeatedPtrField< ::mozilla::devtools::protobuf::Edge >* +Node::mutable_edges() { + // @@protoc_insertion_point(field_mutable_list:mozilla.devtools.protobuf.Node.edges) + return &edges_; +} + +// optional .mozilla.devtools.protobuf.StackFrame allocationStack = 6; +inline bool Node::has_allocationstack() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void Node::set_has_allocationstack() { + _has_bits_[0] |= 0x00000020u; +} +inline void Node::clear_has_allocationstack() { + _has_bits_[0] &= ~0x00000020u; +} +inline void Node::clear_allocationstack() { + if (allocationstack_ != NULL) allocationstack_->::mozilla::devtools::protobuf::StackFrame::Clear(); + clear_has_allocationstack(); +} +inline const ::mozilla::devtools::protobuf::StackFrame& Node::allocationstack() const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.allocationStack) + return allocationstack_ != NULL ? *allocationstack_ : *default_instance_->allocationstack_; +} +inline ::mozilla::devtools::protobuf::StackFrame* Node::mutable_allocationstack() { + set_has_allocationstack(); + if (allocationstack_ == NULL) allocationstack_ = new ::mozilla::devtools::protobuf::StackFrame; + // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.Node.allocationStack) + return allocationstack_; +} +inline ::mozilla::devtools::protobuf::StackFrame* Node::release_allocationstack() { + clear_has_allocationstack(); + ::mozilla::devtools::protobuf::StackFrame* temp = allocationstack_; + allocationstack_ = NULL; + return temp; +} +inline void Node::set_allocated_allocationstack(::mozilla::devtools::protobuf::StackFrame* allocationstack) { + delete allocationstack_; + allocationstack_ = allocationstack; + if (allocationstack) { + set_has_allocationstack(); + } else { + clear_has_allocationstack(); + } + // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.Node.allocationStack) +} + +// optional bytes jsObjectClassName = 7; +inline bool Node::has_jsobjectclassname() const { + return JSObjectClassNameOrRef_case() == kJsObjectClassName; +} +inline void Node::set_has_jsobjectclassname() { + _oneof_case_[1] = kJsObjectClassName; +} +inline void Node::clear_jsobjectclassname() { + if (has_jsobjectclassname()) { + delete JSObjectClassNameOrRef_.jsobjectclassname_; + clear_has_JSObjectClassNameOrRef(); + } +} +inline const ::std::string& Node::jsobjectclassname() const { + if (has_jsobjectclassname()) { + return *JSObjectClassNameOrRef_.jsobjectclassname_; + } + return ::google::protobuf::internal::GetEmptyStringAlreadyInited(); +} +inline void Node::set_jsobjectclassname(const ::std::string& value) { + if (!has_jsobjectclassname()) { + clear_JSObjectClassNameOrRef(); + set_has_jsobjectclassname(); + JSObjectClassNameOrRef_.jsobjectclassname_ = new ::std::string; + } + JSObjectClassNameOrRef_.jsobjectclassname_->assign(value); +} +inline void Node::set_jsobjectclassname(const char* value) { + if (!has_jsobjectclassname()) { + clear_JSObjectClassNameOrRef(); + set_has_jsobjectclassname(); + JSObjectClassNameOrRef_.jsobjectclassname_ = new ::std::string; + } + JSObjectClassNameOrRef_.jsobjectclassname_->assign(value); +} +inline void Node::set_jsobjectclassname(const void* value, size_t size) { + if (!has_jsobjectclassname()) { + clear_JSObjectClassNameOrRef(); + set_has_jsobjectclassname(); + JSObjectClassNameOrRef_.jsobjectclassname_ = new ::std::string; + } + JSObjectClassNameOrRef_.jsobjectclassname_->assign( + reinterpret_cast(value), size); +} +inline ::std::string* Node::mutable_jsobjectclassname() { + if (!has_jsobjectclassname()) { + clear_JSObjectClassNameOrRef(); + set_has_jsobjectclassname(); + JSObjectClassNameOrRef_.jsobjectclassname_ = new ::std::string; + } + return JSObjectClassNameOrRef_.jsobjectclassname_; +} +inline ::std::string* Node::release_jsobjectclassname() { + if (has_jsobjectclassname()) { + clear_has_JSObjectClassNameOrRef(); + ::std::string* temp = JSObjectClassNameOrRef_.jsobjectclassname_; + JSObjectClassNameOrRef_.jsobjectclassname_ = NULL; + return temp; + } else { + return NULL; + } +} +inline void Node::set_allocated_jsobjectclassname(::std::string* jsobjectclassname) { + clear_JSObjectClassNameOrRef(); + if (jsobjectclassname) { + set_has_jsobjectclassname(); + JSObjectClassNameOrRef_.jsobjectclassname_ = jsobjectclassname; + } +} + +// optional uint64 jsObjectClassNameRef = 8; +inline bool Node::has_jsobjectclassnameref() const { + return JSObjectClassNameOrRef_case() == kJsObjectClassNameRef; +} +inline void Node::set_has_jsobjectclassnameref() { + _oneof_case_[1] = kJsObjectClassNameRef; +} +inline void Node::clear_jsobjectclassnameref() { + if (has_jsobjectclassnameref()) { + JSObjectClassNameOrRef_.jsobjectclassnameref_ = GOOGLE_ULONGLONG(0); + clear_has_JSObjectClassNameOrRef(); + } +} +inline ::google::protobuf::uint64 Node::jsobjectclassnameref() const { + if (has_jsobjectclassnameref()) { + return JSObjectClassNameOrRef_.jsobjectclassnameref_; + } + return GOOGLE_ULONGLONG(0); +} +inline void Node::set_jsobjectclassnameref(::google::protobuf::uint64 value) { + if (!has_jsobjectclassnameref()) { + clear_JSObjectClassNameOrRef(); + set_has_jsobjectclassnameref(); + } + JSObjectClassNameOrRef_.jsobjectclassnameref_ = value; +} + +// optional uint32 coarseType = 9 [default = 0]; +inline bool Node::has_coarsetype() const { + return (_has_bits_[0] & 0x00000100u) != 0; +} +inline void Node::set_has_coarsetype() { + _has_bits_[0] |= 0x00000100u; +} +inline void Node::clear_has_coarsetype() { + _has_bits_[0] &= ~0x00000100u; +} +inline void Node::clear_coarsetype() { + coarsetype_ = 0u; + clear_has_coarsetype(); +} +inline ::google::protobuf::uint32 Node::coarsetype() const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.coarseType) + return coarsetype_; +} +inline void Node::set_coarsetype(::google::protobuf::uint32 value) { + set_has_coarsetype(); + coarsetype_ = value; + // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Node.coarseType) +} + +// optional bytes scriptFilename = 10; +inline bool Node::has_scriptfilename() const { + return ScriptFilenameOrRef_case() == kScriptFilename; +} +inline void Node::set_has_scriptfilename() { + _oneof_case_[2] = kScriptFilename; +} +inline void Node::clear_scriptfilename() { + if (has_scriptfilename()) { + delete ScriptFilenameOrRef_.scriptfilename_; + clear_has_ScriptFilenameOrRef(); + } +} +inline const ::std::string& Node::scriptfilename() const { + if (has_scriptfilename()) { + return *ScriptFilenameOrRef_.scriptfilename_; + } + return ::google::protobuf::internal::GetEmptyStringAlreadyInited(); +} +inline void Node::set_scriptfilename(const ::std::string& value) { + if (!has_scriptfilename()) { + clear_ScriptFilenameOrRef(); + set_has_scriptfilename(); + ScriptFilenameOrRef_.scriptfilename_ = new ::std::string; + } + ScriptFilenameOrRef_.scriptfilename_->assign(value); +} +inline void Node::set_scriptfilename(const char* value) { + if (!has_scriptfilename()) { + clear_ScriptFilenameOrRef(); + set_has_scriptfilename(); + ScriptFilenameOrRef_.scriptfilename_ = new ::std::string; + } + ScriptFilenameOrRef_.scriptfilename_->assign(value); +} +inline void Node::set_scriptfilename(const void* value, size_t size) { + if (!has_scriptfilename()) { + clear_ScriptFilenameOrRef(); + set_has_scriptfilename(); + ScriptFilenameOrRef_.scriptfilename_ = new ::std::string; + } + ScriptFilenameOrRef_.scriptfilename_->assign( + reinterpret_cast(value), size); +} +inline ::std::string* Node::mutable_scriptfilename() { + if (!has_scriptfilename()) { + clear_ScriptFilenameOrRef(); + set_has_scriptfilename(); + ScriptFilenameOrRef_.scriptfilename_ = new ::std::string; + } + return ScriptFilenameOrRef_.scriptfilename_; +} +inline ::std::string* Node::release_scriptfilename() { + if (has_scriptfilename()) { + clear_has_ScriptFilenameOrRef(); + ::std::string* temp = ScriptFilenameOrRef_.scriptfilename_; + ScriptFilenameOrRef_.scriptfilename_ = NULL; + return temp; + } else { + return NULL; + } +} +inline void Node::set_allocated_scriptfilename(::std::string* scriptfilename) { + clear_ScriptFilenameOrRef(); + if (scriptfilename) { + set_has_scriptfilename(); + ScriptFilenameOrRef_.scriptfilename_ = scriptfilename; + } +} + +// optional uint64 scriptFilenameRef = 11; +inline bool Node::has_scriptfilenameref() const { + return ScriptFilenameOrRef_case() == kScriptFilenameRef; +} +inline void Node::set_has_scriptfilenameref() { + _oneof_case_[2] = kScriptFilenameRef; +} +inline void Node::clear_scriptfilenameref() { + if (has_scriptfilenameref()) { + ScriptFilenameOrRef_.scriptfilenameref_ = GOOGLE_ULONGLONG(0); + clear_has_ScriptFilenameOrRef(); + } +} +inline ::google::protobuf::uint64 Node::scriptfilenameref() const { + if (has_scriptfilenameref()) { + return ScriptFilenameOrRef_.scriptfilenameref_; + } + return GOOGLE_ULONGLONG(0); +} +inline void Node::set_scriptfilenameref(::google::protobuf::uint64 value) { + if (!has_scriptfilenameref()) { + clear_ScriptFilenameOrRef(); + set_has_scriptfilenameref(); + } + ScriptFilenameOrRef_.scriptfilenameref_ = value; +} + +inline bool Node::has_TypeNameOrRef() { + return TypeNameOrRef_case() != TYPENAMEORREF_NOT_SET; +} +inline void Node::clear_has_TypeNameOrRef() { + _oneof_case_[0] = TYPENAMEORREF_NOT_SET; +} +inline bool Node::has_JSObjectClassNameOrRef() { + return JSObjectClassNameOrRef_case() != JSOBJECTCLASSNAMEORREF_NOT_SET; +} +inline void Node::clear_has_JSObjectClassNameOrRef() { + _oneof_case_[1] = JSOBJECTCLASSNAMEORREF_NOT_SET; +} +inline bool Node::has_ScriptFilenameOrRef() { + return ScriptFilenameOrRef_case() != SCRIPTFILENAMEORREF_NOT_SET; +} +inline void Node::clear_has_ScriptFilenameOrRef() { + _oneof_case_[2] = SCRIPTFILENAMEORREF_NOT_SET; +} +inline Node::TypeNameOrRefCase Node::TypeNameOrRef_case() const { + return Node::TypeNameOrRefCase(_oneof_case_[0]); +} +inline Node::JSObjectClassNameOrRefCase Node::JSObjectClassNameOrRef_case() const { + return Node::JSObjectClassNameOrRefCase(_oneof_case_[1]); +} +inline Node::ScriptFilenameOrRefCase Node::ScriptFilenameOrRef_case() const { + return Node::ScriptFilenameOrRefCase(_oneof_case_[2]); +} +// ------------------------------------------------------------------- + +// Edge + +// optional uint64 referent = 1; +inline bool Edge::has_referent() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void Edge::set_has_referent() { + _has_bits_[0] |= 0x00000001u; +} +inline void Edge::clear_has_referent() { + _has_bits_[0] &= ~0x00000001u; +} +inline void Edge::clear_referent() { + referent_ = GOOGLE_ULONGLONG(0); + clear_has_referent(); +} +inline ::google::protobuf::uint64 Edge::referent() const { + // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Edge.referent) + return referent_; +} +inline void Edge::set_referent(::google::protobuf::uint64 value) { + set_has_referent(); + referent_ = value; + // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Edge.referent) +} + +// optional bytes name = 2; +inline bool Edge::has_name() const { + return EdgeNameOrRef_case() == kName; +} +inline void Edge::set_has_name() { + _oneof_case_[0] = kName; +} +inline void Edge::clear_name() { + if (has_name()) { + delete EdgeNameOrRef_.name_; + clear_has_EdgeNameOrRef(); + } +} +inline const ::std::string& Edge::name() const { + if (has_name()) { + return *EdgeNameOrRef_.name_; + } + return ::google::protobuf::internal::GetEmptyStringAlreadyInited(); +} +inline void Edge::set_name(const ::std::string& value) { + if (!has_name()) { + clear_EdgeNameOrRef(); + set_has_name(); + EdgeNameOrRef_.name_ = new ::std::string; + } + EdgeNameOrRef_.name_->assign(value); +} +inline void Edge::set_name(const char* value) { + if (!has_name()) { + clear_EdgeNameOrRef(); + set_has_name(); + EdgeNameOrRef_.name_ = new ::std::string; + } + EdgeNameOrRef_.name_->assign(value); +} +inline void Edge::set_name(const void* value, size_t size) { + if (!has_name()) { + clear_EdgeNameOrRef(); + set_has_name(); + EdgeNameOrRef_.name_ = new ::std::string; + } + EdgeNameOrRef_.name_->assign( + reinterpret_cast(value), size); +} +inline ::std::string* Edge::mutable_name() { + if (!has_name()) { + clear_EdgeNameOrRef(); + set_has_name(); + EdgeNameOrRef_.name_ = new ::std::string; + } + return EdgeNameOrRef_.name_; +} +inline ::std::string* Edge::release_name() { + if (has_name()) { + clear_has_EdgeNameOrRef(); + ::std::string* temp = EdgeNameOrRef_.name_; + EdgeNameOrRef_.name_ = NULL; + return temp; + } else { + return NULL; + } +} +inline void Edge::set_allocated_name(::std::string* name) { + clear_EdgeNameOrRef(); + if (name) { + set_has_name(); + EdgeNameOrRef_.name_ = name; + } +} + +// optional uint64 nameRef = 3; +inline bool Edge::has_nameref() const { + return EdgeNameOrRef_case() == kNameRef; +} +inline void Edge::set_has_nameref() { + _oneof_case_[0] = kNameRef; +} +inline void Edge::clear_nameref() { + if (has_nameref()) { + EdgeNameOrRef_.nameref_ = GOOGLE_ULONGLONG(0); + clear_has_EdgeNameOrRef(); + } +} +inline ::google::protobuf::uint64 Edge::nameref() const { + if (has_nameref()) { + return EdgeNameOrRef_.nameref_; + } + return GOOGLE_ULONGLONG(0); +} +inline void Edge::set_nameref(::google::protobuf::uint64 value) { + if (!has_nameref()) { + clear_EdgeNameOrRef(); + set_has_nameref(); + } + EdgeNameOrRef_.nameref_ = value; +} + +inline bool Edge::has_EdgeNameOrRef() { + return EdgeNameOrRef_case() != EDGENAMEORREF_NOT_SET; +} +inline void Edge::clear_has_EdgeNameOrRef() { + _oneof_case_[0] = EDGENAMEORREF_NOT_SET; +} +inline Edge::EdgeNameOrRefCase Edge::EdgeNameOrRef_case() const { + return Edge::EdgeNameOrRefCase(_oneof_case_[0]); +} + +// @@protoc_insertion_point(namespace_scope) + +} // namespace protobuf +} // namespace devtools +} // namespace mozilla + +#ifndef SWIG +namespace google { +namespace protobuf { + + +} // namespace google +} // namespace protobuf +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_CoreDump_2eproto__INCLUDED -- cgit v1.2.3