Quelle CoreDump.pb.h Sprache: C

// 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]);
}
--> --------------------

--> maximum size reached

--> --------------------

quality100%

¤ Dauer der Verarbeitung: 0.44 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.