SSL CoreDump.pb.cc Sprache: C

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: CoreDump.proto

#include "CoreDump.pb.h"

#include <algorithm>

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>

PROTOBUF_PRAGMA_INIT_SEG

namespace _pb = ::PROTOBUF_NAMESPACE_ID;
namespace _pbi = _pb::internal;

namespace mozilla {
namespace devtools {
namespace protobuf {
PROTOBUF_CONSTEXPR Metadata::Metadata(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.timestamp_)*/uint64_t{0u}} {}
struct MetadataDefaultTypeInternal {
  PROTOBUF_CONSTEXPR MetadataDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~MetadataDefaultTypeInternal() {}
  union {
    Metadata _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MetadataDefaultTypeInternal _Metadata_default_instance_;
PROTOBUF_CONSTEXPR StackFrame_Data::StackFrame_Data(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.parent_)*/nullptr
  , /*decltype(_impl_.id_)*/uint64_t{0u}
  , /*decltype(_impl_.line_)*/0u
  , /*decltype(_impl_.column_)*/0u
  , /*decltype(_impl_.issystem_)*/false
  , /*decltype(_impl_.isselfhosted_)*/false
  , /*decltype(_impl_.SourceOrRef_)*/{}
  , /*decltype(_impl_.FunctionDisplayNameOrRef_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct StackFrame_DataDefaultTypeInternal {
  PROTOBUF_CONSTEXPR StackFrame_DataDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~StackFrame_DataDefaultTypeInternal() {}
  union {
    StackFrame_Data _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StackFrame_DataDefaultTypeInternal _StackFrame_Data_default_instance_;
PROTOBUF_CONSTEXPR StackFrame::StackFrame(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.StackFrameType_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct StackFrameDefaultTypeInternal {
  PROTOBUF_CONSTEXPR StackFrameDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~StackFrameDefaultTypeInternal() {}
  union {
    StackFrame _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StackFrameDefaultTypeInternal _StackFrame_default_instance_;
PROTOBUF_CONSTEXPR Node::Node(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.edges_)*/{}
  , /*decltype(_impl_.allocationstack_)*/nullptr
  , /*decltype(_impl_.id_)*/uint64_t{0u}
  , /*decltype(_impl_.size_)*/uint64_t{0u}
  , /*decltype(_impl_.coarsetype_)*/0u
  , /*decltype(_impl_.TypeNameOrRef_)*/{}
  , /*decltype(_impl_.JSObjectClassNameOrRef_)*/{}
  , /*decltype(_impl_.ScriptFilenameOrRef_)*/{}
  , /*decltype(_impl_.descriptiveTypeNameOrRef_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct NodeDefaultTypeInternal {
  PROTOBUF_CONSTEXPR NodeDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~NodeDefaultTypeInternal() {}
  union {
    Node _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 NodeDefaultTypeInternal _Node_default_instance_;
PROTOBUF_CONSTEXPR Edge::Edge(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.referent_)*/uint64_t{0u}
  , /*decltype(_impl_.EdgeNameOrRef_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct EdgeDefaultTypeInternal {
  PROTOBUF_CONSTEXPR EdgeDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~EdgeDefaultTypeInternal() {}
  union {
    Edge _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EdgeDefaultTypeInternal _Edge_default_instance_;
}  // namespace protobuf
}  // namespace devtools
}  // namespace mozilla
namespace mozilla {
namespace devtools {
namespace protobuf {

// ===================================================================

class Metadata::_Internal {
public:
  using HasBits = decltype(std::declval<Metadata>()._impl_._has_bits_);
  static void set_has_timestamp(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

Metadata::Metadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:mozilla.devtools.protobuf.Metadata)
}
Metadata::Metadata(const Metadata& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  Metadata* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.timestamp_){}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _this->_impl_.timestamp_ = from._impl_.timestamp_;
  // @@protoc_insertion_point(copy_constructor:mozilla.devtools.protobuf.Metadata)
}

inline void Metadata::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.timestamp_){uint64_t{0u}}
  };
}

Metadata::~Metadata() {
  // @@protoc_insertion_point(destructor:mozilla.devtools.protobuf.Metadata)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void Metadata::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void Metadata::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void Metadata::Clear() {
// @@protoc_insertion_point(message_clear_start:mozilla.devtools.protobuf.Metadata)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.timestamp_ = uint64_t{0u};
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* Metadata::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional uint64 timeStamp = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          _Internal::set_has_timestamp(&has_bits);
          _impl_.timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* Metadata::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:mozilla.devtools.protobuf.Metadata)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  // optional uint64 timeStamp = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_timestamp(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:mozilla.devtools.protobuf.Metadata)
  return target;
}

size_t Metadata::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mozilla.devtools.protobuf.Metadata)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional uint64 timeStamp = 1;
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_timestamp());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Metadata::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const Metadata*>(
      &from));
}

void Metadata::MergeFrom(const Metadata& from) {
  Metadata* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:mozilla.devtools.protobuf.Metadata)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_timestamp()) {
    _this->_internal_set_timestamp(from._internal_timestamp());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void Metadata::CopyFrom(const Metadata& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mozilla.devtools.protobuf.Metadata)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Metadata::IsInitialized() const {
  return true;
}

void Metadata::InternalSwap(Metadata* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  swap(_impl_.timestamp_, other->_impl_.timestamp_);
}

std::string Metadata::GetTypeName() const {
  return "mozilla.devtools.protobuf.Metadata";
}

// ===================================================================

class StackFrame_Data::_Internal {
public:
  using HasBits = decltype(std::declval<StackFrame_Data>()._impl_._has_bits_);
  static void set_has_id(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static const ::mozilla::devtools::protobuf::StackFrame& parent(const StackFrame_Data* msg);
  static void set_has_parent(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_line(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_column(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_issystem(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_isselfhosted(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
};

const ::mozilla::devtools::protobuf::StackFrame&
StackFrame_Data::_Internal::parent(const StackFrame_Data* msg) {
  return *msg->_impl_.parent_;
}
StackFrame_Data::StackFrame_Data(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:mozilla.devtools.protobuf.StackFrame.Data)
}
StackFrame_Data::StackFrame_Data(const StackFrame_Data& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  StackFrame_Data* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.parent_){nullptr}
    , decltype(_impl_.id_){}
    , decltype(_impl_.line_){}
    , decltype(_impl_.column_){}
    , decltype(_impl_.issystem_){}
    , decltype(_impl_.isselfhosted_){}
    , decltype(_impl_.SourceOrRef_){}
    , decltype(_impl_.FunctionDisplayNameOrRef_){}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if (from._internal_has_parent()) {
    _this->_impl_.parent_ = new ::mozilla::devtools::protobuf::StackFrame(*from._impl_.parent_);
  }
  ::memcpy(&_impl_.id_, &from._impl_.id_,
    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.isselfhosted_) -
    reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.isselfhosted_));
  clear_has_SourceOrRef();
  switch (from.SourceOrRef_case()) {
    case kSource: {
      _this->_internal_set_source(from._internal_source());
      break;
    }
    case kSourceRef: {
      _this->_internal_set_sourceref(from._internal_sourceref());
      break;
    }
    case SOURCEORREF_NOT_SET: {
      break;
    }
  }
  clear_has_FunctionDisplayNameOrRef();
  switch (from.FunctionDisplayNameOrRef_case()) {
    case kFunctionDisplayName: {
      _this->_internal_set_functiondisplayname(from._internal_functiondisplayname());
      break;
    }
    case kFunctionDisplayNameRef: {
      _this->_internal_set_functiondisplaynameref(from._internal_functiondisplaynameref());
      break;
    }
    case FUNCTIONDISPLAYNAMEORREF_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:mozilla.devtools.protobuf.StackFrame.Data)
}

inline void StackFrame_Data::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.parent_){nullptr}
    , decltype(_impl_.id_){uint64_t{0u}}
    , decltype(_impl_.line_){0u}
    , decltype(_impl_.column_){0u}
    , decltype(_impl_.issystem_){false}
    , decltype(_impl_.isselfhosted_){false}
    , decltype(_impl_.SourceOrRef_){}
    , decltype(_impl_.FunctionDisplayNameOrRef_){}
    , /*decltype(_impl_._oneof_case_)*/{}
  };
  clear_has_SourceOrRef();
  clear_has_FunctionDisplayNameOrRef();
}

StackFrame_Data::~StackFrame_Data() {
  // @@protoc_insertion_point(destructor:mozilla.devtools.protobuf.StackFrame.Data)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void StackFrame_Data::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.parent_;
  if (has_SourceOrRef()) {
    clear_SourceOrRef();
  }
  if (has_FunctionDisplayNameOrRef()) {
    clear_FunctionDisplayNameOrRef();
  }
}

void StackFrame_Data::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void StackFrame_Data::clear_SourceOrRef() {
// @@protoc_insertion_point(one_of_clear_start:mozilla.devtools.protobuf.StackFrame.Data)
  switch (SourceOrRef_case()) {
    case kSource: {
      _impl_.SourceOrRef_.source_.Destroy();
      break;
    }
    case kSourceRef: {
      // No need to clear
      break;
    }
    case SOURCEORREF_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = SOURCEORREF_NOT_SET;
}

void StackFrame_Data::clear_FunctionDisplayNameOrRef() {
// @@protoc_insertion_point(one_of_clear_start:mozilla.devtools.protobuf.StackFrame.Data)
  switch (FunctionDisplayNameOrRef_case()) {
    case kFunctionDisplayName: {
      _impl_.FunctionDisplayNameOrRef_.functiondisplayname_.Destroy();
      break;
    }
    case kFunctionDisplayNameRef: {
      // No need to clear
      break;
    }
    case FUNCTIONDISPLAYNAMEORREF_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[1] = FUNCTIONDISPLAYNAMEORREF_NOT_SET;
}

void StackFrame_Data::Clear() {
// @@protoc_insertion_point(message_clear_start:mozilla.devtools.protobuf.StackFrame.Data)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(_impl_.parent_ != nullptr);
    _impl_.parent_->Clear();
  }
  if (cached_has_bits & 0x0000003eu) {
    ::memset(&_impl_.id_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&_impl_.isselfhosted_) -
        reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.isselfhosted_));
  }
  clear_SourceOrRef();
  clear_FunctionDisplayNameOrRef();
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* StackFrame_Data::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional uint64 id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          _Internal::set_has_id(&has_bits);
          _impl_.id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional .mozilla.devtools.protobuf.StackFrame parent = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_parent(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional uint32 line = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
          _Internal::set_has_line(&has_bits);
          _impl_.line_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional uint32 column = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
          _Internal::set_has_column(&has_bits);
          _impl_.column_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // bytes source = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
          auto str = _internal_mutable_source();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // uint64 sourceRef = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
          _internal_set_sourceref(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // bytes functionDisplayName = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
          auto str = _internal_mutable_functiondisplayname();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // uint64 functionDisplayNameRef = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 64)) {
          _internal_set_functiondisplaynameref(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool isSystem = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 72)) {
          _Internal::set_has_issystem(&has_bits);
          _impl_.issystem_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool isSelfHosted = 10;
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 80)) {
          _Internal::set_has_isselfhosted(&has_bits);
          _impl_.isselfhosted_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* StackFrame_Data::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:mozilla.devtools.protobuf.StackFrame.Data)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  // optional uint64 id = 1;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_id(), target);
  }

  // optional .mozilla.devtools.protobuf.StackFrame parent = 2;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, _Internal::parent(this),
        _Internal::parent(this).GetCachedSize(), target, stream);
  }

  // optional uint32 line = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_line(), target);
  }

  // optional uint32 column = 4;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_column(), target);
  }

  switch (SourceOrRef_case()) {
    case kSource: {
      target = stream->WriteBytesMaybeAliased(
          5, this->_internal_source(), target);
      break;
    }
    case kSourceRef: {
      target = stream->EnsureSpace(target);
      target = ::_pbi::WireFormatLite::WriteUInt64ToArray(6, this->_internal_sourceref(), target);
      break;
    }
    default: ;
  }
  switch (FunctionDisplayNameOrRef_case()) {
    case kFunctionDisplayName: {
      target = stream->WriteBytesMaybeAliased(
          7, this->_internal_functiondisplayname(), target);
      break;
    }
    case kFunctionDisplayNameRef: {
      target = stream->EnsureSpace(target);
      target = ::_pbi::WireFormatLite::WriteUInt64ToArray(8, this->_internal_functiondisplaynameref(), target);
      break;
    }
    default: ;
  }
  // optional bool isSystem = 9;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(9, this->_internal_issystem(), target);
  }

  // optional bool isSelfHosted = 10;
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(10, this->_internal_isselfhosted(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:mozilla.devtools.protobuf.StackFrame.Data)
  return target;
}

size_t StackFrame_Data::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mozilla.devtools.protobuf.StackFrame.Data)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x0000003fu) {
    // optional .mozilla.devtools.protobuf.StackFrame parent = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.parent_);
    }

    // optional uint64 id = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_id());
    }

    // optional uint32 line = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_line());
    }

    // optional uint32 column = 4;
    if (cached_has_bits & 0x00000008u) {
      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_column());
    }

    // optional bool isSystem = 9;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 + 1;
    }

    // optional bool isSelfHosted = 10;
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 + 1;
    }

  }
  switch (SourceOrRef_case()) {
    // bytes source = 5;
    case kSource: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_source());
      break;
    }
    // uint64 sourceRef = 6;
    case kSourceRef: {
      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_sourceref());
      break;
    }
    case SOURCEORREF_NOT_SET: {
      break;
    }
  }
  switch (FunctionDisplayNameOrRef_case()) {
    // bytes functionDisplayName = 7;
    case kFunctionDisplayName: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_functiondisplayname());
      break;
    }
    // uint64 functionDisplayNameRef = 8;
    case kFunctionDisplayNameRef: {
      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_functiondisplaynameref());
      break;
    }
    case FUNCTIONDISPLAYNAMEORREF_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void StackFrame_Data::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const StackFrame_Data*>(
      &from));
}

void StackFrame_Data::MergeFrom(const StackFrame_Data& from) {
  StackFrame_Data* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:mozilla.devtools.protobuf.StackFrame.Data)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x0000003fu) {
    if (cached_has_bits & 0x00000001u) {
      _this->_internal_mutable_parent()->::mozilla::devtools::protobuf::StackFrame::MergeFrom(
          from._internal_parent());
    }
    if (cached_has_bits & 0x00000002u) {
      _this->_impl_.id_ = from._impl_.id_;
    }
    if (cached_has_bits & 0x00000004u) {
      _this->_impl_.line_ = from._impl_.line_;
    }
    if (cached_has_bits & 0x00000008u) {
      _this->_impl_.column_ = from._impl_.column_;
    }
    if (cached_has_bits & 0x00000010u) {
      _this->_impl_.issystem_ = from._impl_.issystem_;
    }
    if (cached_has_bits & 0x00000020u) {
      _this->_impl_.isselfhosted_ = from._impl_.isselfhosted_;
    }
    _this->_impl_._has_bits_[0] |= cached_has_bits;
  }
  switch (from.SourceOrRef_case()) {
    case kSource: {
      _this->_internal_set_source(from._internal_source());
      break;
    }
    case kSourceRef: {
      _this->_internal_set_sourceref(from._internal_sourceref());
      break;
    }
    case SOURCEORREF_NOT_SET: {
      break;
    }
  }
  switch (from.FunctionDisplayNameOrRef_case()) {
    case kFunctionDisplayName: {
      _this->_internal_set_functiondisplayname(from._internal_functiondisplayname());
      break;
    }
    case kFunctionDisplayNameRef: {
      _this->_internal_set_functiondisplaynameref(from._internal_functiondisplaynameref());
      break;
    }
    case FUNCTIONDISPLAYNAMEORREF_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void StackFrame_Data::CopyFrom(const StackFrame_Data& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mozilla.devtools.protobuf.StackFrame.Data)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool StackFrame_Data::IsInitialized() const {
  return true;
}

void StackFrame_Data::InternalSwap(StackFrame_Data* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(StackFrame_Data, _impl_.isselfhosted_)
      + sizeof(StackFrame_Data::_impl_.isselfhosted_)
      - PROTOBUF_FIELD_OFFSET(StackFrame_Data, _impl_.parent_)>(
          reinterpret_cast<char*>(&_impl_.parent_),
          reinterpret_cast<char*>(&other->_impl_.parent_));
  swap(_impl_.SourceOrRef_, other->_impl_.SourceOrRef_);
  swap(_impl_.FunctionDisplayNameOrRef_, other->_impl_.FunctionDisplayNameOrRef_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
  swap(_impl_._oneof_case_[1], other->_impl_._oneof_case_[1]);
}

std::string StackFrame_Data::GetTypeName() const {
  return "mozilla.devtools.protobuf.StackFrame.Data";
}

// ===================================================================

class StackFrame::_Internal {
public:
  static const ::mozilla::devtools::protobuf::StackFrame_Data& data(const StackFrame* msg);
};

const ::mozilla::devtools::protobuf::StackFrame_Data&
StackFrame::_Internal::data(const StackFrame* msg) {
  return *msg->_impl_.StackFrameType_.data_;
}
void StackFrame::set_allocated_data(::mozilla::devtools::protobuf::StackFrame_Data* data) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_StackFrameType();
  if (data) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(data);
    if (message_arena != submessage_arena) {
      data = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, data, submessage_arena);
    }
    set_has_data();
    _impl_.StackFrameType_.data_ = data;
  }
  // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.StackFrame.data)
}
StackFrame::StackFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:mozilla.devtools.protobuf.StackFrame)
}
StackFrame::StackFrame(const StackFrame& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  StackFrame* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.StackFrameType_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_StackFrameType();
  switch (from.StackFrameType_case()) {
    case kData: {
      _this->_internal_mutable_data()->::mozilla::devtools::protobuf::StackFrame_Data::MergeFrom(
          from._internal_data());
      break;
    }
    case kRef: {
      _this->_internal_set_ref(from._internal_ref());
      break;
    }
    case STACKFRAMETYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:mozilla.devtools.protobuf.StackFrame)
}

inline void StackFrame::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.StackFrameType_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}
  };
  clear_has_StackFrameType();
}

StackFrame::~StackFrame() {
  // @@protoc_insertion_point(destructor:mozilla.devtools.protobuf.StackFrame)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void StackFrame::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_StackFrameType()) {
    clear_StackFrameType();
  }
}

void StackFrame::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void StackFrame::clear_StackFrameType() {
// @@protoc_insertion_point(one_of_clear_start:mozilla.devtools.protobuf.StackFrame)
  switch (StackFrameType_case()) {
    case kData: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.StackFrameType_.data_;
      }
      break;
    }
    case kRef: {
      // No need to clear
      break;
    }
    case STACKFRAMETYPE_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = STACKFRAMETYPE_NOT_SET;
}

void StackFrame::Clear() {
// @@protoc_insertion_point(message_clear_start:mozilla.devtools.protobuf.StackFrame)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_StackFrameType();
  _internal_metadata_.Clear<std::string>();
}

const char* StackFrame::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .mozilla.devtools.protobuf.StackFrame.Data data = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_data(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // uint64 ref = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
          _internal_set_ref(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* StackFrame::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:mozilla.devtools.protobuf.StackFrame)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (StackFrameType_case()) {
    case kData: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(1, _Internal::data(this),
          _Internal::data(this).GetCachedSize(), target, stream);
      break;
    }
    case kRef: {
      target = stream->EnsureSpace(target);
      target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_ref(), target);
      break;
    }
    default: ;
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:mozilla.devtools.protobuf.StackFrame)
  return target;
}

size_t StackFrame::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mozilla.devtools.protobuf.StackFrame)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (StackFrameType_case()) {
    // .mozilla.devtools.protobuf.StackFrame.Data data = 1;
    case kData: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.StackFrameType_.data_);
      break;
    }
    // uint64 ref = 2;
    case kRef: {
      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_ref());
      break;
    }
    case STACKFRAMETYPE_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void StackFrame::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const StackFrame*>(
      &from));
}

void StackFrame::MergeFrom(const StackFrame& from) {
  StackFrame* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:mozilla.devtools.protobuf.StackFrame)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.StackFrameType_case()) {
    case kData: {
      _this->_internal_mutable_data()->::mozilla::devtools::protobuf::StackFrame_Data::MergeFrom(
          from._internal_data());
      break;
    }
    case kRef: {
      _this->_internal_set_ref(from._internal_ref());
      break;
    }
    case STACKFRAMETYPE_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void StackFrame::CopyFrom(const StackFrame& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mozilla.devtools.protobuf.StackFrame)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool StackFrame::IsInitialized() const {
  return true;
}

void StackFrame::InternalSwap(StackFrame* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.StackFrameType_, other->_impl_.StackFrameType_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

std::string StackFrame::GetTypeName() const {
  return "mozilla.devtools.protobuf.StackFrame";
}

// ===================================================================

class Node::_Internal {
public:
  using HasBits = decltype(std::declval<Node>()._impl_._has_bits_);
  static void set_has_id(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_size(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static const ::mozilla::devtools::protobuf::StackFrame& allocationstack(const Node* msg);
  static void set_has_allocationstack(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_coarsetype(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
};

const ::mozilla::devtools::protobuf::StackFrame&
Node::_Internal::allocationstack(const Node* msg) {
  return *msg->_impl_.allocationstack_;
}
Node::Node(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:mozilla.devtools.protobuf.Node)
}
Node::Node(const Node& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  Node* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.edges_){from._impl_.edges_}
    , decltype(_impl_.allocationstack_){nullptr}
    , decltype(_impl_.id_){}
    , decltype(_impl_.size_){}
    , decltype(_impl_.coarsetype_){}
    , decltype(_impl_.TypeNameOrRef_){}
    , decltype(_impl_.JSObjectClassNameOrRef_){}
    , decltype(_impl_.ScriptFilenameOrRef_){}
    , decltype(_impl_.descriptiveTypeNameOrRef_){}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if (from._internal_has_allocationstack()) {
    _this->_impl_.allocationstack_ = new ::mozilla::devtools::protobuf::StackFrame(*from._impl_.allocationstack_);
  }
  ::memcpy(&_impl_.id_, &from._impl_.id_,
    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.coarsetype_) -
    reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.coarsetype_));
  clear_has_TypeNameOrRef();
  switch (from.TypeNameOrRef_case()) {
    case kTypeName: {
      _this->_internal_set_typename_(from._internal_typename_());
      break;
    }
    case kTypeNameRef: {
      _this->_internal_set_typenameref(from._internal_typenameref());
      break;
    }
    case TYPENAMEORREF_NOT_SET: {
      break;
    }
  }
  clear_has_JSObjectClassNameOrRef();
  switch (from.JSObjectClassNameOrRef_case()) {
    case kJsObjectClassName: {
      _this->_internal_set_jsobjectclassname(from._internal_jsobjectclassname());
      break;
    }
    case kJsObjectClassNameRef: {
      _this->_internal_set_jsobjectclassnameref(from._internal_jsobjectclassnameref());
      break;
    }
    case JSOBJECTCLASSNAMEORREF_NOT_SET: {
      break;
    }
  }
  clear_has_ScriptFilenameOrRef();
  switch (from.ScriptFilenameOrRef_case()) {
    case kScriptFilename: {
      _this->_internal_set_scriptfilename(from._internal_scriptfilename());
      break;
    }
    case kScriptFilenameRef: {
      _this->_internal_set_scriptfilenameref(from._internal_scriptfilenameref());
      break;
    }
    case SCRIPTFILENAMEORREF_NOT_SET: {
      break;
    }
  }
  clear_has_descriptiveTypeNameOrRef();
  switch (from.descriptiveTypeNameOrRef_case()) {
    case kDescriptiveTypeName: {
      _this->_internal_set_descriptivetypename(from._internal_descriptivetypename());
      break;
    }
    case kDescriptiveTypeNameRef: {
      _this->_internal_set_descriptivetypenameref(from._internal_descriptivetypenameref());
      break;
    }
    case DESCRIPTIVETYPENAMEORREF_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:mozilla.devtools.protobuf.Node)
}

inline void Node::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.edges_){arena}
    , decltype(_impl_.allocationstack_){nullptr}
    , decltype(_impl_.id_){uint64_t{0u}}
    , decltype(_impl_.size_){uint64_t{0u}}
    , decltype(_impl_.coarsetype_){0u}
    , decltype(_impl_.TypeNameOrRef_){}
    , decltype(_impl_.JSObjectClassNameOrRef_){}
    , decltype(_impl_.ScriptFilenameOrRef_){}
    , decltype(_impl_.descriptiveTypeNameOrRef_){}
    , /*decltype(_impl_._oneof_case_)*/{}
  };
  clear_has_TypeNameOrRef();
  clear_has_JSObjectClassNameOrRef();
  clear_has_ScriptFilenameOrRef();
  clear_has_descriptiveTypeNameOrRef();
}

Node::~Node() {
  // @@protoc_insertion_point(destructor:mozilla.devtools.protobuf.Node)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void Node::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.edges_.~RepeatedPtrField();
  if (this != internal_default_instance()) delete _impl_.allocationstack_;
  if (has_TypeNameOrRef()) {
    clear_TypeNameOrRef();
  }
  if (has_JSObjectClassNameOrRef()) {
    clear_JSObjectClassNameOrRef();
  }
  if (has_ScriptFilenameOrRef()) {
    clear_ScriptFilenameOrRef();
  }
  if (has_descriptiveTypeNameOrRef()) {
    clear_descriptiveTypeNameOrRef();
  }
}

void Node::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void Node::clear_TypeNameOrRef() {
// @@protoc_insertion_point(one_of_clear_start:mozilla.devtools.protobuf.Node)
  switch (TypeNameOrRef_case()) {
    case kTypeName: {
      _impl_.TypeNameOrRef_.typename__.Destroy();
      break;
    }
    case kTypeNameRef: {
      // No need to clear
      break;
    }
    case TYPENAMEORREF_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = TYPENAMEORREF_NOT_SET;
}

void Node::clear_JSObjectClassNameOrRef() {
// @@protoc_insertion_point(one_of_clear_start:mozilla.devtools.protobuf.Node)
  switch (JSObjectClassNameOrRef_case()) {
    case kJsObjectClassName: {
      _impl_.JSObjectClassNameOrRef_.jsobjectclassname_.Destroy();
      break;
    }
    case kJsObjectClassNameRef: {
      // No need to clear
      break;
    }
    case JSOBJECTCLASSNAMEORREF_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[1] = JSOBJECTCLASSNAMEORREF_NOT_SET;
}

void Node::clear_ScriptFilenameOrRef() {
// @@protoc_insertion_point(one_of_clear_start:mozilla.devtools.protobuf.Node)
  switch (ScriptFilenameOrRef_case()) {
    case kScriptFilename: {
      _impl_.ScriptFilenameOrRef_.scriptfilename_.Destroy();
      break;
    }
    case kScriptFilenameRef: {
      // No need to clear
      break;
    }
    case SCRIPTFILENAMEORREF_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[2] = SCRIPTFILENAMEORREF_NOT_SET;
}

void Node::clear_descriptiveTypeNameOrRef() {
// @@protoc_insertion_point(one_of_clear_start:mozilla.devtools.protobuf.Node)
  switch (descriptiveTypeNameOrRef_case()) {
    case kDescriptiveTypeName: {
      _impl_.descriptiveTypeNameOrRef_.descriptivetypename_.Destroy();
      break;
    }
    case kDescriptiveTypeNameRef: {
      // No need to clear
      break;
    }
    case DESCRIPTIVETYPENAMEORREF_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[3] = DESCRIPTIVETYPENAMEORREF_NOT_SET;
}

void Node::Clear() {
// @@protoc_insertion_point(message_clear_start:mozilla.devtools.protobuf.Node)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.edges_.Clear();
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(_impl_.allocationstack_ != nullptr);
    _impl_.allocationstack_->Clear();
  }
  if (cached_has_bits & 0x0000000eu) {
    ::memset(&_impl_.id_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&_impl_.coarsetype_) -
        reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.coarsetype_));
  }
  clear_TypeNameOrRef();
  clear_JSObjectClassNameOrRef();
  clear_ScriptFilenameOrRef();
  clear_descriptiveTypeNameOrRef();
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* Node::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional uint64 id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          _Internal::set_has_id(&has_bits);
          _impl_.id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // bytes typeName = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_typename_();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // uint64 typeNameRef = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
          _internal_set_typenameref(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional uint64 size = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
          _Internal::set_has_size(&has_bits);
          _impl_.size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // repeated .mozilla.devtools.protobuf.Edge edges = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_edges(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
        } else
          goto handle_unusual;
        continue;
      // optional .mozilla.devtools.protobuf.StackFrame allocationStack = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
          ptr = ctx->ParseMessage(_internal_mutable_allocationstack(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // bytes jsObjectClassName = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
          auto str = _internal_mutable_jsobjectclassname();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // uint64 jsObjectClassNameRef = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 64)) {
          _internal_set_jsobjectclassnameref(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional uint32 coarseType = 9 [default = 0];
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 72)) {
          _Internal::set_has_coarsetype(&has_bits);
          _impl_.coarsetype_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // bytes scriptFilename = 10;
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
          auto str = _internal_mutable_scriptfilename();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // uint64 scriptFilenameRef = 11;
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 88)) {
          _internal_set_scriptfilenameref(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // bytes descriptiveTypeName = 12;
      case 12:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 98)) {
          auto str = _internal_mutable_descriptivetypename();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // uint64 descriptiveTypeNameRef = 13;
      case 13:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 104)) {
          _internal_set_descriptivetypenameref(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* Node::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:mozilla.devtools.protobuf.Node)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  // optional uint64 id = 1;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_id(), target);
  }

  switch (TypeNameOrRef_case()) {
    case kTypeName: {
      target = stream->WriteBytesMaybeAliased(
          2, this->_internal_typename_(), target);
      break;
    }
    case kTypeNameRef: {
      target = stream->EnsureSpace(target);
      target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_typenameref(), target);
      break;
    }
    default: ;
  }
  // optional uint64 size = 4;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(4, this->_internal_size(), target);
  }

  // repeated .mozilla.devtools.protobuf.Edge edges = 5;
  for (unsigned i = 0,
      n = static_cast<unsigned>(this->_internal_edges_size()); i < n; i++) {
    const auto& repfield = this->_internal_edges(i);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(5, repfield, repfield.GetCachedSize(), target, stream);
  }

  // optional .mozilla.devtools.protobuf.StackFrame allocationStack = 6;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(6, _Internal::allocationstack(this),
        _Internal::allocationstack(this).GetCachedSize(), target, stream);
  }

  switch (JSObjectClassNameOrRef_case()) {
    case kJsObjectClassName: {
      target = stream->WriteBytesMaybeAliased(
          7, this->_internal_jsobjectclassname(), target);
      break;
    }
    case kJsObjectClassNameRef: {
      target = stream->EnsureSpace(target);
      target = ::_pbi::WireFormatLite::WriteUInt64ToArray(8, this->_internal_jsobjectclassnameref(), target);
      break;
    }
    default: ;
  }
  // optional uint32 coarseType = 9 [default = 0];
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(9, this->_internal_coarsetype(), target);
  }

  switch (ScriptFilenameOrRef_case()) {
    case kScriptFilename: {
      target = stream->WriteBytesMaybeAliased(
          10, this->_internal_scriptfilename(), target);
      break;
    }
    case kScriptFilenameRef: {
      target = stream->EnsureSpace(target);
      target = ::_pbi::WireFormatLite::WriteUInt64ToArray(11, this->_internal_scriptfilenameref(), target);
      break;
    }
    default: ;
  }
  switch (descriptiveTypeNameOrRef_case()) {
    case kDescriptiveTypeName: {
      target = stream->WriteBytesMaybeAliased(
          12, this->_internal_descriptivetypename(), target);
      break;
    }
    case kDescriptiveTypeNameRef: {
      target = stream->EnsureSpace(target);
      target = ::_pbi::WireFormatLite::WriteUInt64ToArray(13, this->_internal_descriptivetypenameref(), target);
      break;
    }
    default: ;
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:mozilla.devtools.protobuf.Node)
  return target;
}

size_t Node::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mozilla.devtools.protobuf.Node)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .mozilla.devtools.protobuf.Edge edges = 5;
  total_size += 1UL * this->_internal_edges_size();
  for (const auto& msg : this->_impl_.edges_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    // optional .mozilla.devtools.protobuf.StackFrame allocationStack = 6;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.allocationstack_);
    }

    // optional uint64 id = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_id());
    }

    // optional uint64 size = 4;
    if (cached_has_bits & 0x00000004u) {
      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_size());
    }

    // optional uint32 coarseType = 9 [default = 0];
    if (cached_has_bits & 0x00000008u) {
      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_coarsetype());
    }

  }
  switch (TypeNameOrRef_case()) {
    // bytes typeName = 2;
    case kTypeName: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_typename_());
      break;
    }
    // uint64 typeNameRef = 3;
    case kTypeNameRef: {
      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_typenameref());
      break;
    }
    case TYPENAMEORREF_NOT_SET: {
      break;
    }
  }
  switch (JSObjectClassNameOrRef_case()) {
    // bytes jsObjectClassName = 7;
    case kJsObjectClassName: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_jsobjectclassname());
      break;
    }
    // uint64 jsObjectClassNameRef = 8;
    case kJsObjectClassNameRef: {
      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_jsobjectclassnameref());
      break;
    }
    case JSOBJECTCLASSNAMEORREF_NOT_SET: {
      break;
    }
  }
  switch (ScriptFilenameOrRef_case()) {
    // bytes scriptFilename = 10;
    case kScriptFilename: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_scriptfilename());
      break;
    }
    // uint64 scriptFilenameRef = 11;
    case kScriptFilenameRef: {
      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_scriptfilenameref());
      break;
    }
    case SCRIPTFILENAMEORREF_NOT_SET: {
      break;
    }
  }
  switch (descriptiveTypeNameOrRef_case()) {
    // bytes descriptiveTypeName = 12;
    case kDescriptiveTypeName: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_descriptivetypename());
      break;
    }
    // uint64 descriptiveTypeNameRef = 13;
    case kDescriptiveTypeNameRef: {
      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_descriptivetypenameref());
      break;
    }
    case DESCRIPTIVETYPENAMEORREF_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Node::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const Node*>(
      &from));
}

void Node::MergeFrom(const Node& from) {
  Node* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:mozilla.devtools.protobuf.Node)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_impl_.edges_.MergeFrom(from._impl_.edges_);
  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      _this->_internal_mutable_allocationstack()->::mozilla::devtools::protobuf::StackFrame::MergeFrom(
          from._internal_allocationstack());
    }
    if (cached_has_bits & 0x00000002u) {
      _this->_impl_.id_ = from._impl_.id_;
    }
    if (cached_has_bits & 0x00000004u) {
      _this->_impl_.size_ = from._impl_.size_;
    }
    if (cached_has_bits & 0x00000008u) {
      _this->_impl_.coarsetype_ = from._impl_.coarsetype_;
    }
    _this->_impl_._has_bits_[0] |= cached_has_bits;
  }
  switch (from.TypeNameOrRef_case()) {
    case kTypeName: {
      _this->_internal_set_typename_(from._internal_typename_());
      break;
    }
    case kTypeNameRef: {
      _this->_internal_set_typenameref(from._internal_typenameref());
      break;
    }
    case TYPENAMEORREF_NOT_SET: {
      break;
    }
  }
  switch (from.JSObjectClassNameOrRef_case()) {
    case kJsObjectClassName: {
      _this->_internal_set_jsobjectclassname(from._internal_jsobjectclassname());
      break;
    }
    case kJsObjectClassNameRef: {
      _this->_internal_set_jsobjectclassnameref(from._internal_jsobjectclassnameref());
      break;
    }
    case JSOBJECTCLASSNAMEORREF_NOT_SET: {
      break;
    }
  }
  switch (from.ScriptFilenameOrRef_case()) {
    case kScriptFilename: {
      _this->_internal_set_scriptfilename(from._internal_scriptfilename());
      break;
    }
    case kScriptFilenameRef: {
      _this->_internal_set_scriptfilenameref(from._internal_scriptfilenameref());
      break;
    }
    case SCRIPTFILENAMEORREF_NOT_SET: {
      break;
    }
  }
  switch (from.descriptiveTypeNameOrRef_case()) {
    case kDescriptiveTypeName: {
      _this->_internal_set_descriptivetypename(from._internal_descriptivetypename());
      break;
    }
    case kDescriptiveTypeNameRef: {
      _this->_internal_set_descriptivetypenameref(from._internal_descriptivetypenameref());
      break;
    }
    case DESCRIPTIVETYPENAMEORREF_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void Node::CopyFrom(const Node& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mozilla.devtools.protobuf.Node)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Node::IsInitialized() const {
  return true;
}

void Node::InternalSwap(Node* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  _impl_.edges_.InternalSwap(&other->_impl_.edges_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Node, _impl_.coarsetype_)
      + sizeof(Node::_impl_.coarsetype_)
      - PROTOBUF_FIELD_OFFSET(Node, _impl_.allocationstack_)>(
          reinterpret_cast<char*>(&_impl_.allocationstack_),
          reinterpret_cast<char*>(&other->_impl_.allocationstack_));
  swap(_impl_.TypeNameOrRef_, other->_impl_.TypeNameOrRef_);
  swap(_impl_.JSObjectClassNameOrRef_, other->_impl_.JSObjectClassNameOrRef_);
  swap(_impl_.ScriptFilenameOrRef_, other->_impl_.ScriptFilenameOrRef_);
  swap(_impl_.descriptiveTypeNameOrRef_, other->_impl_.descriptiveTypeNameOrRef_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
  swap(_impl_._oneof_case_[1], other->_impl_._oneof_case_[1]);
  swap(_impl_._oneof_case_[2], other->_impl_._oneof_case_[2]);
  swap(_impl_._oneof_case_[3], other->_impl_._oneof_case_[3]);
}

std::string Node::GetTypeName() const {
  return "mozilla.devtools.protobuf.Node";
}

// ===================================================================

class Edge::_Internal {
public:
  using HasBits = decltype(std::declval<Edge>()._impl_._has_bits_);
  static void set_has_referent(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

Edge::Edge(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:mozilla.devtools.protobuf.Edge)
}
Edge::Edge(const Edge& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  Edge* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.referent_){}
    , decltype(_impl_.EdgeNameOrRef_){}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _this->_impl_.referent_ = from._impl_.referent_;
  clear_has_EdgeNameOrRef();
  switch (from.EdgeNameOrRef_case()) {
    case kName: {
      _this->_internal_set_name(from._internal_name());
      break;
    }
    case kNameRef: {
      _this->_internal_set_nameref(from._internal_nameref());
      break;
    }
    case EDGENAMEORREF_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:mozilla.devtools.protobuf.Edge)
}

inline void Edge::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.referent_){uint64_t{0u}}
    , decltype(_impl_.EdgeNameOrRef_){}
    , /*decltype(_impl_._oneof_case_)*/{}
  };
  clear_has_EdgeNameOrRef();
}

Edge::~Edge() {
  // @@protoc_insertion_point(destructor:mozilla.devtools.protobuf.Edge)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void Edge::SharedDtor() {
--> --------------------

--> maximum size reached

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

quality90%

¤ Dauer der Verarbeitung: 0.47 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.