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

#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
#include "debug_dump.pb.h"

#include <algorithm>

#include <google/protobuf/stubs/common.h>
#include <google/protobuf/stubs/port.h>
#include <google/protobuf/stubs/once.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/wire_format_lite_inl.h>
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
// @@protoc_insertion_point(includes)

namespace webrtc {
namespace audio_network_adaptor {
namespace debug_dump {
class NetworkMetricsDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<NetworkMetrics> {
} _NetworkMetrics_default_instance_;
class EncoderRuntimeConfigDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<EncoderRuntimeConfig> {
} _EncoderRuntimeConfig_default_instance_;
class EventDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<Event> {
} _Event_default_instance_;

namespace protobuf_debug_5fdump_2eproto {

PROTOBUF_CONSTEXPR_VAR ::google::protobuf::internal::ParseTableField
    const TableStruct::entries[] = {
  {0, 0, 0, ::google::protobuf::internal::kInvalidMask, 0, 0},
};

PROTOBUF_CONSTEXPR_VAR ::google::protobuf::internal::AuxillaryParseTableField
    const TableStruct::aux[] = {
  ::google::protobuf::internal::AuxillaryParseTableField(),
};
PROTOBUF_CONSTEXPR_VAR ::google::protobuf::internal::ParseTable const
    TableStruct::schema[] = {
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
};


void TableStruct::Shutdown() {
  _NetworkMetrics_default_instance_.Shutdown();
  _EncoderRuntimeConfig_default_instance_.Shutdown();
  _Event_default_instance_.Shutdown();
}

void TableStruct::InitDefaultsImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  ::google::protobuf::internal::InitProtobufDefaults();
  ::webrtc::audio_network_adaptor::config::protobuf_config_2eproto::InitDefaults();
  _NetworkMetrics_default_instance_.DefaultConstruct();
  _EncoderRuntimeConfig_default_instance_.DefaultConstruct();
  _Event_default_instance_.DefaultConstruct();
  _Event_default_instance_.get_mutable()->network_metrics_ = const_cast< ::webrtc::audio_network_adaptor::debug_dump::NetworkMetrics*>(
      ::webrtc::audio_network_adaptor::debug_dump::NetworkMetrics::internal_default_instance());
  _Event_default_instance_.get_mutable()->encoder_runtime_config_ = const_cast< ::webrtc::audio_network_adaptor::debug_dump::EncoderRuntimeConfig*>(
      ::webrtc::audio_network_adaptor::debug_dump::EncoderRuntimeConfig::internal_default_instance());
  _Event_default_instance_.get_mutable()->controller_manager_config_ = const_cast< ::webrtc::audio_network_adaptor::config::ControllerManager*>(
      ::webrtc::audio_network_adaptor::config::ControllerManager::internal_default_instance());
}

void InitDefaults() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &TableStruct::InitDefaultsImpl);
}
void AddDescriptorsImpl() {
  InitDefaults();
  ::webrtc::audio_network_adaptor::config::protobuf_config_2eproto::AddDescriptors();
  ::google::protobuf::internal::OnShutdown(&TableStruct::Shutdown);
}

void AddDescriptors() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &AddDescriptorsImpl);
}

}  // namespace protobuf_debug_5fdump_2eproto

bool Event_Type_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const Event_Type Event::NETWORK_METRICS;
const Event_Type Event::ENCODER_RUNTIME_CONFIG;
const Event_Type Event::CONTROLLER_MANAGER_CONFIG;
const Event_Type Event::Type_MIN;
const Event_Type Event::Type_MAX;
const int Event::Type_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int NetworkMetrics::kUplinkBandwidthBpsFieldNumber;
const int NetworkMetrics::kUplinkPacketLossFractionFieldNumber;
const int NetworkMetrics::kTargetAudioBitrateBpsFieldNumber;
const int NetworkMetrics::kRttMsFieldNumber;
const int NetworkMetrics::kUplinkRecoverablePacketLossFractionFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

NetworkMetrics::NetworkMetrics()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_debug_5fdump_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:webrtc.audio_network_adaptor.debug_dump.NetworkMetrics)
}
NetworkMetrics::NetworkMetrics(const NetworkMetrics& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&uplink_bandwidth_bps_, &from.uplink_bandwidth_bps_,
    static_cast<size_t>(reinterpret_cast<char*>(&uplink_recoverable_packet_loss_fraction_) -
    reinterpret_cast<char*>(&uplink_bandwidth_bps_)) + sizeof(uplink_recoverable_packet_loss_fraction_));
  // @@protoc_insertion_point(copy_constructor:webrtc.audio_network_adaptor.debug_dump.NetworkMetrics)
}

void NetworkMetrics::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&uplink_bandwidth_bps_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&uplink_recoverable_packet_loss_fraction_) -
      reinterpret_cast<char*>(&uplink_bandwidth_bps_)) + sizeof(uplink_recoverable_packet_loss_fraction_));
}

NetworkMetrics::~NetworkMetrics() {
  // @@protoc_insertion_point(destructor:webrtc.audio_network_adaptor.debug_dump.NetworkMetrics)
  SharedDtor();
}

void NetworkMetrics::SharedDtor() {
}

void NetworkMetrics::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const NetworkMetrics& NetworkMetrics::default_instance() {
  protobuf_debug_5fdump_2eproto::InitDefaults();
  return *internal_default_instance();
}

NetworkMetrics* NetworkMetrics::New(::google::protobuf::Arena* arena) const {
  NetworkMetrics* n = new NetworkMetrics;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void NetworkMetrics::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.audio_network_adaptor.debug_dump.NetworkMetrics)
  if (_has_bits_[0 / 32] & 31u) {
    ::memset(&uplink_bandwidth_bps_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&uplink_recoverable_packet_loss_fraction_) -
        reinterpret_cast<char*>(&uplink_bandwidth_bps_)) + sizeof(uplink_recoverable_packet_loss_fraction_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool NetworkMetrics::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:webrtc.audio_network_adaptor.debug_dump.NetworkMetrics)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 uplink_bandwidth_bps = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_uplink_bandwidth_bps();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &uplink_bandwidth_bps_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float uplink_packet_loss_fraction = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(21u)) {
          set_has_uplink_packet_loss_fraction();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &uplink_packet_loss_fraction_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 target_audio_bitrate_bps = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u)) {
          set_has_target_audio_bitrate_bps();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &target_audio_bitrate_bps_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 rtt_ms = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u)) {
          set_has_rtt_ms();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &rtt_ms_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 uplink_recoverable_packet_loss_fraction = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(40u)) {
          set_has_uplink_recoverable_packet_loss_fraction();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &uplink_recoverable_packet_loss_fraction_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:webrtc.audio_network_adaptor.debug_dump.NetworkMetrics)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:webrtc.audio_network_adaptor.debug_dump.NetworkMetrics)
  return false;
#undef DO_
}

void NetworkMetrics::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:webrtc.audio_network_adaptor.debug_dump.NetworkMetrics)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 uplink_bandwidth_bps = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->uplink_bandwidth_bps(), output);
  }

  // optional float uplink_packet_loss_fraction = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->uplink_packet_loss_fraction(), output);
  }

  // optional int32 target_audio_bitrate_bps = 3;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->target_audio_bitrate_bps(), output);
  }

  // optional int32 rtt_ms = 4;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->rtt_ms(), output);
  }

  // optional int32 uplink_recoverable_packet_loss_fraction = 5;
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->uplink_recoverable_packet_loss_fraction(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:webrtc.audio_network_adaptor.debug_dump.NetworkMetrics)
}

size_t NetworkMetrics::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:webrtc.audio_network_adaptor.debug_dump.NetworkMetrics)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 31u) {
    // optional int32 uplink_bandwidth_bps = 1;
    if (has_uplink_bandwidth_bps()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->uplink_bandwidth_bps());
    }

    // optional float uplink_packet_loss_fraction = 2;
    if (has_uplink_packet_loss_fraction()) {
      total_size += 1 + 4;
    }

    // optional int32 target_audio_bitrate_bps = 3;
    if (has_target_audio_bitrate_bps()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->target_audio_bitrate_bps());
    }

    // optional int32 rtt_ms = 4;
    if (has_rtt_ms()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->rtt_ms());
    }

    // optional int32 uplink_recoverable_packet_loss_fraction = 5;
    if (has_uplink_recoverable_packet_loss_fraction()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->uplink_recoverable_packet_loss_fraction());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void NetworkMetrics::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const NetworkMetrics*>(&from));
}

void NetworkMetrics::MergeFrom(const NetworkMetrics& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:webrtc.audio_network_adaptor.debug_dump.NetworkMetrics)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 31u) {
    if (cached_has_bits & 0x00000001u) {
      uplink_bandwidth_bps_ = from.uplink_bandwidth_bps_;
    }
    if (cached_has_bits & 0x00000002u) {
      uplink_packet_loss_fraction_ = from.uplink_packet_loss_fraction_;
    }
    if (cached_has_bits & 0x00000004u) {
      target_audio_bitrate_bps_ = from.target_audio_bitrate_bps_;
    }
    if (cached_has_bits & 0x00000008u) {
      rtt_ms_ = from.rtt_ms_;
    }
    if (cached_has_bits & 0x00000010u) {
      uplink_recoverable_packet_loss_fraction_ = from.uplink_recoverable_packet_loss_fraction_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void NetworkMetrics::CopyFrom(const NetworkMetrics& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:webrtc.audio_network_adaptor.debug_dump.NetworkMetrics)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void NetworkMetrics::Swap(NetworkMetrics* other) {
  if (other == this) return;
  InternalSwap(other);
}
void NetworkMetrics::InternalSwap(NetworkMetrics* other) {
  std::swap(uplink_bandwidth_bps_, other->uplink_bandwidth_bps_);
  std::swap(uplink_packet_loss_fraction_, other->uplink_packet_loss_fraction_);
  std::swap(target_audio_bitrate_bps_, other->target_audio_bitrate_bps_);
  std::swap(rtt_ms_, other->rtt_ms_);
  std::swap(uplink_recoverable_packet_loss_fraction_, other->uplink_recoverable_packet_loss_fraction_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string NetworkMetrics::GetTypeName() const {
  return "webrtc.audio_network_adaptor.debug_dump.NetworkMetrics";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// NetworkMetrics

// optional int32 uplink_bandwidth_bps = 1;
bool NetworkMetrics::has_uplink_bandwidth_bps() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void NetworkMetrics::set_has_uplink_bandwidth_bps() {
  _has_bits_[0] |= 0x00000001u;
}
void NetworkMetrics::clear_has_uplink_bandwidth_bps() {
  _has_bits_[0] &= ~0x00000001u;
}
void NetworkMetrics::clear_uplink_bandwidth_bps() {
  uplink_bandwidth_bps_ = 0;
  clear_has_uplink_bandwidth_bps();
}
::google::protobuf::int32 NetworkMetrics::uplink_bandwidth_bps() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.debug_dump.NetworkMetrics.uplink_bandwidth_bps)
  return uplink_bandwidth_bps_;
}
void NetworkMetrics::set_uplink_bandwidth_bps(::google::protobuf::int32 value) {
  set_has_uplink_bandwidth_bps();
  uplink_bandwidth_bps_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audio_network_adaptor.debug_dump.NetworkMetrics.uplink_bandwidth_bps)
}

// optional float uplink_packet_loss_fraction = 2;
bool NetworkMetrics::has_uplink_packet_loss_fraction() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void NetworkMetrics::set_has_uplink_packet_loss_fraction() {
  _has_bits_[0] |= 0x00000002u;
}
void NetworkMetrics::clear_has_uplink_packet_loss_fraction() {
  _has_bits_[0] &= ~0x00000002u;
}
void NetworkMetrics::clear_uplink_packet_loss_fraction() {
  uplink_packet_loss_fraction_ = 0;
  clear_has_uplink_packet_loss_fraction();
}
float NetworkMetrics::uplink_packet_loss_fraction() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.debug_dump.NetworkMetrics.uplink_packet_loss_fraction)
  return uplink_packet_loss_fraction_;
}
void NetworkMetrics::set_uplink_packet_loss_fraction(float value) {
  set_has_uplink_packet_loss_fraction();
  uplink_packet_loss_fraction_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audio_network_adaptor.debug_dump.NetworkMetrics.uplink_packet_loss_fraction)
}

// optional int32 target_audio_bitrate_bps = 3;
bool NetworkMetrics::has_target_audio_bitrate_bps() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void NetworkMetrics::set_has_target_audio_bitrate_bps() {
  _has_bits_[0] |= 0x00000004u;
}
void NetworkMetrics::clear_has_target_audio_bitrate_bps() {
  _has_bits_[0] &= ~0x00000004u;
}
void NetworkMetrics::clear_target_audio_bitrate_bps() {
  target_audio_bitrate_bps_ = 0;
  clear_has_target_audio_bitrate_bps();
}
::google::protobuf::int32 NetworkMetrics::target_audio_bitrate_bps() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.debug_dump.NetworkMetrics.target_audio_bitrate_bps)
  return target_audio_bitrate_bps_;
}
void NetworkMetrics::set_target_audio_bitrate_bps(::google::protobuf::int32 value) {
  set_has_target_audio_bitrate_bps();
  target_audio_bitrate_bps_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audio_network_adaptor.debug_dump.NetworkMetrics.target_audio_bitrate_bps)
}

// optional int32 rtt_ms = 4;
bool NetworkMetrics::has_rtt_ms() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void NetworkMetrics::set_has_rtt_ms() {
  _has_bits_[0] |= 0x00000008u;
}
void NetworkMetrics::clear_has_rtt_ms() {
  _has_bits_[0] &= ~0x00000008u;
}
void NetworkMetrics::clear_rtt_ms() {
  rtt_ms_ = 0;
  clear_has_rtt_ms();
}
::google::protobuf::int32 NetworkMetrics::rtt_ms() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.debug_dump.NetworkMetrics.rtt_ms)
  return rtt_ms_;
}
void NetworkMetrics::set_rtt_ms(::google::protobuf::int32 value) {
  set_has_rtt_ms();
  rtt_ms_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audio_network_adaptor.debug_dump.NetworkMetrics.rtt_ms)
}

// optional int32 uplink_recoverable_packet_loss_fraction = 5;
bool NetworkMetrics::has_uplink_recoverable_packet_loss_fraction() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
void NetworkMetrics::set_has_uplink_recoverable_packet_loss_fraction() {
  _has_bits_[0] |= 0x00000010u;
}
void NetworkMetrics::clear_has_uplink_recoverable_packet_loss_fraction() {
  _has_bits_[0] &= ~0x00000010u;
}
void NetworkMetrics::clear_uplink_recoverable_packet_loss_fraction() {
  uplink_recoverable_packet_loss_fraction_ = 0;
  clear_has_uplink_recoverable_packet_loss_fraction();
}
::google::protobuf::int32 NetworkMetrics::uplink_recoverable_packet_loss_fraction() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.debug_dump.NetworkMetrics.uplink_recoverable_packet_loss_fraction)
  return uplink_recoverable_packet_loss_fraction_;
}
void NetworkMetrics::set_uplink_recoverable_packet_loss_fraction(::google::protobuf::int32 value) {
  set_has_uplink_recoverable_packet_loss_fraction();
  uplink_recoverable_packet_loss_fraction_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audio_network_adaptor.debug_dump.NetworkMetrics.uplink_recoverable_packet_loss_fraction)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int EncoderRuntimeConfig::kBitrateBpsFieldNumber;
const int EncoderRuntimeConfig::kFrameLengthMsFieldNumber;
const int EncoderRuntimeConfig::kUplinkPacketLossFractionFieldNumber;
const int EncoderRuntimeConfig::kEnableFecFieldNumber;
const int EncoderRuntimeConfig::kEnableDtxFieldNumber;
const int EncoderRuntimeConfig::kNumChannelsFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

EncoderRuntimeConfig::EncoderRuntimeConfig()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_debug_5fdump_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:webrtc.audio_network_adaptor.debug_dump.EncoderRuntimeConfig)
}
EncoderRuntimeConfig::EncoderRuntimeConfig(const EncoderRuntimeConfig& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&bitrate_bps_, &from.bitrate_bps_,
    static_cast<size_t>(reinterpret_cast<char*>(&num_channels_) -
    reinterpret_cast<char*>(&bitrate_bps_)) + sizeof(num_channels_));
  // @@protoc_insertion_point(copy_constructor:webrtc.audio_network_adaptor.debug_dump.EncoderRuntimeConfig)
}

void EncoderRuntimeConfig::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&bitrate_bps_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&num_channels_) -
      reinterpret_cast<char*>(&bitrate_bps_)) + sizeof(num_channels_));
}

EncoderRuntimeConfig::~EncoderRuntimeConfig() {
  // @@protoc_insertion_point(destructor:webrtc.audio_network_adaptor.debug_dump.EncoderRuntimeConfig)
  SharedDtor();
}

void EncoderRuntimeConfig::SharedDtor() {
}

void EncoderRuntimeConfig::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const EncoderRuntimeConfig& EncoderRuntimeConfig::default_instance() {
  protobuf_debug_5fdump_2eproto::InitDefaults();
  return *internal_default_instance();
}

EncoderRuntimeConfig* EncoderRuntimeConfig::New(::google::protobuf::Arena* arena) const {
  EncoderRuntimeConfig* n = new EncoderRuntimeConfig;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void EncoderRuntimeConfig::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.audio_network_adaptor.debug_dump.EncoderRuntimeConfig)
  if (_has_bits_[0 / 32] & 63u) {
    ::memset(&bitrate_bps_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&num_channels_) -
        reinterpret_cast<char*>(&bitrate_bps_)) + sizeof(num_channels_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool EncoderRuntimeConfig::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:webrtc.audio_network_adaptor.debug_dump.EncoderRuntimeConfig)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 bitrate_bps = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_bitrate_bps();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &bitrate_bps_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 frame_length_ms = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u)) {
          set_has_frame_length_ms();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &frame_length_ms_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float uplink_packet_loss_fraction = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(29u)) {
          set_has_uplink_packet_loss_fraction();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &uplink_packet_loss_fraction_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool enable_fec = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u)) {
          set_has_enable_fec();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &enable_fec_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool enable_dtx = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(40u)) {
          set_has_enable_dtx();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &enable_dtx_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 num_channels = 6;
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(48u)) {
          set_has_num_channels();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &num_channels_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:webrtc.audio_network_adaptor.debug_dump.EncoderRuntimeConfig)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:webrtc.audio_network_adaptor.debug_dump.EncoderRuntimeConfig)
  return false;
#undef DO_
}

void EncoderRuntimeConfig::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:webrtc.audio_network_adaptor.debug_dump.EncoderRuntimeConfig)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 bitrate_bps = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->bitrate_bps(), output);
  }

  // optional int32 frame_length_ms = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->frame_length_ms(), output);
  }

  // optional float uplink_packet_loss_fraction = 3;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->uplink_packet_loss_fraction(), output);
  }

  // optional bool enable_fec = 4;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->enable_fec(), output);
  }

  // optional bool enable_dtx = 5;
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->enable_dtx(), output);
  }

  // optional uint32 num_channels = 6;
  if (cached_has_bits & 0x00000020u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->num_channels(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:webrtc.audio_network_adaptor.debug_dump.EncoderRuntimeConfig)
}

size_t EncoderRuntimeConfig::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:webrtc.audio_network_adaptor.debug_dump.EncoderRuntimeConfig)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 63u) {
    // optional int32 bitrate_bps = 1;
    if (has_bitrate_bps()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->bitrate_bps());
    }

    // optional int32 frame_length_ms = 2;
    if (has_frame_length_ms()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->frame_length_ms());
    }

    // optional float uplink_packet_loss_fraction = 3;
    if (has_uplink_packet_loss_fraction()) {
      total_size += 1 + 4;
    }

    // optional bool enable_fec = 4;
    if (has_enable_fec()) {
      total_size += 1 + 1;
    }

    // optional bool enable_dtx = 5;
    if (has_enable_dtx()) {
      total_size += 1 + 1;
    }

    // optional uint32 num_channels = 6;
    if (has_num_channels()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->num_channels());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void EncoderRuntimeConfig::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const EncoderRuntimeConfig*>(&from));
}

void EncoderRuntimeConfig::MergeFrom(const EncoderRuntimeConfig& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:webrtc.audio_network_adaptor.debug_dump.EncoderRuntimeConfig)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 63u) {
    if (cached_has_bits & 0x00000001u) {
      bitrate_bps_ = from.bitrate_bps_;
    }
    if (cached_has_bits & 0x00000002u) {
      frame_length_ms_ = from.frame_length_ms_;
    }
    if (cached_has_bits & 0x00000004u) {
      uplink_packet_loss_fraction_ = from.uplink_packet_loss_fraction_;
    }
    if (cached_has_bits & 0x00000008u) {
      enable_fec_ = from.enable_fec_;
    }
    if (cached_has_bits & 0x00000010u) {
      enable_dtx_ = from.enable_dtx_;
    }
    if (cached_has_bits & 0x00000020u) {
      num_channels_ = from.num_channels_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void EncoderRuntimeConfig::CopyFrom(const EncoderRuntimeConfig& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:webrtc.audio_network_adaptor.debug_dump.EncoderRuntimeConfig)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void EncoderRuntimeConfig::Swap(EncoderRuntimeConfig* other) {
  if (other == this) return;
  InternalSwap(other);
}
void EncoderRuntimeConfig::InternalSwap(EncoderRuntimeConfig* other) {
  std::swap(bitrate_bps_, other->bitrate_bps_);
  std::swap(frame_length_ms_, other->frame_length_ms_);
  std::swap(uplink_packet_loss_fraction_, other->uplink_packet_loss_fraction_);
  std::swap(enable_fec_, other->enable_fec_);
  std::swap(enable_dtx_, other->enable_dtx_);
  std::swap(num_channels_, other->num_channels_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string EncoderRuntimeConfig::GetTypeName() const {
  return "webrtc.audio_network_adaptor.debug_dump.EncoderRuntimeConfig";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// EncoderRuntimeConfig

// optional int32 bitrate_bps = 1;
bool EncoderRuntimeConfig::has_bitrate_bps() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void EncoderRuntimeConfig::set_has_bitrate_bps() {
  _has_bits_[0] |= 0x00000001u;
}
void EncoderRuntimeConfig::clear_has_bitrate_bps() {
  _has_bits_[0] &= ~0x00000001u;
}
void EncoderRuntimeConfig::clear_bitrate_bps() {
  bitrate_bps_ = 0;
  clear_has_bitrate_bps();
}
::google::protobuf::int32 EncoderRuntimeConfig::bitrate_bps() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.debug_dump.EncoderRuntimeConfig.bitrate_bps)
  return bitrate_bps_;
}
void EncoderRuntimeConfig::set_bitrate_bps(::google::protobuf::int32 value) {
  set_has_bitrate_bps();
  bitrate_bps_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audio_network_adaptor.debug_dump.EncoderRuntimeConfig.bitrate_bps)
}

// optional int32 frame_length_ms = 2;
bool EncoderRuntimeConfig::has_frame_length_ms() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void EncoderRuntimeConfig::set_has_frame_length_ms() {
  _has_bits_[0] |= 0x00000002u;
}
void EncoderRuntimeConfig::clear_has_frame_length_ms() {
  _has_bits_[0] &= ~0x00000002u;
}
void EncoderRuntimeConfig::clear_frame_length_ms() {
  frame_length_ms_ = 0;
  clear_has_frame_length_ms();
}
::google::protobuf::int32 EncoderRuntimeConfig::frame_length_ms() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.debug_dump.EncoderRuntimeConfig.frame_length_ms)
  return frame_length_ms_;
}
void EncoderRuntimeConfig::set_frame_length_ms(::google::protobuf::int32 value) {
  set_has_frame_length_ms();
  frame_length_ms_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audio_network_adaptor.debug_dump.EncoderRuntimeConfig.frame_length_ms)
}

// optional float uplink_packet_loss_fraction = 3;
bool EncoderRuntimeConfig::has_uplink_packet_loss_fraction() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void EncoderRuntimeConfig::set_has_uplink_packet_loss_fraction() {
  _has_bits_[0] |= 0x00000004u;
}
void EncoderRuntimeConfig::clear_has_uplink_packet_loss_fraction() {
  _has_bits_[0] &= ~0x00000004u;
}
void EncoderRuntimeConfig::clear_uplink_packet_loss_fraction() {
  uplink_packet_loss_fraction_ = 0;
  clear_has_uplink_packet_loss_fraction();
}
float EncoderRuntimeConfig::uplink_packet_loss_fraction() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.debug_dump.EncoderRuntimeConfig.uplink_packet_loss_fraction)
  return uplink_packet_loss_fraction_;
}
void EncoderRuntimeConfig::set_uplink_packet_loss_fraction(float value) {
  set_has_uplink_packet_loss_fraction();
  uplink_packet_loss_fraction_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audio_network_adaptor.debug_dump.EncoderRuntimeConfig.uplink_packet_loss_fraction)
}

// optional bool enable_fec = 4;
bool EncoderRuntimeConfig::has_enable_fec() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void EncoderRuntimeConfig::set_has_enable_fec() {
  _has_bits_[0] |= 0x00000008u;
}
void EncoderRuntimeConfig::clear_has_enable_fec() {
  _has_bits_[0] &= ~0x00000008u;
}
void EncoderRuntimeConfig::clear_enable_fec() {
  enable_fec_ = false;
  clear_has_enable_fec();
}
bool EncoderRuntimeConfig::enable_fec() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.debug_dump.EncoderRuntimeConfig.enable_fec)
  return enable_fec_;
}
void EncoderRuntimeConfig::set_enable_fec(bool value) {
  set_has_enable_fec();
  enable_fec_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audio_network_adaptor.debug_dump.EncoderRuntimeConfig.enable_fec)
}

// optional bool enable_dtx = 5;
bool EncoderRuntimeConfig::has_enable_dtx() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
void EncoderRuntimeConfig::set_has_enable_dtx() {
  _has_bits_[0] |= 0x00000010u;
}
void EncoderRuntimeConfig::clear_has_enable_dtx() {
  _has_bits_[0] &= ~0x00000010u;
}
void EncoderRuntimeConfig::clear_enable_dtx() {
  enable_dtx_ = false;
  clear_has_enable_dtx();
}
bool EncoderRuntimeConfig::enable_dtx() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.debug_dump.EncoderRuntimeConfig.enable_dtx)
  return enable_dtx_;
}
void EncoderRuntimeConfig::set_enable_dtx(bool value) {
  set_has_enable_dtx();
  enable_dtx_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audio_network_adaptor.debug_dump.EncoderRuntimeConfig.enable_dtx)
}

// optional uint32 num_channels = 6;
bool EncoderRuntimeConfig::has_num_channels() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
void EncoderRuntimeConfig::set_has_num_channels() {
  _has_bits_[0] |= 0x00000020u;
}
void EncoderRuntimeConfig::clear_has_num_channels() {
  _has_bits_[0] &= ~0x00000020u;
}
void EncoderRuntimeConfig::clear_num_channels() {
  num_channels_ = 0u;
  clear_has_num_channels();
}
::google::protobuf::uint32 EncoderRuntimeConfig::num_channels() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.debug_dump.EncoderRuntimeConfig.num_channels)
  return num_channels_;
}
void EncoderRuntimeConfig::set_num_channels(::google::protobuf::uint32 value) {
  set_has_num_channels();
  num_channels_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audio_network_adaptor.debug_dump.EncoderRuntimeConfig.num_channels)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int Event::kTypeFieldNumber;
const int Event::kTimestampFieldNumber;
const int Event::kNetworkMetricsFieldNumber;
const int Event::kEncoderRuntimeConfigFieldNumber;
const int Event::kControllerManagerConfigFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

Event::Event()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_debug_5fdump_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:webrtc.audio_network_adaptor.debug_dump.Event)
}
Event::Event(const Event& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_network_metrics()) {
    network_metrics_ = new ::webrtc::audio_network_adaptor::debug_dump::NetworkMetrics(*from.network_metrics_);
  } else {
    network_metrics_ = NULL;
  }
  if (from.has_encoder_runtime_config()) {
    encoder_runtime_config_ = new ::webrtc::audio_network_adaptor::debug_dump::EncoderRuntimeConfig(*from.encoder_runtime_config_);
  } else {
    encoder_runtime_config_ = NULL;
  }
  if (from.has_controller_manager_config()) {
    controller_manager_config_ = new ::webrtc::audio_network_adaptor::config::ControllerManager(*from.controller_manager_config_);
  } else {
    controller_manager_config_ = NULL;
  }
  ::memcpy(&type_, &from.type_,
    static_cast<size_t>(reinterpret_cast<char*>(&timestamp_) -
    reinterpret_cast<char*>(&type_)) + sizeof(timestamp_));
  // @@protoc_insertion_point(copy_constructor:webrtc.audio_network_adaptor.debug_dump.Event)
}

void Event::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&network_metrics_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&timestamp_) -
      reinterpret_cast<char*>(&network_metrics_)) + sizeof(timestamp_));
}

Event::~Event() {
  // @@protoc_insertion_point(destructor:webrtc.audio_network_adaptor.debug_dump.Event)
  SharedDtor();
}

void Event::SharedDtor() {
  if (this != internal_default_instance()) {
    delete network_metrics_;
  }
  if (this != internal_default_instance()) {
    delete encoder_runtime_config_;
  }
  if (this != internal_default_instance()) {
    delete controller_manager_config_;
  }
}

void Event::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const Event& Event::default_instance() {
  protobuf_debug_5fdump_2eproto::InitDefaults();
  return *internal_default_instance();
}

Event* Event::New(::google::protobuf::Arena* arena) const {
  Event* n = new Event;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void Event::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.audio_network_adaptor.debug_dump.Event)
  if (_has_bits_[0 / 32] & 7u) {
    if (has_network_metrics()) {
      GOOGLE_DCHECK(network_metrics_ != NULL);
      network_metrics_->::webrtc::audio_network_adaptor::debug_dump::NetworkMetrics::Clear();
    }
    if (has_encoder_runtime_config()) {
      GOOGLE_DCHECK(encoder_runtime_config_ != NULL);
      encoder_runtime_config_->::webrtc::audio_network_adaptor::debug_dump::EncoderRuntimeConfig::Clear();
    }
    if (has_controller_manager_config()) {
      GOOGLE_DCHECK(controller_manager_config_ != NULL);
      controller_manager_config_->::webrtc::audio_network_adaptor::config::ControllerManager::Clear();
    }
  }
  if (_has_bits_[0 / 32] & 24u) {
    ::memset(&type_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&timestamp_) -
        reinterpret_cast<char*>(&type_)) + sizeof(timestamp_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool Event::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:webrtc.audio_network_adaptor.debug_dump.Event)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .webrtc.audio_network_adaptor.debug_dump.Event.Type type = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::webrtc::audio_network_adaptor::debug_dump::Event_Type_IsValid(value)) {
            set_type(static_cast< ::webrtc::audio_network_adaptor::debug_dump::Event_Type >(value));
          } else {
            unknown_fields_stream.WriteVarint32(8u);
            unknown_fields_stream.WriteVarint32(
                static_cast< ::google::protobuf::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // required uint32 timestamp = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u)) {
          set_has_timestamp();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &timestamp_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.audio_network_adaptor.debug_dump.NetworkMetrics network_metrics = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_network_metrics()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.audio_network_adaptor.debug_dump.EncoderRuntimeConfig encoder_runtime_config = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(34u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_encoder_runtime_config()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.audio_network_adaptor.config.ControllerManager controller_manager_config = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(42u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_controller_manager_config()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:webrtc.audio_network_adaptor.debug_dump.Event)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:webrtc.audio_network_adaptor.debug_dump.Event)
  return false;
#undef DO_
}

void Event::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:webrtc.audio_network_adaptor.debug_dump.Event)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required .webrtc.audio_network_adaptor.debug_dump.Event.Type type = 1;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->type(), output);
  }

  // required uint32 timestamp = 2;
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->timestamp(), output);
  }

  // optional .webrtc.audio_network_adaptor.debug_dump.NetworkMetrics network_metrics = 3;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      3, *this->network_metrics_, output);
  }

  // optional .webrtc.audio_network_adaptor.debug_dump.EncoderRuntimeConfig encoder_runtime_config = 4;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      4, *this->encoder_runtime_config_, output);
  }

  // optional .webrtc.audio_network_adaptor.config.ControllerManager controller_manager_config = 5;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      5, *this->controller_manager_config_, output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:webrtc.audio_network_adaptor.debug_dump.Event)
}

size_t Event::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:webrtc.audio_network_adaptor.debug_dump.Event)
  size_t total_size = 0;

  if (has_type()) {
    // required .webrtc.audio_network_adaptor.debug_dump.Event.Type type = 1;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
  }

  if (has_timestamp()) {
    // required uint32 timestamp = 2;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::UInt32Size(
        this->timestamp());
  }

  return total_size;
}
size_t Event::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:webrtc.audio_network_adaptor.debug_dump.Event)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (((_has_bits_[0] & 0x00000018) ^ 0x00000018) == 0) {  // All required fields are present.
    // required .webrtc.audio_network_adaptor.debug_dump.Event.Type type = 1;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());

    // required uint32 timestamp = 2;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::UInt32Size(
        this->timestamp());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  if (_has_bits_[0 / 32] & 7u) {
    // optional .webrtc.audio_network_adaptor.debug_dump.NetworkMetrics network_metrics = 3;
    if (has_network_metrics()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->network_metrics_);
    }

    // optional .webrtc.audio_network_adaptor.debug_dump.EncoderRuntimeConfig encoder_runtime_config = 4;
    if (has_encoder_runtime_config()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->encoder_runtime_config_);
    }

    // optional .webrtc.audio_network_adaptor.config.ControllerManager controller_manager_config = 5;
    if (has_controller_manager_config()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->controller_manager_config_);
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Event::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const Event*>(&from));
}

void Event::MergeFrom(const Event& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:webrtc.audio_network_adaptor.debug_dump.Event)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 31u) {
    if (cached_has_bits & 0x00000001u) {
      mutable_network_metrics()->::webrtc::audio_network_adaptor::debug_dump::NetworkMetrics::MergeFrom(from.network_metrics());
    }
    if (cached_has_bits & 0x00000002u) {
      mutable_encoder_runtime_config()->::webrtc::audio_network_adaptor::debug_dump::EncoderRuntimeConfig::MergeFrom(from.encoder_runtime_config());
    }
    if (cached_has_bits & 0x00000004u) {
      mutable_controller_manager_config()->::webrtc::audio_network_adaptor::config::ControllerManager::MergeFrom(from.controller_manager_config());
    }
    if (cached_has_bits & 0x00000008u) {
      type_ = from.type_;
    }
    if (cached_has_bits & 0x00000010u) {
      timestamp_ = from.timestamp_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void Event::CopyFrom(const Event& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:webrtc.audio_network_adaptor.debug_dump.Event)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Event::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000018) != 0x00000018) return false;
  return true;
}

void Event::Swap(Event* other) {
  if (other == this) return;
  InternalSwap(other);
}
void Event::InternalSwap(Event* other) {
  std::swap(network_metrics_, other->network_metrics_);
  std::swap(encoder_runtime_config_, other->encoder_runtime_config_);
  std::swap(controller_manager_config_, other->controller_manager_config_);
  std::swap(type_, other->type_);
  std::swap(timestamp_, other->timestamp_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string Event::GetTypeName() const {
  return "webrtc.audio_network_adaptor.debug_dump.Event";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// Event

// required .webrtc.audio_network_adaptor.debug_dump.Event.Type type = 1;
bool Event::has_type() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void Event::set_has_type() {
  _has_bits_[0] |= 0x00000008u;
}
void Event::clear_has_type() {
  _has_bits_[0] &= ~0x00000008u;
}
void Event::clear_type() {
  type_ = 0;
  clear_has_type();
}
::webrtc::audio_network_adaptor::debug_dump::Event_Type Event::type() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.debug_dump.Event.type)
  return static_cast< ::webrtc::audio_network_adaptor::debug_dump::Event_Type >(type_);
}
void Event::set_type(::webrtc::audio_network_adaptor::debug_dump::Event_Type value) {
  assert(::webrtc::audio_network_adaptor::debug_dump::Event_Type_IsValid(value));
  set_has_type();
  type_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audio_network_adaptor.debug_dump.Event.type)
}

// required uint32 timestamp = 2;
bool Event::has_timestamp() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
void Event::set_has_timestamp() {
  _has_bits_[0] |= 0x00000010u;
}
void Event::clear_has_timestamp() {
  _has_bits_[0] &= ~0x00000010u;
}
void Event::clear_timestamp() {
  timestamp_ = 0u;
  clear_has_timestamp();
}
::google::protobuf::uint32 Event::timestamp() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.debug_dump.Event.timestamp)
  return timestamp_;
}
void Event::set_timestamp(::google::protobuf::uint32 value) {
  set_has_timestamp();
  timestamp_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audio_network_adaptor.debug_dump.Event.timestamp)
}

// optional .webrtc.audio_network_adaptor.debug_dump.NetworkMetrics network_metrics = 3;
bool Event::has_network_metrics() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void Event::set_has_network_metrics() {
  _has_bits_[0] |= 0x00000001u;
}
void Event::clear_has_network_metrics() {
  _has_bits_[0] &= ~0x00000001u;
}
void Event::clear_network_metrics() {
  if (network_metrics_ != NULL) network_metrics_->::webrtc::audio_network_adaptor::debug_dump::NetworkMetrics::Clear();
  clear_has_network_metrics();
}
const ::webrtc::audio_network_adaptor::debug_dump::NetworkMetrics& Event::network_metrics() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.debug_dump.Event.network_metrics)
  return network_metrics_ != NULL ? *network_metrics_
                         : *::webrtc::audio_network_adaptor::debug_dump::NetworkMetrics::internal_default_instance();
}
::webrtc::audio_network_adaptor::debug_dump::NetworkMetrics* Event::mutable_network_metrics() {
  set_has_network_metrics();
  if (network_metrics_ == NULL) {
    network_metrics_ = new ::webrtc::audio_network_adaptor::debug_dump::NetworkMetrics;
  }
  // @@protoc_insertion_point(field_mutable:webrtc.audio_network_adaptor.debug_dump.Event.network_metrics)
  return network_metrics_;
}
::webrtc::audio_network_adaptor::debug_dump::NetworkMetrics* Event::release_network_metrics() {
  // @@protoc_insertion_point(field_release:webrtc.audio_network_adaptor.debug_dump.Event.network_metrics)
  clear_has_network_metrics();
  ::webrtc::audio_network_adaptor::debug_dump::NetworkMetrics* temp = network_metrics_;
  network_metrics_ = NULL;
  return temp;
}
void Event::set_allocated_network_metrics(::webrtc::audio_network_adaptor::debug_dump::NetworkMetrics* network_metrics) {
  delete network_metrics_;
  network_metrics_ = network_metrics;
  if (network_metrics) {
    set_has_network_metrics();
  } else {
    clear_has_network_metrics();
  }
  // @@protoc_insertion_point(field_set_allocated:webrtc.audio_network_adaptor.debug_dump.Event.network_metrics)
}

// optional .webrtc.audio_network_adaptor.debug_dump.EncoderRuntimeConfig encoder_runtime_config = 4;
bool Event::has_encoder_runtime_config() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void Event::set_has_encoder_runtime_config() {
  _has_bits_[0] |= 0x00000002u;
}
void Event::clear_has_encoder_runtime_config() {
  _has_bits_[0] &= ~0x00000002u;
}
void Event::clear_encoder_runtime_config() {
  if (encoder_runtime_config_ != NULL) encoder_runtime_config_->::webrtc::audio_network_adaptor::debug_dump::EncoderRuntimeConfig::Clear();
  clear_has_encoder_runtime_config();
}
const ::webrtc::audio_network_adaptor::debug_dump::EncoderRuntimeConfig& Event::encoder_runtime_config() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.debug_dump.Event.encoder_runtime_config)
  return encoder_runtime_config_ != NULL ? *encoder_runtime_config_
                         : *::webrtc::audio_network_adaptor::debug_dump::EncoderRuntimeConfig::internal_default_instance();
}
::webrtc::audio_network_adaptor::debug_dump::EncoderRuntimeConfig* Event::mutable_encoder_runtime_config() {
  set_has_encoder_runtime_config();
  if (encoder_runtime_config_ == NULL) {
    encoder_runtime_config_ = new ::webrtc::audio_network_adaptor::debug_dump::EncoderRuntimeConfig;
  }
  // @@protoc_insertion_point(field_mutable:webrtc.audio_network_adaptor.debug_dump.Event.encoder_runtime_config)
  return encoder_runtime_config_;
}
::webrtc::audio_network_adaptor::debug_dump::EncoderRuntimeConfig* Event::release_encoder_runtime_config() {
  // @@protoc_insertion_point(field_release:webrtc.audio_network_adaptor.debug_dump.Event.encoder_runtime_config)
  clear_has_encoder_runtime_config();
  ::webrtc::audio_network_adaptor::debug_dump::EncoderRuntimeConfig* temp = encoder_runtime_config_;
  encoder_runtime_config_ = NULL;
  return temp;
}
void Event::set_allocated_encoder_runtime_config(::webrtc::audio_network_adaptor::debug_dump::EncoderRuntimeConfig* encoder_runtime_config) {
  delete encoder_runtime_config_;
  encoder_runtime_config_ = encoder_runtime_config;
  if (encoder_runtime_config) {
    set_has_encoder_runtime_config();
  } else {
    clear_has_encoder_runtime_config();
  }
  // @@protoc_insertion_point(field_set_allocated:webrtc.audio_network_adaptor.debug_dump.Event.encoder_runtime_config)
}

// optional .webrtc.audio_network_adaptor.config.ControllerManager controller_manager_config = 5;
bool Event::has_controller_manager_config() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void Event::set_has_controller_manager_config() {
  _has_bits_[0] |= 0x00000004u;
}
void Event::clear_has_controller_manager_config() {
  _has_bits_[0] &= ~0x00000004u;
}
void Event::clear_controller_manager_config() {
  if (controller_manager_config_ != NULL) controller_manager_config_->::webrtc::audio_network_adaptor::config::ControllerManager::Clear();
  clear_has_controller_manager_config();
}
const ::webrtc::audio_network_adaptor::config::ControllerManager& Event::controller_manager_config() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.debug_dump.Event.controller_manager_config)
  return controller_manager_config_ != NULL ? *controller_manager_config_
                         : *::webrtc::audio_network_adaptor::config::ControllerManager::internal_default_instance();
}
::webrtc::audio_network_adaptor::config::ControllerManager* Event::mutable_controller_manager_config() {
  set_has_controller_manager_config();
  if (controller_manager_config_ == NULL) {
    controller_manager_config_ = new ::webrtc::audio_network_adaptor::config::ControllerManager;
  }
  // @@protoc_insertion_point(field_mutable:webrtc.audio_network_adaptor.debug_dump.Event.controller_manager_config)
  return controller_manager_config_;
}
::webrtc::audio_network_adaptor::config::ControllerManager* Event::release_controller_manager_config() {
  // @@protoc_insertion_point(field_release:webrtc.audio_network_adaptor.debug_dump.Event.controller_manager_config)
  clear_has_controller_manager_config();
  ::webrtc::audio_network_adaptor::config::ControllerManager* temp = controller_manager_config_;
  controller_manager_config_ = NULL;
  return temp;
}
void Event::set_allocated_controller_manager_config(::webrtc::audio_network_adaptor::config::ControllerManager* controller_manager_config) {
  delete controller_manager_config_;
  controller_manager_config_ = controller_manager_config;
  if (controller_manager_config) {
    set_has_controller_manager_config();
  } else {
    clear_has_controller_manager_config();
  }
  // @@protoc_insertion_point(field_set_allocated:webrtc.audio_network_adaptor.debug_dump.Event.controller_manager_config)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// @@protoc_insertion_point(namespace_scope)

}  // namespace debug_dump
}  // namespace audio_network_adaptor
}  // namespace webrtc

// @@protoc_insertion_point(global_scope)
