chromium/out/Default/gen/modules/audio_coding/audio_network_adaptor/config.pb.cc

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

#include "config.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

_pb;
_pbi;

namespace webrtc {
namespace audio_network_adaptor {
namespace config {
PROTOBUF_CONSTEXPR FecController_Threshold::FecController_Threshold(
    ::_pbi::ConstantInitialized): … { … }
struct FecController_ThresholdDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FecController_ThresholdDefaultTypeInternal _FecController_Threshold_default_instance_;
PROTOBUF_CONSTEXPR FecController::FecController(
    ::_pbi::ConstantInitialized): … { … }
struct FecControllerDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FecControllerDefaultTypeInternal _FecController_default_instance_;
PROTOBUF_CONSTEXPR FecControllerRplrBased_Threshold::FecControllerRplrBased_Threshold(
    ::_pbi::ConstantInitialized): … { … }
struct FecControllerRplrBased_ThresholdDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FecControllerRplrBased_ThresholdDefaultTypeInternal _FecControllerRplrBased_Threshold_default_instance_;
PROTOBUF_CONSTEXPR FecControllerRplrBased::FecControllerRplrBased(
    ::_pbi::ConstantInitialized): … { … }
struct FecControllerRplrBasedDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FecControllerRplrBasedDefaultTypeInternal _FecControllerRplrBased_default_instance_;
PROTOBUF_CONSTEXPR FrameLengthController::FrameLengthController(
    ::_pbi::ConstantInitialized): … { … }
struct FrameLengthControllerDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FrameLengthControllerDefaultTypeInternal _FrameLengthController_default_instance_;
PROTOBUF_CONSTEXPR FrameLengthControllerV2::FrameLengthControllerV2(
    ::_pbi::ConstantInitialized): … { … }
struct FrameLengthControllerV2DefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FrameLengthControllerV2DefaultTypeInternal _FrameLengthControllerV2_default_instance_;
PROTOBUF_CONSTEXPR ChannelController::ChannelController(
    ::_pbi::ConstantInitialized): … { … }
struct ChannelControllerDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ChannelControllerDefaultTypeInternal _ChannelController_default_instance_;
PROTOBUF_CONSTEXPR DtxController::DtxController(
    ::_pbi::ConstantInitialized): … { … }
struct DtxControllerDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DtxControllerDefaultTypeInternal _DtxController_default_instance_;
PROTOBUF_CONSTEXPR BitrateController::BitrateController(
    ::_pbi::ConstantInitialized): … { … }
struct BitrateControllerDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BitrateControllerDefaultTypeInternal _BitrateController_default_instance_;
PROTOBUF_CONSTEXPR Controller_ScoringPoint::Controller_ScoringPoint(
    ::_pbi::ConstantInitialized): … { … }
struct Controller_ScoringPointDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Controller_ScoringPointDefaultTypeInternal _Controller_ScoringPoint_default_instance_;
PROTOBUF_CONSTEXPR Controller::Controller(
    ::_pbi::ConstantInitialized): … { … }
struct ControllerDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ControllerDefaultTypeInternal _Controller_default_instance_;
PROTOBUF_CONSTEXPR ControllerManager::ControllerManager(
    ::_pbi::ConstantInitialized): … { … }
struct ControllerManagerDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ControllerManagerDefaultTypeInternal _ControllerManager_default_instance_;
}  // namespace config
}  // namespace audio_network_adaptor
}  // namespace webrtc
namespace webrtc {
namespace audio_network_adaptor {
namespace config {

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

class FecController_Threshold::_Internal { … };

FecController_Threshold::FecController_Threshold(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
FecController_Threshold::FecController_Threshold(const FecController_Threshold& from)
  : … { … }

inline void FecController_Threshold::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

FecController_Threshold::~FecController_Threshold() { … }

inline void FecController_Threshold::SharedDtor() { … }

void FecController_Threshold::SetCachedSize(int size) const { … }

void FecController_Threshold::Clear() { … }

const char* FecController_Threshold::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* FecController_Threshold::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t FecController_Threshold::ByteSizeLong() const { … }

void FecController_Threshold::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void FecController_Threshold::MergeFrom(const FecController_Threshold& from) { … }

void FecController_Threshold::CopyFrom(const FecController_Threshold& from) { … }

bool FecController_Threshold::IsInitialized() const { … }

void FecController_Threshold::InternalSwap(FecController_Threshold* other) { … }

std::string FecController_Threshold::GetTypeName() const { … }


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

class FecController::_Internal { … };

const ::webrtc::audio_network_adaptor::config::FecController_Threshold&
FecController::_Internal::fec_enabling_threshold(const FecController* msg) { … }
const ::webrtc::audio_network_adaptor::config::FecController_Threshold&
FecController::_Internal::fec_disabling_threshold(const FecController* msg) { … }
FecController::FecController(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
FecController::FecController(const FecController& from)
  : … { … }

inline void FecController::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

FecController::~FecController() { … }

inline void FecController::SharedDtor() { … }

void FecController::SetCachedSize(int size) const { … }

void FecController::Clear() { … }

const char* FecController::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* FecController::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t FecController::ByteSizeLong() const { … }

void FecController::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void FecController::MergeFrom(const FecController& from) { … }

void FecController::CopyFrom(const FecController& from) { … }

bool FecController::IsInitialized() const { … }

void FecController::InternalSwap(FecController* other) { … }

std::string FecController::GetTypeName() const { … }


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

class FecControllerRplrBased_Threshold::_Internal { … };

FecControllerRplrBased_Threshold::FecControllerRplrBased_Threshold(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
FecControllerRplrBased_Threshold::FecControllerRplrBased_Threshold(const FecControllerRplrBased_Threshold& from)
  : … { … }

inline void FecControllerRplrBased_Threshold::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

FecControllerRplrBased_Threshold::~FecControllerRplrBased_Threshold() { … }

inline void FecControllerRplrBased_Threshold::SharedDtor() { … }

void FecControllerRplrBased_Threshold::SetCachedSize(int size) const { … }

void FecControllerRplrBased_Threshold::Clear() { … }

const char* FecControllerRplrBased_Threshold::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* FecControllerRplrBased_Threshold::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t FecControllerRplrBased_Threshold::ByteSizeLong() const { … }

void FecControllerRplrBased_Threshold::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void FecControllerRplrBased_Threshold::MergeFrom(const FecControllerRplrBased_Threshold& from) { … }

void FecControllerRplrBased_Threshold::CopyFrom(const FecControllerRplrBased_Threshold& from) { … }

bool FecControllerRplrBased_Threshold::IsInitialized() const { … }

void FecControllerRplrBased_Threshold::InternalSwap(FecControllerRplrBased_Threshold* other) { … }

std::string FecControllerRplrBased_Threshold::GetTypeName() const { … }


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

class FecControllerRplrBased::_Internal { … };

const ::webrtc::audio_network_adaptor::config::FecControllerRplrBased_Threshold&
FecControllerRplrBased::_Internal::fec_enabling_threshold(const FecControllerRplrBased* msg) { … }
const ::webrtc::audio_network_adaptor::config::FecControllerRplrBased_Threshold&
FecControllerRplrBased::_Internal::fec_disabling_threshold(const FecControllerRplrBased* msg) { … }
FecControllerRplrBased::FecControllerRplrBased(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
FecControllerRplrBased::FecControllerRplrBased(const FecControllerRplrBased& from)
  : … { … }

inline void FecControllerRplrBased::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

FecControllerRplrBased::~FecControllerRplrBased() { … }

inline void FecControllerRplrBased::SharedDtor() { … }

void FecControllerRplrBased::SetCachedSize(int size) const { … }

void FecControllerRplrBased::Clear() { … }

const char* FecControllerRplrBased::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* FecControllerRplrBased::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t FecControllerRplrBased::ByteSizeLong() const { … }

void FecControllerRplrBased::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void FecControllerRplrBased::MergeFrom(const FecControllerRplrBased& from) { … }

void FecControllerRplrBased::CopyFrom(const FecControllerRplrBased& from) { … }

bool FecControllerRplrBased::IsInitialized() const { … }

void FecControllerRplrBased::InternalSwap(FecControllerRplrBased* other) { … }

std::string FecControllerRplrBased::GetTypeName() const { … }


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

class FrameLengthController::_Internal { … };

FrameLengthController::FrameLengthController(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
FrameLengthController::FrameLengthController(const FrameLengthController& from)
  : … { … }

inline void FrameLengthController::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

FrameLengthController::~FrameLengthController() { … }

inline void FrameLengthController::SharedDtor() { … }

void FrameLengthController::SetCachedSize(int size) const { … }

void FrameLengthController::Clear() { … }

const char* FrameLengthController::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* FrameLengthController::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t FrameLengthController::ByteSizeLong() const { … }

void FrameLengthController::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void FrameLengthController::MergeFrom(const FrameLengthController& from) { … }

void FrameLengthController::CopyFrom(const FrameLengthController& from) { … }

bool FrameLengthController::IsInitialized() const { … }

void FrameLengthController::InternalSwap(FrameLengthController* other) { … }

std::string FrameLengthController::GetTypeName() const { … }


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

class FrameLengthControllerV2::_Internal { … };

FrameLengthControllerV2::FrameLengthControllerV2(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
FrameLengthControllerV2::FrameLengthControllerV2(const FrameLengthControllerV2& from)
  : … { … }

inline void FrameLengthControllerV2::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

FrameLengthControllerV2::~FrameLengthControllerV2() { … }

inline void FrameLengthControllerV2::SharedDtor() { … }

void FrameLengthControllerV2::SetCachedSize(int size) const { … }

void FrameLengthControllerV2::Clear() { … }

const char* FrameLengthControllerV2::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* FrameLengthControllerV2::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t FrameLengthControllerV2::ByteSizeLong() const { … }

void FrameLengthControllerV2::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void FrameLengthControllerV2::MergeFrom(const FrameLengthControllerV2& from) { … }

void FrameLengthControllerV2::CopyFrom(const FrameLengthControllerV2& from) { … }

bool FrameLengthControllerV2::IsInitialized() const { … }

void FrameLengthControllerV2::InternalSwap(FrameLengthControllerV2* other) { … }

std::string FrameLengthControllerV2::GetTypeName() const { … }


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

class ChannelController::_Internal { … };

ChannelController::ChannelController(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
ChannelController::ChannelController(const ChannelController& from)
  : … { … }

inline void ChannelController::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

ChannelController::~ChannelController() { … }

inline void ChannelController::SharedDtor() { … }

void ChannelController::SetCachedSize(int size) const { … }

void ChannelController::Clear() { … }

const char* ChannelController::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* ChannelController::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t ChannelController::ByteSizeLong() const { … }

void ChannelController::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void ChannelController::MergeFrom(const ChannelController& from) { … }

void ChannelController::CopyFrom(const ChannelController& from) { … }

bool ChannelController::IsInitialized() const { … }

void ChannelController::InternalSwap(ChannelController* other) { … }

std::string ChannelController::GetTypeName() const { … }


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

class DtxController::_Internal { … };

DtxController::DtxController(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
DtxController::DtxController(const DtxController& from)
  : … { … }

inline void DtxController::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

DtxController::~DtxController() { … }

inline void DtxController::SharedDtor() { … }

void DtxController::SetCachedSize(int size) const { … }

void DtxController::Clear() { … }

const char* DtxController::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* DtxController::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t DtxController::ByteSizeLong() const { … }

void DtxController::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void DtxController::MergeFrom(const DtxController& from) { … }

void DtxController::CopyFrom(const DtxController& from) { … }

bool DtxController::IsInitialized() const { … }

void DtxController::InternalSwap(DtxController* other) { … }

std::string DtxController::GetTypeName() const { … }


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

class BitrateController::_Internal { … };

BitrateController::BitrateController(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
BitrateController::BitrateController(const BitrateController& from)
  : … { … }

inline void BitrateController::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

BitrateController::~BitrateController() { … }

inline void BitrateController::SharedDtor() { … }

void BitrateController::SetCachedSize(int size) const { … }

void BitrateController::Clear() { … }

const char* BitrateController::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* BitrateController::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t BitrateController::ByteSizeLong() const { … }

void BitrateController::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void BitrateController::MergeFrom(const BitrateController& from) { … }

void BitrateController::CopyFrom(const BitrateController& from) { … }

bool BitrateController::IsInitialized() const { … }

void BitrateController::InternalSwap(BitrateController* other) { … }

std::string BitrateController::GetTypeName() const { … }


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

class Controller_ScoringPoint::_Internal { … };

Controller_ScoringPoint::Controller_ScoringPoint(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
Controller_ScoringPoint::Controller_ScoringPoint(const Controller_ScoringPoint& from)
  : … { … }

inline void Controller_ScoringPoint::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

Controller_ScoringPoint::~Controller_ScoringPoint() { … }

inline void Controller_ScoringPoint::SharedDtor() { … }

void Controller_ScoringPoint::SetCachedSize(int size) const { … }

void Controller_ScoringPoint::Clear() { … }

const char* Controller_ScoringPoint::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* Controller_ScoringPoint::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t Controller_ScoringPoint::ByteSizeLong() const { … }

void Controller_ScoringPoint::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void Controller_ScoringPoint::MergeFrom(const Controller_ScoringPoint& from) { … }

void Controller_ScoringPoint::CopyFrom(const Controller_ScoringPoint& from) { … }

bool Controller_ScoringPoint::IsInitialized() const { … }

void Controller_ScoringPoint::InternalSwap(Controller_ScoringPoint* other) { … }

std::string Controller_ScoringPoint::GetTypeName() const { … }


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

class Controller::_Internal { … };

const ::webrtc::audio_network_adaptor::config::Controller_ScoringPoint&
Controller::_Internal::scoring_point(const Controller* msg) { … }
const ::webrtc::audio_network_adaptor::config::FecController&
Controller::_Internal::fec_controller(const Controller* msg) { … }
const ::webrtc::audio_network_adaptor::config::FrameLengthController&
Controller::_Internal::frame_length_controller(const Controller* msg) { … }
const ::webrtc::audio_network_adaptor::config::ChannelController&
Controller::_Internal::channel_controller(const Controller* msg) { … }
const ::webrtc::audio_network_adaptor::config::DtxController&
Controller::_Internal::dtx_controller(const Controller* msg) { … }
const ::webrtc::audio_network_adaptor::config::BitrateController&
Controller::_Internal::bitrate_controller(const Controller* msg) { … }
const ::webrtc::audio_network_adaptor::config::FecControllerRplrBased&
Controller::_Internal::fec_controller_rplr_based(const Controller* msg) { … }
const ::webrtc::audio_network_adaptor::config::FrameLengthControllerV2&
Controller::_Internal::frame_length_controller_v2(const Controller* msg) { … }
void Controller::set_allocated_fec_controller(::webrtc::audio_network_adaptor::config::FecController* fec_controller) { … }
void Controller::set_allocated_frame_length_controller(::webrtc::audio_network_adaptor::config::FrameLengthController* frame_length_controller) { … }
void Controller::set_allocated_channel_controller(::webrtc::audio_network_adaptor::config::ChannelController* channel_controller) { … }
void Controller::set_allocated_dtx_controller(::webrtc::audio_network_adaptor::config::DtxController* dtx_controller) { … }
void Controller::set_allocated_bitrate_controller(::webrtc::audio_network_adaptor::config::BitrateController* bitrate_controller) { … }
void Controller::set_allocated_fec_controller_rplr_based(::webrtc::audio_network_adaptor::config::FecControllerRplrBased* fec_controller_rplr_based) { … }
void Controller::set_allocated_frame_length_controller_v2(::webrtc::audio_network_adaptor::config::FrameLengthControllerV2* frame_length_controller_v2) { … }
Controller::Controller(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
Controller::Controller(const Controller& from)
  : … { … }

inline void Controller::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

Controller::~Controller() { … }

inline void Controller::SharedDtor() { … }

void Controller::SetCachedSize(int size) const { … }

void Controller::clear_controller() { … }


void Controller::Clear() { … }

const char* Controller::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* Controller::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t Controller::ByteSizeLong() const { … }

void Controller::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void Controller::MergeFrom(const Controller& from) { … }

void Controller::CopyFrom(const Controller& from) { … }

bool Controller::IsInitialized() const { … }

void Controller::InternalSwap(Controller* other) { … }

std::string Controller::GetTypeName() const { … }


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

class ControllerManager::_Internal { … };

ControllerManager::ControllerManager(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
ControllerManager::ControllerManager(const ControllerManager& from)
  : … { … }

inline void ControllerManager::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

ControllerManager::~ControllerManager() { … }

inline void ControllerManager::SharedDtor() { … }

void ControllerManager::SetCachedSize(int size) const { … }

void ControllerManager::Clear() { … }

const char* ControllerManager::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* ControllerManager::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t ControllerManager::ByteSizeLong() const { … }

void ControllerManager::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void ControllerManager::MergeFrom(const ControllerManager& from) { … }

void ControllerManager::CopyFrom(const ControllerManager& from) { … }

bool ControllerManager::IsInitialized() const { … }

void ControllerManager::InternalSwap(ControllerManager* other) { … }

std::string ControllerManager::GetTypeName() const { … }


// @@protoc_insertion_point(namespace_scope)
}  // namespace config
}  // namespace audio_network_adaptor
}  // namespace webrtc
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::webrtc::audio_network_adaptor::config::FecController_Threshold*
Arena::CreateMaybeMessage< ::webrtc::audio_network_adaptor::config::FecController_Threshold >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::webrtc::audio_network_adaptor::config::FecController*
Arena::CreateMaybeMessage< ::webrtc::audio_network_adaptor::config::FecController >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::webrtc::audio_network_adaptor::config::FecControllerRplrBased_Threshold*
Arena::CreateMaybeMessage< ::webrtc::audio_network_adaptor::config::FecControllerRplrBased_Threshold >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::webrtc::audio_network_adaptor::config::FecControllerRplrBased*
Arena::CreateMaybeMessage< ::webrtc::audio_network_adaptor::config::FecControllerRplrBased >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::webrtc::audio_network_adaptor::config::FrameLengthController*
Arena::CreateMaybeMessage< ::webrtc::audio_network_adaptor::config::FrameLengthController >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::webrtc::audio_network_adaptor::config::FrameLengthControllerV2*
Arena::CreateMaybeMessage< ::webrtc::audio_network_adaptor::config::FrameLengthControllerV2 >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::webrtc::audio_network_adaptor::config::ChannelController*
Arena::CreateMaybeMessage< ::webrtc::audio_network_adaptor::config::ChannelController >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::webrtc::audio_network_adaptor::config::DtxController*
Arena::CreateMaybeMessage< ::webrtc::audio_network_adaptor::config::DtxController >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::webrtc::audio_network_adaptor::config::BitrateController*
Arena::CreateMaybeMessage< ::webrtc::audio_network_adaptor::config::BitrateController >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::webrtc::audio_network_adaptor::config::Controller_ScoringPoint*
Arena::CreateMaybeMessage< ::webrtc::audio_network_adaptor::config::Controller_ScoringPoint >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::webrtc::audio_network_adaptor::config::Controller*
Arena::CreateMaybeMessage< ::webrtc::audio_network_adaptor::config::Controller >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::webrtc::audio_network_adaptor::config::ControllerManager*
Arena::CreateMaybeMessage< ::webrtc::audio_network_adaptor::config::ControllerManager >(Arena* arena) { … }
PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>