From 24e8ec496476196bfd925470442cbb7fdd7d9294 Mon Sep 17 00:00:00 2001 From: Auzan Date: Tue, 20 Mar 2018 11:09:25 +0700 Subject: [PATCH 01/78] adding feature sendUserState and voice target for whisper. --- .gitignore | 3 ++ include/mumlib.hpp | 8 +++++ include/mumlib/enums.hpp | 10 ++++++ src/CryptState.cpp | 3 +- src/mumlib.cpp | 69 ++++++++++++++++++++++++++++++++++++++-- 5 files changed, 90 insertions(+), 3 deletions(-) diff --git a/.gitignore b/.gitignore index 4286771..da3351e 100644 --- a/.gitignore +++ b/.gitignore @@ -32,3 +32,6 @@ build/ # IntelliJ *.iml .idea/ + +# Boost +include/boost/ diff --git a/include/mumlib.hpp b/include/mumlib.hpp index 95afe02..ef84744 100644 --- a/include/mumlib.hpp +++ b/include/mumlib.hpp @@ -50,10 +50,18 @@ namespace mumlib { void sendAudioData(int16_t *pcmData, int pcmLength); + void sendAudioDataTarget(int targetId, int16_t *pcmData, int pcmLength); + void sendTextMessage(std::string message); void joinChannel(int channelId); + void sendVoiceTarget(int targetId, int channelId); + + void sendUserState(mumlib::UserState state, bool val); + + void sendUserState(mumlib::UserState state, std::string value); + private: _Mumlib_Private *impl; }; diff --git a/include/mumlib/enums.hpp b/include/mumlib/enums.hpp index b4a9b43..ea189f9 100644 --- a/include/mumlib/enums.hpp +++ b/include/mumlib/enums.hpp @@ -45,4 +45,14 @@ namespace mumlib { OPUS }; + enum class UserState { + MUTE, + DEAF, + SUPPRESS, + SELF_MUTE, + SELF_DEAF, + COMMENT, + PRIORITY_SPEAKER, + RECORDING + }; } \ No newline at end of file diff --git a/src/CryptState.cpp b/src/CryptState.cpp index 0760374..467955d 100644 --- a/src/CryptState.cpp +++ b/src/CryptState.cpp @@ -181,7 +181,8 @@ bool mumlib::CryptState::decrypt(const unsigned char *source, unsigned char *dst #define SHIFTBITS 63 typedef uint64_t subblock; -#define SWAP64(x) ({register uint64_t __out, __in = (x); __asm__("bswap %q0" : "=r"(__out) : "0"(__in)); __out;}) +// #define SWAP64(x) ({register uint64_t __out, __in = (x); __asm__("bswap %q0" : "=r"(__out) : "0"(__in)); __out;}) +#define SWAP64(x) (__builtin_bswap64(x)) #define SWAPPED(x) SWAP64(x) typedef subblock keyblock[BLOCKSIZE]; diff --git a/src/mumlib.cpp b/src/mumlib.cpp index 08197d1..16e5c4b 100644 --- a/src/mumlib.cpp +++ b/src/mumlib.cpp @@ -152,7 +152,7 @@ namespace mumlib { links_remove.push_back(channelState.links_remove(i)); } - this->channelId = channel_id; + // this->channelId = channel_id; callback.channelState( channelState.name(), @@ -369,7 +369,7 @@ namespace mumlib { void Mumlib::disconnect() { if (not impl->externalIoService) { - impl->ioService.reset(); + impl->ioService.stop(); } if (impl->transport.getConnectionState() != ConnectionState::NOT_CONNECTED) { impl->transport.disconnect(); @@ -390,6 +390,12 @@ namespace mumlib { impl->transport.sendEncodedAudioPacket(encodedData, length); } + void Mumlib::sendAudioDataTarget(int targetId, int16_t *pcmData, int pcmLength) { + uint8_t encodedData[5000]; + int length = impl->audio.encodeAudioPacket(targetId, pcmData, pcmLength, encodedData, 5000); + impl->transport.sendEncodedAudioPacket(encodedData, length); + } + void Mumlib::sendTextMessage(string message) { MumbleProto::TextMessage textMessage; textMessage.set_actor(impl->sessionId); @@ -404,4 +410,63 @@ namespace mumlib { impl->transport.sendControlMessage(MessageType::USERSTATE, userState); impl->channelId = channelId; } + + void Mumlib::sendVoiceTarget(int targetId, int channelId) { + MumbleProto::VoiceTarget voiceTarget; + MumbleProto::VoiceTarget_Target voiceTargetTarget; + voiceTargetTarget.set_channel_id(channelId); + voiceTargetTarget.set_children(true); + voiceTarget.set_id(targetId); + voiceTarget.add_targets()->CopyFrom(voiceTargetTarget); + impl->transport.sendControlMessage(MessageType::VOICETARGET, voiceTarget); + } + + void Mumlib::sendUserState(mumlib::UserState field, bool val) { + MumbleProto::UserState userState; + + switch (field) { + case UserState::MUTE: + userState.set_mute(val); + break; + case UserState::DEAF: + userState.set_deaf(val); + break; + case UserState::SUPPRESS: + userState.set_suppress(val); + break; + case UserState::SELF_MUTE: + userState.set_self_mute(val); + break; + case UserState::SELF_DEAF: + userState.set_self_deaf(val); + break; + case UserState::PRIORITY_SPEAKER: + userState.set_priority_speaker(val); + break; + case UserState::RECORDING: + userState.set_recording(val); + break; + default: + // in any other case, just ignore the command + return; + } + + impl->transport.sendControlMessage(MessageType::USERSTATE, userState); + } + + void Mumlib::sendUserState(mumlib::UserState field, std::string val) { + MumbleProto::UserState userState; + + switch (field) { + case UserState::COMMENT: + // TODO: if comment longer than 128 bytes, we need to set the SHA1 hash + userState.set_comment(val); + break; + default: + // in any other case, just ignore the command + return; + } + + impl->transport.sendControlMessage(MessageType::USERSTATE, userState); + } } From 993ea209c7ff108aa3c8f632bcb33f0171d74ce7 Mon Sep 17 00:00:00 2001 From: Auzan Date: Wed, 21 Mar 2018 10:46:07 +0700 Subject: [PATCH 02/78] remove boost include library from .gitignore --- .gitignore | 3 --- 1 file changed, 3 deletions(-) diff --git a/.gitignore b/.gitignore index da3351e..4286771 100644 --- a/.gitignore +++ b/.gitignore @@ -32,6 +32,3 @@ build/ # IntelliJ *.iml .idea/ - -# Boost -include/boost/ From 7d64b05e3cb6627116d8725aec3c91694627d382 Mon Sep 17 00:00:00 2001 From: Auzan Date: Wed, 28 Mar 2018 10:37:59 +0700 Subject: [PATCH 03/78] intelij hack --- include/mumlib.hpp | 8 ++++++- include/mumlib/Audio.hpp | 11 ++++----- include/mumlib/Callback.hpp | 38 ++++++++++++++--------------- include/mumlib/Transport.hpp | 5 +++- include/mumlib/VarInt.hpp | 2 +- src/Audio.cpp | 17 ++++++------- src/Callback.cpp | 2 +- src/Transport.cpp | 46 ++++++++++++++++++++++-------------- src/VarInt.cpp | 41 ++++++++++++++++---------------- src/mumlib.cpp | 16 ++++++++++++- 10 files changed, 110 insertions(+), 76 deletions(-) diff --git a/include/mumlib.hpp b/include/mumlib.hpp index ef84744..af979a0 100644 --- a/include/mumlib.hpp +++ b/include/mumlib.hpp @@ -11,6 +11,7 @@ namespace mumlib { constexpr int DEFAULT_OPUS_ENCODER_BITRATE = 16000; + constexpr int DEFAULT_OPUS_SAMPLE_RATE = 48000; using namespace std; using namespace boost::asio; @@ -22,6 +23,7 @@ namespace mumlib { struct MumlibConfiguration { int opusEncoderBitrate = DEFAULT_OPUS_ENCODER_BITRATE; + int opusSampleRate = DEFAULT_OPUS_SAMPLE_RATE; // additional fields will be added in the future }; @@ -30,7 +32,7 @@ namespace mumlib { class Mumlib : boost::noncopyable { public: - Mumlib(Callback &callback); + explicit Mumlib(Callback &callback); Mumlib(Callback &callback, io_service &ioService); @@ -44,10 +46,14 @@ namespace mumlib { void disconnect(); + void reconnect(); + void run(); ConnectionState getConnectionState(); + int getChannelId(); + void sendAudioData(int16_t *pcmData, int pcmLength); void sendAudioDataTarget(int targetId, int16_t *pcmData, int pcmLength); diff --git a/include/mumlib/Audio.hpp b/include/mumlib/Audio.hpp index d98f41a..df3ed11 100644 --- a/include/mumlib/Audio.hpp +++ b/include/mumlib/Audio.hpp @@ -2,19 +2,17 @@ #include "Transport.hpp" -#include +#include #include namespace mumlib { - constexpr int SAMPLE_RATE = 48000; - class MumlibException; class AudioException : public MumlibException { public: - AudioException(string message) : MumlibException(message) { } + explicit AudioException(string message) : MumlibException(message) { } }; struct IncomingAudioPacket { @@ -27,8 +25,8 @@ namespace mumlib { }; class Audio : boost::noncopyable { - public: - Audio(int opusEncoderBitrate = DEFAULT_OPUS_ENCODER_BITRATE); + public: + Audio(int opusSampleRate, int opusEncoderBitrate); virtual ~Audio(); @@ -59,6 +57,7 @@ namespace mumlib { OpusEncoder *opusEncoder; int64_t outgoingSequenceNumber; + int sampleRate; std::chrono::time_point lastEncodedAudioPacketTimestamp; }; diff --git a/include/mumlib/Callback.hpp b/include/mumlib/Callback.hpp index a11b7b4..3e3ac4c 100644 --- a/include/mumlib/Callback.hpp +++ b/include/mumlib/Callback.hpp @@ -153,7 +153,7 @@ namespace mumlib { ~BasicCallback(); - virtual void version( + void version( uint16_t major, uint8_t minor, uint8_t patch, @@ -161,29 +161,29 @@ namespace mumlib { string os, string os_version) override; - virtual void audio( + void audio( int target, int sessionId, int sequenceNumber, int16_t *pcm_data, uint32_t pcm_data_size) override; - virtual void unsupportedAudio( + void unsupportedAudio( int target, int sessionId, int sequenceNumber, uint8_t *encoded_audio_data, uint32_t encoded_audio_data_size) override; - virtual void serverSync( + void serverSync( string welcome_text, int32_t session, int32_t max_bandwidth, int64_t permissions) override; - virtual void channelRemove(uint32_t channel_id) override; + void channelRemove(uint32_t channel_id) override; - virtual void channelState( + void channelState( string name, int32_t channel_id, int32_t parent, @@ -194,13 +194,13 @@ namespace mumlib { bool temporary, int32_t position) override; - virtual void userRemove( + void userRemove( uint32_t session, int32_t actor, string reason, bool ban) override; - virtual void userState( + void userState( int32_t session, int32_t actor, string name, @@ -215,7 +215,7 @@ namespace mumlib { int32_t priority_speaker, int32_t recording) override; - virtual void banList( + void banList( const uint8_t *ip_data, uint32_t ip_data_size, uint32_t mask, @@ -225,14 +225,14 @@ namespace mumlib { string start, int32_t duration) override; - virtual void textMessage( + void textMessage( uint32_t actor, std::vector session, std::vector channel_id, std::vector tree_id, string message) override; - virtual void permissionDenied( + void permissionDenied( int32_t permission, int32_t channel_id, int32_t session, @@ -240,48 +240,48 @@ namespace mumlib { int32_t deny_type, string name) override; - virtual void queryUsers( + void queryUsers( uint32_t n_ids, uint32_t *ids, uint32_t n_names, string *names) override; - virtual void contextActionModify( + void contextActionModify( string action, string text, uint32_t m_context, uint32_t operation) override; - virtual void contextAction( + void contextAction( int32_t session, int32_t channel_id, string action) override; - virtual void userList( + void userList( uint32_t user_id, string name, string last_seen, int32_t last_channel) override; - virtual void permissionQuery( + void permissionQuery( int32_t channel_id, uint32_t permissions, int32_t flush) override; - virtual void codecVersion( + void codecVersion( int32_t alpha, int32_t beta, uint32_t prefer_alpha, int32_t opus) override; - virtual void serverConfig( + void serverConfig( uint32_t max_bandwidth, string welcome_text, uint32_t allow_html, uint32_t message_length, uint32_t image_message_length) override; - virtual void suggestConfig( + void suggestConfig( uint32_t version, uint32_t positional, uint32_t push_to_talk) override; diff --git a/include/mumlib/Transport.hpp b/include/mumlib/Transport.hpp index ccf94a7..f200dca 100644 --- a/include/mumlib/Transport.hpp +++ b/include/mumlib/Transport.hpp @@ -14,6 +14,7 @@ #include #include +#include namespace mumlib { @@ -30,7 +31,7 @@ namespace mumlib { class TransportException : public MumlibException { public: - TransportException(string message) : MumlibException(message) { } + TransportException(string message) : MumlibException(std::move(message)) { } }; class Transport : boost::noncopyable { @@ -49,6 +50,8 @@ namespace mumlib { void disconnect(); + void reconnect(); + ConnectionState getConnectionState() { return state; } diff --git a/include/mumlib/VarInt.hpp b/include/mumlib/VarInt.hpp index 451c61e..5ebacce 100644 --- a/include/mumlib/VarInt.hpp +++ b/include/mumlib/VarInt.hpp @@ -29,6 +29,6 @@ namespace mumlib { private: const int64_t value; - int64_t parseVariant(uint8_t *buffer); + long parseVariant(const uint8_t *buffer); }; } \ No newline at end of file diff --git a/src/Audio.cpp b/src/Audio.cpp index 3ce7594..384942d 100644 --- a/src/Audio.cpp +++ b/src/Audio.cpp @@ -4,20 +4,21 @@ static boost::posix_time::seconds RESET_SEQUENCE_NUMBER_INTERVAL(5); -mumlib::Audio::Audio(int opusEncoderBitrate) +mumlib::Audio::Audio(int opusSampleRate, int opusEncoderBitrate) : logger(log4cpp::Category::getInstance("mumlib.Audio")), opusDecoder(nullptr), opusEncoder(nullptr), outgoingSequenceNumber(0) { int error; + this->sampleRate = opusSampleRate; - opusDecoder = opus_decoder_create(SAMPLE_RATE, 1, &error); + opusDecoder = opus_decoder_create(opusSampleRate, 1, &error); if (error != OPUS_OK) { throw AudioException((boost::format("failed to initialize OPUS decoder: %s") % opus_strerror(error)).str()); } - opusEncoder = opus_encoder_create(SAMPLE_RATE, 1, OPUS_APPLICATION_VOIP, &error); + opusEncoder = opus_encoder_create(opusSampleRate, 1, OPUS_APPLICATION_VOIP, &error); if (error != OPUS_OK) { throw AudioException((boost::format("failed to initialize OPUS encoder: %s") % opus_strerror(error)).str()); } @@ -108,7 +109,7 @@ int mumlib::Audio::encodeAudioPacket(int target, int16_t *inputPcmBuffer, int in std::vector header; - header.push_back(0x80 | target); + header.push_back(static_cast(0x80 | target)); auto sequenceNumberEnc = VarInt(outgoingSequenceNumber).getEncoded(); header.insert(header.end(), sequenceNumberEnc.begin(), sequenceNumberEnc.end()); @@ -130,15 +131,15 @@ int mumlib::Audio::encodeAudioPacket(int target, int16_t *inputPcmBuffer, int in header.insert(header.end(), outputSizeEnc.begin(), outputSizeEnc.end()); memcpy(outputBuffer, &header[0], header.size()); - memcpy(outputBuffer + header.size(), tmpOpusBuffer, outputSize); + memcpy(outputBuffer + header.size(), tmpOpusBuffer, (size_t) outputSize); - int incrementNumber = 100 * inputLength / SAMPLE_RATE; + int incrementNumber = 100 * inputLength / this->sampleRate; outgoingSequenceNumber += incrementNumber; lastEncodedAudioPacketTimestamp = std::chrono::system_clock::now(); - return outputSize + header.size(); + return static_cast(outputSize + header.size()); } void mumlib::Audio::resetEncoder() { @@ -152,7 +153,7 @@ void mumlib::Audio::resetEncoder() { } mumlib::IncomingAudioPacket mumlib::Audio::decodeIncomingAudioPacket(uint8_t *inputBuffer, int inputBufferLength) { - mumlib::IncomingAudioPacket incomingAudioPacket; + mumlib::IncomingAudioPacket incomingAudioPacket{}; incomingAudioPacket.type = static_cast((inputBuffer[0] & 0xE0) >> 5); incomingAudioPacket.target = inputBuffer[0] & 0x1F; diff --git a/src/Callback.cpp b/src/Callback.cpp index ea8fb80..5bc69e3 100644 --- a/src/Callback.cpp +++ b/src/Callback.cpp @@ -35,7 +35,7 @@ void mumlib::BasicCallback::version( os_version.c_str()); } -void mumlib::BasicCallback::audio( +void BasicCallback::audio( int target, int sessionId, int sequenceNumber, diff --git a/src/Transport.cpp b/src/Transport.cpp index f134512..e016f50 100644 --- a/src/Transport.cpp +++ b/src/Transport.cpp @@ -3,6 +3,7 @@ #include "Mumble.pb.h" #include +#include using namespace std; @@ -32,15 +33,15 @@ mumlib::Transport::Transport( bool noUdp) : logger(log4cpp::Category::getInstance("mumlib.Transport")), ioService(ioService), - processMessageFunction(processMessageFunc), - processEncodedAudioPacketFunction(processEncodedAudioPacketFunction), + processMessageFunction(std::move(processMessageFunc)), + processEncodedAudioPacketFunction(std::move(processEncodedAudioPacketFunction)), noUdp(noUdp), state(ConnectionState::NOT_CONNECTED), udpSocket(ioService), sslContext(ssl::context::sslv23), sslSocket(ioService, sslContext), pingTimer(ioService, PING_INTERVAL), - asyncBufferPool(max(MAX_UDP_LENGTH, MAX_TCP_LENGTH)) { + asyncBufferPool(static_cast(max(MAX_UDP_LENGTH, MAX_TCP_LENGTH))) { sslIncomingBuffer = new uint8_t[MAX_TCP_LENGTH]; @@ -118,6 +119,15 @@ void mumlib::Transport::disconnect() { } } +void mumlib::Transport::reconnect() { + boost::system::error_code errorCode; + + udpSocket.close(errorCode); + if (errorCode) { + logger.warn("SSL socket close return an error: %s.", errorCode.message().c_str()); + } +} + void mumlib::Transport::sendVersion() { MumbleProto::Version version; @@ -185,10 +195,10 @@ void mumlib::Transport::doReceiveUdp() { } uint8_t plainBuffer[1024]; - const int plainBufferLength = bytesTransferred - 4; + const int plainBufferLength = static_cast(bytesTransferred - 4); bool success = cryptState.decrypt( - udpIncomingBuffer, plainBuffer, bytesTransferred); + udpIncomingBuffer, plainBuffer, static_cast(bytesTransferred)); if (not success) { throwTransportException("UDP packet decryption failed"); @@ -263,12 +273,12 @@ void mumlib::Transport::sendUdpAsync(uint8_t *buff, int length) { auto *encryptedMsgBuff = asyncBufferPool.malloc(); const int encryptedMsgLength = length + 4; - cryptState.encrypt(buff, reinterpret_cast(encryptedMsgBuff), length); + cryptState.encrypt(buff, reinterpret_cast(encryptedMsgBuff), static_cast(length)); logger.debug("Sending %d B of data UDP asynchronously.", encryptedMsgLength); udpSocket.async_send_to( - boost::asio::buffer(encryptedMsgBuff, length + 4), + boost::asio::buffer(encryptedMsgBuff, static_cast(length + 4)), udpReceiverEndpoint, [this, encryptedMsgBuff](const boost::system::error_code &ec, size_t bytesTransferred) { asyncBufferPool.free(encryptedMsgBuff); @@ -318,7 +328,7 @@ void mumlib::Transport::doReceiveSsl() { processMessageInternal( static_cast(messageType), &sslIncomingBuffer[6], - bytesTransferred - 6); + static_cast(bytesTransferred - 6)); doReceiveSsl(); } else { @@ -438,10 +448,10 @@ void mumlib::Transport::sendUdpPing() { vector message; message.push_back(0x20); - auto timestampVarint = VarInt(time(nullptr)).getEncoded(); + auto timestampVarint = VarInt(static_cast(time(nullptr))).getEncoded(); message.insert(message.end(), timestampVarint.begin(), timestampVarint.end()); - sendUdpAsync(&message[0], message.size()); + sendUdpAsync(&message[0], static_cast(message.size())); } void mumlib::Transport::sendSsl(uint8_t *buff, int length) { @@ -453,7 +463,7 @@ void mumlib::Transport::sendSsl(uint8_t *buff, int length) { logger.debug("Sending %d bytes of data.", length); try { - write(sslSocket, boost::asio::buffer(buff, length)); + write(sslSocket, boost::asio::buffer(buff, static_cast(length))); } catch (boost::system::system_error &err) { throwTransportException(std::string("SSL send failed: ") + err.what()); } @@ -467,13 +477,13 @@ void mumlib::Transport::sendSslAsync(uint8_t *buff, int length) { auto *asyncBuff = asyncBufferPool.malloc(); - memcpy(asyncBuff, buff, length); + memcpy(asyncBuff, buff, static_cast(length)); logger.debug("Sending %d B of data asynchronously.", length); async_write( sslSocket, - boost::asio::buffer(asyncBuff, length), + boost::asio::buffer(asyncBuff, static_cast(length)), [this, asyncBuff](const boost::system::error_code &ec, size_t bytesTransferred) { asyncBufferPool.free(asyncBuff); logger.debug("Sent %d B.", bytesTransferred); @@ -499,7 +509,7 @@ void mumlib::Transport::sendControlMessagePrivate(MessageType type, google::prot const uint16_t type_network = htons(static_cast(type)); const int size = message.ByteSize(); - const uint32_t size_network = htonl(size); + const uint32_t size_network = htonl((uint32_t) size); const int length = sizeof(type_network) + sizeof(size_network) + size; @@ -517,7 +527,7 @@ void mumlib::Transport::sendControlMessagePrivate(MessageType type, google::prot void mumlib::Transport::throwTransportException(string message) { state = ConnectionState::FAILED; - throw TransportException(message); + throw TransportException(std::move(message)); } void mumlib::Transport::sendEncodedAudioPacket(uint8_t *buffer, int length) { @@ -534,7 +544,7 @@ void mumlib::Transport::sendEncodedAudioPacket(uint8_t *buffer, int length) { const uint16_t netUdptunnelType = htons(static_cast(MessageType::UDPTUNNEL)); - const uint32_t netLength = htonl(length); + const uint32_t netLength = htonl(static_cast(length)); const int packet = sizeof(netUdptunnelType) + sizeof(netLength) + length; @@ -542,14 +552,14 @@ void mumlib::Transport::sendEncodedAudioPacket(uint8_t *buffer, int length) { memcpy(packetBuff, &netUdptunnelType, sizeof(netUdptunnelType)); memcpy(packetBuff + sizeof(netUdptunnelType), &netLength, sizeof(netLength)); - memcpy(packetBuff + sizeof(netUdptunnelType) + sizeof(netLength), buffer, length); + memcpy(packetBuff + sizeof(netUdptunnelType) + sizeof(netLength), buffer, static_cast(length)); sendSslAsync(packetBuff, length + sizeof(netUdptunnelType) + sizeof(netLength)); } } void mumlib::Transport::processAudioPacket(uint8_t *buff, int length) { - AudioPacketType type = static_cast((buff[0] & 0xE0) >> 5); + auto type = static_cast((buff[0] & 0xE0) >> 5); switch (type) { case AudioPacketType::CELT_Alpha: case AudioPacketType::Speex: diff --git a/src/VarInt.cpp b/src/VarInt.cpp index 2eeebf8..bd489da 100644 --- a/src/VarInt.cpp +++ b/src/VarInt.cpp @@ -12,7 +12,7 @@ mumlib::VarInt::VarInt(std::vector encoded) : value(parseVariant(&encod * This code was taken from Mumble source code * https://github.com/mumble-voip/mumble/blob/master/src/PacketDataStream.h */ -int64_t mumlib::VarInt::parseVariant(uint8_t *buffer) { +int64_t mumlib::VarInt::parseVariant(const uint8_t *buffer) { int64_t v = buffer[0]; if ((v & 0x80) == 0x00) { return (v & 0x7F); @@ -36,6 +36,7 @@ int64_t mumlib::VarInt::parseVariant(uint8_t *buffer) { return (v & 0x1F) << 16 | buffer[1] << 8 | buffer[2]; } + throw VarIntException("invalid varint"); } @@ -46,7 +47,7 @@ std::vector mumlib::VarInt::getEncoded() const { if ((i & 0x8000000000000000LL) && (~i < 0x100000000LL)) { i = ~i; if (i <= 0x3) { - encoded.push_back(0xFC | i); + encoded.push_back(static_cast(0xFC | i)); return encoded; } else { encoded.push_back(0xF8); @@ -54,29 +55,29 @@ std::vector mumlib::VarInt::getEncoded() const { } if (i < 0x80) { - encoded.push_back(i); + encoded.push_back(static_cast(i)); } else if (i < 0x4000) { - encoded.push_back(0x80 | (i >> 8)); - encoded.push_back(i & 0xFF); + encoded.push_back(static_cast(0x80 | (i >> 8))); + encoded.push_back(static_cast(i & 0xFF)); } else if (i < 0x200000) { - encoded.push_back(0xC0 | (i >> 16)); - encoded.push_back((i >> 8) & 0xFF); - encoded.push_back(i & 0xFF); + encoded.push_back(static_cast(0xC0 | (i >> 16))); + encoded.push_back(static_cast((i >> 8) & 0xFF)); + encoded.push_back(static_cast(i & 0xFF)); } else if (i < 0x10000000) { - encoded.push_back(0xE0 | (i >> 24)); - encoded.push_back((i >> 16) & 0xFF); - encoded.push_back((i >> 8) & 0xFF); - encoded.push_back(i & 0xFF); + encoded.push_back(static_cast(0xE0 | (i >> 24))); + encoded.push_back(static_cast((i >> 16) & 0xFF)); + encoded.push_back(static_cast((i >> 8) & 0xFF)); + encoded.push_back(static_cast(i & 0xFF)); } else { encoded.push_back(0xF4); - encoded.push_back((i >> 56) & 0xFF); - encoded.push_back((i >> 48) & 0xFF); - encoded.push_back((i >> 40) & 0xFF); - encoded.push_back((i >> 32) & 0xFF); - encoded.push_back((i >> 24) & 0xFF); - encoded.push_back((i >> 16) & 0xFF); - encoded.push_back((i >> 8) & 0xFF); - encoded.push_back(i & 0xFF); + encoded.push_back(static_cast((i >> 56) & 0xFF)); + encoded.push_back(static_cast((i >> 48) & 0xFF)); + encoded.push_back(static_cast((i >> 40) & 0xFF)); + encoded.push_back(static_cast((i >> 32) & 0xFF)); + encoded.push_back(static_cast((i >> 24) & 0xFF)); + encoded.push_back(static_cast((i >> 16) & 0xFF)); + encoded.push_back(static_cast((i >> 8) & 0xFF)); + encoded.push_back(static_cast(i & 0xFF)); } return encoded; diff --git a/src/mumlib.cpp b/src/mumlib.cpp index 16e5c4b..6f7038f 100644 --- a/src/mumlib.cpp +++ b/src/mumlib.cpp @@ -43,7 +43,8 @@ namespace mumlib { ioService(ioService), externalIoService(true), transport(ioService, boost::bind(&_Mumlib_Private::processIncomingTcpMessage, this, _1, _2, _3), - boost::bind(&_Mumlib_Private::processAudioPacket, this, _1, _2, _3)) { + boost::bind(&_Mumlib_Private::processAudioPacket, this, _1, _2, _3)), + audio(configuration.opusSampleRate, configuration.opusEncoderBitrate) { audio.setOpusEncoderBitrate(configuration.opusEncoderBitrate); } @@ -363,6 +364,10 @@ namespace mumlib { return impl->transport.getConnectionState(); } + int Mumlib::getChannelId() { + return impl->channelId; + } + void Mumlib::connect(string host, int port, string user, string password) { impl->transport.connect(host, port, user, password); } @@ -376,6 +381,15 @@ namespace mumlib { } } + void Mumlib::reconnect() { + if (not impl->externalIoService) { + impl->ioService.reset(); + } + if (impl->transport.getConnectionState() != ConnectionState::NOT_CONNECTED) { + impl->transport.disconnect(); + } + } + void Mumlib::run() { if (impl->externalIoService) { throw MumlibException("can't call run() when using external io_service"); From 429e1a54f7a0ea8604a172f78a615e86f73c5c3f Mon Sep 17 00:00:00 2001 From: Auzan Date: Thu, 29 Mar 2018 09:53:47 +0700 Subject: [PATCH 04/78] adding opus chanel in mumblib configuration --- include/mumlib.hpp | 2 ++ include/mumlib/Audio.hpp | 6 ++++-- include/mumlib/VarInt.hpp | 2 +- src/Audio.cpp | 6 +++--- src/Transport.cpp | 1 + src/mumlib.cpp | 2 +- 6 files changed, 12 insertions(+), 7 deletions(-) diff --git a/include/mumlib.hpp b/include/mumlib.hpp index af979a0..da0baf0 100644 --- a/include/mumlib.hpp +++ b/include/mumlib.hpp @@ -12,6 +12,7 @@ namespace mumlib { constexpr int DEFAULT_OPUS_ENCODER_BITRATE = 16000; constexpr int DEFAULT_OPUS_SAMPLE_RATE = 48000; + constexpr int DEFAULT_OPUS_NUM_CHANNELS = 1; using namespace std; using namespace boost::asio; @@ -24,6 +25,7 @@ namespace mumlib { struct MumlibConfiguration { int opusEncoderBitrate = DEFAULT_OPUS_ENCODER_BITRATE; int opusSampleRate = DEFAULT_OPUS_SAMPLE_RATE; + int opusChannels = DEFAULT_OPUS_NUM_CHANNELS; // additional fields will be added in the future }; diff --git a/include/mumlib/Audio.hpp b/include/mumlib/Audio.hpp index df3ed11..7e1433a 100644 --- a/include/mumlib/Audio.hpp +++ b/include/mumlib/Audio.hpp @@ -25,8 +25,10 @@ namespace mumlib { }; class Audio : boost::noncopyable { - public: - Audio(int opusSampleRate, int opusEncoderBitrate); + public: + explicit Audio(int opusSampleRate=DEFAULT_OPUS_SAMPLE_RATE, + int opusEncoderBitrate=DEFAULT_OPUS_ENCODER_BITRATE, + int channels=DEFAULT_OPUS_NUM_CHANNELS); virtual ~Audio(); diff --git a/include/mumlib/VarInt.hpp b/include/mumlib/VarInt.hpp index 5ebacce..7e301c7 100644 --- a/include/mumlib/VarInt.hpp +++ b/include/mumlib/VarInt.hpp @@ -29,6 +29,6 @@ namespace mumlib { private: const int64_t value; - long parseVariant(const uint8_t *buffer); + int64_t parseVariant(const uint8_t *buffer); }; } \ No newline at end of file diff --git a/src/Audio.cpp b/src/Audio.cpp index 384942d..2a0eac2 100644 --- a/src/Audio.cpp +++ b/src/Audio.cpp @@ -4,7 +4,7 @@ static boost::posix_time::seconds RESET_SEQUENCE_NUMBER_INTERVAL(5); -mumlib::Audio::Audio(int opusSampleRate, int opusEncoderBitrate) +mumlib::Audio::Audio(int opusSampleRate, int opusEncoderBitrate, int channels) : logger(log4cpp::Category::getInstance("mumlib.Audio")), opusDecoder(nullptr), opusEncoder(nullptr), @@ -13,12 +13,12 @@ mumlib::Audio::Audio(int opusSampleRate, int opusEncoderBitrate) int error; this->sampleRate = opusSampleRate; - opusDecoder = opus_decoder_create(opusSampleRate, 1, &error); + opusDecoder = opus_decoder_create(opusSampleRate, channels, &error); if (error != OPUS_OK) { throw AudioException((boost::format("failed to initialize OPUS decoder: %s") % opus_strerror(error)).str()); } - opusEncoder = opus_encoder_create(opusSampleRate, 1, OPUS_APPLICATION_VOIP, &error); + opusEncoder = opus_encoder_create(opusSampleRate, channels, OPUS_APPLICATION_VOIP, &error); if (error != OPUS_OK) { throw AudioException((boost::format("failed to initialize OPUS encoder: %s") % opus_strerror(error)).str()); } diff --git a/src/Transport.cpp b/src/Transport.cpp index e016f50..2c14e4d 100644 --- a/src/Transport.cpp +++ b/src/Transport.cpp @@ -95,6 +95,7 @@ void mumlib::Transport::connect( void mumlib::Transport::disconnect() { + pingTimer.cancel(); if (state != ConnectionState::NOT_CONNECTED) { boost::system::error_code errorCode; diff --git a/src/mumlib.cpp b/src/mumlib.cpp index 6f7038f..f289992 100644 --- a/src/mumlib.cpp +++ b/src/mumlib.cpp @@ -44,7 +44,7 @@ namespace mumlib { externalIoService(true), transport(ioService, boost::bind(&_Mumlib_Private::processIncomingTcpMessage, this, _1, _2, _3), boost::bind(&_Mumlib_Private::processAudioPacket, this, _1, _2, _3)), - audio(configuration.opusSampleRate, configuration.opusEncoderBitrate) { + audio(configuration.opusSampleRate, configuration.opusEncoderBitrate, configuration.opusChannels) { audio.setOpusEncoderBitrate(configuration.opusEncoderBitrate); } From 38f480566085f01d9776dc69b44db6778a0d47f4 Mon Sep 17 00:00:00 2001 From: Auzan Date: Thu, 12 Apr 2018 08:33:44 +0700 Subject: [PATCH 05/78] Update mumble proto to latest version. --- Mumble.proto | 35 +++++++++++++++++++++++++++-------- include/mumlib.hpp | 2 -- include/mumlib/Transport.hpp | 2 -- src/Transport.cpp | 11 ----------- src/mumlib.cpp | 32 +++++++++++++++++++++----------- 5 files changed, 48 insertions(+), 34 deletions(-) diff --git a/Mumble.proto b/Mumble.proto index 92b8737..a74f247 100644 --- a/Mumble.proto +++ b/Mumble.proto @@ -1,3 +1,10 @@ +// Copyright 2005-2018 The Mumble Developers. All rights reserved. +// Use of this source code is governed by a BSD-style license +// that can be found in the LICENSE file at the root of the +// Mumble source tree or at . + +syntax = "proto2"; + package MumbleProto; option optimize_for = SPEED; @@ -63,7 +70,8 @@ message Ping { // Sent by the server when it rejects the user connection. message Reject { enum RejectType { - // TODO ?? + // The rejection reason is unknown (details should be available + // in Reject.reason). None = 0; // The client attempted to connect with an incompatible version. WrongVersion = 1; @@ -98,7 +106,7 @@ message ServerSync { optional uint32 max_bandwidth = 2; // Server welcome text. optional string welcome_text = 3; - // Current user permissions TODO: Confirm?? + // Current user permissions in the root channel. optional uint64 permissions = 4; } @@ -134,6 +142,10 @@ message ChannelState { optional int32 position = 9 [default = 0]; // SHA1 hash of the description if the description is 128 bytes or more. optional bytes description_hash = 10; + // Maximum number of users allowed in the channel. If this value is zero, + // the maximum number of users allowed in the channel is given by the + // server's "usersperchannel" setting. + optional uint32 max_users = 11; } // Used to communicate user leaving or being kicked. May be sent by the client @@ -180,9 +192,14 @@ message UserState { optional bool self_deaf = 10; // User image if it is less than 128 bytes. optional bytes texture = 11; - // TODO ?? + // The positional audio plugin identifier. + // Positional audio information is only sent to users who share + // identical plugin contexts. + // + // This value is not trasmitted to clients. optional bytes plugin_context = 12; - // TODO ?? + // The user's plugin-specific identity. + // This value is not transmitted to clients. optional string plugin_identity = 13; // User comment if it is less than 128 bytes. optional string comment = 14; @@ -209,7 +226,7 @@ message BanList { required uint32 mask = 2; // User name for identification purposes (does not affect the ban). optional string name = 3; - // TODO ?? + // The certificate hash of the banned user. optional string hash = 4; // Reason for the ban (does not affect the ban). optional string reason = 5; @@ -403,9 +420,9 @@ message VoiceTarget { message Target { // Users that are included as targets. repeated uint32 session = 1; - // Channels that are included as targets. + // Channel that is included as a target. optional uint32 channel_id = 2; - // TODO ?? + // ACL group that is included as a target. optional string group = 3; // True if the voice should follow links from the specified channel. optional bool links = 4 [default = false]; @@ -529,6 +546,8 @@ message ServerConfig { optional uint32 message_length = 4; // Maximum image message length. optional uint32 image_message_length = 5; + // The maximum number of users allowed on the server. + optional uint32 max_users = 6; } // Sent by the server to inform the clients of suggested client configuration @@ -541,4 +560,4 @@ message SuggestConfig { optional bool positional = 2; // True if the administrator suggests push to talk to be used on this server. optional bool push_to_talk = 3; -} +} \ No newline at end of file diff --git a/include/mumlib.hpp b/include/mumlib.hpp index da0baf0..ee18567 100644 --- a/include/mumlib.hpp +++ b/include/mumlib.hpp @@ -48,8 +48,6 @@ namespace mumlib { void disconnect(); - void reconnect(); - void run(); ConnectionState getConnectionState(); diff --git a/include/mumlib/Transport.hpp b/include/mumlib/Transport.hpp index f200dca..346728b 100644 --- a/include/mumlib/Transport.hpp +++ b/include/mumlib/Transport.hpp @@ -50,8 +50,6 @@ namespace mumlib { void disconnect(); - void reconnect(); - ConnectionState getConnectionState() { return state; } diff --git a/src/Transport.cpp b/src/Transport.cpp index 2c14e4d..b3803f6 100644 --- a/src/Transport.cpp +++ b/src/Transport.cpp @@ -95,7 +95,6 @@ void mumlib::Transport::connect( void mumlib::Transport::disconnect() { - pingTimer.cancel(); if (state != ConnectionState::NOT_CONNECTED) { boost::system::error_code errorCode; @@ -120,16 +119,6 @@ void mumlib::Transport::disconnect() { } } -void mumlib::Transport::reconnect() { - boost::system::error_code errorCode; - - udpSocket.close(errorCode); - if (errorCode) { - logger.warn("SSL socket close return an error: %s.", errorCode.message().c_str()); - } -} - - void mumlib::Transport::sendVersion() { MumbleProto::Version version; diff --git a/src/mumlib.cpp b/src/mumlib.cpp index f289992..e21d1e1 100644 --- a/src/mumlib.cpp +++ b/src/mumlib.cpp @@ -8,6 +8,7 @@ #include #include +#include #include #include @@ -201,6 +202,9 @@ namespace mumlib { int32_t priority_speaker = userState.has_priority_speaker() ? userState.priority_speaker() : -1; int32_t recording = userState.has_recording() ? userState.recording() : -1; + if(session == this->sessionId) { + this->channelId = channel_id; + } callback.userState(session, actor, userState.name(), @@ -381,15 +385,6 @@ namespace mumlib { } } - void Mumlib::reconnect() { - if (not impl->externalIoService) { - impl->ioService.reset(); - } - if (impl->transport.getConnectionState() != ConnectionState::NOT_CONNECTED) { - impl->transport.disconnect(); - } - } - void Mumlib::run() { if (impl->externalIoService) { throw MumlibException("can't call run() when using external io_service"); @@ -473,8 +468,23 @@ namespace mumlib { switch (field) { case UserState::COMMENT: - // TODO: if comment longer than 128 bytes, we need to set the SHA1 hash - userState.set_comment(val); + + if(val.size() < 128) { + userState.set_comment(val); + } else { + // if comment longer than 128 bytes, we need to set the SHA1 hash + boost::uuids::detail::sha1 sha1; + uint hash[5]; + sha1.process_bytes(val.c_str(), val.size()); + sha1.get_digest(hash); + + std::stringstream valStream; + for(std::size_t i=0; i Date: Wed, 18 Apr 2018 12:43:52 +0700 Subject: [PATCH 06/78] Add MumbleUser and MumbleChannel --- include/mumlib.hpp | 23 ++++++++++- include/mumlib/CryptState.hpp | 7 +++- src/CryptState.cpp | 38 +++++++++++++++++- src/Transport.cpp | 1 - src/mumlib.cpp | 74 +++++++++++++++++++++++++++++++++-- 5 files changed, 134 insertions(+), 9 deletions(-) diff --git a/include/mumlib.hpp b/include/mumlib.hpp index ee18567..96b2165 100644 --- a/include/mumlib.hpp +++ b/include/mumlib.hpp @@ -29,6 +29,17 @@ namespace mumlib { // additional fields will be added in the future }; + struct MumbleUser { + int32_t sessionId; + string name; + }; + + struct MumbleChannel { + int32_t channelId; + string name; + string description; + }; + struct _Mumlib_Private; @@ -54,6 +65,10 @@ namespace mumlib { int getChannelId(); + vector getListUser(); + + vector getListChannel(); + void sendAudioData(int16_t *pcmData, int pcmLength); void sendAudioDataTarget(int targetId, int16_t *pcmData, int pcmLength); @@ -62,13 +77,19 @@ namespace mumlib { void joinChannel(int channelId); + void joinChannel(std::string channelName); + void sendVoiceTarget(int targetId, int channelId); + void sendVoiceTarget(int targetId, std::string channelName); + void sendUserState(mumlib::UserState state, bool val); void sendUserState(mumlib::UserState state, std::string value); - + private: _Mumlib_Private *impl; + + int getListChannelIdBy(std::string channelName); }; } diff --git a/include/mumlib/CryptState.hpp b/include/mumlib/CryptState.hpp index cf5b61f..5d53c73 100644 --- a/include/mumlib/CryptState.hpp +++ b/include/mumlib/CryptState.hpp @@ -36,7 +36,7 @@ namespace mumlib { class CryptState : boost::noncopyable { - public: + private: unsigned char raw_key[AES_BLOCK_SIZE]; unsigned char encrypt_iv[AES_BLOCK_SIZE]; unsigned char decrypt_iv[AES_BLOCK_SIZE]; @@ -56,14 +56,19 @@ namespace mumlib { AES_KEY decrypt_key; bool bInit; + public: CryptState(); bool isValid() const; + void genKey(); + void setKey(const unsigned char *rkey, const unsigned char *eiv, const unsigned char *div); void setDecryptIV(const unsigned char *iv); + const unsigned char* getEncryptIV() const; + void ocb_encrypt(const unsigned char *plain, unsigned char *encrypted, unsigned int len, const unsigned char *nonce, unsigned char *tag); diff --git a/src/CryptState.cpp b/src/CryptState.cpp index 467955d..55ca26d 100644 --- a/src/CryptState.cpp +++ b/src/CryptState.cpp @@ -40,6 +40,7 @@ #include "mumlib/CryptState.hpp" +#include #include #include @@ -57,6 +58,15 @@ bool mumlib::CryptState::isValid() const { return bInit; } +void mumlib::CryptState::genKey() { + RAND_bytes(raw_key, AES_BLOCK_SIZE); + RAND_bytes(encrypt_iv, AES_BLOCK_SIZE); + RAND_bytes(decrypt_iv, AES_BLOCK_SIZE); + AES_set_encrypt_key(raw_key, 128, &encrypt_key); + AES_set_decrypt_key(raw_key, 128, &decrypt_key); + bInit = true; +} + void mumlib::CryptState::setKey(const unsigned char *rkey, const unsigned char *eiv, const unsigned char *div) { memcpy(raw_key, rkey, AES_BLOCK_SIZE); memcpy(encrypt_iv, eiv, AES_BLOCK_SIZE); @@ -70,6 +80,10 @@ void mumlib::CryptState::setDecryptIV(const unsigned char *iv) { memcpy(decrypt_iv, iv, AES_BLOCK_SIZE); } +const unsigned char* mumlib::CryptState::getEncryptIV() const { + return encrypt_iv; +} + void mumlib::CryptState::encrypt(const unsigned char *source, unsigned char *dst, unsigned int plain_length) { unsigned char tag[AES_BLOCK_SIZE]; @@ -177,14 +191,34 @@ bool mumlib::CryptState::decrypt(const unsigned char *source, unsigned char *dst return true; } +#if defined(__LP64__) + #define BLOCKSIZE 2 #define SHIFTBITS 63 typedef uint64_t subblock; -// #define SWAP64(x) ({register uint64_t __out, __in = (x); __asm__("bswap %q0" : "=r"(__out) : "0"(__in)); __out;}) -#define SWAP64(x) (__builtin_bswap64(x)) +#ifdef __x86_64__ +static inline uint64_t SWAP64(register uint64_t __in) { register uint64_t __out; __asm__("bswap %q0" : "=r"(__out) : "0"(__in)); return __out; } +#else +#define SWAP64(x) ((static_cast(x) << 56) | \ + ((static_cast(x) << 40) & 0xff000000000000ULL) | \ + ((static_cast(x) << 24) & 0xff0000000000ULL) | \ + ((static_cast(x) << 8) & 0xff00000000ULL) | \ + ((static_cast(x) >> 8) & 0xff000000ULL) | \ + ((static_cast(x) >> 24) & 0xff0000ULL) | \ + ((static_cast(x) >> 40) & 0xff00ULL) | \ + ((static_cast(x) >> 56))) +#endif +// #define SWAP64(x) (__builtin_bswap64(x)) #define SWAPPED(x) SWAP64(x) +#else +#define BLOCKSIZE 4 +#define SHIFTBITS 31 +typedef uint32_t subblock; +#define SWAPPED(x) htonl(x) +#endif + typedef subblock keyblock[BLOCKSIZE]; static void inline XOR(subblock *dst, const subblock *a, const subblock *b) { diff --git a/src/Transport.cpp b/src/Transport.cpp index b3803f6..01b712a 100644 --- a/src/Transport.cpp +++ b/src/Transport.cpp @@ -3,7 +3,6 @@ #include "Mumble.pb.h" #include -#include using namespace std; diff --git a/src/mumlib.cpp b/src/mumlib.cpp index e21d1e1..ff3c76b 100644 --- a/src/mumlib.cpp +++ b/src/mumlib.cpp @@ -34,6 +34,9 @@ namespace mumlib { int sessionId = 0; int channelId = 0; + std::vector listMumbleUser; + std::vector listMumbleChannel; + _Mumlib_Private(Callback &callback, MumlibConfiguration &configuration) : _Mumlib_Private(callback, *(new io_service()), configuration) { externalIoService = false; @@ -154,7 +157,14 @@ namespace mumlib { links_remove.push_back(channelState.links_remove(i)); } - // this->channelId = channel_id; + MumbleChannel mumbleChannel; + mumbleChannel.channelId = channel_id; + mumbleChannel.name = channelState.name(); + mumbleChannel.description = channelState.description(); + + if(not isListChannelContains(channel_id)) { + listMumbleChannel.push_back(mumbleChannel); + } callback.channelState( channelState.name(), @@ -177,6 +187,10 @@ namespace mumlib { bool ban = user_remove.has_ban() ? user_remove.ban() : false; //todo make sure it's correct to assume it's false + if(isListUserContains(user_remove.session())) { + listUserRemovedBy(user_remove.session()); + } + callback.userRemove( user_remove.session(), actor, @@ -205,6 +219,15 @@ namespace mumlib { if(session == this->sessionId) { this->channelId = channel_id; } + + MumbleUser mumbleUser; + mumbleUser.name = userState.name(); + mumbleUser.sessionId = session; + + if(not isListUserContains(session)) { + listMumbleUser.push_back(mumbleUser); + } + callback.userState(session, actor, userState.name(), @@ -339,7 +362,25 @@ namespace mumlib { return true; } + bool isListUserContains(int sessionId) { + for(int i = 0; i < listMumbleUser.size(); i++) + if(listMumbleUser[i].sessionId == sessionId) + return true; + return false; + } + + void listUserRemovedBy(int sessionId) { + for(int i = 0; i < listMumbleUser.size(); i++) + if(listMumbleUser[i].sessionId == sessionId) + listMumbleUser.erase(listMumbleUser.begin() + i); + } + bool isListChannelContains(int channelId) { + for(int i = 0; i < listMumbleChannel.size(); i++) + if(listMumbleChannel[i].channelId == channelId) + return true; + return false; + } }; Mumlib::Mumlib(Callback &callback) { @@ -372,6 +413,14 @@ namespace mumlib { return impl->channelId; } + vector Mumlib::getListUser() { + return impl->listMumbleUser; + } + + vector Mumlib::getListChannel() { + return impl->listMumbleChannel; + } + void Mumlib::connect(string host, int port, string user, string password) { impl->transport.connect(host, port, user, password); } @@ -394,9 +443,7 @@ namespace mumlib { } void Mumlib::sendAudioData(int16_t *pcmData, int pcmLength) { - uint8_t encodedData[5000]; - int length = impl->audio.encodeAudioPacket(0, pcmData, pcmLength, encodedData, 5000); - impl->transport.sendEncodedAudioPacket(encodedData, length); + Mumlib::sendAudioDataTarget(0, pcmData, pcmLength); } void Mumlib::sendAudioDataTarget(int targetId, int16_t *pcmData, int pcmLength) { @@ -420,6 +467,11 @@ namespace mumlib { impl->channelId = channelId; } + void Mumlib::joinChannel(string name) { + int channelId = Mumlib::getListChannelIdBy(name); + Mumlib::joinChannel(channelId); + } + void Mumlib::sendVoiceTarget(int targetId, int channelId) { MumbleProto::VoiceTarget voiceTarget; MumbleProto::VoiceTarget_Target voiceTargetTarget; @@ -430,6 +482,11 @@ namespace mumlib { impl->transport.sendControlMessage(MessageType::VOICETARGET, voiceTarget); } + void Mumlib::sendVoiceTarget(int targetId, string channelName) { + int channelId = Mumlib::getListChannelIdBy(channelName); + Mumlib::sendVoiceTarget(targetId, channelId); + } + void Mumlib::sendUserState(mumlib::UserState field, bool val) { MumbleProto::UserState userState; @@ -493,4 +550,13 @@ namespace mumlib { impl->transport.sendControlMessage(MessageType::USERSTATE, userState); } + + int Mumlib::getListChannelIdBy(string name) { + vector listMumbleChannel = impl->listMumbleChannel; + int channelId = impl->channelId; + for(int i = 0; i < listMumbleChannel.size(); i++) + if(listMumbleChannel[i].name == name) + channelId = listMumbleChannel[i].channelId; + return channelId; + } } From f6ef5949a16df3af2ae4d0f2ab6c78e83698c670 Mon Sep 17 00:00:00 2001 From: Auzan Date: Fri, 20 Apr 2018 11:43:27 +0700 Subject: [PATCH 07/78] adding some method, and look for cause issue #3 --- include/mumlib.hpp | 12 ++++--- include/mumlib/enums.hpp | 5 +++ src/Audio.cpp | 12 ++++++- src/CryptState.cpp | 23 +------------ src/mumlib.cpp | 71 +++++++++++++++++++++++++++++++++------- 5 files changed, 83 insertions(+), 40 deletions(-) diff --git a/include/mumlib.hpp b/include/mumlib.hpp index 96b2165..cab8e31 100644 --- a/include/mumlib.hpp +++ b/include/mumlib.hpp @@ -65,9 +65,9 @@ namespace mumlib { int getChannelId(); - vector getListUser(); + vector getListAllUser(); - vector getListChannel(); + vector getListAllChannel(); void sendAudioData(int16_t *pcmData, int pcmLength); @@ -79,9 +79,9 @@ namespace mumlib { void joinChannel(std::string channelName); - void sendVoiceTarget(int targetId, int channelId); + void sendVoiceTarget(mumlib::VoiceTargetType type, int targetId, int id); - void sendVoiceTarget(int targetId, std::string channelName); + bool sendVoiceTarget(mumlib::VoiceTargetType type, int targetId, std::string name); void sendUserState(mumlib::UserState state, bool val); @@ -90,6 +90,8 @@ namespace mumlib { private: _Mumlib_Private *impl; - int getListChannelIdBy(std::string channelName); + int getChannelIdBy(std::string channelName); + + int getUserIdBy(std::string userName); }; } diff --git a/include/mumlib/enums.hpp b/include/mumlib/enums.hpp index ea189f9..740d83b 100644 --- a/include/mumlib/enums.hpp +++ b/include/mumlib/enums.hpp @@ -55,4 +55,9 @@ namespace mumlib { PRIORITY_SPEAKER, RECORDING }; + + enum class VoiceTargetType { + CHANNEL, + USER + }; } \ No newline at end of file diff --git a/src/Audio.cpp b/src/Audio.cpp index 2a0eac2..60277df 100644 --- a/src/Audio.cpp +++ b/src/Audio.cpp @@ -76,6 +76,16 @@ std::pair mumlib::Audio::decodeOpusPayload(uint8_t *inputBuffer, % inputLength % dataPointer % opusDataLength).str()); } + // Issue #3 (Users speaking simultaneously) + // https://mf4.xiph.org/jenkins/view/opus/job/opus/ws/doc/html/group__opus__decoder.html + // Opus is a stateful codec with overlapping blocks and as a result Opus packets are not coded independently of each other. + // Packets must be passed into the decoder serially and in the correct order for a correct decode. + // Lost packets can be replaced with loss concealment by calling the decoder with a null pointer and zero length for the missing packet. + // A single codec state may only be accessed from a single thread at a time and any required locking must be performed by the caller. + // Separate streams must be decoded with separate decoder states and can be decoded in parallel unless the library was compiled with NONTHREADSAFE_PSEUDOSTACK defined. + + int frame = opus_packet_get_nb_frames(&inputBuffer[dataPointer], opusDataLength); + int samples = frame * opus_packet_get_samples_per_frame(&inputBuffer[dataPointer], sampleRate); int outputSize = opus_decode(opusDecoder, reinterpret_cast(&inputBuffer[dataPointer]), opusDataLength, @@ -133,7 +143,7 @@ int mumlib::Audio::encodeAudioPacket(int target, int16_t *inputPcmBuffer, int in memcpy(outputBuffer, &header[0], header.size()); memcpy(outputBuffer + header.size(), tmpOpusBuffer, (size_t) outputSize); - int incrementNumber = 100 * inputLength / this->sampleRate; + int incrementNumber = 100 * inputLength / sampleRate; outgoingSequenceNumber += incrementNumber; diff --git a/src/CryptState.cpp b/src/CryptState.cpp index 55ca26d..e1763c3 100644 --- a/src/CryptState.cpp +++ b/src/CryptState.cpp @@ -191,34 +191,13 @@ bool mumlib::CryptState::decrypt(const unsigned char *source, unsigned char *dst return true; } -#if defined(__LP64__) - #define BLOCKSIZE 2 #define SHIFTBITS 63 typedef uint64_t subblock; -#ifdef __x86_64__ -static inline uint64_t SWAP64(register uint64_t __in) { register uint64_t __out; __asm__("bswap %q0" : "=r"(__out) : "0"(__in)); return __out; } -#else -#define SWAP64(x) ((static_cast(x) << 56) | \ - ((static_cast(x) << 40) & 0xff000000000000ULL) | \ - ((static_cast(x) << 24) & 0xff0000000000ULL) | \ - ((static_cast(x) << 8) & 0xff00000000ULL) | \ - ((static_cast(x) >> 8) & 0xff000000ULL) | \ - ((static_cast(x) >> 24) & 0xff0000ULL) | \ - ((static_cast(x) >> 40) & 0xff00ULL) | \ - ((static_cast(x) >> 56))) -#endif -// #define SWAP64(x) (__builtin_bswap64(x)) +#define SWAP64(x) (__builtin_bswap64(x)) #define SWAPPED(x) SWAP64(x) -#else -#define BLOCKSIZE 4 -#define SHIFTBITS 31 -typedef uint32_t subblock; -#define SWAPPED(x) htonl(x) -#endif - typedef subblock keyblock[BLOCKSIZE]; static void inline XOR(subblock *dst, const subblock *a, const subblock *b) { diff --git a/src/mumlib.cpp b/src/mumlib.cpp index ff3c76b..c8101b5 100644 --- a/src/mumlib.cpp +++ b/src/mumlib.cpp @@ -65,6 +65,8 @@ namespace mumlib { auto incomingAudioPacket = audio.decodeIncomingAudioPacket(buffer, length); if (type == AudioPacketType::OPUS) { + // todo: multiple users speaking simultaneously (Issue #3) + // something weird while decoding the opus payload int16_t pcmData[5000]; auto status = audio.decodeOpusPayload(incomingAudioPacket.audioPayload, incomingAudioPacket.audioPayloadLength, @@ -127,6 +129,11 @@ namespace mumlib { case MessageType::CHANNELREMOVE: { MumbleProto::ChannelRemove channelRemove; channelRemove.ParseFromArray(buffer, length); + + if(isListChannelContains(channelRemove.channel_id())) { + listChannelRemovedBy(channelRemove.channel_id()); + } + callback.channelRemove(channelRemove.channel_id()); } break; @@ -381,6 +388,12 @@ namespace mumlib { return true; return false; } + + void listChannelRemovedBy(int channelId) { + for(int i = 0; i < listMumbleChannel.size(); i++) + if(listMumbleChannel[i].channelId == channelId) + listMumbleChannel.erase(listMumbleChannel.begin() + i); + } }; Mumlib::Mumlib(Callback &callback) { @@ -413,11 +426,11 @@ namespace mumlib { return impl->channelId; } - vector Mumlib::getListUser() { + vector Mumlib::getListAllUser() { return impl->listMumbleUser; } - vector Mumlib::getListChannel() { + vector Mumlib::getListAllChannel() { return impl->listMumbleChannel; } @@ -468,23 +481,48 @@ namespace mumlib { } void Mumlib::joinChannel(string name) { - int channelId = Mumlib::getListChannelIdBy(name); - Mumlib::joinChannel(channelId); + int channelId = Mumlib::getChannelIdBy(name); + if(!channelId < 0) // when channel has not been registered / create + Mumlib::joinChannel(channelId); } - void Mumlib::sendVoiceTarget(int targetId, int channelId) { + void Mumlib::sendVoiceTarget(VoiceTargetType type, int targetId, int id) { MumbleProto::VoiceTarget voiceTarget; MumbleProto::VoiceTarget_Target voiceTargetTarget; - voiceTargetTarget.set_channel_id(channelId); - voiceTargetTarget.set_children(true); + switch(type) { + case VoiceTargetType::CHANNEL: { + voiceTargetTarget.set_channel_id(id); + voiceTargetTarget.set_children(true); + } + break; + case VoiceTargetType::USER: { + voiceTargetTarget.add_session(id); + } + break; + default: + return; + } voiceTarget.set_id(targetId); voiceTarget.add_targets()->CopyFrom(voiceTargetTarget); impl->transport.sendControlMessage(MessageType::VOICETARGET, voiceTarget); } - void Mumlib::sendVoiceTarget(int targetId, string channelName) { - int channelId = Mumlib::getListChannelIdBy(channelName); - Mumlib::sendVoiceTarget(targetId, channelId); + bool Mumlib::sendVoiceTarget(VoiceTargetType type, int targetId, string name) { + int id = -1; + switch(type) { + case VoiceTargetType::CHANNEL: + id = getChannelIdBy(name); + break; + case VoiceTargetType::USER: + id = getUserIdBy(name); + break; + default: + break; + } + if(id < 0) + return false; + sendVoiceTarget(type, targetId, id); + return true; } void Mumlib::sendUserState(mumlib::UserState field, bool val) { @@ -551,12 +589,21 @@ namespace mumlib { impl->transport.sendControlMessage(MessageType::USERSTATE, userState); } - int Mumlib::getListChannelIdBy(string name) { + int Mumlib::getChannelIdBy(string name) { vector listMumbleChannel = impl->listMumbleChannel; - int channelId = impl->channelId; + int channelId = -1; for(int i = 0; i < listMumbleChannel.size(); i++) if(listMumbleChannel[i].name == name) channelId = listMumbleChannel[i].channelId; return channelId; } + + int Mumlib::getUserIdBy(string name) { + vector listMumbleUser = impl->listMumbleUser; + int sessionId = -1; + for(int i = 0; i < listMumbleUser.size(); i++) + if(listMumbleUser[i].name == name) + sessionId = listMumbleUser[i].sessionId; + return sessionId; + } } From fe9a39ad5e3d8a9c61aea4c83b6217486429c0f4 Mon Sep 17 00:00:00 2001 From: Auzan Date: Wed, 23 May 2018 16:21:08 +0700 Subject: [PATCH 08/78] hack typo, adding frame to buffer --- CMakeLists.txt | 22 +++-- include/mumlib.hpp | 8 +- include/mumlib/Audio.hpp | 28 ++++++- src/Audio.cpp | 176 +++++++++++++++++++++++++++++++++++---- src/mumlib.cpp | 119 +++++++++++++++----------- 5 files changed, 280 insertions(+), 73 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 9fbbab3..e4e177f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -42,15 +42,23 @@ set(MUMLIB_SRC src/Audio.cpp ) +set(SPEEX_LIBRARIES + speex + speexdsp + ) + PROTOBUF_GENERATE_CPP(PROTO_SRCS PROTO_HDRS Mumble.proto) add_library(mumlib SHARED ${MUMLIB_SRC} ${MUMLIB_PUBLIC_HEADERS} ${MUMLIB_PRIVATE_HEADERS} ${PROTO_SRCS} ${PROTO_HDRS}) -target_link_libraries(mumlib ${PROTOBUF_LIBRARIES}) -target_link_libraries(mumlib ${Boost_LIBRARIES}) -target_link_libraries(mumlib ${OPENSSL_LIBRARIES}) -target_link_libraries(mumlib ${LOG4CPP_LIBRARIES}) -target_link_libraries(mumlib ${OPUS_LIBRARIES}) +target_link_libraries(mumlib + ${SPEEX_LIBRARIES} + ${PROTOBUF_LIBRARIES} + ${Boost_LIBRARIES} + ${OPENSSL_LIBRARIES} + ${LOG4CPP_LIBRARIES} + ${OPUS_LIBRARIES}) +# add_executable(mumlib_example mumlib_example.cpp) +# target_link_libraries(mumlib_example mumlib) -add_executable(mumlib_example mumlib_example.cpp) -target_link_libraries(mumlib_example mumlib) +install(TARGETS mumlib LIBRARY DESTINATION lib) diff --git a/include/mumlib.hpp b/include/mumlib.hpp index cab8e31..08297d1 100644 --- a/include/mumlib.hpp +++ b/include/mumlib.hpp @@ -79,9 +79,9 @@ namespace mumlib { void joinChannel(std::string channelName); - void sendVoiceTarget(mumlib::VoiceTargetType type, int targetId, int id); + void sendVoiceTarget(int targetId, mumlib::VoiceTargetType type, int sessionId); - bool sendVoiceTarget(mumlib::VoiceTargetType type, int targetId, std::string name); + void sendVoiceTarget(int targetId, mumlib::VoiceTargetType type, std::string name, int &error); void sendUserState(mumlib::UserState state, bool val); @@ -93,5 +93,9 @@ namespace mumlib { int getChannelIdBy(std::string channelName); int getUserIdBy(std::string userName); + + bool isSessionIdValid(int sessionId); + + bool isChannelIdValid(int channelId); }; } diff --git a/include/mumlib/Audio.hpp b/include/mumlib/Audio.hpp index 7e1433a..19d89a3 100644 --- a/include/mumlib/Audio.hpp +++ b/include/mumlib/Audio.hpp @@ -4,6 +4,8 @@ #include +#include + #include namespace mumlib { @@ -26,14 +28,24 @@ namespace mumlib { class Audio : boost::noncopyable { public: - explicit Audio(int opusSampleRate=DEFAULT_OPUS_SAMPLE_RATE, - int opusEncoderBitrate=DEFAULT_OPUS_ENCODER_BITRATE, + explicit Audio(int sampleRate=DEFAULT_OPUS_SAMPLE_RATE, + int bitrate=DEFAULT_OPUS_ENCODER_BITRATE, int channels=DEFAULT_OPUS_NUM_CHANNELS); virtual ~Audio(); IncomingAudioPacket decodeIncomingAudioPacket(uint8_t *inputBuffer, int inputBufferLength); + void addFrameToBuffer(uint8_t *inputBuffer, int inputLength, int sequence); + + // todo: mix audio + void mixAudio(uint8_t *dest, uint8_t *src, int bufferOffset, int inputLength); + + void resizeBuffer(); + + std::pair decodeOpusPayload(int16_t *pcmBuffer, + int pcmBufferSize); + std::pair decodeOpusPayload(uint8_t *inputBuffer, int inputLength, int16_t *pcmBuffer, @@ -52,14 +64,24 @@ namespace mumlib { void resetEncoder(); + void resetJitterBuffer(); + private: log4cpp::Category &logger; OpusDecoder *opusDecoder; OpusEncoder *opusEncoder; + JitterBuffer *jbBuffer; int64_t outgoingSequenceNumber; - int sampleRate; + + unsigned int iSampleRate; + unsigned int iChannels; + unsigned int iFrameSize; + unsigned int iAudioBufferSize; + + float *fFadeIn; + float *fFadeOut; std::chrono::time_point lastEncodedAudioPacketTimestamp; }; diff --git a/src/Audio.cpp b/src/Audio.cpp index 60277df..393b674 100644 --- a/src/Audio.cpp +++ b/src/Audio.cpp @@ -4,30 +4,69 @@ static boost::posix_time::seconds RESET_SEQUENCE_NUMBER_INTERVAL(5); -mumlib::Audio::Audio(int opusSampleRate, int opusEncoderBitrate, int channels) +mumlib::Audio::Audio(int sampleRate, int bitrate, int channels) : logger(log4cpp::Category::getInstance("mumlib.Audio")), opusDecoder(nullptr), opusEncoder(nullptr), - outgoingSequenceNumber(0) { + outgoingSequenceNumber(0), + iSampleRate(sampleRate), + iChannels(channels) { - int error; - this->sampleRate = opusSampleRate; + int error, ret; + iFrameSize = sampleRate / 100; + iAudioBufferSize = iFrameSize; + iAudioBufferSize *= 12; - opusDecoder = opus_decoder_create(opusSampleRate, channels, &error); + opusDecoder = opus_decoder_create(sampleRate, channels, &error); if (error != OPUS_OK) { throw AudioException((boost::format("failed to initialize OPUS decoder: %s") % opus_strerror(error)).str()); } - opusEncoder = opus_encoder_create(opusSampleRate, channels, OPUS_APPLICATION_VOIP, &error); + opusEncoder = opus_encoder_create(sampleRate, channels, OPUS_APPLICATION_VOIP, &error); if (error != OPUS_OK) { throw AudioException((boost::format("failed to initialize OPUS encoder: %s") % opus_strerror(error)).str()); } - opus_encoder_ctl(opusEncoder, OPUS_SET_VBR(0)); - - setOpusEncoderBitrate(opusEncoderBitrate); + ret = opus_encoder_ctl(opusEncoder, OPUS_SET_BITRATE(bitrate)); + if (ret != OPUS_OK) { + throw AudioException((boost::format("failed to initialize transmission bitrate to %d B/s: %s") + % bitrate % opus_strerror(ret)).str()); + } + ret = opus_encoder_ctl(opusEncoder, OPUS_SET_VBR(0)); + if (ret != OPUS_OK) { + throw AudioException((boost::format("failed to initialize variable bitrate: %s") + % opus_strerror(ret)).str()); + } + ret = opus_encoder_ctl(opusEncoder, OPUS_SET_VBR_CONSTRAINT(0)); + if (ret != OPUS_OK) { + throw AudioException((boost::format("failed to initialize variable bitrate constraint: %s") + % opus_strerror(ret)).str()); + } + ret = opus_encoder_ctl(opusEncoder, OPUS_SET_BANDWIDTH(OPUS_BANDWIDTH_NARROWBAND)); + if (ret != OPUS_OK) { + throw AudioException((boost::format("failed to initialize bandwidth narrow: %s") + % opus_strerror(ret)).str()); + } + ret = opus_encoder_ctl(opusEncoder, OPUS_SET_MAX_BANDWIDTH(OPUS_BANDWIDTH_NARROWBAND)); + if (ret != OPUS_OK) { + throw AudioException((boost::format("failed to initialize maximum bandwidth narrow: %s") + % opus_strerror(ret)).str()); + } resetEncoder(); + + jbBuffer = jitter_buffer_init(iFrameSize); + int margin = 10 * iFrameSize; + jitter_buffer_ctl(jbBuffer, JITTER_BUFFER_SET_MARGIN, &margin); + + fFadeIn = new float[iFrameSize]; + fFadeOut = new float[iFrameSize]; + + // Sine function to represent fade in/out. Period is FRAME_SIZE. + float mul = static_cast(M_PI / 2.0 * static_cast(iFrameSize)); + for(unsigned int i = 0; i < iFrameSize; i++) { + fFadeIn[i] = fFadeOut[iFrameSize - 1 - 1] = sinf(static_cast(i) * mul); + } } mumlib::Audio::~Audio() { @@ -38,6 +77,11 @@ mumlib::Audio::~Audio() { if (opusEncoder) { opus_encoder_destroy(opusEncoder); } + + jitter_buffer_destroy(jbBuffer); + + delete[] fFadeIn; + delete[] fFadeOut; } void mumlib::Audio::setOpusEncoderBitrate(int bitrate) { @@ -57,6 +101,105 @@ int mumlib::Audio::getOpusEncoderBitrate() { return bitrate; } +void mumlib::Audio::addFrameToBuffer(uint8_t *inputBuffer, int inputLength, int sequence) { + int dataPointer = 0; + VarInt varInt(inputBuffer); + int opusDataLength = varInt.getValue(); + dataPointer += varInt.getEncoded().size(); + bool lastPacket = (opusDataLength & 0x2000) != 0; + opusDataLength &= 0x1fff; + + auto *packet = reinterpret_cast(&inputBuffer[dataPointer]); + int frame = opus_packet_get_nb_frames(packet, opusDataLength); + int samples = frame * opus_packet_get_samples_per_frame(packet, iSampleRate); + int channel = opus_packet_get_nb_channels(packet); + + if(not sequence) { + resetJitterBuffer(); + } + + logger.info("Opus packet, frame: %d, samples: %d, channel: %d", frame, samples, channel); + + JitterBufferPacket jbPacket; + jbPacket.data = reinterpret_cast(&inputBuffer[dataPointer]); + jbPacket.len = opusDataLength; + jbPacket.span = samples; + jbPacket.timestamp = iFrameSize * sequence; + jbPacket.user_data = lastPacket; + + jitter_buffer_put(jbBuffer, &jbPacket); +} + +std::pair mumlib::Audio::decodeOpusPayload(int16_t *pcmBuffer, int pcmBufferSize) { + int avail = 0; + spx_uint32_t remaining = 0; + jitter_buffer_ctl(jbBuffer, JITTER_BUFFER_GET_AVAILABLE_COUNT, &avail); + jitter_buffer_remaining_span(jbBuffer, remaining); + int timestamp = jitter_buffer_get_pointer_timestamp(jbBuffer); + + logger.warn("jbBufer, avail: %d, remain: %d, timestamp: %d", avail, remaining, timestamp); + + char data[4096]; + JitterBufferPacket jbPacket; + jbPacket.data = data; + jbPacket.len = 4096; + + spx_int32_t startofs = 0; + int opusDataLength; + int outputSize; + spx_uint32_t lastPacket; + + if(jitter_buffer_get(jbBuffer, &jbPacket, iFrameSize, &startofs) == JITTER_BUFFER_OK) { + opusDataLength = jbPacket.len; + lastPacket = jbPacket.user_data; + } else { + jitter_buffer_update_delay(jbBuffer, &jbPacket, NULL); + } + + if(opusDataLength) { + outputSize = opus_decode(opusDecoder, + reinterpret_cast(jbPacket.data), + jbPacket.len, + pcmBuffer, + pcmBufferSize, 0); + } else { + outputSize = opus_decode(opusDecoder, + NULL, 0, pcmBuffer, pcmBufferSize, 0); + } + + if(outputSize < 0) { + outputSize = iFrameSize; + memset(pcmBuffer, 0, iFrameSize * sizeof(float)); + } + + if(lastPacket) { + for(unsigned int i = 0; i < iFrameSize; i++) + pcmBuffer[i] *= fFadeOut[i]; + } + + for (int i = outputSize / iFrameSize; i > 0; --i) { + jitter_buffer_tick(jbBuffer); + } + + logger.debug("%d B of Opus data decoded to %d PCM samples, last packet: %d.", + opusDataLength, outputSize, lastPacket); + + return std::make_pair(outputSize, lastPacket); +} + +void mumlib::Audio::mixAudio(uint8_t *dest, uint8_t *src, int bufferOffset, int inputLength) { + for(int i = 0; i < inputLength; i++) { + float mix = 0; + + // Clip to [-1,1] + if(mix > 1) + mix = 1; + else if(mix < -1) + mix = -1; + dest[i + bufferOffset] = mix; + } +} + std::pair mumlib::Audio::decodeOpusPayload(uint8_t *inputBuffer, int inputLength, int16_t *pcmBuffer, @@ -83,11 +226,11 @@ std::pair mumlib::Audio::decodeOpusPayload(uint8_t *inputBuffer, // Lost packets can be replaced with loss concealment by calling the decoder with a null pointer and zero length for the missing packet. // A single codec state may only be accessed from a single thread at a time and any required locking must be performed by the caller. // Separate streams must be decoded with separate decoder states and can be decoded in parallel unless the library was compiled with NONTHREADSAFE_PSEUDOSTACK defined. - - int frame = opus_packet_get_nb_frames(&inputBuffer[dataPointer], opusDataLength); - int samples = frame * opus_packet_get_samples_per_frame(&inputBuffer[dataPointer], sampleRate); + auto *packet = reinterpret_cast(&inputBuffer[dataPointer]); + int frame = opus_packet_get_nb_frames(packet, opusDataLength); + int samples = frame * opus_packet_get_samples_per_frame(packet, iSampleRate); int outputSize = opus_decode(opusDecoder, - reinterpret_cast(&inputBuffer[dataPointer]), + packet, opusDataLength, pcmBuffer, pcmBufferSize, @@ -143,7 +286,7 @@ int mumlib::Audio::encodeAudioPacket(int target, int16_t *inputPcmBuffer, int in memcpy(outputBuffer, &header[0], header.size()); memcpy(outputBuffer + header.size(), tmpOpusBuffer, (size_t) outputSize); - int incrementNumber = 100 * inputLength / sampleRate; + int incrementNumber = 100 * inputLength / iSampleRate; outgoingSequenceNumber += incrementNumber; @@ -162,6 +305,11 @@ void mumlib::Audio::resetEncoder() { outgoingSequenceNumber = 0; } +void mumlib::Audio::resetJitterBuffer() { + logger.debug("Last audio packet, resetting jitter buffer"); + jitter_buffer_reset(jbBuffer); +} + mumlib::IncomingAudioPacket mumlib::Audio::decodeIncomingAudioPacket(uint8_t *inputBuffer, int inputBufferLength) { mumlib::IncomingAudioPacket incomingAudioPacket{}; diff --git a/src/mumlib.cpp b/src/mumlib.cpp index c8101b5..3c85cec 100644 --- a/src/mumlib.cpp +++ b/src/mumlib.cpp @@ -8,7 +8,7 @@ #include #include -#include +#include #include #include @@ -33,6 +33,7 @@ namespace mumlib { int sessionId = 0; int channelId = 0; + int64_t seq = 0; std::vector listMumbleUser; std::vector listMumbleChannel; @@ -65,19 +66,27 @@ namespace mumlib { auto incomingAudioPacket = audio.decodeIncomingAudioPacket(buffer, length); if (type == AudioPacketType::OPUS) { - // todo: multiple users speaking simultaneously (Issue #3) - // something weird while decoding the opus payload int16_t pcmData[5000]; - auto status = audio.decodeOpusPayload(incomingAudioPacket.audioPayload, - incomingAudioPacket.audioPayloadLength, - pcmData, - 5000); + + audio.addFrameToBuffer(incomingAudioPacket.audioPayload, + incomingAudioPacket.audioPayloadLength, + seq); + + auto status = audio.decodeOpusPayload(pcmData, 5000); + + // auto status = audio.decodeOpusPayload(incomingAudioPacket.audioPayload, + // incomingAudioPacket.audioPayloadLength, + // pcmData, + // 5000); + + if(status.second) seq = 0; else seq++; callback.audio(incomingAudioPacket.target, - incomingAudioPacket.sessionId, - incomingAudioPacket.sequenceNumber, - pcmData, - status.first); + incomingAudioPacket.sessionId, + incomingAudioPacket.sequenceNumber, + pcmData, + status.first); + } else { logger.warn("Incoming audio packet doesn't contain Opus data, calling unsupportedAudio callback."); callback.unsupportedAudio(incomingAudioPacket.target, @@ -377,9 +386,12 @@ namespace mumlib { } void listUserRemovedBy(int sessionId) { - for(int i = 0; i < listMumbleUser.size(); i++) - if(listMumbleUser[i].sessionId == sessionId) + for(int i = 0; i < listMumbleUser.size(); i++) { + if(listMumbleUser[i].sessionId == sessionId) { listMumbleUser.erase(listMumbleUser.begin() + i); + return; + } + } } bool isListChannelContains(int channelId) { @@ -390,9 +402,12 @@ namespace mumlib { } void listChannelRemovedBy(int channelId) { - for(int i = 0; i < listMumbleChannel.size(); i++) - if(listMumbleChannel[i].channelId == channelId) + for(int i = 0; i < listMumbleChannel.size(); i++) { + if(listMumbleChannel[i].channelId == channelId) { listMumbleChannel.erase(listMumbleChannel.begin() + i); + return; + } + } } }; @@ -474,6 +489,8 @@ namespace mumlib { } void Mumlib::joinChannel(int channelId) { + if(!isChannelIdValid(channelId)) // when channel has not been registered / create + return; MumbleProto::UserState userState; userState.set_channel_id(channelId); impl->transport.sendControlMessage(MessageType::USERSTATE, userState); @@ -482,11 +499,10 @@ namespace mumlib { void Mumlib::joinChannel(string name) { int channelId = Mumlib::getChannelIdBy(name); - if(!channelId < 0) // when channel has not been registered / create - Mumlib::joinChannel(channelId); + Mumlib::joinChannel(channelId); } - void Mumlib::sendVoiceTarget(VoiceTargetType type, int targetId, int id) { + void Mumlib::sendVoiceTarget(int targetId, VoiceTargetType type, int id) { MumbleProto::VoiceTarget voiceTarget; MumbleProto::VoiceTarget_Target voiceTargetTarget; switch(type) { @@ -507,8 +523,8 @@ namespace mumlib { impl->transport.sendControlMessage(MessageType::VOICETARGET, voiceTarget); } - bool Mumlib::sendVoiceTarget(VoiceTargetType type, int targetId, string name) { - int id = -1; + void Mumlib::sendVoiceTarget(int targetId, VoiceTargetType type, string name, int &error) { + int id; switch(type) { case VoiceTargetType::CHANNEL: id = getChannelIdBy(name); @@ -519,10 +535,9 @@ namespace mumlib { default: break; } - if(id < 0) - return false; - sendVoiceTarget(type, targetId, id); - return true; + error = id < 0 ? 1: 0; + if(error) return; + sendVoiceTarget(targetId, type, id); } void Mumlib::sendUserState(mumlib::UserState field, bool val) { @@ -560,26 +575,22 @@ namespace mumlib { void Mumlib::sendUserState(mumlib::UserState field, std::string val) { MumbleProto::UserState userState; - + + // if comment longer than 128 bytes, we need to set the SHA1 hash + // http://www.askyb.com/cpp/openssl-sha1-hashing-example-in-cpp/ + unsigned char digest[SHA_DIGEST_LENGTH]; + char mdString[SHA_DIGEST_LENGTH * 2 + 1]; + + SHA1((unsigned char*) val.c_str(), val.size(), digest); + for(int i = 0; i < SHA_DIGEST_LENGTH; i++) + sprintf(&mdString[i*2], "%02x", (unsigned int) digest[i]); + switch (field) { case UserState::COMMENT: - - if(val.size() < 128) { + if(val.size() < 128) userState.set_comment(val); - } else { - // if comment longer than 128 bytes, we need to set the SHA1 hash - boost::uuids::detail::sha1 sha1; - uint hash[5]; - sha1.process_bytes(val.c_str(), val.size()); - sha1.get_digest(hash); - - std::stringstream valStream; - for(std::size_t i=0; i listMumbleChannel = impl->listMumbleChannel; - int channelId = -1; for(int i = 0; i < listMumbleChannel.size(); i++) if(listMumbleChannel[i].name == name) - channelId = listMumbleChannel[i].channelId; - return channelId; + return listMumbleChannel[i].channelId; + return -1; } int Mumlib::getUserIdBy(string name) { vector listMumbleUser = impl->listMumbleUser; - int sessionId = -1; for(int i = 0; i < listMumbleUser.size(); i++) if(listMumbleUser[i].name == name) - sessionId = listMumbleUser[i].sessionId; - return sessionId; + return listMumbleUser[i].sessionId; + return -1; + } + + bool Mumlib::isSessionIdValid(int sessionId) { + vector listMumbleUser = impl->listMumbleUser; + for(int i = 0; i < listMumbleUser.size(); i++) + if(listMumbleUser[i].sessionId == sessionId) + return true; + return false; + } + + bool Mumlib::isChannelIdValid(int channelId) { + vector listMumbleChannel = impl->listMumbleChannel; + for(int i = 0; i < listMumbleChannel.size(); i++) + if(listMumbleChannel[i].channelId == channelId) + return true; + return false; } } From 8ea7113d2197ce801797a7b67cdd9301a86a0961 Mon Sep 17 00:00:00 2001 From: Auzan Muhammad Date: Fri, 25 Jan 2019 15:06:18 +0700 Subject: [PATCH 09/78] update --- CMakeLists.txt | 8 ++ include/mumlib.hpp | 8 +- include/mumlib/Audio.hpp | 31 +++++++- src/Audio.cpp | 168 ++++++++++++++++++++++++++++++++++++--- src/Transport.cpp | 2 +- src/mumlib.cpp | 111 ++++++++++++++++---------- 6 files changed, 268 insertions(+), 60 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 9fbbab3..aea43b2 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -42,9 +42,15 @@ set(MUMLIB_SRC src/Audio.cpp ) +set(MUMLIB_LIBRARIES + speex + speexdsp + ) + PROTOBUF_GENERATE_CPP(PROTO_SRCS PROTO_HDRS Mumble.proto) add_library(mumlib SHARED ${MUMLIB_SRC} ${MUMLIB_PUBLIC_HEADERS} ${MUMLIB_PRIVATE_HEADERS} ${PROTO_SRCS} ${PROTO_HDRS}) +target_link_libraries(mumlib ${MUMLIB_LIBRARIES}) target_link_libraries(mumlib ${PROTOBUF_LIBRARIES}) target_link_libraries(mumlib ${Boost_LIBRARIES}) target_link_libraries(mumlib ${OPENSSL_LIBRARIES}) @@ -54,3 +60,5 @@ target_link_libraries(mumlib ${OPUS_LIBRARIES}) add_executable(mumlib_example mumlib_example.cpp) target_link_libraries(mumlib_example mumlib) + +install(TARGETS mumlib LIBRARY DESTINATION lib) diff --git a/include/mumlib.hpp b/include/mumlib.hpp index cab8e31..08297d1 100644 --- a/include/mumlib.hpp +++ b/include/mumlib.hpp @@ -79,9 +79,9 @@ namespace mumlib { void joinChannel(std::string channelName); - void sendVoiceTarget(mumlib::VoiceTargetType type, int targetId, int id); + void sendVoiceTarget(int targetId, mumlib::VoiceTargetType type, int sessionId); - bool sendVoiceTarget(mumlib::VoiceTargetType type, int targetId, std::string name); + void sendVoiceTarget(int targetId, mumlib::VoiceTargetType type, std::string name, int &error); void sendUserState(mumlib::UserState state, bool val); @@ -93,5 +93,9 @@ namespace mumlib { int getChannelIdBy(std::string channelName); int getUserIdBy(std::string userName); + + bool isSessionIdValid(int sessionId); + + bool isChannelIdValid(int channelId); }; } diff --git a/include/mumlib/Audio.hpp b/include/mumlib/Audio.hpp index 7e1433a..d75ac70 100644 --- a/include/mumlib/Audio.hpp +++ b/include/mumlib/Audio.hpp @@ -4,6 +4,8 @@ #include +#include + #include namespace mumlib { @@ -26,19 +28,30 @@ namespace mumlib { class Audio : boost::noncopyable { public: - explicit Audio(int opusSampleRate=DEFAULT_OPUS_SAMPLE_RATE, - int opusEncoderBitrate=DEFAULT_OPUS_ENCODER_BITRATE, + explicit Audio(int sampleRate=DEFAULT_OPUS_SAMPLE_RATE, + int bitrate=DEFAULT_OPUS_ENCODER_BITRATE, int channels=DEFAULT_OPUS_NUM_CHANNELS); virtual ~Audio(); IncomingAudioPacket decodeIncomingAudioPacket(uint8_t *inputBuffer, int inputBufferLength); + void addFrameToBuffer(uint8_t *inputBuffer, int inputLength, int sequence); + + void fetchAudio(uint8_t *inputBuffer, int bufferOffset, int inputLength); + + void mixAudio(uint8_t *inputBuffer, uint8_t *outputBuffer, int bufferOffset, int inputLength); + + void resizeBuffer(); + std::pair decodeOpusPayload(uint8_t *inputBuffer, int inputLength, int16_t *pcmBuffer, int pcmBufferSize); + std::pair decodeOpusPayload(int16_t *pcmBuffer, + int pcmBufferSize); + int encodeAudioPacket( int target, int16_t *inputPcmBuffer, @@ -52,14 +65,26 @@ namespace mumlib { void resetEncoder(); + void resetJitterBuffer(); + private: log4cpp::Category &logger; OpusDecoder *opusDecoder; OpusEncoder *opusEncoder; + JitterBuffer *jbBuffer; + + mutex m_jitter_mutex; int64_t outgoingSequenceNumber; - int sampleRate; + + unsigned int mSampleRate; + unsigned int mChannels; + unsigned int mFrameSize; + unsigned int mAudioBufferSize; + + float *mFadeIn; + float *mFadeOut; std::chrono::time_point lastEncodedAudioPacketTimestamp; }; diff --git a/src/Audio.cpp b/src/Audio.cpp index 60277df..80d8b72 100644 --- a/src/Audio.cpp +++ b/src/Audio.cpp @@ -4,30 +4,69 @@ static boost::posix_time::seconds RESET_SEQUENCE_NUMBER_INTERVAL(5); -mumlib::Audio::Audio(int opusSampleRate, int opusEncoderBitrate, int channels) +mumlib::Audio::Audio(int sampleRate, int bitrate, int channels) : logger(log4cpp::Category::getInstance("mumlib.Audio")), opusDecoder(nullptr), opusEncoder(nullptr), outgoingSequenceNumber(0) { - int error; - this->sampleRate = opusSampleRate; + int error, ret; + mSampleRate = sampleRate; + mChannels = channels; + mFrameSize = sampleRate / 100; + mAudioBufferSize = mFrameSize; + mAudioBufferSize *= 12; - opusDecoder = opus_decoder_create(opusSampleRate, channels, &error); + opusDecoder = opus_decoder_create(sampleRate, channels, &error); if (error != OPUS_OK) { throw AudioException((boost::format("failed to initialize OPUS decoder: %s") % opus_strerror(error)).str()); } - opusEncoder = opus_encoder_create(opusSampleRate, channels, OPUS_APPLICATION_VOIP, &error); + opusEncoder = opus_encoder_create(sampleRate, channels, OPUS_APPLICATION_VOIP, &error); if (error != OPUS_OK) { throw AudioException((boost::format("failed to initialize OPUS encoder: %s") % opus_strerror(error)).str()); } - opus_encoder_ctl(opusEncoder, OPUS_SET_VBR(0)); - - setOpusEncoderBitrate(opusEncoderBitrate); + ret = opus_encoder_ctl(opusEncoder, OPUS_SET_BITRATE(bitrate)); + if (ret != OPUS_OK) { + throw AudioException((boost::format("failed to initialize transmission bitrate to %d B/s: %s") + % bitrate % opus_strerror(ret)).str()); + } + ret = opus_encoder_ctl(opusEncoder, OPUS_SET_VBR(0)); + if (ret != OPUS_OK) { + throw AudioException((boost::format("failed to initialize variable bitrate: %s") + % opus_strerror(ret)).str()); + } + ret = opus_encoder_ctl(opusEncoder, OPUS_SET_VBR_CONSTRAINT(0)); + if (ret != OPUS_OK) { + throw AudioException((boost::format("failed to initialize variable bitrate constraint: %s") + % opus_strerror(ret)).str()); + } + ret = opus_encoder_ctl(opusEncoder, OPUS_SET_BANDWIDTH(OPUS_BANDWIDTH_NARROWBAND)); + if (ret != OPUS_OK) { + throw AudioException((boost::format("failed to initialize bandwidth narrow: %s") + % opus_strerror(ret)).str()); + } + ret = opus_encoder_ctl(opusEncoder, OPUS_SET_MAX_BANDWIDTH(OPUS_BANDWIDTH_NARROWBAND)); + if (ret != OPUS_OK) { + throw AudioException((boost::format("failed to initialize maximum bandwidth narrow: %s") + % opus_strerror(ret)).str()); + } resetEncoder(); + + jbBuffer = jitter_buffer_init(mFrameSize); + int margin = 10 * mFrameSize; + jitter_buffer_ctl(jbBuffer, JITTER_BUFFER_SET_MARGIN, &margin); + + mFadeIn = new float[mFrameSize]; + mFadeOut = new float[mFrameSize]; + + // Sine function to represent fade in/out. Period is FRAME_SIZE. + float mul = static_cast(M_PI / 2.0 * static_cast(mFrameSize)); + for(unsigned int i = 0; i < mFrameSize; i++) { + mFadeIn[i] = mFadeOut[mFrameSize - 1 - 1] = sinf(static_cast(i) * mul); + } } mumlib::Audio::~Audio() { @@ -38,6 +77,11 @@ mumlib::Audio::~Audio() { if (opusEncoder) { opus_encoder_destroy(opusEncoder); } + + jitter_buffer_destroy(jbBuffer); + + delete[] mFadeIn; + delete[] mFadeOut; } void mumlib::Audio::setOpusEncoderBitrate(int bitrate) { @@ -57,6 +101,99 @@ int mumlib::Audio::getOpusEncoderBitrate() { return bitrate; } +void mumlib::Audio::addFrameToBuffer(uint8_t *inputBuffer, int inputLength, int sequence) { + int dataPointer = 0; + VarInt varInt(inputBuffer); + int opusDataLength = varInt.getValue(); + dataPointer += varInt.getEncoded().size(); + bool lastPacket = (opusDataLength & 0x2000) != 0; + opusDataLength &= 0x1fff; + + auto *packet = reinterpret_cast(&inputBuffer[dataPointer]); + int frame = opus_packet_get_nb_frames(packet, opusDataLength); + int samples = frame * opus_packet_get_samples_per_frame(packet, mSampleRate); + + if(not sequence) { + resetJitterBuffer(); + } + + JitterBufferPacket jbPacket; + jbPacket.data = reinterpret_cast(&inputBuffer[dataPointer]); + jbPacket.len = opusDataLength; + jbPacket.span = samples; + jbPacket.timestamp = mFrameSize * sequence; + jbPacket.user_data = lastPacket; + + jitter_buffer_put(jbBuffer, &jbPacket); +} + +std::pair mumlib::Audio::decodeOpusPayload(int16_t *pcmBuffer, int pcmBufferSize) { + int avail = 0; + int ts = jitter_buffer_get_pointer_timestamp(jbBuffer); + jitter_buffer_ctl(jbBuffer, JITTER_BUFFER_GET_AVAILABLE_COUNT, &avail); + + char data[4096]; + JitterBufferPacket jbPacket; + jbPacket.data = data; + jbPacket.len = 4096; + + spx_int32_t startofs = 0; + int opusDataLength; + int outputSize; + spx_uint32_t lastPacket; + + if(jitter_buffer_get(jbBuffer, &jbPacket, mFrameSize, &startofs) == JITTER_BUFFER_OK) { + opusDataLength = jbPacket.len; + lastPacket = jbPacket.user_data; + + } else { + jitter_buffer_update_delay(jbBuffer, &jbPacket, NULL); + } + + if(opusDataLength) { + outputSize = opus_decode(opusDecoder, + reinterpret_cast(jbPacket.data), + jbPacket.len, + pcmBuffer, + pcmBufferSize, 0); + } else { + outputSize = opus_decode(opusDecoder, + NULL, 0, pcmBuffer, pcmBufferSize, 0); + } + + if(outputSize < 0) { + outputSize = mFrameSize; + memset(pcmBuffer, 0, mFrameSize * sizeof(float)); + } + + if(lastPacket) { + for(unsigned int i = 0; i < mFrameSize; i++) + pcmBuffer[i] *= mFadeOut[i]; + } + + for (int i = outputSize / mFrameSize; i > 0; --i) { + jitter_buffer_tick(jbBuffer); + } + + logger.debug("%d B of Opus data decoded to %d PCM samples, last packet: %d.", + opusDataLength, outputSize, lastPacket); + + return std::make_pair(outputSize, lastPacket); +} + +void mumlib::Audio::mixAudio(uint8_t *inputBuffer, uint8_t *outputBuffer, int bufferOffset, int inputLength) { + for(int i = 0; i < inputLength; i++) { + float mix = 0; + + // Clip to [-1,1] + if(mix > 1) + mix = 1; + else if(mix < -1) + mix = -1; + outputBuffer[i + bufferOffset] = mix; + } +} + std::pair mumlib::Audio::decodeOpusPayload(uint8_t *inputBuffer, int inputLength, int16_t *pcmBuffer, @@ -83,11 +220,11 @@ std::pair mumlib::Audio::decodeOpusPayload(uint8_t *inputBuffer, // Lost packets can be replaced with loss concealment by calling the decoder with a null pointer and zero length for the missing packet. // A single codec state may only be accessed from a single thread at a time and any required locking must be performed by the caller. // Separate streams must be decoded with separate decoder states and can be decoded in parallel unless the library was compiled with NONTHREADSAFE_PSEUDOSTACK defined. - - int frame = opus_packet_get_nb_frames(&inputBuffer[dataPointer], opusDataLength); - int samples = frame * opus_packet_get_samples_per_frame(&inputBuffer[dataPointer], sampleRate); + auto *packet = reinterpret_cast(&inputBuffer[dataPointer]); + int frame = opus_packet_get_nb_frames(packet, opusDataLength); + int samples = frame * opus_packet_get_samples_per_frame(packet, mSampleRate); int outputSize = opus_decode(opusDecoder, - reinterpret_cast(&inputBuffer[dataPointer]), + packet, opusDataLength, pcmBuffer, pcmBufferSize, @@ -143,7 +280,7 @@ int mumlib::Audio::encodeAudioPacket(int target, int16_t *inputPcmBuffer, int in memcpy(outputBuffer, &header[0], header.size()); memcpy(outputBuffer + header.size(), tmpOpusBuffer, (size_t) outputSize); - int incrementNumber = 100 * inputLength / sampleRate; + int incrementNumber = 100 * inputLength / mSampleRate; outgoingSequenceNumber += incrementNumber; @@ -162,6 +299,11 @@ void mumlib::Audio::resetEncoder() { outgoingSequenceNumber = 0; } +void mumlib::Audio::resetJitterBuffer() { + logger.debug("Last audio packet, resetting jitter buffer"); + jitter_buffer_reset(jbBuffer); +} + mumlib::IncomingAudioPacket mumlib::Audio::decodeIncomingAudioPacket(uint8_t *inputBuffer, int inputBufferLength) { mumlib::IncomingAudioPacket incomingAudioPacket{}; diff --git a/src/Transport.cpp b/src/Transport.cpp index 01b712a..83a383a 100644 --- a/src/Transport.cpp +++ b/src/Transport.cpp @@ -81,7 +81,7 @@ void mumlib::Transport::connect( doReceiveUdp(); } - + ip::tcp::resolver resolverTcp(ioService); ip::tcp::resolver::query queryTcp(host, to_string(port)); diff --git a/src/mumlib.cpp b/src/mumlib.cpp index c8101b5..eb33dad 100644 --- a/src/mumlib.cpp +++ b/src/mumlib.cpp @@ -8,7 +8,7 @@ #include #include -#include +#include #include #include @@ -33,6 +33,8 @@ namespace mumlib { int sessionId = 0; int channelId = 0; + int64_t seq = 0; + mutex jitter_mutex; std::vector listMumbleUser; std::vector listMumbleChannel; @@ -68,10 +70,21 @@ namespace mumlib { // todo: multiple users speaking simultaneously (Issue #3) // something weird while decoding the opus payload int16_t pcmData[5000]; - auto status = audio.decodeOpusPayload(incomingAudioPacket.audioPayload, - incomingAudioPacket.audioPayloadLength, - pcmData, - 5000); + + audio.addFrameToBuffer(incomingAudioPacket.audioPayload, + incomingAudioPacket.audioPayloadLength, + seq); + + auto status = audio.decodeOpusPayload(pcmData, 5000); + + // auto status = audio.decodeOpusPayload(incomingAudioPacket.audioPayload, + // incomingAudioPacket.audioPayloadLength, + // pcmData, + // 5000); + + if(status.second) seq = 0; else seq++; + + // logger.warn("Decode audio: %d , seq %d", incomingAudioPacket.sessionId, seq); callback.audio(incomingAudioPacket.target, incomingAudioPacket.sessionId, @@ -377,9 +390,12 @@ namespace mumlib { } void listUserRemovedBy(int sessionId) { - for(int i = 0; i < listMumbleUser.size(); i++) - if(listMumbleUser[i].sessionId == sessionId) + for(int i = 0; i < listMumbleUser.size(); i++) { + if(listMumbleUser[i].sessionId == sessionId) { listMumbleUser.erase(listMumbleUser.begin() + i); + return; + } + } } bool isListChannelContains(int channelId) { @@ -390,9 +406,12 @@ namespace mumlib { } void listChannelRemovedBy(int channelId) { - for(int i = 0; i < listMumbleChannel.size(); i++) - if(listMumbleChannel[i].channelId == channelId) + for(int i = 0; i < listMumbleChannel.size(); i++) { + if(listMumbleChannel[i].channelId == channelId) { listMumbleChannel.erase(listMumbleChannel.begin() + i); + return; + } + } } }; @@ -474,6 +493,8 @@ namespace mumlib { } void Mumlib::joinChannel(int channelId) { + if(!isChannelIdValid(channelId)) // when channel has not been registered / create + return; MumbleProto::UserState userState; userState.set_channel_id(channelId); impl->transport.sendControlMessage(MessageType::USERSTATE, userState); @@ -482,11 +503,10 @@ namespace mumlib { void Mumlib::joinChannel(string name) { int channelId = Mumlib::getChannelIdBy(name); - if(!channelId < 0) // when channel has not been registered / create - Mumlib::joinChannel(channelId); + Mumlib::joinChannel(channelId); } - void Mumlib::sendVoiceTarget(VoiceTargetType type, int targetId, int id) { + void Mumlib::sendVoiceTarget(int targetId, VoiceTargetType type, int id) { MumbleProto::VoiceTarget voiceTarget; MumbleProto::VoiceTarget_Target voiceTargetTarget; switch(type) { @@ -507,8 +527,8 @@ namespace mumlib { impl->transport.sendControlMessage(MessageType::VOICETARGET, voiceTarget); } - bool Mumlib::sendVoiceTarget(VoiceTargetType type, int targetId, string name) { - int id = -1; + void Mumlib::sendVoiceTarget(int targetId, VoiceTargetType type, string name, int &error) { + int id; switch(type) { case VoiceTargetType::CHANNEL: id = getChannelIdBy(name); @@ -519,10 +539,9 @@ namespace mumlib { default: break; } - if(id < 0) - return false; - sendVoiceTarget(type, targetId, id); - return true; + error = id < 0 ? 1: 0; + if(error) return; + sendVoiceTarget(targetId, type, id); } void Mumlib::sendUserState(mumlib::UserState field, bool val) { @@ -560,26 +579,22 @@ namespace mumlib { void Mumlib::sendUserState(mumlib::UserState field, std::string val) { MumbleProto::UserState userState; - + + // if comment longer than 128 bytes, we need to set the SHA1 hash + // http://www.askyb.com/cpp/openssl-sha1-hashing-example-in-cpp/ + unsigned char digest[SHA_DIGEST_LENGTH]; + char mdString[SHA_DIGEST_LENGTH * 2 + 1]; + + SHA1((unsigned char*) val.c_str(), val.size(), digest); + for(int i = 0; i < SHA_DIGEST_LENGTH; i++) + sprintf(&mdString[i*2], "%02x", (unsigned int) digest[i]); + switch (field) { case UserState::COMMENT: - - if(val.size() < 128) { + if(val.size() < 128) userState.set_comment(val); - } else { - // if comment longer than 128 bytes, we need to set the SHA1 hash - boost::uuids::detail::sha1 sha1; - uint hash[5]; - sha1.process_bytes(val.c_str(), val.size()); - sha1.get_digest(hash); - - std::stringstream valStream; - for(std::size_t i=0; i listMumbleChannel = impl->listMumbleChannel; - int channelId = -1; for(int i = 0; i < listMumbleChannel.size(); i++) if(listMumbleChannel[i].name == name) - channelId = listMumbleChannel[i].channelId; - return channelId; + return listMumbleChannel[i].channelId; + return -1; } int Mumlib::getUserIdBy(string name) { vector listMumbleUser = impl->listMumbleUser; - int sessionId = -1; for(int i = 0; i < listMumbleUser.size(); i++) if(listMumbleUser[i].name == name) - sessionId = listMumbleUser[i].sessionId; - return sessionId; + return listMumbleUser[i].sessionId; + return -1; + } + + bool Mumlib::isSessionIdValid(int sessionId) { + vector listMumbleUser = impl->listMumbleUser; + for(int i = 0; i < listMumbleUser.size(); i++) + if(listMumbleUser[i].sessionId == sessionId) + return true; + return false; + } + + bool Mumlib::isChannelIdValid(int channelId) { + vector listMumbleChannel = impl->listMumbleChannel; + for(int i = 0; i < listMumbleChannel.size(); i++) + if(listMumbleChannel[i].channelId == channelId) + return true; + return false; } } From 792517ddb4d4eea95748d7ea52dc19a253f84e0a Mon Sep 17 00:00:00 2001 From: HeroCC Date: Wed, 27 Jun 2018 10:14:14 -0400 Subject: [PATCH 10/78] Fix compiling on MacOSX Systems Setting those options made OSX quite upset for some reason, so disable them when on Macs. I haven't been able to find any issues with this, so hopefully it doesn't subtly break anything. Additionally, this will add the default MacPorts library directory to the LD Path, which fixes linking against Log4CPP. --- CMakeLists.txt | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index e4e177f..6408971 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -2,7 +2,12 @@ cmake_minimum_required(VERSION 2.8.0) project(mumlib) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11") -add_definitions(-DOPT_TLS_GNUTLS -D_POSIX_C_SOURCE=200112L) + +if (NOT APPLE) + add_definitions(-DOPT_TLS_GNUTLS -D_POSIX_C_SOURCE=200112L) +else() + LINK_DIRECTORIES(/opt/local/lib) # Include the default MacPorts library directory +endif() INCLUDE(FindPkgConfig) find_package(PkgConfig REQUIRED) From d3bcced88de9baffe67010c26db79baa7ff0393d Mon Sep 17 00:00:00 2001 From: HeroCC Date: Thu, 5 Jul 2018 14:19:28 -0400 Subject: [PATCH 11/78] Fix an import statement that was causing some compilations to fail --- include/mumlib.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/mumlib.hpp b/include/mumlib.hpp index 08297d1..09e1b90 100644 --- a/include/mumlib.hpp +++ b/include/mumlib.hpp @@ -1,12 +1,12 @@ #pragma once #include "mumlib/Callback.hpp" +#include "mumlib/enums.hpp" #include #include #include -#include namespace mumlib { From e402d62f33d88630e883cc23da7302543fb4060e Mon Sep 17 00:00:00 2001 From: Scott Hardin Date: Sun, 28 May 2017 21:02:45 +0200 Subject: [PATCH 12/78] add initial support for client certs --- README.md | 4 +++- include/mumlib.hpp | 2 ++ include/mumlib/Transport.hpp | 24 +++++++++++++++++++++++- mumlib_example.cpp | 10 +++++++--- src/Transport.cpp | 16 +++++++++++++++- src/mumlib.cpp | 14 +++++++++++--- 6 files changed, 61 insertions(+), 9 deletions(-) diff --git a/README.md b/README.md index efae754..90bb781 100644 --- a/README.md +++ b/README.md @@ -35,6 +35,8 @@ make Sample usage is covered in *mumlib_example.cpp* file. Basically, you should extend *mumlib::Callback* class to implement your own handlers. +To use a client certificate, you'll need a PEM certificate and private key without a passphrase. These are assed in the MumlibConfig struct to the Mumlib object constructor. Support for passphrase still needs to be added. + ## Credits 2015 MichaÅ‚ SÅ‚omkowski. The code is published under the terms of Lesser General Public License Version 3. @@ -42,4 +44,4 @@ to implement your own handlers. The library contains code from following 3rd party projects: * official Mumble Client: https://github.com/mumble-voip/mumble -* *libmumble*: https://github.com/cornejo/libmumble \ No newline at end of file +* *libmumble*: https://github.com/cornejo/libmumble diff --git a/include/mumlib.hpp b/include/mumlib.hpp index 09e1b90..9350b38 100644 --- a/include/mumlib.hpp +++ b/include/mumlib.hpp @@ -26,6 +26,8 @@ namespace mumlib { int opusEncoderBitrate = DEFAULT_OPUS_ENCODER_BITRATE; int opusSampleRate = DEFAULT_OPUS_SAMPLE_RATE; int opusChannels = DEFAULT_OPUS_NUM_CHANNELS; + std::string cert_file = ""; + std::string privkey_file = ""; // additional fields will be added in the future }; diff --git a/include/mumlib/Transport.hpp b/include/mumlib/Transport.hpp index 346728b..2bc7f6c 100644 --- a/include/mumlib/Transport.hpp +++ b/include/mumlib/Transport.hpp @@ -34,12 +34,26 @@ namespace mumlib { TransportException(string message) : MumlibException(std::move(message)) { } }; + /* This helper is needed because the sslContext and sslSocket are initialized in + * the Transport constructor and there wasn't an easier way of passing these two + * arguments. + * TODO: add support for password callback. + */ + class SslContextHelper : boost::noncopyable { + public: + SslContextHelper(boost::asio::ssl::context &ctx, + std::string cert_file, std::string privkey_file); + ~SslContextHelper() { }; + }; + class Transport : boost::noncopyable { public: Transport(io_service &ioService, ProcessControlMessageFunction processControlMessageFunc, ProcessEncodedAudioPacketFunction processEncodedAudioPacketFunction, - bool noUdp = false); + bool noUdp = false, + std::string cert_file = "", + std::string privkey_file = ""); ~Transport(); @@ -48,6 +62,13 @@ namespace mumlib { string user, string password); + void connect(string host, + int port, + string user, + string password, + string cert_file, + string privkey_file); + void disconnect(); ConnectionState getConnectionState() { @@ -85,6 +106,7 @@ namespace mumlib { CryptState cryptState; ssl::context sslContext; + SslContextHelper sslContextHelper; ssl::stream sslSocket; uint8_t *sslIncomingBuffer; diff --git a/mumlib_example.cpp b/mumlib_example.cpp index 2e874d6..6cebc0f 100644 --- a/mumlib_example.cpp +++ b/mumlib_example.cpp @@ -39,8 +39,8 @@ int main(int argc, char *argv[]) { logger.setPriority(log4cpp::Priority::NOTICE); logger.addAppender(appender1); - if (argc < 3) { - logger.crit("Usage: %s {server} {password}", argv[0]); + if (argc < 3 || argc == 4 || argc > 5) { + logger.crit("Usage: %s {server} {password} [{certfile} {keyfile}]", argv[0]); return 1; } @@ -50,6 +50,10 @@ int main(int argc, char *argv[]) { try { mumlib::MumlibConfiguration conf; conf.opusEncoderBitrate = 32000; + if ( argc > 3 && argc <= 5 ) { + conf.cert_file = argv[3]; + conf.privkey_file = argv[4]; + } mumlib::Mumlib mum(myCallback, conf); myCallback.mum = &mum; mum.connect(argv[1], 64738, "mumlib_example", argv[2]); @@ -61,4 +65,4 @@ int main(int argc, char *argv[]) { std::this_thread::sleep_for(std::chrono::seconds(5)); } } -} \ No newline at end of file +} diff --git a/src/Transport.cpp b/src/Transport.cpp index 83a383a..4af0a91 100644 --- a/src/Transport.cpp +++ b/src/Transport.cpp @@ -29,7 +29,9 @@ mumlib::Transport::Transport( io_service &ioService, mumlib::ProcessControlMessageFunction processMessageFunc, ProcessEncodedAudioPacketFunction processEncodedAudioPacketFunction, - bool noUdp) : + bool noUdp, + std::string cert_file, + std::string privkey_file) : logger(log4cpp::Category::getInstance("mumlib.Transport")), ioService(ioService), processMessageFunction(std::move(processMessageFunc)), @@ -38,6 +40,7 @@ mumlib::Transport::Transport( state(ConnectionState::NOT_CONNECTED), udpSocket(ioService), sslContext(ssl::context::sslv23), + sslContextHelper(sslContext, cert_file, privkey_file), sslSocket(ioService, sslContext), pingTimer(ioService, PING_INTERVAL), asyncBufferPool(static_cast(max(MAX_UDP_LENGTH, MAX_TCP_LENGTH))) { @@ -67,6 +70,7 @@ void mumlib::Transport::connect( sslSocket.set_verify_mode(boost::asio::ssl::verify_peer); + //todo for now it accepts every certificate, move it to callback sslSocket.set_verify_callback([](bool preverified, boost::asio::ssl::verify_context &ctx) { return true; @@ -519,6 +523,16 @@ void mumlib::Transport::throwTransportException(string message) { throw TransportException(std::move(message)); } +mumlib::SslContextHelper::SslContextHelper(ssl::context &ctx, std::string cert_file, std::string privkey_file) { + if ( cert_file.size() > 0 ) { + ctx.use_certificate_file(cert_file, ssl::context::file_format::pem); + } + if ( privkey_file.size() > 0 ) { + ctx.use_private_key_file(privkey_file, ssl::context::file_format::pem); + } +} + + void mumlib::Transport::sendEncodedAudioPacket(uint8_t *buffer, int length) { if (state != ConnectionState::CONNECTED) { logger.warn("Connection not established."); diff --git a/src/mumlib.cpp b/src/mumlib.cpp index 3c85cec..0447b7f 100644 --- a/src/mumlib.cpp +++ b/src/mumlib.cpp @@ -43,12 +43,20 @@ namespace mumlib { externalIoService = false; } - _Mumlib_Private(Callback &callback, io_service &ioService, MumlibConfiguration &configuration) + _Mumlib_Private( + Callback &callback, + io_service &ioService, + MumlibConfiguration &configuration) : callback(callback), ioService(ioService), externalIoService(true), - transport(ioService, boost::bind(&_Mumlib_Private::processIncomingTcpMessage, this, _1, _2, _3), - boost::bind(&_Mumlib_Private::processAudioPacket, this, _1, _2, _3)), + transport( + ioService, + boost::bind(&_Mumlib_Private::processIncomingTcpMessage, this, _1, _2, _3), + boost::bind(&_Mumlib_Private::processAudioPacket, this, _1, _2, _3), + false, + configuration.cert_file, + configuration.privkey_file), audio(configuration.opusSampleRate, configuration.opusEncoderBitrate, configuration.opusChannels) { audio.setOpusEncoderBitrate(configuration.opusEncoderBitrate); From bb2cfe636cb7bd4186957a4c082648dc4360edd3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Patrik=20Dahlstr=C3=B6m?= Date: Thu, 26 Mar 2020 21:23:29 +0100 Subject: [PATCH 13/78] Compile and link example again --- CMakeLists.txt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 6408971..3121f8f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -63,7 +63,7 @@ target_link_libraries(mumlib ${LOG4CPP_LIBRARIES} ${OPUS_LIBRARIES}) -# add_executable(mumlib_example mumlib_example.cpp) -# target_link_libraries(mumlib_example mumlib) +add_executable(mumlib_example mumlib_example.cpp) +target_link_libraries(mumlib_example mumlib) install(TARGETS mumlib LIBRARY DESTINATION lib) From a5bf9ab3dbad4fa8b3e73a9c49c7cdc8acaa87ae Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Patrik=20Dahlstr=C3=B6m?= Date: Thu, 26 Mar 2020 21:59:40 +0100 Subject: [PATCH 14/78] Also install headers --- CMakeLists.txt | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 3121f8f..c2328a0 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -63,7 +63,9 @@ target_link_libraries(mumlib ${LOG4CPP_LIBRARIES} ${OPUS_LIBRARIES}) +set_target_properties(mumlib PROPERTIES PUBLIC_HEADER "${MUMLIB_PUBLIC_HEADERS}") + add_executable(mumlib_example mumlib_example.cpp) target_link_libraries(mumlib_example mumlib) -install(TARGETS mumlib LIBRARY DESTINATION lib) +install(TARGETS mumlib LIBRARY DESTINATION lib PUBLIC_HEADER DESTINATION include/mumlib) From 0f93187eaa36d3f0d45b5d8b022b8e27a0881b19 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Patrik=20Dahlstr=C3=B6m?= Date: Thu, 26 Mar 2020 23:14:24 +0100 Subject: [PATCH 15/78] Remove spam printout --- src/Audio.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/Audio.cpp b/src/Audio.cpp index 393b674..dcfe6dd 100644 --- a/src/Audio.cpp +++ b/src/Audio.cpp @@ -137,8 +137,6 @@ std::pair mumlib::Audio::decodeOpusPayload(int16_t *pcmBuffer, int pc jitter_buffer_remaining_span(jbBuffer, remaining); int timestamp = jitter_buffer_get_pointer_timestamp(jbBuffer); - logger.warn("jbBufer, avail: %d, remain: %d, timestamp: %d", avail, remaining, timestamp); - char data[4096]; JitterBufferPacket jbPacket; jbPacket.data = data; From 932a09ec2c363596af0bb13e467dcdf48b752faa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Patrik=20Dahlstr=C3=B6m?= Date: Sun, 29 Mar 2020 17:15:33 +0200 Subject: [PATCH 16/78] Use separate opus decoder state per session --- include/mumlib/Audio.hpp | 9 ++++++--- src/Audio.cpp | 39 +++++++++++++++++++++++++++++---------- src/mumlib.cpp | 2 +- 3 files changed, 36 insertions(+), 14 deletions(-) diff --git a/include/mumlib/Audio.hpp b/include/mumlib/Audio.hpp index 862eeef..cfea013 100644 --- a/include/mumlib/Audio.hpp +++ b/include/mumlib/Audio.hpp @@ -7,6 +7,7 @@ #include #include +#include namespace mumlib { @@ -43,11 +44,13 @@ namespace mumlib { void resizeBuffer(); - std::pair decodeOpusPayload(int16_t *pcmBuffer, + std::pair decodeOpusPayload(int sessionId, + int16_t *pcmBuffer, int pcmBufferSize); std::pair decodeOpusPayload(uint8_t *inputBuffer, int inputLength, + int sessionId, int16_t *pcmBuffer, int pcmBufferSize); @@ -70,7 +73,7 @@ namespace mumlib { private: log4cpp::Category &logger; - OpusDecoder *opusDecoder; + std::map opusDecoders; OpusEncoder *opusEncoder; JitterBuffer *jbBuffer; @@ -86,4 +89,4 @@ namespace mumlib { std::chrono::time_point lastEncodedAudioPacketTimestamp; }; -} \ No newline at end of file +} diff --git a/src/Audio.cpp b/src/Audio.cpp index dcfe6dd..189b9c6 100644 --- a/src/Audio.cpp +++ b/src/Audio.cpp @@ -4,9 +4,25 @@ static boost::posix_time::seconds RESET_SEQUENCE_NUMBER_INTERVAL(5); +namespace { + +OpusDecoder* CreateOpusDecoder(int sampleRate, int channels) +{ + int error; + OpusDecoder* decoder = nullptr; + + decoder = opus_decoder_create(sampleRate, channels, &error); + if (error != OPUS_OK) { + throw mumlib::AudioException((boost::format("failed to initialize OPUS decoder: %s") % opus_strerror(error)).str()); + } + + return decoder; +} + +} // anonymous namespace + mumlib::Audio::Audio(int sampleRate, int bitrate, int channels) : logger(log4cpp::Category::getInstance("mumlib.Audio")), - opusDecoder(nullptr), opusEncoder(nullptr), outgoingSequenceNumber(0), iSampleRate(sampleRate), @@ -17,11 +33,6 @@ mumlib::Audio::Audio(int sampleRate, int bitrate, int channels) iAudioBufferSize = iFrameSize; iAudioBufferSize *= 12; - opusDecoder = opus_decoder_create(sampleRate, channels, &error); - if (error != OPUS_OK) { - throw AudioException((boost::format("failed to initialize OPUS decoder: %s") % opus_strerror(error)).str()); - } - opusEncoder = opus_encoder_create(sampleRate, channels, OPUS_APPLICATION_VOIP, &error); if (error != OPUS_OK) { throw AudioException((boost::format("failed to initialize OPUS encoder: %s") % opus_strerror(error)).str()); @@ -70,8 +81,8 @@ mumlib::Audio::Audio(int sampleRate, int bitrate, int channels) } mumlib::Audio::~Audio() { - if (opusDecoder) { - opus_decoder_destroy(opusDecoder); + for (const auto decoder : opusDecoders) { + opus_decoder_destroy(decoder.second); } if (opusEncoder) { @@ -130,7 +141,7 @@ void mumlib::Audio::addFrameToBuffer(uint8_t *inputBuffer, int inputLength, int jitter_buffer_put(jbBuffer, &jbPacket); } -std::pair mumlib::Audio::decodeOpusPayload(int16_t *pcmBuffer, int pcmBufferSize) { +std::pair mumlib::Audio::decodeOpusPayload(int sessionId, int16_t *pcmBuffer, int pcmBufferSize) { int avail = 0; spx_uint32_t remaining = 0; jitter_buffer_ctl(jbBuffer, JITTER_BUFFER_GET_AVAILABLE_COUNT, &avail); @@ -153,7 +164,10 @@ std::pair mumlib::Audio::decodeOpusPayload(int16_t *pcmBuffer, int pc } else { jitter_buffer_update_delay(jbBuffer, &jbPacket, NULL); } - + OpusDecoder* &opusDecoder = opusDecoders[sessionId]; + if (!opusDecoder) { + opusDecoder = CreateOpusDecoder(iSampleRate, iChannels); + } if(opusDataLength) { outputSize = opus_decode(opusDecoder, reinterpret_cast(jbPacket.data), @@ -200,6 +214,7 @@ void mumlib::Audio::mixAudio(uint8_t *dest, uint8_t *src, int bufferOffset, int std::pair mumlib::Audio::decodeOpusPayload(uint8_t *inputBuffer, int inputLength, + int sessionId, int16_t *pcmBuffer, int pcmBufferSize) { int64_t opusDataLength; @@ -227,6 +242,10 @@ std::pair mumlib::Audio::decodeOpusPayload(uint8_t *inputBuffer, auto *packet = reinterpret_cast(&inputBuffer[dataPointer]); int frame = opus_packet_get_nb_frames(packet, opusDataLength); int samples = frame * opus_packet_get_samples_per_frame(packet, iSampleRate); + OpusDecoder* &opusDecoder = opusDecoders[sessionId]; + if (!opusDecoder) { + opusDecoder = CreateOpusDecoder(iSampleRate, iChannels); + } int outputSize = opus_decode(opusDecoder, packet, opusDataLength, diff --git a/src/mumlib.cpp b/src/mumlib.cpp index 0447b7f..ec7a7a6 100644 --- a/src/mumlib.cpp +++ b/src/mumlib.cpp @@ -80,7 +80,7 @@ namespace mumlib { incomingAudioPacket.audioPayloadLength, seq); - auto status = audio.decodeOpusPayload(pcmData, 5000); + auto status = audio.decodeOpusPayload(incomingAudioPacket.sessionId, pcmData, 5000); // auto status = audio.decodeOpusPayload(incomingAudioPacket.audioPayload, // incomingAudioPacket.audioPayloadLength, From 2a2ccebfa5b2682c2508c969a90ec49cac1e4fbd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Patrik=20Dahlstr=C3=B6m?= Date: Sun, 29 Mar 2020 17:16:35 +0200 Subject: [PATCH 17/78] Ignore .user files --- .gitignore | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/.gitignore b/.gitignore index 4286771..baa92b9 100644 --- a/.gitignore +++ b/.gitignore @@ -32,3 +32,7 @@ build/ # IntelliJ *.iml .idea/ + + +# QtCreator +*.user From 6c76dbc291b03af459fc5a7c9ea7c348a775d402 Mon Sep 17 00:00:00 2001 From: "Hiroshi Takey F. (hiro2233)" Date: Thu, 4 Jun 2020 06:47:48 -0400 Subject: [PATCH 18/78] include: set opus sample rate to 24000. --- include/mumlib.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/mumlib.hpp b/include/mumlib.hpp index 9350b38..1be5c02 100644 --- a/include/mumlib.hpp +++ b/include/mumlib.hpp @@ -11,7 +11,7 @@ namespace mumlib { constexpr int DEFAULT_OPUS_ENCODER_BITRATE = 16000; - constexpr int DEFAULT_OPUS_SAMPLE_RATE = 48000; + constexpr int DEFAULT_OPUS_SAMPLE_RATE = 24000; constexpr int DEFAULT_OPUS_NUM_CHANNELS = 1; using namespace std; From d30b2cb56fec3c5f5a73665cf6ff897e60fc1336 Mon Sep 17 00:00:00 2001 From: "Hiroshi Takey F. (hiro2233)" Date: Thu, 4 Jun 2020 06:48:24 -0400 Subject: [PATCH 19/78] example: set bitrate 16000 and port 1234. --- mumlib_example.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/mumlib_example.cpp b/mumlib_example.cpp index 6cebc0f..3640374 100644 --- a/mumlib_example.cpp +++ b/mumlib_example.cpp @@ -49,14 +49,14 @@ int main(int argc, char *argv[]) { while (true) { try { mumlib::MumlibConfiguration conf; - conf.opusEncoderBitrate = 32000; + conf.opusEncoderBitrate = 16000; if ( argc > 3 && argc <= 5 ) { conf.cert_file = argv[3]; conf.privkey_file = argv[4]; } mumlib::Mumlib mum(myCallback, conf); myCallback.mum = &mum; - mum.connect(argv[1], 64738, "mumlib_example", argv[2]); + mum.connect(argv[1], 1234, "mumlib_example2", argv[2]); mum.run(); } catch (mumlib::TransportException &exp) { logger.error("TransportException: %s.", exp.what()); From 7cb5c367300f4706266c6d62f90b7ba0e8dec3a3 Mon Sep 17 00:00:00 2001 From: "Hiroshi Takey F. (hiro2233)" Date: Thu, 4 Jun 2020 06:49:24 -0400 Subject: [PATCH 20/78] src: set OPUS enc ctl signal. --- src/Audio.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/Audio.cpp b/src/Audio.cpp index 189b9c6..a347a75 100644 --- a/src/Audio.cpp +++ b/src/Audio.cpp @@ -64,6 +64,8 @@ mumlib::Audio::Audio(int sampleRate, int bitrate, int channels) % opus_strerror(ret)).str()); } + opus_encoder_ctl(opusEncoder, OPUS_SET_SIGNAL(OPUS_SIGNAL_VOICE)); + resetEncoder(); jbBuffer = jitter_buffer_init(iFrameSize); @@ -273,7 +275,7 @@ int mumlib::Audio::encodeAudioPacket(int target, int16_t *inputPcmBuffer, int in system_clock::now() - lastEncodedAudioPacketTimestamp).count(); if (lastAudioPacketSentInterval > RESET_SEQUENCE_NUMBER_INTERVAL.total_milliseconds() + 1000) { - logger.debug("Last audio packet was sent %d ms ago, resetting encoder.", lastAudioPacketSentInterval); + logger.notice("Last audio packet was sent %d ms ago, resetting encoder.", lastAudioPacketSentInterval); resetEncoder(); } From cfa875f0af874a71ab9235a5b4f2fd8618725365 Mon Sep 17 00:00:00 2001 From: "Hiroshi Takey F. (hiro2233)" Date: Thu, 4 Jun 2020 06:50:05 -0400 Subject: [PATCH 21/78] src: set logger callback to warn. --- src/Callback.cpp | 38 +++++++++++++++++++------------------- 1 file changed, 19 insertions(+), 19 deletions(-) diff --git a/src/Callback.cpp b/src/Callback.cpp index 5bc69e3..b50c7a8 100644 --- a/src/Callback.cpp +++ b/src/Callback.cpp @@ -31,7 +31,7 @@ void mumlib::BasicCallback::version( string release, string os, string os_version) { - impl->logger.debug("version: v%d.%d.%d. %s/%s/%s\n", major, minor, patch, release.c_str(), os.c_str(), + impl->logger.warn("version: v%d.%d.%d. %s/%s/%s\n", major, minor, patch, release.c_str(), os.c_str(), os_version.c_str()); } @@ -41,7 +41,7 @@ void BasicCallback::audio( int sequenceNumber, int16_t *pcmData, uint32_t pcm_data_size) { - impl->logger.debug("audio: %d bytes of raw PCM data, target: %d, session: %d, seq: %d.", + impl->logger.warn("audio: %d bytes of raw PCM data, target: %d, session: %d, seq: %d.", pcm_data_size, target, sessionId, sequenceNumber); } @@ -51,40 +51,40 @@ void BasicCallback::unsupportedAudio( int sequenceNumber, uint8_t *encoded_audio_data, uint32_t encoded_audio_data_size) { - impl->logger.debug("unsupportedAudio: received %d bytes of encoded data, target: %d, session: %d, seq: %d.", + impl->logger.warn("unsupportedAudio: received %d bytes of encoded data, target: %d, session: %d, seq: %d.", encoded_audio_data_size, target, sessionId, sequenceNumber); } void BasicCallback::serverSync(string welcome_text, int32_t session, int32_t max_bandwidth, int64_t permissions) { - impl->logger.debug("serverSync: text: %s, session: %d, max bandwidth: %d, permissions: %d", welcome_text.c_str(), + impl->logger.warn("serverSync: text: %s, session: %d, max bandwidth: %d, permissions: %d", welcome_text.c_str(), session, max_bandwidth, permissions); } void BasicCallback::channelRemove(uint32_t channel_id) { - impl->logger.debug("channelRemove: %d", channel_id); + impl->logger.warn("channelRemove: %d", channel_id); } void BasicCallback::channelState(string name, int32_t channel_id, int32_t parent, string description, vector links, vector inks_add, vector links_remove, bool temporary, int32_t position) { - impl->logger.debug("channelState: %d: %s, %s", channel_id, name.c_str(), description.c_str()); + impl->logger.warn("channelState: %d: %s, %s", channel_id, name.c_str(), description.c_str()); } void BasicCallback::userRemove(uint32_t session, int32_t actor, string reason, bool ban) { - impl->logger.debug("userRemove: session: %d, actor: %d, reason: %s, ban: %d.", session, actor, reason.c_str(), ban); + impl->logger.warn("userRemove: session: %d, actor: %d, reason: %s, ban: %d.", session, actor, reason.c_str(), ban); } void BasicCallback::userState(int32_t session, int32_t actor, string name, int32_t user_id, int32_t channel_id, int32_t mute, int32_t deaf, int32_t suppress, int32_t self_mute, int32_t self_deaf, string comment, int32_t priority_speaker, int32_t recording) { - impl->logger.debug("userState: %s: mute: %d, deaf: %d, suppress: %d, self mute: %d, self deaf: %d", + impl->logger.warn("userState: %s: mute: %d, deaf: %d, suppress: %d, self mute: %d, self deaf: %d", name.c_str(), mute, deaf, suppress, self_mute, self_deaf); } void BasicCallback::banList(const uint8_t *ip_data, uint32_t ip_data_size, uint32_t mask, string name, string hash, string reason, string start, int32_t duration) { - impl->logger.debug("banList: %s, hash: %s, reason: %s", name.c_str(), hash.c_str(), reason.c_str()); + impl->logger.warn("banList: %s, hash: %s, reason: %s", name.c_str(), hash.c_str(), reason.c_str()); } void BasicCallback::textMessage( @@ -93,43 +93,43 @@ void BasicCallback::textMessage( std::vector channel_id, std::vector tree_id, string message) { - impl->logger.debug("textMessage: %d: %s", actor, message.c_str()); + impl->logger.warn("textMessage: %d: %s", actor, message.c_str()); } void BasicCallback::permissionDenied(int32_t permission, int32_t channel_id, int32_t session, string reason, int32_t deny_type, string name) { - impl->logger.debug("permissionDenied: %s %s", name.c_str(), reason.c_str()); + impl->logger.warn("permissionDenied: %s %s", name.c_str(), reason.c_str()); } void BasicCallback::queryUsers(uint32_t n_ids, uint32_t *ids, uint32_t n_names, string *names) { - impl->logger.debug("queryUsers: %d users", n_names); //todo make it more high-level + impl->logger.warn("queryUsers: %d users", n_names); //todo make it more high-level } void BasicCallback::contextActionModify(string action, string text, uint32_t m_context, uint32_t operation) { - impl->logger.debug("contextActionModify: "); + impl->logger.warn("contextActionModify: "); } void BasicCallback::contextAction(int32_t session, int32_t channel_id, string action) { - impl->logger.debug("contextAction."); + impl->logger.warn("contextAction."); } void BasicCallback::userList(uint32_t user_id, string name, string last_seen, int32_t last_channel) { - impl->logger.debug("userList."); + impl->logger.warn("userList."); } void BasicCallback::permissionQuery(int32_t channel_id, uint32_t permissions, int32_t flush) { - impl->logger.debug("permissionQuery."); + impl->logger.warn("permissionQuery."); } void BasicCallback::codecVersion(int32_t alpha, int32_t beta, uint32_t prefer_alpha, int32_t opus) { - impl->logger.debug("codecVersion."); + impl->logger.warn("codecVersion."); } void BasicCallback::serverConfig(uint32_t max_bandwidth, string welcome_text, uint32_t allow_html, uint32_t message_length, uint32_t image_message_length) { - impl->logger.debug("serverConfig: %s", welcome_text.c_str()); + impl->logger.warn("serverConfig: %s", welcome_text.c_str()); } void BasicCallback::suggestConfig(uint32_t version, uint32_t positional, uint32_t push_to_talk) { - impl->logger.debug("suggestConfig."); + impl->logger.warn("suggestConfig."); } From 007f9735a6ce36aff5bad8a5c9c10b636042a1a1 Mon Sep 17 00:00:00 2001 From: "Hiroshi Takey F. (hiro2233)" Date: Thu, 4 Jun 2020 06:50:49 -0400 Subject: [PATCH 22/78] src: fixed ssl Transport reconnection. --- src/Transport.cpp | 31 ++++++++++++++++--------------- 1 file changed, 16 insertions(+), 15 deletions(-) diff --git a/src/Transport.cpp b/src/Transport.cpp index 4af0a91..1218291 100644 --- a/src/Transport.cpp +++ b/src/Transport.cpp @@ -6,7 +6,7 @@ using namespace std; -static boost::posix_time::seconds PING_INTERVAL(5); +static boost::posix_time::seconds PING_INTERVAL(4); const long CLIENT_VERSION = 0x01020A; const string CLIENT_RELEASE("Mumlib"); @@ -102,13 +102,13 @@ void mumlib::Transport::disconnect() { boost::system::error_code errorCode; // todo perform different operations for each ConnectionState - +/* sslSocket.shutdown(errorCode); if (errorCode) { logger.warn("SSL socket shutdown returned an error: %s.", errorCode.message().c_str()); } - - sslSocket.lowest_layer().shutdown(tcp::socket::shutdown_both, errorCode); +*/ + sslSocket.lowest_layer().close(errorCode); if (errorCode) { logger.warn("SSL socket lowest layer shutdown returned an error: %s.", errorCode.message().c_str()); } @@ -315,8 +315,8 @@ void mumlib::Transport::doReceiveSsl() { int messageType = ntohs(*reinterpret_cast(sslIncomingBuffer)); - logger.debug("Received %d B of data (%d B payload, type %d).", bytesTransferred, - bytesTransferred - 6, messageType); + //logger.warn("Received %d B of data (%d B payload, type %d).", bytesTransferred, + // bytesTransferred - 6, messageType); processMessageInternal( static_cast(messageType), @@ -337,7 +337,7 @@ void mumlib::Transport::processMessageInternal(MessageType messageType, uint8_t switch (messageType) { case MessageType::UDPTUNNEL: { - logger.debug("Received %d B of encoded audio data via TCP.", length); + logger.warn("Received %d B of encoded audio data via TCP.", length); processAudioPacket(buffer, length); } break; @@ -365,7 +365,7 @@ void mumlib::Transport::processMessageInternal(MessageType messageType, uint8_t if (ping.has_udp_ping_avg()) { log << " UDP avg: " << ping.udp_ping_avg() << " ms"; } - logger.debug(log.str()); + //logger.warn(log.str()); } break; case MessageType::REJECT: { @@ -389,7 +389,7 @@ void mumlib::Transport::processMessageInternal(MessageType messageType, uint8_t case MessageType::SERVERSYNC: { state = ConnectionState::CONNECTED; - logger.debug("SERVERSYNC. Calling external ProcessControlMessageFunction."); + logger.warn("SERVERSYNC. Calling external ProcessControlMessageFunction."); processMessageFunction(messageType, buffer, length); } break; @@ -413,17 +413,17 @@ void mumlib::Transport::processMessageInternal(MessageType messageType, uint8_t throwTransportException("crypt setup data not valid"); } - logger.info("Set up cryptography for UDP transport. Sending UDP ping."); + logger.warn("Set up cryptography for UDP transport. Sending UDP ping."); sendUdpPing(); } else { - logger.info("Ignoring crypt setup message, because UDP is disabled."); + logger.warn("Ignoring crypt setup message, because UDP is disabled."); } } break; default: { - logger.debug("Calling external ProcessControlMessageFunction."); + logger.warn("Calling external ProcessControlMessageFunction."); processMessageFunction(messageType, buffer, length); } break; @@ -540,10 +540,10 @@ void mumlib::Transport::sendEncodedAudioPacket(uint8_t *buffer, int length) { } if (udpActive) { - logger.info("Sending %d B of audio data via UDP.", length); + //logger.warn("Sending %d B of audio data via UDP.", length); sendUdpAsync(buffer, length); } else { - logger.info("Sending %d B of audio data via TCP.", length); + //logger.warn("Sending %d B of audio data via TCP.", length); const uint16_t netUdptunnelType = htons(static_cast(MessageType::UDPTUNNEL)); @@ -557,7 +557,7 @@ void mumlib::Transport::sendEncodedAudioPacket(uint8_t *buffer, int length) { memcpy(packetBuff + sizeof(netUdptunnelType), &netLength, sizeof(netLength)); memcpy(packetBuff + sizeof(netUdptunnelType) + sizeof(netLength), buffer, static_cast(length)); - sendSslAsync(packetBuff, length + sizeof(netUdptunnelType) + sizeof(netLength)); + sendSsl(packetBuff, length + sizeof(netUdptunnelType) + sizeof(netLength)); } } @@ -569,6 +569,7 @@ void mumlib::Transport::processAudioPacket(uint8_t *buff, int length) { case AudioPacketType::CELT_Beta: case AudioPacketType::OPUS: processEncodedAudioPacketFunction(type, buff, length); + logger.warn("audio typehex: 0x%2x typedec: %d", buff[0], type); break; case AudioPacketType::Ping: break; From 01fe2f6e78eb137f2dca3112d28e6088a7d759e1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Micha=C5=82=20S=C5=82omkowski?= Date: Wed, 12 Dec 2018 01:37:45 +0100 Subject: [PATCH 23/78] Add maintenance disclaimer. --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index 90bb781..b0ee43e 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,5 @@ +**I do not maintain this project and [mumsi](https://github.com/slomkowski/mumsi) any longer, but some new features and bugfixes have been implemented in the [forks](https://github.com/slomkowski/mumlib/network). Check them out!** + # mumlib - simple Mumble client library Fairy simple Mumble library written in C++, using *boost::asio* asynchronous networking framework. Library supports: From 9a2683d1ce021230e6716e332751239b3c598de9 Mon Sep 17 00:00:00 2001 From: "Hiroshi Takey F. (hiro2233)" Date: Sun, 29 Mar 2020 02:49:11 -0400 Subject: [PATCH 24/78] src: added medium bandwith and signal voice ctl. --- src/Audio.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Audio.cpp b/src/Audio.cpp index a347a75..373fc6f 100644 --- a/src/Audio.cpp +++ b/src/Audio.cpp @@ -2,7 +2,7 @@ #include -static boost::posix_time::seconds RESET_SEQUENCE_NUMBER_INTERVAL(5); +static boost::posix_time::seconds RESET_SEQUENCE_NUMBER_INTERVAL(2); namespace { From 818524c62d41de328f6d52844aaece8adaa72fa2 Mon Sep 17 00:00:00 2001 From: "Hiroshi Takey F. (hiro2233)" Date: Sun, 29 Mar 2020 02:49:53 -0400 Subject: [PATCH 25/78] root: set 1234 port udp by default. --- mumlib_example.cpp | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/mumlib_example.cpp b/mumlib_example.cpp index 3640374..96c4c7e 100644 --- a/mumlib_example.cpp +++ b/mumlib_example.cpp @@ -12,11 +12,14 @@ class MyCallback : public mumlib::BasicCallback { public: mumlib::Mumlib *mum; + log4cpp::Category &logger = log4cpp::Category::getRoot(); + virtual void audio(int target, int sessionId, int sequenceNumber, int16_t *pcm_data, uint32_t pcm_data_size) override { + logger.notice("Received audio: pcm_data_size: %d", pcm_data_size); mum->sendAudioData(pcm_data, pcm_data_size); } @@ -27,6 +30,7 @@ class MyCallback : public mumlib::BasicCallback { std::vector tree_id, std::string message) override { mumlib::BasicCallback::textMessage(actor, session, channel_id, tree_id, message); + logger.notice("Received text message: %s", message.c_str()); mum->sendTextMessage("someone said: " + message); } }; From a036d9655af7bc7e12dcd8b0870ee097b8010375 Mon Sep 17 00:00:00 2001 From: "Hiroshi Takey F. (hiro2233)" Date: Sun, 29 Mar 2020 02:50:34 -0400 Subject: [PATCH 26/78] include: set 1500 encoder bitrate by default. --- include/mumlib.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/mumlib.hpp b/include/mumlib.hpp index 1be5c02..1b434cc 100644 --- a/include/mumlib.hpp +++ b/include/mumlib.hpp @@ -10,7 +10,7 @@ namespace mumlib { - constexpr int DEFAULT_OPUS_ENCODER_BITRATE = 16000; + constexpr int DEFAULT_OPUS_ENCODER_BITRATE = 1500; constexpr int DEFAULT_OPUS_SAMPLE_RATE = 24000; constexpr int DEFAULT_OPUS_NUM_CHANNELS = 1; From 6db519da4b0358b5f58477c4405f25e7a6f122d1 Mon Sep 17 00:00:00 2001 From: "Hiroshi Takey F. (hiro2233)" Date: Sun, 29 Mar 2020 02:51:09 -0400 Subject: [PATCH 27/78] include: mumlib: set 24000 sample rate to audio. --- include/mumlib/Audio.hpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/include/mumlib/Audio.hpp b/include/mumlib/Audio.hpp index cfea013..b5b3fe0 100644 --- a/include/mumlib/Audio.hpp +++ b/include/mumlib/Audio.hpp @@ -11,6 +11,8 @@ namespace mumlib { + constexpr int SAMPLE_RATE = 24000; + class MumlibException; class AudioException : public MumlibException { From e15c07feb313d1eeb855ea9364543910d975ec1f Mon Sep 17 00:00:00 2001 From: "Hiroshi Takey F. (hiro2233)" Date: Mon, 30 Mar 2020 04:48:56 -0400 Subject: [PATCH 28/78] include: updated max udp len by 4. --- include/mumlib/Transport.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/mumlib/Transport.hpp b/include/mumlib/Transport.hpp index 2bc7f6c..ce1d748 100644 --- a/include/mumlib/Transport.hpp +++ b/include/mumlib/Transport.hpp @@ -18,7 +18,7 @@ namespace mumlib { - constexpr int MAX_UDP_LENGTH = 1024; + constexpr int MAX_UDP_LENGTH = 4 * 1024; constexpr int MAX_TCP_LENGTH = 129 * 1024; // 128 kB + some reserve using namespace std; From 34a136a2c3f7a71a7995b76a78df492377d8e6ea Mon Sep 17 00:00:00 2001 From: "Hiroshi Takey F. (hiro2233)" Date: Mon, 30 Mar 2020 04:49:22 -0400 Subject: [PATCH 29/78] src: added debugging print. --- src/Audio.cpp | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/src/Audio.cpp b/src/Audio.cpp index 373fc6f..04b4ccb 100644 --- a/src/Audio.cpp +++ b/src/Audio.cpp @@ -352,15 +352,17 @@ mumlib::IncomingAudioPacket mumlib::Audio::decodeIncomingAudioPacket(uint8_t *in dataPointer).str()); } - logger.debug( - "Received %d B of audio packet, %d B header, %d B payload (target: %d, sessionID: %ld, seq num: %ld).", + //logger.debug( +/* + printf( + "Received %d B of audio packet, %d B header, %d B payload (target: %d, sessionID: %ld, seq num: %ld).\n", inputBufferLength, dataPointer, incomingAudioPacket.audioPayloadLength, incomingAudioPacket.target, incomingAudioPacket.sessionId, incomingAudioPacket.sequenceNumber); - +*/ return incomingAudioPacket; } From 3093809024d537860a027d71b476c639a02f21c3 Mon Sep 17 00:00:00 2001 From: "Hiroshi Takey F. (hiro2233)" Date: Mon, 30 Mar 2020 04:50:10 -0400 Subject: [PATCH 30/78] src: changed tcp to udp buf len def macro. --- src/Transport.cpp | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/Transport.cpp b/src/Transport.cpp index 1218291..cd44f96 100644 --- a/src/Transport.cpp +++ b/src/Transport.cpp @@ -117,7 +117,6 @@ void mumlib::Transport::disconnect() { if (errorCode) { logger.warn("UDP socket close returned error: %s.", errorCode.message().c_str()); } - state = ConnectionState::NOT_CONNECTED; } } @@ -506,7 +505,7 @@ void mumlib::Transport::sendControlMessagePrivate(MessageType type, google::prot const int length = sizeof(type_network) + sizeof(size_network) + size; - uint8_t buff[MAX_TCP_LENGTH]; + uint8_t buff[MAX_UDP_LENGTH]; memcpy(buff, &type_network, sizeof(type_network)); @@ -551,7 +550,7 @@ void mumlib::Transport::sendEncodedAudioPacket(uint8_t *buffer, int length) { const int packet = sizeof(netUdptunnelType) + sizeof(netLength) + length; - uint8_t packetBuff[MAX_TCP_LENGTH]; + uint8_t packetBuff[MAX_UDP_LENGTH]; memcpy(packetBuff, &netUdptunnelType, sizeof(netUdptunnelType)); memcpy(packetBuff + sizeof(netUdptunnelType), &netLength, sizeof(netLength)); From 43f9fee3ed0acb30959b281eb102c76f8eca9312 Mon Sep 17 00:00:00 2001 From: "Hiroshi Takey F. (hiro2233)" Date: Mon, 30 Mar 2020 04:51:30 -0400 Subject: [PATCH 31/78] src: added and commented add session textmsg. --- src/mumlib.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/src/mumlib.cpp b/src/mumlib.cpp index ec7a7a6..0d7333e 100644 --- a/src/mumlib.cpp +++ b/src/mumlib.cpp @@ -492,6 +492,7 @@ namespace mumlib { MumbleProto::TextMessage textMessage; textMessage.set_actor(impl->sessionId); textMessage.add_channel_id(impl->channelId); + //textMessage.add_session(4); //send to a specific user textMessage.set_message(message); impl->transport.sendControlMessage(MessageType::TEXTMESSAGE, textMessage); } From 4460b7f09ee2d57b43398aea5b17809a1fc57e69 Mon Sep 17 00:00:00 2001 From: "Hiroshi Takey F. (hiro2233)" Date: Thu, 28 May 2020 15:43:22 -0400 Subject: [PATCH 32/78] added ping status. --- include/mumlib/Transport.hpp | 3 +- include/mumlib/enums.hpp | 7 ++ src/Transport.cpp | 139 +++++++++++++++++++++++++++-------- 3 files changed, 119 insertions(+), 30 deletions(-) diff --git a/include/mumlib/Transport.hpp b/include/mumlib/Transport.hpp index ce1d748..20b5956 100644 --- a/include/mumlib/Transport.hpp +++ b/include/mumlib/Transport.hpp @@ -18,7 +18,7 @@ namespace mumlib { - constexpr int MAX_UDP_LENGTH = 4 * 1024; + constexpr int MAX_UDP_LENGTH = 1024; constexpr int MAX_TCP_LENGTH = 129 * 1024; // 128 kB + some reserve using namespace std; @@ -99,6 +99,7 @@ namespace mumlib { volatile bool udpActive; ConnectionState state; + PingState ping_state; udp::socket udpSocket; ip::udp::endpoint udpReceiverEndpoint; diff --git a/include/mumlib/enums.hpp b/include/mumlib/enums.hpp index 740d83b..afdeb46 100644 --- a/include/mumlib/enums.hpp +++ b/include/mumlib/enums.hpp @@ -60,4 +60,11 @@ namespace mumlib { CHANNEL, USER }; + + enum class PingState { + PING, + PONG, + NONE + }; + } \ No newline at end of file diff --git a/src/Transport.cpp b/src/Transport.cpp index cd44f96..bd23998 100644 --- a/src/Transport.cpp +++ b/src/Transport.cpp @@ -38,6 +38,7 @@ mumlib::Transport::Transport( processEncodedAudioPacketFunction(std::move(processEncodedAudioPacketFunction)), noUdp(noUdp), state(ConnectionState::NOT_CONNECTED), + ping_state(PingState::NONE), udpSocket(ioService), sslContext(ssl::context::sslv23), sslContextHelper(sslContext, cert_file, privkey_file), @@ -61,6 +62,8 @@ void mumlib::Transport::connect( std::string user, std::string password) { + boost::system::error_code errorCode; + state = ConnectionState::IN_PROGRESS; connectionParams = make_pair(host, port); @@ -68,14 +71,18 @@ void mumlib::Transport::connect( udpActive = false; + printf("Verify_mode\n"); sslSocket.set_verify_mode(boost::asio::ssl::verify_peer); + printf("set_verify_callback\n"); //todo for now it accepts every certificate, move it to callback sslSocket.set_verify_callback([](bool preverified, boost::asio::ssl::verify_context &ctx) { return true; }); + printf("Trying connection...\n"); + try { if (not noUdp) { ip::udp::resolver resolverUdp(ioService); @@ -84,14 +91,26 @@ void mumlib::Transport::connect( udpSocket.open(ip::udp::v4()); doReceiveUdp(); + printf("noUdp try\n"); } - + + printf("after noUdp try\n"); + ip::tcp::resolver resolverTcp(ioService); + printf("resolverTcp\n"); ip::tcp::resolver::query queryTcp(host, to_string(port)); + printf("queryTcp\n"); async_connect(sslSocket.lowest_layer(), resolverTcp.resolve(queryTcp), bind(&Transport::sslConnectHandler, this, boost::asio::placeholders::error)); + printf("async_connect try\n"); } catch (runtime_error &exp) { + //ioService.reset(); + udpSocket.shutdown(boost::asio::ip::tcp::socket::shutdown_both, errorCode); + udpSocket.close(errorCode); + sslSocket.lowest_layer().shutdown(tcp::socket::shutdown_both, errorCode); + //sslSocket.shutdown(errorCode); + sslSocket.lowest_layer().close(); throwTransportException(string("failed to establish connection: ") + exp.what()); } } @@ -102,23 +121,54 @@ void mumlib::Transport::disconnect() { boost::system::error_code errorCode; // todo perform different operations for each ConnectionState + + if (ping_state != PingState::PING) { + sslSocket.shutdown(errorCode); + if (errorCode) { + logger.warn("SSL socket shutdown returned an error: %s.", errorCode.message().c_str()); + } + + sslSocket.lowest_layer().shutdown(tcp::socket::shutdown_both, errorCode); + if (errorCode) { + logger.warn("SSL socket lowest layer shutdown returned an error: %s.", errorCode.message().c_str()); + } + + udpSocket.shutdown(boost::asio::ip::tcp::socket::shutdown_both, errorCode); + udpSocket.close(errorCode); + if (errorCode) { + logger.warn("UDP socket close returned error: %s.", errorCode.message().c_str()); + } + + udpActive = false; + state = ConnectionState::NOT_CONNECTED; + + } else { + + //sslSocket.shutdown(errorCode); + //if (errorCode) { + // logger.warn("Not ping: SSL socket shutdown returned an error: %s.", errorCode.message().c_str()); + //} /* - sslSocket.shutdown(errorCode); - if (errorCode) { - logger.warn("SSL socket shutdown returned an error: %s.", errorCode.message().c_str()); - } + sslSocket.lowest_layer().shutdown(boost::asio::ip::tcp::socket::shutdown_both, errorCode); + if (errorCode) { + logger.warn("Not ping: SSL socket lowest layer shutdown returned an error: %s.", errorCode.message().c_str()); + } + + sslSocket.lowest_layer().close(errorCode); */ - sslSocket.lowest_layer().close(errorCode); - if (errorCode) { - logger.warn("SSL socket lowest layer shutdown returned an error: %s.", errorCode.message().c_str()); - } + udpSocket.shutdown(boost::asio::ip::tcp::socket::shutdown_both, errorCode); + udpSocket.close(errorCode); + if (errorCode) { + logger.warn("Not ping: UDP socket close returned error: %s.", errorCode.message().c_str()); + } - udpSocket.close(errorCode); - if (errorCode) { - logger.warn("UDP socket close returned error: %s.", errorCode.message().c_str()); + udpActive = false; + state = ConnectionState::NOT_CONNECTED; + ping_state = PingState::NONE; } - state = ConnectionState::NOT_CONNECTED; + } + printf("Not Connected\n"); } void mumlib::Transport::sendVersion() { @@ -151,10 +201,18 @@ void mumlib::Transport::sendAuthentication() { } void mumlib::Transport::sendSslPing() { + + if (ping_state == PingState::PING) { + return; + } + + ping_state = PingState::PING; + MumbleProto::Ping ping; + ping.set_timestamp(std::time(nullptr)); - logger.debug("Sending SSL ping."); + logger.warn("Sending SSL ping."); sendControlMessagePrivate(MessageType::PING, ping); } @@ -174,7 +232,7 @@ void mumlib::Transport::doReceiveUdp() { udpReceiverEndpoint, [this](const boost::system::error_code &ec, size_t bytesTransferred) { if (!ec and bytesTransferred > 0) { - logger.debug("Received UDP packet of %d B.", bytesTransferred); + //logger.warn("Received UDP packet of %d B.", bytesTransferred); if (not cryptState.isValid()) { throwTransportException("received UDP packet before CRYPT SETUP message"); @@ -183,7 +241,7 @@ void mumlib::Transport::doReceiveUdp() { if (udpActive == false) { udpActive = true; - logger.notice("UDP is up."); + logger.warn("UDP is up."); } uint8_t plainBuffer[1024]; @@ -201,7 +259,16 @@ void mumlib::Transport::doReceiveUdp() { doReceiveUdp(); } else if (ec == boost::asio::error::operation_aborted) { - logger.debug("UDP receive function cancelled."); + boost::system::error_code errorCode; + logger.warn("UDP receive function cancelled."); + if (ping_state == PingState::PING) { + //udpSocket.shutdown(boost::asio::ip::tcp::socket::shutdown_both, errorCode); + //udpSocket.close(errorCode); + //udpActive = false; + //state = ConnectionState::NOT_CONNECTED; + logger.warn("UDP receive function cancelled PONG."); + throwTransportException("doReceiveUdp: UDP receive failed: " + ec.message()); + } } else { throwTransportException("UDP receive failed: " + ec.message()); } @@ -215,7 +282,7 @@ void mumlib::Transport::sslConnectHandler(const boost::system::error_code &error boost::asio::placeholders::error)); } else { - throwTransportException((boost::format("Connect failed: %s.") % error.message()).str()); + throwTransportException((boost::format("sslConnectHandler: Connect failed: %s.") % error.message()).str()); } } @@ -248,6 +315,10 @@ void mumlib::Transport::pingTimerTick(const boost::system::error_code &e) { if (lastUdpReceivedMilliseconds > PING_INTERVAL.total_milliseconds() + 1000) { udpActive = false; logger.warn("Didn't receive UDP ping in %d ms, falling back to TCP.", lastUdpReceivedMilliseconds); + ioService.reset(); + //disconnect(); + throwTransportException("pingTimerTick: Didn't receive UDP ping"); + return; } } } @@ -267,7 +338,7 @@ void mumlib::Transport::sendUdpAsync(uint8_t *buff, int length) { cryptState.encrypt(buff, reinterpret_cast(encryptedMsgBuff), static_cast(length)); - logger.debug("Sending %d B of data UDP asynchronously.", encryptedMsgLength); + //logger.warn("Sending %d B of data UDP asynchronously.", encryptedMsgLength); udpSocket.async_send_to( boost::asio::buffer(encryptedMsgBuff, static_cast(length + 4)), @@ -275,7 +346,7 @@ void mumlib::Transport::sendUdpAsync(uint8_t *buff, int length) { [this, encryptedMsgBuff](const boost::system::error_code &ec, size_t bytesTransferred) { asyncBufferPool.free(encryptedMsgBuff); if (!ec and bytesTransferred > 0) { - logger.debug("Sent %d B via UDP.", bytesTransferred); + //logger.warn("Sent %d B via UDP.", bytesTransferred); } else { throwTransportException("UDP send failed: " + ec.message()); } @@ -364,7 +435,9 @@ void mumlib::Transport::processMessageInternal(MessageType messageType, uint8_t if (ping.has_udp_ping_avg()) { log << " UDP avg: " << ping.udp_ping_avg() << " ms"; } + //logger.warn(log.str()); + ping_state = PingState::PONG; } break; case MessageType::REJECT: { @@ -389,6 +462,8 @@ void mumlib::Transport::processMessageInternal(MessageType messageType, uint8_t state = ConnectionState::CONNECTED; logger.warn("SERVERSYNC. Calling external ProcessControlMessageFunction."); + printf("SERVERSYNC. Calling external ProcessControlMessageFunction.\n"); + processMessageFunction(messageType, buffer, length); } break; @@ -431,11 +506,11 @@ void mumlib::Transport::processMessageInternal(MessageType messageType, uint8_t void mumlib::Transport::sendUdpPing() { if (state == ConnectionState::NOT_CONNECTED) { - logger.debug("State changed to NOT_CONNECTED, skipping UDP ping."); + logger.warn("State changed to NOT_CONNECTED, skipping UDP ping."); return; } - logger.debug("Sending UDP ping."); + //logger.warn("Sending UDP ping."); vector message; message.push_back(0x20); @@ -447,16 +522,22 @@ void mumlib::Transport::sendUdpPing() { } void mumlib::Transport::sendSsl(uint8_t *buff, int length) { + if (length > MAX_TCP_LENGTH) { logger.warn("Sending %d B of data via SSL. Maximal allowed data length to receive is %d B.", length, MAX_TCP_LENGTH); } - logger.debug("Sending %d bytes of data.", length); + //logger.warn("Sending %d bytes of data.", length); + + if (!buff) { + return; + } try { write(sslSocket, boost::asio::buffer(buff, static_cast(length))); } catch (boost::system::system_error &err) { + //disconnect(); throwTransportException(std::string("SSL send failed: ") + err.what()); } } @@ -471,14 +552,14 @@ void mumlib::Transport::sendSslAsync(uint8_t *buff, int length) { memcpy(asyncBuff, buff, static_cast(length)); - logger.debug("Sending %d B of data asynchronously.", length); + //logger.warn("Sending %d B of data asynchronously.", length); async_write( sslSocket, boost::asio::buffer(asyncBuff, static_cast(length)), [this, asyncBuff](const boost::system::error_code &ec, size_t bytesTransferred) { asyncBufferPool.free(asyncBuff); - logger.debug("Sent %d B.", bytesTransferred); + //logger.warn("Sent %d B.", bytesTransferred); if (!ec and bytesTransferred > 0) { } else { @@ -489,7 +570,7 @@ void mumlib::Transport::sendSslAsync(uint8_t *buff, int length) { void mumlib::Transport::sendControlMessage(MessageType type, google::protobuf::Message &message) { if (state != ConnectionState::CONNECTED) { - logger.warn("Connection not established."); + logger.warn("sendControlMessage: Connection not established."); return; } sendControlMessagePrivate(type, message); @@ -534,15 +615,15 @@ mumlib::SslContextHelper::SslContextHelper(ssl::context &ctx, std::string cert_f void mumlib::Transport::sendEncodedAudioPacket(uint8_t *buffer, int length) { if (state != ConnectionState::CONNECTED) { - logger.warn("Connection not established."); + logger.warn("sendEncodedAudioPacket: Connection not established."); return; } if (udpActive) { - //logger.warn("Sending %d B of audio data via UDP.", length); + //logger.info("Sending %d B of audio data via UDP.", length); sendUdpAsync(buffer, length); } else { - //logger.warn("Sending %d B of audio data via TCP.", length); + //logger.info("Sending %d B of audio data via TCP.", length); const uint16_t netUdptunnelType = htons(static_cast(MessageType::UDPTUNNEL)); From 3ce8d7ca6b2d264aacc96d1aeec3995807511999 Mon Sep 17 00:00:00 2001 From: "Hiroshi Takey F. (hiro2233)" Date: Fri, 29 May 2020 09:38:33 -0400 Subject: [PATCH 33/78] src: fixed disconnection. --- src/Transport.cpp | 135 +++++++++++++++------------------------------- 1 file changed, 42 insertions(+), 93 deletions(-) diff --git a/src/Transport.cpp b/src/Transport.cpp index bd23998..0ae051b 100644 --- a/src/Transport.cpp +++ b/src/Transport.cpp @@ -52,7 +52,7 @@ mumlib::Transport::Transport( } mumlib::Transport::~Transport() { - disconnect(); + //disconnect(); delete[] sslIncomingBuffer; } @@ -64,24 +64,22 @@ void mumlib::Transport::connect( boost::system::error_code errorCode; - state = ConnectionState::IN_PROGRESS; - connectionParams = make_pair(host, port); credentials = make_pair(user, password); udpActive = false; - printf("Verify_mode\n"); + logger.warn("Verify_mode"); sslSocket.set_verify_mode(boost::asio::ssl::verify_peer); - printf("set_verify_callback\n"); + logger.warn("set_verify_callback"); //todo for now it accepts every certificate, move it to callback sslSocket.set_verify_callback([](bool preverified, boost::asio::ssl::verify_context &ctx) { return true; }); - printf("Trying connection...\n"); + logger.warn("Trying connection..."); try { if (not noUdp) { @@ -91,84 +89,44 @@ void mumlib::Transport::connect( udpSocket.open(ip::udp::v4()); doReceiveUdp(); - printf("noUdp try\n"); + logger.warn("noUdp try"); } - printf("after noUdp try\n"); + logger.warn("after noUdp try"); ip::tcp::resolver resolverTcp(ioService); - printf("resolverTcp\n"); + logger.warn("resolverTcp"); ip::tcp::resolver::query queryTcp(host, to_string(port)); - printf("queryTcp\n"); + logger.warn("queryTcp"); async_connect(sslSocket.lowest_layer(), resolverTcp.resolve(queryTcp), bind(&Transport::sslConnectHandler, this, boost::asio::placeholders::error)); - printf("async_connect try\n"); + logger.warn("async_connect try"); } catch (runtime_error &exp) { - //ioService.reset(); - udpSocket.shutdown(boost::asio::ip::tcp::socket::shutdown_both, errorCode); - udpSocket.close(errorCode); - sslSocket.lowest_layer().shutdown(tcp::socket::shutdown_both, errorCode); - //sslSocket.shutdown(errorCode); - sslSocket.lowest_layer().close(); throwTransportException(string("failed to establish connection: ") + exp.what()); } } -void mumlib::Transport::disconnect() { - +void mumlib::Transport::disconnect() +{ if (state != ConnectionState::NOT_CONNECTED) { boost::system::error_code errorCode; // todo perform different operations for each ConnectionState - if (ping_state != PingState::PING) { - sslSocket.shutdown(errorCode); - if (errorCode) { - logger.warn("SSL socket shutdown returned an error: %s.", errorCode.message().c_str()); - } - - sslSocket.lowest_layer().shutdown(tcp::socket::shutdown_both, errorCode); - if (errorCode) { - logger.warn("SSL socket lowest layer shutdown returned an error: %s.", errorCode.message().c_str()); - } - - udpSocket.shutdown(boost::asio::ip::tcp::socket::shutdown_both, errorCode); - udpSocket.close(errorCode); - if (errorCode) { - logger.warn("UDP socket close returned error: %s.", errorCode.message().c_str()); - } - - udpActive = false; - state = ConnectionState::NOT_CONNECTED; - - } else { - - //sslSocket.shutdown(errorCode); - //if (errorCode) { - // logger.warn("Not ping: SSL socket shutdown returned an error: %s.", errorCode.message().c_str()); - //} -/* - sslSocket.lowest_layer().shutdown(boost::asio::ip::tcp::socket::shutdown_both, errorCode); - if (errorCode) { - logger.warn("Not ping: SSL socket lowest layer shutdown returned an error: %s.", errorCode.message().c_str()); - } - - sslSocket.lowest_layer().close(errorCode); -*/ - udpSocket.shutdown(boost::asio::ip::tcp::socket::shutdown_both, errorCode); - udpSocket.close(errorCode); - if (errorCode) { - logger.warn("Not ping: UDP socket close returned error: %s.", errorCode.message().c_str()); - } + sslSocket.lowest_layer().close(errorCode); - udpActive = false; - state = ConnectionState::NOT_CONNECTED; - ping_state = PingState::NONE; + udpSocket.shutdown(boost::asio::ip::udp::socket::shutdown_both, errorCode); + udpSocket.close(errorCode); + if (errorCode) { + logger.warn("Not ping: UDP socket close returned error: %s.", errorCode.message().c_str()); } + state = ConnectionState::NOT_CONNECTED; + printf("Not Connected\n"); } - printf("Not Connected\n"); + + printf("Disconnected\n"); } void mumlib::Transport::sendVersion() { @@ -179,7 +137,7 @@ void mumlib::Transport::sendVersion() { version.set_release(CLIENT_RELEASE); version.set_os_version(CLIENT_OS_VERSION); - logger.info("Sending version information."); + logger.warn("Sending version information."); sendControlMessagePrivate(MessageType::VERSION, version); } @@ -195,7 +153,7 @@ void mumlib::Transport::sendAuthentication() { authenticate.clear_tokens(); authenticate.set_opus(true); - logger.info("Sending authententication."); + logger.warn("Sending authententication."); sendControlMessagePrivate(MessageType::AUTHENTICATE, authenticate); } @@ -203,6 +161,8 @@ void mumlib::Transport::sendAuthentication() { void mumlib::Transport::sendSslPing() { if (ping_state == PingState::PING) { + logger.warn("Continue sending SSL ping."); + disconnect(); return; } @@ -222,11 +182,8 @@ bool mumlib::Transport::isUdpActive() { return udpActive; } -void mumlib::Transport::doReceiveUdp() { - if (state == ConnectionState::NOT_CONNECTED) { - return; - } - +void mumlib::Transport::doReceiveUdp() +{ udpSocket.async_receive_from( buffer(udpIncomingBuffer, MAX_UDP_LENGTH), udpReceiverEndpoint, @@ -262,12 +219,7 @@ void mumlib::Transport::doReceiveUdp() { boost::system::error_code errorCode; logger.warn("UDP receive function cancelled."); if (ping_state == PingState::PING) { - //udpSocket.shutdown(boost::asio::ip::tcp::socket::shutdown_both, errorCode); - //udpSocket.close(errorCode); - //udpActive = false; - //state = ConnectionState::NOT_CONNECTED; logger.warn("UDP receive function cancelled PONG."); - throwTransportException("doReceiveUdp: UDP receive failed: " + ec.message()); } } else { throwTransportException("UDP receive failed: " + ec.message()); @@ -282,11 +234,13 @@ void mumlib::Transport::sslConnectHandler(const boost::system::error_code &error boost::asio::placeholders::error)); } else { - throwTransportException((boost::format("sslConnectHandler: Connect failed: %s.") % error.message()).str()); + throwTransportException((boost::format("sslConnectHandler: Connect failed: %s.") % error.message()).str()); } } -void mumlib::Transport::sslHandshakeHandler(const boost::system::error_code &error) { +void mumlib::Transport::sslHandshakeHandler(const boost::system::error_code &error) +{ + boost::system::error_code errorCode = error; if (!error) { doReceiveSsl(); @@ -306,6 +260,7 @@ void mumlib::Transport::pingTimerTick(const boost::system::error_code &e) { if (not noUdp) { using namespace std::chrono; + logger.warn("pingTimerTick: Sending UDP ping."); sendUdpPing(); if (udpActive) { @@ -313,10 +268,7 @@ void mumlib::Transport::pingTimerTick(const boost::system::error_code &e) { system_clock::now() - lastReceivedUdpPacketTimestamp).count(); if (lastUdpReceivedMilliseconds > PING_INTERVAL.total_milliseconds() + 1000) { - udpActive = false; logger.warn("Didn't receive UDP ping in %d ms, falling back to TCP.", lastUdpReceivedMilliseconds); - ioService.reset(); - //disconnect(); throwTransportException("pingTimerTick: Didn't receive UDP ping"); return; } @@ -324,6 +276,13 @@ void mumlib::Transport::pingTimerTick(const boost::system::error_code &e) { } } + if ((state == ConnectionState::NOT_CONNECTED) && (ping_state == PingState::PING)) { + logger.warn("ioService RESET!."); + throwTransportException("pingTimerTick: NOT CONNECTED PING"); + return; + } + + logger.warn("TimerTick!."); pingTimer.expires_at(pingTimer.expires_at() + PING_INTERVAL); pingTimer.async_wait(boost::bind(&Transport::pingTimerTick, this, _1)); } @@ -354,10 +313,6 @@ void mumlib::Transport::sendUdpAsync(uint8_t *buff, int length) { } void mumlib::Transport::doReceiveSsl() { - if (state == ConnectionState::NOT_CONNECTED) { - return; - } - async_read( sslSocket, boost::asio::buffer(sslIncomingBuffer, MAX_TCP_LENGTH), @@ -462,7 +417,6 @@ void mumlib::Transport::processMessageInternal(MessageType messageType, uint8_t state = ConnectionState::CONNECTED; logger.warn("SERVERSYNC. Calling external ProcessControlMessageFunction."); - printf("SERVERSYNC. Calling external ProcessControlMessageFunction.\n"); processMessageFunction(messageType, buffer, length); } @@ -504,12 +458,8 @@ void mumlib::Transport::processMessageInternal(MessageType messageType, uint8_t } } -void mumlib::Transport::sendUdpPing() { - if (state == ConnectionState::NOT_CONNECTED) { - logger.warn("State changed to NOT_CONNECTED, skipping UDP ping."); - return; - } - +void mumlib::Transport::sendUdpPing() +{ //logger.warn("Sending UDP ping."); vector message; @@ -537,7 +487,6 @@ void mumlib::Transport::sendSsl(uint8_t *buff, int length) { try { write(sslSocket, boost::asio::buffer(buff, static_cast(length))); } catch (boost::system::system_error &err) { - //disconnect(); throwTransportException(std::string("SSL send failed: ") + err.what()); } } @@ -620,10 +569,10 @@ void mumlib::Transport::sendEncodedAudioPacket(uint8_t *buffer, int length) { } if (udpActive) { - //logger.info("Sending %d B of audio data via UDP.", length); + //logger.warn("Sending %d B of audio data via UDP.", length); sendUdpAsync(buffer, length); } else { - //logger.info("Sending %d B of audio data via TCP.", length); + //logger.warn("Sending %d B of audio data via TCP.", length); const uint16_t netUdptunnelType = htons(static_cast(MessageType::UDPTUNNEL)); From 785b8cdae32e67a271e4c732f30cc7fb21c52b55 Mon Sep 17 00:00:00 2001 From: "Hiroshi Takey F. (hiro2233)" Date: Thu, 4 Jun 2020 07:29:35 -0400 Subject: [PATCH 34/78] include: set opus enc 8000 and sample rate 16000. --- include/mumlib.hpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/include/mumlib.hpp b/include/mumlib.hpp index 1b434cc..d75ee4d 100644 --- a/include/mumlib.hpp +++ b/include/mumlib.hpp @@ -10,8 +10,8 @@ namespace mumlib { - constexpr int DEFAULT_OPUS_ENCODER_BITRATE = 1500; - constexpr int DEFAULT_OPUS_SAMPLE_RATE = 24000; + constexpr int DEFAULT_OPUS_ENCODER_BITRATE = 8000; + constexpr int DEFAULT_OPUS_SAMPLE_RATE = 16000; constexpr int DEFAULT_OPUS_NUM_CHANNELS = 1; using namespace std; From 81c802cd18e0529d48d531c5bf48dfc52b61d6ce Mon Sep 17 00:00:00 2001 From: "Hiroshi Takey F. (hiro2233)" Date: Thu, 4 Jun 2020 07:30:00 -0400 Subject: [PATCH 35/78] header: removed unused macro. --- include/mumlib/Audio.hpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/include/mumlib/Audio.hpp b/include/mumlib/Audio.hpp index b5b3fe0..cfea013 100644 --- a/include/mumlib/Audio.hpp +++ b/include/mumlib/Audio.hpp @@ -11,8 +11,6 @@ namespace mumlib { - constexpr int SAMPLE_RATE = 24000; - class MumlibException; class AudioException : public MumlibException { From c106ecc8805a97024584c396842414e4f310c06e Mon Sep 17 00:00:00 2001 From: "Hiroshi Takey F. (hiro2233)" Date: Thu, 4 Jun 2020 07:30:57 -0400 Subject: [PATCH 36/78] src: Transprot: commented logger audiopacket. --- src/Transport.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Transport.cpp b/src/Transport.cpp index 0ae051b..6d254c5 100644 --- a/src/Transport.cpp +++ b/src/Transport.cpp @@ -598,7 +598,7 @@ void mumlib::Transport::processAudioPacket(uint8_t *buff, int length) { case AudioPacketType::CELT_Beta: case AudioPacketType::OPUS: processEncodedAudioPacketFunction(type, buff, length); - logger.warn("audio typehex: 0x%2x typedec: %d", buff[0], type); + //logger.warn("audio typehex: 0x%2x typedec: %d", buff[0], type); break; case AudioPacketType::Ping: break; From 13805491d338cc10ffb9908f64d2adb38ba89b57 Mon Sep 17 00:00:00 2001 From: "Hiroshi Takey F. (hiro2233)" Date: Wed, 10 Jun 2020 00:29:18 -0400 Subject: [PATCH 37/78] build: added MSYS target. --- CMakeLists.txt | 40 +++++++++++++++++++++++++++------------- 1 file changed, 27 insertions(+), 13 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index c2328a0..c9fea75 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,29 +1,30 @@ cmake_minimum_required(VERSION 2.8.0) project(mumlib) -set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11") - -if (NOT APPLE) - add_definitions(-DOPT_TLS_GNUTLS -D_POSIX_C_SOURCE=200112L) -else() +if (MSYS) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -DLOG4CPP_FIX_ERROR_COLLISION=1 -D__USE_W32_SOCKETS") + add_definitions(-DOPT_TLS_OPENSSL) +elseif (NOT APPLE) + add_definitions(-DOPT_TLS_OPENSSL -D_POSIX_C_SOURCE=200112L) +elseif() LINK_DIRECTORIES(/opt/local/lib) # Include the default MacPorts library directory endif() INCLUDE(FindPkgConfig) find_package(PkgConfig REQUIRED) -find_package(Boost COMPONENTS system REQUIRED) +#find_package(Boost COMPONENTS system REQUIRED) find_package(OpenSSL REQUIRED) find_package(Protobuf REQUIRED) pkg_check_modules(LOG4CPP "log4cpp") pkg_check_modules(OPUS "opus") +#INCLUDE_DIRECTORIES(${Boost_INCLUDE_DIR}) -INCLUDE_DIRECTORIES(${Boost_INCLUDE_DIR}) include_directories(${OPENSSL_INCLUDE_DIR}) include_directories(${PROTOBUF_INCLUDE_DIRS}) include_directories(${OPUS_INCLUDE_DIRS}) - +include_directories(~/boost_1_72_0) include_directories(${CMAKE_CURRENT_BINARY_DIR}) include_directories(${LOG4CPP_INCLUDE_DIRS}) include_directories(include) @@ -48,24 +49,37 @@ set(MUMLIB_SRC ) set(SPEEX_LIBRARIES - speex speexdsp ) PROTOBUF_GENERATE_CPP(PROTO_SRCS PROTO_HDRS Mumble.proto) -add_library(mumlib SHARED ${MUMLIB_SRC} ${MUMLIB_PUBLIC_HEADERS} ${MUMLIB_PRIVATE_HEADERS} ${PROTO_SRCS} ${PROTO_HDRS}) -target_link_libraries(mumlib +add_library(mumlib STATIC ${MUMLIB_SRC} ${MUMLIB_PUBLIC_HEADERS} ${MUMLIB_PRIVATE_HEADERS} ${PROTO_SRCS} ${PROTO_HDRS}) + +if (MSYS) +target_link_libraries(mumlib + ${SPEEX_LIBRARIES} + ${PROTOBUF_LIBRARIES} + ${OPENSSL_LIBRARIES} + ${LOG4CPP_LIBRARIES} + ${OPUS_LIBRARIES} ws2_32) +else () +target_link_libraries(mumlib ${SPEEX_LIBRARIES} ${PROTOBUF_LIBRARIES} - ${Boost_LIBRARIES} ${OPENSSL_LIBRARIES} ${LOG4CPP_LIBRARIES} ${OPUS_LIBRARIES}) +endif () set_target_properties(mumlib PROPERTIES PUBLIC_HEADER "${MUMLIB_PUBLIC_HEADERS}") add_executable(mumlib_example mumlib_example.cpp) + +if (MSYS) +target_link_libraries(mumlib_example mumlib ws2_32) +else () target_link_libraries(mumlib_example mumlib) +endif () -install(TARGETS mumlib LIBRARY DESTINATION lib PUBLIC_HEADER DESTINATION include/mumlib) +install(TARGETS DESTINATION mumlib LIBRARY DESTINATION lib PUBLIC_HEADER DESTINATION include/mumlib) From 84581b583c2e76c5fd8df98f085c85505329cbdb Mon Sep 17 00:00:00 2001 From: "Hiroshi Takey F. (hiro2233)" Date: Wed, 10 Jun 2020 00:30:14 -0400 Subject: [PATCH 38/78] mumlib: adeded MSYS macro to header. --- include/mumlib.hpp | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/include/mumlib.hpp b/include/mumlib.hpp index d75ee4d..0de9902 100644 --- a/include/mumlib.hpp +++ b/include/mumlib.hpp @@ -3,6 +3,10 @@ #include "mumlib/Callback.hpp" #include "mumlib/enums.hpp" +#ifdef __MSYS__ +#define __MSABI_LONG(x) x +#endif + #include #include @@ -88,7 +92,7 @@ namespace mumlib { void sendUserState(mumlib::UserState state, bool val); void sendUserState(mumlib::UserState state, std::string value); - + private: _Mumlib_Private *impl; From 5ea225e5c5ad6b5e4b683316ef724432c51cc40d Mon Sep 17 00:00:00 2001 From: "Hiroshi Takey F. (hiro2233)" Date: Wed, 10 Jun 2020 01:08:09 -0400 Subject: [PATCH 39/78] mumlib: added msys macro on transport for noudp. --- include/mumlib/Transport.hpp | 4 ++++ src/Transport.cpp | 7 +++++-- 2 files changed, 9 insertions(+), 2 deletions(-) diff --git a/include/mumlib/Transport.hpp b/include/mumlib/Transport.hpp index 20b5956..2850c5b 100644 --- a/include/mumlib/Transport.hpp +++ b/include/mumlib/Transport.hpp @@ -94,7 +94,11 @@ namespace mumlib { ProcessEncodedAudioPacketFunction processEncodedAudioPacketFunction; +#ifdef __MSYS__ + bool noUdp; +#else const bool noUdp; +#endif volatile bool udpActive; diff --git a/src/Transport.cpp b/src/Transport.cpp index 6d254c5..66368af 100644 --- a/src/Transport.cpp +++ b/src/Transport.cpp @@ -67,6 +67,9 @@ void mumlib::Transport::connect( connectionParams = make_pair(host, port); credentials = make_pair(user, password); +#ifdef __MSYS__ + noUdp = true; +#endif udpActive = false; logger.warn("Verify_mode"); @@ -234,7 +237,7 @@ void mumlib::Transport::sslConnectHandler(const boost::system::error_code &error boost::asio::placeholders::error)); } else { - throwTransportException((boost::format("sslConnectHandler: Connect failed: %s.") % error.message()).str()); + throwTransportException((boost::format("sslConnectHandler: Connect failed: %s.") % error.message()).str()); } } @@ -362,7 +365,7 @@ void mumlib::Transport::processMessageInternal(MessageType messageType, uint8_t switch (messageType) { case MessageType::UDPTUNNEL: { - logger.warn("Received %d B of encoded audio data via TCP.", length); + //logger.warn("Received %d B of encoded audio data via TCP.", length); processAudioPacket(buffer, length); } break; From 82d9eaed678529acbc9bf52cec555cf374b2df4c Mon Sep 17 00:00:00 2001 From: "Hiroshi Takey F. (hiro2233)" Date: Wed, 10 Jun 2020 01:08:49 -0400 Subject: [PATCH 40/78] src: added missin param on mumlib. --- src/mumlib.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/mumlib.cpp b/src/mumlib.cpp index 0d7333e..f4654b7 100644 --- a/src/mumlib.cpp +++ b/src/mumlib.cpp @@ -84,6 +84,7 @@ namespace mumlib { // auto status = audio.decodeOpusPayload(incomingAudioPacket.audioPayload, // incomingAudioPacket.audioPayloadLength, + // incomingAudioPacket.sessionId, // pcmData, // 5000); @@ -96,7 +97,7 @@ namespace mumlib { status.first); } else { - logger.warn("Incoming audio packet doesn't contain Opus data, calling unsupportedAudio callback."); + logger.warn("Incoming audio packet doesn't contain Opus data, calling unsupportedAudio callback. Type: %d", type); callback.unsupportedAudio(incomingAudioPacket.target, incomingAudioPacket.sessionId, incomingAudioPacket.sequenceNumber, From 07d67859e13abffd2a290f74126e4c15aab61377 Mon Sep 17 00:00:00 2001 From: "Hiroshi Takey F. (hiro2233)" Date: Wed, 10 Jun 2020 01:14:51 -0400 Subject: [PATCH 41/78] root: added mumble c src and headers proto. --- Mumble.pb.cc | 13279 ++++++++++++++++++++++++++++++++++++++++++ Mumble.pb.h | 15226 +++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 28505 insertions(+) create mode 100644 Mumble.pb.cc create mode 100644 Mumble.pb.h diff --git a/Mumble.pb.cc b/Mumble.pb.cc new file mode 100644 index 0000000..c6b044f --- /dev/null +++ b/Mumble.pb.cc @@ -0,0 +1,13279 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: Mumble.proto + +#include "Mumble.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) +#include +extern PROTOBUF_INTERNAL_EXPORT_Mumble_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ACL_ChanACL_Mumble_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_Mumble_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ACL_ChanGroup_Mumble_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_Mumble_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_BanList_BanEntry_Mumble_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_Mumble_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_UserList_User_Mumble_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_Mumble_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_UserStats_Stats_Mumble_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_Mumble_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Version_Mumble_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_Mumble_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_VoiceTarget_Target_Mumble_2eproto; +namespace MumbleProto { +class VersionDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _Version_default_instance_; +class UDPTunnelDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _UDPTunnel_default_instance_; +class AuthenticateDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _Authenticate_default_instance_; +class PingDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _Ping_default_instance_; +class RejectDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _Reject_default_instance_; +class ServerSyncDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _ServerSync_default_instance_; +class ChannelRemoveDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _ChannelRemove_default_instance_; +class ChannelStateDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _ChannelState_default_instance_; +class UserRemoveDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _UserRemove_default_instance_; +class UserStateDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _UserState_default_instance_; +class BanList_BanEntryDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _BanList_BanEntry_default_instance_; +class BanListDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _BanList_default_instance_; +class TextMessageDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _TextMessage_default_instance_; +class PermissionDeniedDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _PermissionDenied_default_instance_; +class ACL_ChanGroupDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _ACL_ChanGroup_default_instance_; +class ACL_ChanACLDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _ACL_ChanACL_default_instance_; +class ACLDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _ACL_default_instance_; +class QueryUsersDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _QueryUsers_default_instance_; +class CryptSetupDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _CryptSetup_default_instance_; +class ContextActionModifyDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _ContextActionModify_default_instance_; +class ContextActionDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _ContextAction_default_instance_; +class UserList_UserDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _UserList_User_default_instance_; +class UserListDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _UserList_default_instance_; +class VoiceTarget_TargetDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _VoiceTarget_Target_default_instance_; +class VoiceTargetDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _VoiceTarget_default_instance_; +class PermissionQueryDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _PermissionQuery_default_instance_; +class CodecVersionDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _CodecVersion_default_instance_; +class UserStats_StatsDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _UserStats_Stats_default_instance_; +class UserStatsDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _UserStats_default_instance_; +class RequestBlobDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _RequestBlob_default_instance_; +class ServerConfigDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _ServerConfig_default_instance_; +class SuggestConfigDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _SuggestConfig_default_instance_; +} // namespace MumbleProto +static void InitDefaultsscc_info_ACL_Mumble_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::MumbleProto::_ACL_default_instance_; + new (ptr) ::MumbleProto::ACL(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::MumbleProto::ACL::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_ACL_Mumble_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_ACL_Mumble_2eproto}, { + &scc_info_ACL_ChanGroup_Mumble_2eproto.base, + &scc_info_ACL_ChanACL_Mumble_2eproto.base,}}; + +static void InitDefaultsscc_info_ACL_ChanACL_Mumble_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::MumbleProto::_ACL_ChanACL_default_instance_; + new (ptr) ::MumbleProto::ACL_ChanACL(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::MumbleProto::ACL_ChanACL::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ACL_ChanACL_Mumble_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ACL_ChanACL_Mumble_2eproto}, {}}; + +static void InitDefaultsscc_info_ACL_ChanGroup_Mumble_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::MumbleProto::_ACL_ChanGroup_default_instance_; + new (ptr) ::MumbleProto::ACL_ChanGroup(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::MumbleProto::ACL_ChanGroup::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ACL_ChanGroup_Mumble_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ACL_ChanGroup_Mumble_2eproto}, {}}; + +static void InitDefaultsscc_info_Authenticate_Mumble_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::MumbleProto::_Authenticate_default_instance_; + new (ptr) ::MumbleProto::Authenticate(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::MumbleProto::Authenticate::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Authenticate_Mumble_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_Authenticate_Mumble_2eproto}, {}}; + +static void InitDefaultsscc_info_BanList_Mumble_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::MumbleProto::_BanList_default_instance_; + new (ptr) ::MumbleProto::BanList(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::MumbleProto::BanList::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_BanList_Mumble_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_BanList_Mumble_2eproto}, { + &scc_info_BanList_BanEntry_Mumble_2eproto.base,}}; + +static void InitDefaultsscc_info_BanList_BanEntry_Mumble_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::MumbleProto::_BanList_BanEntry_default_instance_; + new (ptr) ::MumbleProto::BanList_BanEntry(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::MumbleProto::BanList_BanEntry::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_BanList_BanEntry_Mumble_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_BanList_BanEntry_Mumble_2eproto}, {}}; + +static void InitDefaultsscc_info_ChannelRemove_Mumble_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::MumbleProto::_ChannelRemove_default_instance_; + new (ptr) ::MumbleProto::ChannelRemove(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::MumbleProto::ChannelRemove::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ChannelRemove_Mumble_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ChannelRemove_Mumble_2eproto}, {}}; + +static void InitDefaultsscc_info_ChannelState_Mumble_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::MumbleProto::_ChannelState_default_instance_; + new (ptr) ::MumbleProto::ChannelState(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::MumbleProto::ChannelState::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ChannelState_Mumble_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ChannelState_Mumble_2eproto}, {}}; + +static void InitDefaultsscc_info_CodecVersion_Mumble_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::MumbleProto::_CodecVersion_default_instance_; + new (ptr) ::MumbleProto::CodecVersion(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::MumbleProto::CodecVersion::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_CodecVersion_Mumble_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_CodecVersion_Mumble_2eproto}, {}}; + +static void InitDefaultsscc_info_ContextAction_Mumble_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::MumbleProto::_ContextAction_default_instance_; + new (ptr) ::MumbleProto::ContextAction(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::MumbleProto::ContextAction::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ContextAction_Mumble_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ContextAction_Mumble_2eproto}, {}}; + +static void InitDefaultsscc_info_ContextActionModify_Mumble_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::MumbleProto::_ContextActionModify_default_instance_; + new (ptr) ::MumbleProto::ContextActionModify(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::MumbleProto::ContextActionModify::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ContextActionModify_Mumble_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ContextActionModify_Mumble_2eproto}, {}}; + +static void InitDefaultsscc_info_CryptSetup_Mumble_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::MumbleProto::_CryptSetup_default_instance_; + new (ptr) ::MumbleProto::CryptSetup(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::MumbleProto::CryptSetup::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_CryptSetup_Mumble_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_CryptSetup_Mumble_2eproto}, {}}; + +static void InitDefaultsscc_info_PermissionDenied_Mumble_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::MumbleProto::_PermissionDenied_default_instance_; + new (ptr) ::MumbleProto::PermissionDenied(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::MumbleProto::PermissionDenied::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_PermissionDenied_Mumble_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_PermissionDenied_Mumble_2eproto}, {}}; + +static void InitDefaultsscc_info_PermissionQuery_Mumble_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::MumbleProto::_PermissionQuery_default_instance_; + new (ptr) ::MumbleProto::PermissionQuery(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::MumbleProto::PermissionQuery::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_PermissionQuery_Mumble_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_PermissionQuery_Mumble_2eproto}, {}}; + +static void InitDefaultsscc_info_Ping_Mumble_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::MumbleProto::_Ping_default_instance_; + new (ptr) ::MumbleProto::Ping(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::MumbleProto::Ping::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Ping_Mumble_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_Ping_Mumble_2eproto}, {}}; + +static void InitDefaultsscc_info_QueryUsers_Mumble_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::MumbleProto::_QueryUsers_default_instance_; + new (ptr) ::MumbleProto::QueryUsers(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::MumbleProto::QueryUsers::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_QueryUsers_Mumble_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_QueryUsers_Mumble_2eproto}, {}}; + +static void InitDefaultsscc_info_Reject_Mumble_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::MumbleProto::_Reject_default_instance_; + new (ptr) ::MumbleProto::Reject(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::MumbleProto::Reject::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Reject_Mumble_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_Reject_Mumble_2eproto}, {}}; + +static void InitDefaultsscc_info_RequestBlob_Mumble_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::MumbleProto::_RequestBlob_default_instance_; + new (ptr) ::MumbleProto::RequestBlob(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::MumbleProto::RequestBlob::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RequestBlob_Mumble_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_RequestBlob_Mumble_2eproto}, {}}; + +static void InitDefaultsscc_info_ServerConfig_Mumble_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::MumbleProto::_ServerConfig_default_instance_; + new (ptr) ::MumbleProto::ServerConfig(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::MumbleProto::ServerConfig::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ServerConfig_Mumble_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ServerConfig_Mumble_2eproto}, {}}; + +static void InitDefaultsscc_info_ServerSync_Mumble_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::MumbleProto::_ServerSync_default_instance_; + new (ptr) ::MumbleProto::ServerSync(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::MumbleProto::ServerSync::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ServerSync_Mumble_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ServerSync_Mumble_2eproto}, {}}; + +static void InitDefaultsscc_info_SuggestConfig_Mumble_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::MumbleProto::_SuggestConfig_default_instance_; + new (ptr) ::MumbleProto::SuggestConfig(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::MumbleProto::SuggestConfig::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_SuggestConfig_Mumble_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_SuggestConfig_Mumble_2eproto}, {}}; + +static void InitDefaultsscc_info_TextMessage_Mumble_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::MumbleProto::_TextMessage_default_instance_; + new (ptr) ::MumbleProto::TextMessage(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::MumbleProto::TextMessage::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_TextMessage_Mumble_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_TextMessage_Mumble_2eproto}, {}}; + +static void InitDefaultsscc_info_UDPTunnel_Mumble_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::MumbleProto::_UDPTunnel_default_instance_; + new (ptr) ::MumbleProto::UDPTunnel(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::MumbleProto::UDPTunnel::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_UDPTunnel_Mumble_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_UDPTunnel_Mumble_2eproto}, {}}; + +static void InitDefaultsscc_info_UserList_Mumble_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::MumbleProto::_UserList_default_instance_; + new (ptr) ::MumbleProto::UserList(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::MumbleProto::UserList::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_UserList_Mumble_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_UserList_Mumble_2eproto}, { + &scc_info_UserList_User_Mumble_2eproto.base,}}; + +static void InitDefaultsscc_info_UserList_User_Mumble_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::MumbleProto::_UserList_User_default_instance_; + new (ptr) ::MumbleProto::UserList_User(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::MumbleProto::UserList_User::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_UserList_User_Mumble_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_UserList_User_Mumble_2eproto}, {}}; + +static void InitDefaultsscc_info_UserRemove_Mumble_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::MumbleProto::_UserRemove_default_instance_; + new (ptr) ::MumbleProto::UserRemove(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::MumbleProto::UserRemove::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_UserRemove_Mumble_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_UserRemove_Mumble_2eproto}, {}}; + +static void InitDefaultsscc_info_UserState_Mumble_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::MumbleProto::_UserState_default_instance_; + new (ptr) ::MumbleProto::UserState(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::MumbleProto::UserState::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_UserState_Mumble_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_UserState_Mumble_2eproto}, {}}; + +static void InitDefaultsscc_info_UserStats_Mumble_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::MumbleProto::_UserStats_default_instance_; + new (ptr) ::MumbleProto::UserStats(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::MumbleProto::UserStats::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_UserStats_Mumble_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_UserStats_Mumble_2eproto}, { + &scc_info_UserStats_Stats_Mumble_2eproto.base, + &scc_info_Version_Mumble_2eproto.base,}}; + +static void InitDefaultsscc_info_UserStats_Stats_Mumble_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::MumbleProto::_UserStats_Stats_default_instance_; + new (ptr) ::MumbleProto::UserStats_Stats(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::MumbleProto::UserStats_Stats::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_UserStats_Stats_Mumble_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_UserStats_Stats_Mumble_2eproto}, {}}; + +static void InitDefaultsscc_info_Version_Mumble_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::MumbleProto::_Version_default_instance_; + new (ptr) ::MumbleProto::Version(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::MumbleProto::Version::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Version_Mumble_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_Version_Mumble_2eproto}, {}}; + +static void InitDefaultsscc_info_VoiceTarget_Mumble_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::MumbleProto::_VoiceTarget_default_instance_; + new (ptr) ::MumbleProto::VoiceTarget(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::MumbleProto::VoiceTarget::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_VoiceTarget_Mumble_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_VoiceTarget_Mumble_2eproto}, { + &scc_info_VoiceTarget_Target_Mumble_2eproto.base,}}; + +static void InitDefaultsscc_info_VoiceTarget_Target_Mumble_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::MumbleProto::_VoiceTarget_Target_default_instance_; + new (ptr) ::MumbleProto::VoiceTarget_Target(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::MumbleProto::VoiceTarget_Target::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_VoiceTarget_Target_Mumble_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_VoiceTarget_Target_Mumble_2eproto}, {}}; + +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_Mumble_2eproto[32]; +static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_Mumble_2eproto[4]; +static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_Mumble_2eproto = nullptr; + +const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_Mumble_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + PROTOBUF_FIELD_OFFSET(::MumbleProto::Version, _has_bits_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::Version, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::MumbleProto::Version, version_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::Version, release_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::Version, os_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::Version, os_version_), + 3, + 0, + 1, + 2, + PROTOBUF_FIELD_OFFSET(::MumbleProto::UDPTunnel, _has_bits_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UDPTunnel, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::MumbleProto::UDPTunnel, packet_), + 0, + PROTOBUF_FIELD_OFFSET(::MumbleProto::Authenticate, _has_bits_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::Authenticate, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::MumbleProto::Authenticate, username_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::Authenticate, password_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::Authenticate, tokens_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::Authenticate, celt_versions_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::Authenticate, opus_), + 0, + 1, + ~0u, + ~0u, + 2, + PROTOBUF_FIELD_OFFSET(::MumbleProto::Ping, _has_bits_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::Ping, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::MumbleProto::Ping, timestamp_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::Ping, good_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::Ping, late_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::Ping, lost_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::Ping, resync_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::Ping, udp_packets_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::Ping, tcp_packets_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::Ping, udp_ping_avg_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::Ping, udp_ping_var_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::Ping, tcp_ping_avg_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::Ping, tcp_ping_var_), + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + PROTOBUF_FIELD_OFFSET(::MumbleProto::Reject, _has_bits_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::Reject, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::MumbleProto::Reject, type_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::Reject, reason_), + 1, + 0, + PROTOBUF_FIELD_OFFSET(::MumbleProto::ServerSync, _has_bits_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ServerSync, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::MumbleProto::ServerSync, session_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ServerSync, max_bandwidth_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ServerSync, welcome_text_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ServerSync, permissions_), + 1, + 2, + 0, + 3, + PROTOBUF_FIELD_OFFSET(::MumbleProto::ChannelRemove, _has_bits_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ChannelRemove, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::MumbleProto::ChannelRemove, channel_id_), + 0, + PROTOBUF_FIELD_OFFSET(::MumbleProto::ChannelState, _has_bits_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ChannelState, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::MumbleProto::ChannelState, channel_id_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ChannelState, parent_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ChannelState, name_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ChannelState, links_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ChannelState, description_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ChannelState, links_add_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ChannelState, links_remove_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ChannelState, temporary_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ChannelState, position_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ChannelState, description_hash_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ChannelState, max_users_), + 3, + 4, + 0, + ~0u, + 1, + ~0u, + ~0u, + 5, + 6, + 2, + 7, + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserRemove, _has_bits_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserRemove, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserRemove, session_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserRemove, actor_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserRemove, reason_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserRemove, ban_), + 1, + 2, + 0, + 3, + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserState, _has_bits_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserState, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserState, session_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserState, actor_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserState, name_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserState, user_id_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserState, channel_id_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserState, mute_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserState, deaf_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserState, suppress_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserState, self_mute_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserState, self_deaf_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserState, texture_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserState, plugin_context_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserState, plugin_identity_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserState, comment_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserState, hash_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserState, comment_hash_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserState, texture_hash_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserState, priority_speaker_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserState, recording_), + 8, + 9, + 0, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 17, + 18, + PROTOBUF_FIELD_OFFSET(::MumbleProto::BanList_BanEntry, _has_bits_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::BanList_BanEntry, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::MumbleProto::BanList_BanEntry, address_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::BanList_BanEntry, mask_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::BanList_BanEntry, name_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::BanList_BanEntry, hash_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::BanList_BanEntry, reason_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::BanList_BanEntry, start_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::BanList_BanEntry, duration_), + 0, + 5, + 1, + 2, + 3, + 4, + 6, + PROTOBUF_FIELD_OFFSET(::MumbleProto::BanList, _has_bits_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::BanList, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::MumbleProto::BanList, bans_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::BanList, query_), + ~0u, + 0, + PROTOBUF_FIELD_OFFSET(::MumbleProto::TextMessage, _has_bits_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::TextMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::MumbleProto::TextMessage, actor_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::TextMessage, session_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::TextMessage, channel_id_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::TextMessage, tree_id_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::TextMessage, message_), + 1, + ~0u, + ~0u, + ~0u, + 0, + PROTOBUF_FIELD_OFFSET(::MumbleProto::PermissionDenied, _has_bits_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::PermissionDenied, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::MumbleProto::PermissionDenied, permission_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::PermissionDenied, channel_id_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::PermissionDenied, session_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::PermissionDenied, reason_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::PermissionDenied, type_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::PermissionDenied, name_), + 2, + 3, + 4, + 0, + 5, + 1, + PROTOBUF_FIELD_OFFSET(::MumbleProto::ACL_ChanGroup, _has_bits_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ACL_ChanGroup, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::MumbleProto::ACL_ChanGroup, name_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ACL_ChanGroup, inherited_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ACL_ChanGroup, inherit_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ACL_ChanGroup, inheritable_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ACL_ChanGroup, add_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ACL_ChanGroup, remove_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ACL_ChanGroup, inherited_members_), + 0, + 1, + 2, + 3, + ~0u, + ~0u, + ~0u, + PROTOBUF_FIELD_OFFSET(::MumbleProto::ACL_ChanACL, _has_bits_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ACL_ChanACL, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::MumbleProto::ACL_ChanACL, apply_here_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ACL_ChanACL, apply_subs_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ACL_ChanACL, inherited_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ACL_ChanACL, user_id_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ACL_ChanACL, group_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ACL_ChanACL, grant_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ACL_ChanACL, deny_), + 4, + 5, + 6, + 1, + 0, + 2, + 3, + PROTOBUF_FIELD_OFFSET(::MumbleProto::ACL, _has_bits_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ACL, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::MumbleProto::ACL, channel_id_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ACL, inherit_acls_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ACL, groups_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ACL, acls_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ACL, query_), + 0, + 2, + ~0u, + ~0u, + 1, + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::MumbleProto::QueryUsers, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::MumbleProto::QueryUsers, ids_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::QueryUsers, names_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::CryptSetup, _has_bits_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::CryptSetup, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::MumbleProto::CryptSetup, key_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::CryptSetup, client_nonce_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::CryptSetup, server_nonce_), + 0, + 1, + 2, + PROTOBUF_FIELD_OFFSET(::MumbleProto::ContextActionModify, _has_bits_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ContextActionModify, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::MumbleProto::ContextActionModify, action_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ContextActionModify, text_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ContextActionModify, context_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ContextActionModify, operation_), + 0, + 1, + 2, + 3, + PROTOBUF_FIELD_OFFSET(::MumbleProto::ContextAction, _has_bits_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ContextAction, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::MumbleProto::ContextAction, session_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ContextAction, channel_id_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ContextAction, action_), + 1, + 2, + 0, + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserList_User, _has_bits_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserList_User, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserList_User, user_id_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserList_User, name_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserList_User, last_seen_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserList_User, last_channel_), + 2, + 0, + 1, + 3, + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserList, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserList, users_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::VoiceTarget_Target, _has_bits_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::VoiceTarget_Target, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::MumbleProto::VoiceTarget_Target, session_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::VoiceTarget_Target, channel_id_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::VoiceTarget_Target, group_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::VoiceTarget_Target, links_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::VoiceTarget_Target, children_), + ~0u, + 1, + 0, + 2, + 3, + PROTOBUF_FIELD_OFFSET(::MumbleProto::VoiceTarget, _has_bits_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::VoiceTarget, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::MumbleProto::VoiceTarget, id_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::VoiceTarget, targets_), + 0, + ~0u, + PROTOBUF_FIELD_OFFSET(::MumbleProto::PermissionQuery, _has_bits_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::PermissionQuery, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::MumbleProto::PermissionQuery, channel_id_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::PermissionQuery, permissions_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::PermissionQuery, flush_), + 0, + 1, + 2, + PROTOBUF_FIELD_OFFSET(::MumbleProto::CodecVersion, _has_bits_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::CodecVersion, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::MumbleProto::CodecVersion, alpha_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::CodecVersion, beta_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::CodecVersion, prefer_alpha_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::CodecVersion, opus_), + 0, + 1, + 3, + 2, + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserStats_Stats, _has_bits_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserStats_Stats, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserStats_Stats, good_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserStats_Stats, late_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserStats_Stats, lost_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserStats_Stats, resync_), + 0, + 1, + 2, + 3, + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserStats, _has_bits_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserStats, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserStats, session_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserStats, stats_only_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserStats, certificates_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserStats, from_client_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserStats, from_server_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserStats, udp_packets_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserStats, tcp_packets_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserStats, udp_ping_avg_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserStats, udp_ping_var_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserStats, tcp_ping_avg_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserStats, tcp_ping_var_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserStats, version_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserStats, celt_versions_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserStats, address_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserStats, bandwidth_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserStats, onlinesecs_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserStats, idlesecs_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserStats, strong_certificate_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::UserStats, opus_), + 4, + 11, + ~0u, + 1, + 2, + 5, + 6, + 7, + 8, + 9, + 10, + 3, + ~0u, + 0, + 14, + 15, + 16, + 12, + 13, + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::MumbleProto::RequestBlob, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::MumbleProto::RequestBlob, session_texture_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::RequestBlob, session_comment_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::RequestBlob, channel_description_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ServerConfig, _has_bits_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ServerConfig, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::MumbleProto::ServerConfig, max_bandwidth_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ServerConfig, welcome_text_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ServerConfig, allow_html_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ServerConfig, message_length_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ServerConfig, image_message_length_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::ServerConfig, max_users_), + 1, + 0, + 2, + 3, + 4, + 5, + PROTOBUF_FIELD_OFFSET(::MumbleProto::SuggestConfig, _has_bits_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::SuggestConfig, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::MumbleProto::SuggestConfig, version_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::SuggestConfig, positional_), + PROTOBUF_FIELD_OFFSET(::MumbleProto::SuggestConfig, push_to_talk_), + 0, + 1, + 2, +}; +static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + { 0, 9, sizeof(::MumbleProto::Version)}, + { 13, 19, sizeof(::MumbleProto::UDPTunnel)}, + { 20, 30, sizeof(::MumbleProto::Authenticate)}, + { 35, 51, sizeof(::MumbleProto::Ping)}, + { 62, 69, sizeof(::MumbleProto::Reject)}, + { 71, 80, sizeof(::MumbleProto::ServerSync)}, + { 84, 90, sizeof(::MumbleProto::ChannelRemove)}, + { 91, 107, sizeof(::MumbleProto::ChannelState)}, + { 118, 127, sizeof(::MumbleProto::UserRemove)}, + { 131, 155, sizeof(::MumbleProto::UserState)}, + { 174, 186, sizeof(::MumbleProto::BanList_BanEntry)}, + { 193, 200, sizeof(::MumbleProto::BanList)}, + { 202, 212, sizeof(::MumbleProto::TextMessage)}, + { 217, 228, sizeof(::MumbleProto::PermissionDenied)}, + { 234, 246, sizeof(::MumbleProto::ACL_ChanGroup)}, + { 253, 265, sizeof(::MumbleProto::ACL_ChanACL)}, + { 272, 282, sizeof(::MumbleProto::ACL)}, + { 287, -1, sizeof(::MumbleProto::QueryUsers)}, + { 294, 302, sizeof(::MumbleProto::CryptSetup)}, + { 305, 314, sizeof(::MumbleProto::ContextActionModify)}, + { 318, 326, sizeof(::MumbleProto::ContextAction)}, + { 329, 338, sizeof(::MumbleProto::UserList_User)}, + { 342, -1, sizeof(::MumbleProto::UserList)}, + { 348, 358, sizeof(::MumbleProto::VoiceTarget_Target)}, + { 363, 370, sizeof(::MumbleProto::VoiceTarget)}, + { 372, 380, sizeof(::MumbleProto::PermissionQuery)}, + { 383, 392, sizeof(::MumbleProto::CodecVersion)}, + { 396, 405, sizeof(::MumbleProto::UserStats_Stats)}, + { 409, 433, sizeof(::MumbleProto::UserStats)}, + { 452, -1, sizeof(::MumbleProto::RequestBlob)}, + { 460, 471, sizeof(::MumbleProto::ServerConfig)}, + { 477, 485, sizeof(::MumbleProto::SuggestConfig)}, +}; + +static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { + reinterpret_cast(&::MumbleProto::_Version_default_instance_), + reinterpret_cast(&::MumbleProto::_UDPTunnel_default_instance_), + reinterpret_cast(&::MumbleProto::_Authenticate_default_instance_), + reinterpret_cast(&::MumbleProto::_Ping_default_instance_), + reinterpret_cast(&::MumbleProto::_Reject_default_instance_), + reinterpret_cast(&::MumbleProto::_ServerSync_default_instance_), + reinterpret_cast(&::MumbleProto::_ChannelRemove_default_instance_), + reinterpret_cast(&::MumbleProto::_ChannelState_default_instance_), + reinterpret_cast(&::MumbleProto::_UserRemove_default_instance_), + reinterpret_cast(&::MumbleProto::_UserState_default_instance_), + reinterpret_cast(&::MumbleProto::_BanList_BanEntry_default_instance_), + reinterpret_cast(&::MumbleProto::_BanList_default_instance_), + reinterpret_cast(&::MumbleProto::_TextMessage_default_instance_), + reinterpret_cast(&::MumbleProto::_PermissionDenied_default_instance_), + reinterpret_cast(&::MumbleProto::_ACL_ChanGroup_default_instance_), + reinterpret_cast(&::MumbleProto::_ACL_ChanACL_default_instance_), + reinterpret_cast(&::MumbleProto::_ACL_default_instance_), + reinterpret_cast(&::MumbleProto::_QueryUsers_default_instance_), + reinterpret_cast(&::MumbleProto::_CryptSetup_default_instance_), + reinterpret_cast(&::MumbleProto::_ContextActionModify_default_instance_), + reinterpret_cast(&::MumbleProto::_ContextAction_default_instance_), + reinterpret_cast(&::MumbleProto::_UserList_User_default_instance_), + reinterpret_cast(&::MumbleProto::_UserList_default_instance_), + reinterpret_cast(&::MumbleProto::_VoiceTarget_Target_default_instance_), + reinterpret_cast(&::MumbleProto::_VoiceTarget_default_instance_), + reinterpret_cast(&::MumbleProto::_PermissionQuery_default_instance_), + reinterpret_cast(&::MumbleProto::_CodecVersion_default_instance_), + reinterpret_cast(&::MumbleProto::_UserStats_Stats_default_instance_), + reinterpret_cast(&::MumbleProto::_UserStats_default_instance_), + reinterpret_cast(&::MumbleProto::_RequestBlob_default_instance_), + reinterpret_cast(&::MumbleProto::_ServerConfig_default_instance_), + reinterpret_cast(&::MumbleProto::_SuggestConfig_default_instance_), +}; + +const char descriptor_table_protodef_Mumble_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = + "\n\014Mumble.proto\022\013MumbleProto\"K\n\007Version\022\017" + "\n\007version\030\001 \001(\r\022\017\n\007release\030\002 \001(\t\022\n\n\002os\030\003" + " \001(\t\022\022\n\nos_version\030\004 \001(\t\"\033\n\tUDPTunnel\022\016\n" + "\006packet\030\001 \002(\014\"n\n\014Authenticate\022\020\n\010usernam" + "e\030\001 \001(\t\022\020\n\010password\030\002 \001(\t\022\016\n\006tokens\030\003 \003(" + "\t\022\025\n\rcelt_versions\030\004 \003(\005\022\023\n\004opus\030\005 \001(\010:\005" + "false\"\325\001\n\004Ping\022\021\n\ttimestamp\030\001 \001(\004\022\014\n\004goo" + "d\030\002 \001(\r\022\014\n\004late\030\003 \001(\r\022\014\n\004lost\030\004 \001(\r\022\016\n\006r" + "esync\030\005 \001(\r\022\023\n\013udp_packets\030\006 \001(\r\022\023\n\013tcp_" + "packets\030\007 \001(\r\022\024\n\014udp_ping_avg\030\010 \001(\002\022\024\n\014u" + "dp_ping_var\030\t \001(\002\022\024\n\014tcp_ping_avg\030\n \001(\002\022" + "\024\n\014tcp_ping_var\030\013 \001(\002\"\367\001\n\006Reject\022,\n\004type" + "\030\001 \001(\0162\036.MumbleProto.Reject.RejectType\022\016" + "\n\006reason\030\002 \001(\t\"\256\001\n\nRejectType\022\010\n\004None\020\000\022" + "\020\n\014WrongVersion\020\001\022\023\n\017InvalidUsername\020\002\022\017" + "\n\013WrongUserPW\020\003\022\021\n\rWrongServerPW\020\004\022\021\n\rUs" + "ernameInUse\020\005\022\016\n\nServerFull\020\006\022\021\n\rNoCerti" + "ficate\020\007\022\025\n\021AuthenticatorFail\020\010\"_\n\nServe" + "rSync\022\017\n\007session\030\001 \001(\r\022\025\n\rmax_bandwidth\030" + "\002 \001(\r\022\024\n\014welcome_text\030\003 \001(\t\022\023\n\013permissio" + "ns\030\004 \001(\004\"#\n\rChannelRemove\022\022\n\nchannel_id\030" + "\001 \002(\r\"\351\001\n\014ChannelState\022\022\n\nchannel_id\030\001 \001" + "(\r\022\016\n\006parent\030\002 \001(\r\022\014\n\004name\030\003 \001(\t\022\r\n\005link" + "s\030\004 \003(\r\022\023\n\013description\030\005 \001(\t\022\021\n\tlinks_ad" + "d\030\006 \003(\r\022\024\n\014links_remove\030\007 \003(\r\022\030\n\ttempora" + "ry\030\010 \001(\010:\005false\022\023\n\010position\030\t \001(\005:\0010\022\030\n\020" + "description_hash\030\n \001(\014\022\021\n\tmax_users\030\013 \001(" + "\r\"I\n\nUserRemove\022\017\n\007session\030\001 \002(\r\022\r\n\005acto" + "r\030\002 \001(\r\022\016\n\006reason\030\003 \001(\t\022\013\n\003ban\030\004 \001(\010\"\354\002\n" + "\tUserState\022\017\n\007session\030\001 \001(\r\022\r\n\005actor\030\002 \001" + "(\r\022\014\n\004name\030\003 \001(\t\022\017\n\007user_id\030\004 \001(\r\022\022\n\ncha" + "nnel_id\030\005 \001(\r\022\014\n\004mute\030\006 \001(\010\022\014\n\004deaf\030\007 \001(" + "\010\022\020\n\010suppress\030\010 \001(\010\022\021\n\tself_mute\030\t \001(\010\022\021" + "\n\tself_deaf\030\n \001(\010\022\017\n\007texture\030\013 \001(\014\022\026\n\016pl" + "ugin_context\030\014 \001(\014\022\027\n\017plugin_identity\030\r " + "\001(\t\022\017\n\007comment\030\016 \001(\t\022\014\n\004hash\030\017 \001(\t\022\024\n\014co" + "mment_hash\030\020 \001(\014\022\024\n\014texture_hash\030\021 \001(\014\022\030" + "\n\020priority_speaker\030\022 \001(\010\022\021\n\trecording\030\023 " + "\001(\010\"\304\001\n\007BanList\022+\n\004bans\030\001 \003(\0132\035.MumblePr" + "oto.BanList.BanEntry\022\024\n\005query\030\002 \001(\010:\005fal" + "se\032v\n\010BanEntry\022\017\n\007address\030\001 \002(\014\022\014\n\004mask\030" + "\002 \002(\r\022\014\n\004name\030\003 \001(\t\022\014\n\004hash\030\004 \001(\t\022\016\n\006rea" + "son\030\005 \001(\t\022\r\n\005start\030\006 \001(\t\022\020\n\010duration\030\007 \001" + "(\r\"c\n\013TextMessage\022\r\n\005actor\030\001 \001(\r\022\017\n\007sess" + "ion\030\002 \003(\r\022\022\n\nchannel_id\030\003 \003(\r\022\017\n\007tree_id" + "\030\004 \003(\r\022\017\n\007message\030\005 \002(\t\"\337\002\n\020PermissionDe" + "nied\022\022\n\npermission\030\001 \001(\r\022\022\n\nchannel_id\030\002" + " \001(\r\022\017\n\007session\030\003 \001(\r\022\016\n\006reason\030\004 \001(\t\0224\n" + "\004type\030\005 \001(\0162&.MumbleProto.PermissionDeni" + "ed.DenyType\022\014\n\004name\030\006 \001(\t\"\275\001\n\010DenyType\022\010" + "\n\004Text\020\000\022\016\n\nPermission\020\001\022\r\n\tSuperUser\020\002\022" + "\017\n\013ChannelName\020\003\022\017\n\013TextTooLong\020\004\022\007\n\003H9K" + "\020\005\022\024\n\020TemporaryChannel\020\006\022\026\n\022MissingCerti" + "ficate\020\007\022\014\n\010UserName\020\010\022\017\n\013ChannelFull\020\t\022" + "\020\n\014NestingLimit\020\n\"\324\003\n\003ACL\022\022\n\nchannel_id\030" + "\001 \002(\r\022\032\n\014inherit_acls\030\002 \001(\010:\004true\022*\n\006gro" + "ups\030\003 \003(\0132\032.MumbleProto.ACL.ChanGroup\022&\n" + "\004acls\030\004 \003(\0132\030.MumbleProto.ACL.ChanACL\022\024\n" + "\005query\030\005 \001(\010:\005false\032\234\001\n\tChanGroup\022\014\n\004nam" + "e\030\001 \002(\t\022\027\n\tinherited\030\002 \001(\010:\004true\022\025\n\007inhe" + "rit\030\003 \001(\010:\004true\022\031\n\013inheritable\030\004 \001(\010:\004tr" + "ue\022\013\n\003add\030\005 \003(\r\022\016\n\006remove\030\006 \003(\r\022\031\n\021inher" + "ited_members\030\007 \003(\r\032\223\001\n\007ChanACL\022\030\n\napply_" + "here\030\001 \001(\010:\004true\022\030\n\napply_subs\030\002 \001(\010:\004tr" + "ue\022\027\n\tinherited\030\003 \001(\010:\004true\022\017\n\007user_id\030\004" + " \001(\r\022\r\n\005group\030\005 \001(\t\022\r\n\005grant\030\006 \001(\r\022\014\n\004de" + "ny\030\007 \001(\r\"(\n\nQueryUsers\022\013\n\003ids\030\001 \003(\r\022\r\n\005n" + "ames\030\002 \003(\t\"E\n\nCryptSetup\022\013\n\003key\030\001 \001(\014\022\024\n" + "\014client_nonce\030\002 \001(\014\022\024\n\014server_nonce\030\003 \001(" + "\014\"\323\001\n\023ContextActionModify\022\016\n\006action\030\001 \002(" + "\t\022\014\n\004text\030\002 \001(\t\022\017\n\007context\030\003 \001(\r\022=\n\toper" + "ation\030\004 \001(\0162*.MumbleProto.ContextActionM" + "odify.Operation\",\n\007Context\022\n\n\006Server\020\001\022\013" + "\n\007Channel\020\002\022\010\n\004User\020\004\" \n\tOperation\022\007\n\003Ad" + "d\020\000\022\n\n\006Remove\020\001\"D\n\rContextAction\022\017\n\007sess" + "ion\030\001 \001(\r\022\022\n\nchannel_id\030\002 \001(\r\022\016\n\006action\030" + "\003 \002(\t\"\205\001\n\010UserList\022)\n\005users\030\001 \003(\0132\032.Mumb" + "leProto.UserList.User\032N\n\004User\022\017\n\007user_id" + "\030\001 \002(\r\022\014\n\004name\030\002 \001(\t\022\021\n\tlast_seen\030\003 \001(\t\022" + "\024\n\014last_channel\030\004 \001(\r\"\270\001\n\013VoiceTarget\022\n\n" + "\002id\030\001 \001(\r\0220\n\007targets\030\002 \003(\0132\037.MumbleProto" + ".VoiceTarget.Target\032k\n\006Target\022\017\n\007session" + "\030\001 \003(\r\022\022\n\nchannel_id\030\002 \001(\r\022\r\n\005group\030\003 \001(" + "\t\022\024\n\005links\030\004 \001(\010:\005false\022\027\n\010children\030\005 \001(" + "\010:\005false\"P\n\017PermissionQuery\022\022\n\nchannel_i" + "d\030\001 \001(\r\022\023\n\013permissions\030\002 \001(\r\022\024\n\005flush\030\003 " + "\001(\010:\005false\"\\\n\014CodecVersion\022\r\n\005alpha\030\001 \002(" + "\005\022\014\n\004beta\030\002 \002(\005\022\032\n\014prefer_alpha\030\003 \002(\010:\004t" + "rue\022\023\n\004opus\030\004 \001(\010:\005false\"\270\004\n\tUserStats\022\017" + "\n\007session\030\001 \001(\r\022\031\n\nstats_only\030\002 \001(\010:\005fal" + "se\022\024\n\014certificates\030\003 \003(\014\0221\n\013from_client\030" + "\004 \001(\0132\034.MumbleProto.UserStats.Stats\0221\n\013f" + "rom_server\030\005 \001(\0132\034.MumbleProto.UserStats" + ".Stats\022\023\n\013udp_packets\030\006 \001(\r\022\023\n\013tcp_packe" + "ts\030\007 \001(\r\022\024\n\014udp_ping_avg\030\010 \001(\002\022\024\n\014udp_pi" + "ng_var\030\t \001(\002\022\024\n\014tcp_ping_avg\030\n \001(\002\022\024\n\014tc" + "p_ping_var\030\013 \001(\002\022%\n\007version\030\014 \001(\0132\024.Mumb" + "leProto.Version\022\025\n\rcelt_versions\030\r \003(\005\022\017" + "\n\007address\030\016 \001(\014\022\021\n\tbandwidth\030\017 \001(\r\022\022\n\non" + "linesecs\030\020 \001(\r\022\020\n\010idlesecs\030\021 \001(\r\022!\n\022stro" + "ng_certificate\030\022 \001(\010:\005false\022\023\n\004opus\030\023 \001(" + "\010:\005false\032A\n\005Stats\022\014\n\004good\030\001 \001(\r\022\014\n\004late\030" + "\002 \001(\r\022\014\n\004lost\030\003 \001(\r\022\016\n\006resync\030\004 \001(\r\"\\\n\013R" + "equestBlob\022\027\n\017session_texture\030\001 \003(\r\022\027\n\017s" + "ession_comment\030\002 \003(\r\022\033\n\023channel_descript" + "ion\030\003 \003(\r\"\230\001\n\014ServerConfig\022\025\n\rmax_bandwi" + "dth\030\001 \001(\r\022\024\n\014welcome_text\030\002 \001(\t\022\022\n\nallow" + "_html\030\003 \001(\010\022\026\n\016message_length\030\004 \001(\r\022\034\n\024i" + "mage_message_length\030\005 \001(\r\022\021\n\tmax_users\030\006" + " \001(\r\"J\n\rSuggestConfig\022\017\n\007version\030\001 \001(\r\022\022" + "\n\npositional\030\002 \001(\010\022\024\n\014push_to_talk\030\003 \001(\010" + "B\002H\001" + ; +static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_Mumble_2eproto_deps[1] = { +}; +static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_Mumble_2eproto_sccs[32] = { + &scc_info_ACL_Mumble_2eproto.base, + &scc_info_ACL_ChanACL_Mumble_2eproto.base, + &scc_info_ACL_ChanGroup_Mumble_2eproto.base, + &scc_info_Authenticate_Mumble_2eproto.base, + &scc_info_BanList_Mumble_2eproto.base, + &scc_info_BanList_BanEntry_Mumble_2eproto.base, + &scc_info_ChannelRemove_Mumble_2eproto.base, + &scc_info_ChannelState_Mumble_2eproto.base, + &scc_info_CodecVersion_Mumble_2eproto.base, + &scc_info_ContextAction_Mumble_2eproto.base, + &scc_info_ContextActionModify_Mumble_2eproto.base, + &scc_info_CryptSetup_Mumble_2eproto.base, + &scc_info_PermissionDenied_Mumble_2eproto.base, + &scc_info_PermissionQuery_Mumble_2eproto.base, + &scc_info_Ping_Mumble_2eproto.base, + &scc_info_QueryUsers_Mumble_2eproto.base, + &scc_info_Reject_Mumble_2eproto.base, + &scc_info_RequestBlob_Mumble_2eproto.base, + &scc_info_ServerConfig_Mumble_2eproto.base, + &scc_info_ServerSync_Mumble_2eproto.base, + &scc_info_SuggestConfig_Mumble_2eproto.base, + &scc_info_TextMessage_Mumble_2eproto.base, + &scc_info_UDPTunnel_Mumble_2eproto.base, + &scc_info_UserList_Mumble_2eproto.base, + &scc_info_UserList_User_Mumble_2eproto.base, + &scc_info_UserRemove_Mumble_2eproto.base, + &scc_info_UserState_Mumble_2eproto.base, + &scc_info_UserStats_Mumble_2eproto.base, + &scc_info_UserStats_Stats_Mumble_2eproto.base, + &scc_info_Version_Mumble_2eproto.base, + &scc_info_VoiceTarget_Mumble_2eproto.base, + &scc_info_VoiceTarget_Target_Mumble_2eproto.base, +}; +static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_Mumble_2eproto_once; +const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_Mumble_2eproto = { + false, false, descriptor_table_protodef_Mumble_2eproto, "Mumble.proto", 4444, + &descriptor_table_Mumble_2eproto_once, descriptor_table_Mumble_2eproto_sccs, descriptor_table_Mumble_2eproto_deps, 32, 0, + schemas, file_default_instances, TableStruct_Mumble_2eproto::offsets, + file_level_metadata_Mumble_2eproto, 32, file_level_enum_descriptors_Mumble_2eproto, file_level_service_descriptors_Mumble_2eproto, +}; + +// Force running AddDescriptors() at dynamic initialization time. +static bool dynamic_init_dummy_Mumble_2eproto = (static_cast(::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_Mumble_2eproto)), true); +namespace MumbleProto { +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Reject_RejectType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_Mumble_2eproto); + return file_level_enum_descriptors_Mumble_2eproto[0]; +} +bool Reject_RejectType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +constexpr Reject_RejectType Reject::None; +constexpr Reject_RejectType Reject::WrongVersion; +constexpr Reject_RejectType Reject::InvalidUsername; +constexpr Reject_RejectType Reject::WrongUserPW; +constexpr Reject_RejectType Reject::WrongServerPW; +constexpr Reject_RejectType Reject::UsernameInUse; +constexpr Reject_RejectType Reject::ServerFull; +constexpr Reject_RejectType Reject::NoCertificate; +constexpr Reject_RejectType Reject::AuthenticatorFail; +constexpr Reject_RejectType Reject::RejectType_MIN; +constexpr Reject_RejectType Reject::RejectType_MAX; +constexpr int Reject::RejectType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PermissionDenied_DenyType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_Mumble_2eproto); + return file_level_enum_descriptors_Mumble_2eproto[1]; +} +bool PermissionDenied_DenyType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + case 10: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +constexpr PermissionDenied_DenyType PermissionDenied::Text; +constexpr PermissionDenied_DenyType PermissionDenied::Permission; +constexpr PermissionDenied_DenyType PermissionDenied::SuperUser; +constexpr PermissionDenied_DenyType PermissionDenied::ChannelName; +constexpr PermissionDenied_DenyType PermissionDenied::TextTooLong; +constexpr PermissionDenied_DenyType PermissionDenied::H9K; +constexpr PermissionDenied_DenyType PermissionDenied::TemporaryChannel; +constexpr PermissionDenied_DenyType PermissionDenied::MissingCertificate; +constexpr PermissionDenied_DenyType PermissionDenied::UserName; +constexpr PermissionDenied_DenyType PermissionDenied::ChannelFull; +constexpr PermissionDenied_DenyType PermissionDenied::NestingLimit; +constexpr PermissionDenied_DenyType PermissionDenied::DenyType_MIN; +constexpr PermissionDenied_DenyType PermissionDenied::DenyType_MAX; +constexpr int PermissionDenied::DenyType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ContextActionModify_Context_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_Mumble_2eproto); + return file_level_enum_descriptors_Mumble_2eproto[2]; +} +bool ContextActionModify_Context_IsValid(int value) { + switch (value) { + case 1: + case 2: + case 4: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +constexpr ContextActionModify_Context ContextActionModify::Server; +constexpr ContextActionModify_Context ContextActionModify::Channel; +constexpr ContextActionModify_Context ContextActionModify::User; +constexpr ContextActionModify_Context ContextActionModify::Context_MIN; +constexpr ContextActionModify_Context ContextActionModify::Context_MAX; +constexpr int ContextActionModify::Context_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ContextActionModify_Operation_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_Mumble_2eproto); + return file_level_enum_descriptors_Mumble_2eproto[3]; +} +bool ContextActionModify_Operation_IsValid(int value) { + switch (value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +constexpr ContextActionModify_Operation ContextActionModify::Add; +constexpr ContextActionModify_Operation ContextActionModify::Remove; +constexpr ContextActionModify_Operation ContextActionModify::Operation_MIN; +constexpr ContextActionModify_Operation ContextActionModify::Operation_MAX; +constexpr int ContextActionModify::Operation_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) + +// =================================================================== + +void Version::InitAsDefaultInstance() { +} +class Version::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_version(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_release(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_os(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_os_version(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +Version::Version(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:MumbleProto.Version) +} +Version::Version(const Version& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + release_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_release()) { + release_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_release(), + GetArena()); + } + os_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_os()) { + os_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_os(), + GetArena()); + } + os_version_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_os_version()) { + os_version_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_os_version(), + GetArena()); + } + version_ = from.version_; + // @@protoc_insertion_point(copy_constructor:MumbleProto.Version) +} + +void Version::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Version_Mumble_2eproto.base); + release_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + os_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + os_version_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + version_ = 0u; +} + +Version::~Version() { + // @@protoc_insertion_point(destructor:MumbleProto.Version) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Version::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + release_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + os_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + os_version_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void Version::ArenaDtor(void* object) { + Version* _this = reinterpret_cast< Version* >(object); + (void)_this; +} +void Version::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Version::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const Version& Version::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Version_Mumble_2eproto.base); + return *internal_default_instance(); +} + + +void Version::Clear() { +// @@protoc_insertion_point(message_clear_start:MumbleProto.Version) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + release_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + os_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + os_version_.ClearNonDefaultToEmpty(); + } + } + version_ = 0u; + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Version::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional uint32 version = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + _Internal::set_has_version(&has_bits); + version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string release = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_release(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MumbleProto.Version.release"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string os = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + auto str = _internal_mutable_os(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MumbleProto.Version.os"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string os_version = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + auto str = _internal_mutable_os_version(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MumbleProto.Version.os_version"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Version::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MumbleProto.Version) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional uint32 version = 1; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_version(), target); + } + + // optional string release = 2; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_release().data(), static_cast(this->_internal_release().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "MumbleProto.Version.release"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_release(), target); + } + + // optional string os = 3; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_os().data(), static_cast(this->_internal_os().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "MumbleProto.Version.os"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_os(), target); + } + + // optional string os_version = 4; + if (cached_has_bits & 0x00000004u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_os_version().data(), static_cast(this->_internal_os_version().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "MumbleProto.Version.os_version"); + target = stream->WriteStringMaybeAliased( + 4, this->_internal_os_version(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MumbleProto.Version) + return target; +} + +size_t Version::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MumbleProto.Version) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + // optional string release = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_release()); + } + + // optional string os = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_os()); + } + + // optional string os_version = 4; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_os_version()); + } + + // optional uint32 version = 1; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_version()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Version::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:MumbleProto.Version) + GOOGLE_DCHECK_NE(&from, this); + const Version* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:MumbleProto.Version) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:MumbleProto.Version) + MergeFrom(*source); + } +} + +void Version::MergeFrom(const Version& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MumbleProto.Version) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_release(from._internal_release()); + } + if (cached_has_bits & 0x00000002u) { + _internal_set_os(from._internal_os()); + } + if (cached_has_bits & 0x00000004u) { + _internal_set_os_version(from._internal_os_version()); + } + if (cached_has_bits & 0x00000008u) { + version_ = from.version_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void Version::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:MumbleProto.Version) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Version::CopyFrom(const Version& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MumbleProto.Version) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Version::IsInitialized() const { + return true; +} + +void Version::InternalSwap(Version* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + release_.Swap(&other->release_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + os_.Swap(&other->os_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + os_version_.Swap(&other->os_version_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + swap(version_, other->version_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Version::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void UDPTunnel::InitAsDefaultInstance() { +} +class UDPTunnel::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_packet(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static bool MissingRequiredFields(const HasBits& has_bits) { + return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0; + } +}; + +UDPTunnel::UDPTunnel(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:MumbleProto.UDPTunnel) +} +UDPTunnel::UDPTunnel(const UDPTunnel& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + packet_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_packet()) { + packet_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_packet(), + GetArena()); + } + // @@protoc_insertion_point(copy_constructor:MumbleProto.UDPTunnel) +} + +void UDPTunnel::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_UDPTunnel_Mumble_2eproto.base); + packet_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +UDPTunnel::~UDPTunnel() { + // @@protoc_insertion_point(destructor:MumbleProto.UDPTunnel) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void UDPTunnel::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + packet_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void UDPTunnel::ArenaDtor(void* object) { + UDPTunnel* _this = reinterpret_cast< UDPTunnel* >(object); + (void)_this; +} +void UDPTunnel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void UDPTunnel::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const UDPTunnel& UDPTunnel::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_UDPTunnel_Mumble_2eproto.base); + return *internal_default_instance(); +} + + +void UDPTunnel::Clear() { +// @@protoc_insertion_point(message_clear_start:MumbleProto.UDPTunnel) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + packet_.ClearNonDefaultToEmpty(); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* UDPTunnel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // required bytes packet = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_packet(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* UDPTunnel::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MumbleProto.UDPTunnel) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // required bytes packet = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_packet(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MumbleProto.UDPTunnel) + return target; +} + +size_t UDPTunnel::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MumbleProto.UDPTunnel) + size_t total_size = 0; + + // required bytes packet = 1; + if (_internal_has_packet()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_packet()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void UDPTunnel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:MumbleProto.UDPTunnel) + GOOGLE_DCHECK_NE(&from, this); + const UDPTunnel* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:MumbleProto.UDPTunnel) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:MumbleProto.UDPTunnel) + MergeFrom(*source); + } +} + +void UDPTunnel::MergeFrom(const UDPTunnel& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MumbleProto.UDPTunnel) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_packet()) { + _internal_set_packet(from._internal_packet()); + } +} + +void UDPTunnel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:MumbleProto.UDPTunnel) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void UDPTunnel::CopyFrom(const UDPTunnel& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MumbleProto.UDPTunnel) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool UDPTunnel::IsInitialized() const { + if (_Internal::MissingRequiredFields(_has_bits_)) return false; + return true; +} + +void UDPTunnel::InternalSwap(UDPTunnel* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + packet_.Swap(&other->packet_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata UDPTunnel::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void Authenticate::InitAsDefaultInstance() { +} +class Authenticate::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_username(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_password(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_opus(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +Authenticate::Authenticate(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + tokens_(arena), + celt_versions_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:MumbleProto.Authenticate) +} +Authenticate::Authenticate(const Authenticate& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_), + tokens_(from.tokens_), + celt_versions_(from.celt_versions_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + username_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_username()) { + username_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_username(), + GetArena()); + } + password_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_password()) { + password_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_password(), + GetArena()); + } + opus_ = from.opus_; + // @@protoc_insertion_point(copy_constructor:MumbleProto.Authenticate) +} + +void Authenticate::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Authenticate_Mumble_2eproto.base); + username_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + password_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + opus_ = false; +} + +Authenticate::~Authenticate() { + // @@protoc_insertion_point(destructor:MumbleProto.Authenticate) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Authenticate::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + username_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + password_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void Authenticate::ArenaDtor(void* object) { + Authenticate* _this = reinterpret_cast< Authenticate* >(object); + (void)_this; +} +void Authenticate::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Authenticate::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const Authenticate& Authenticate::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Authenticate_Mumble_2eproto.base); + return *internal_default_instance(); +} + + +void Authenticate::Clear() { +// @@protoc_insertion_point(message_clear_start:MumbleProto.Authenticate) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + tokens_.Clear(); + celt_versions_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + username_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + password_.ClearNonDefaultToEmpty(); + } + } + opus_ = false; + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Authenticate::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional string username = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_username(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MumbleProto.Authenticate.username"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string password = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_password(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MumbleProto.Authenticate.password"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated string tokens = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_tokens(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MumbleProto.Authenticate.tokens"); + #endif // !NDEBUG + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); + } else goto handle_unusual; + continue; + // repeated int32 celt_versions = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_celt_versions(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<32>(ptr)); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_celt_versions(), ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool opus = 5 [default = false]; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) { + _Internal::set_has_opus(&has_bits); + opus_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Authenticate::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MumbleProto.Authenticate) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional string username = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_username().data(), static_cast(this->_internal_username().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "MumbleProto.Authenticate.username"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_username(), target); + } + + // optional string password = 2; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_password().data(), static_cast(this->_internal_password().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "MumbleProto.Authenticate.password"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_password(), target); + } + + // repeated string tokens = 3; + for (int i = 0, n = this->_internal_tokens_size(); i < n; i++) { + const auto& s = this->_internal_tokens(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "MumbleProto.Authenticate.tokens"); + target = stream->WriteString(3, s, target); + } + + // repeated int32 celt_versions = 4; + for (int i = 0, n = this->_internal_celt_versions_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_celt_versions(i), target); + } + + // optional bool opus = 5 [default = false]; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(5, this->_internal_opus(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MumbleProto.Authenticate) + return target; +} + +size_t Authenticate::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MumbleProto.Authenticate) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string tokens = 3; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(tokens_.size()); + for (int i = 0, n = tokens_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + tokens_.Get(i)); + } + + // repeated int32 celt_versions = 4; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + Int32Size(this->celt_versions_); + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_celt_versions_size()); + total_size += data_size; + } + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional string username = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_username()); + } + + // optional string password = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_password()); + } + + // optional bool opus = 5 [default = false]; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + 1; + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Authenticate::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:MumbleProto.Authenticate) + GOOGLE_DCHECK_NE(&from, this); + const Authenticate* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:MumbleProto.Authenticate) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:MumbleProto.Authenticate) + MergeFrom(*source); + } +} + +void Authenticate::MergeFrom(const Authenticate& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MumbleProto.Authenticate) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + tokens_.MergeFrom(from.tokens_); + celt_versions_.MergeFrom(from.celt_versions_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _internal_set_username(from._internal_username()); + } + if (cached_has_bits & 0x00000002u) { + _internal_set_password(from._internal_password()); + } + if (cached_has_bits & 0x00000004u) { + opus_ = from.opus_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void Authenticate::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:MumbleProto.Authenticate) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Authenticate::CopyFrom(const Authenticate& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MumbleProto.Authenticate) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Authenticate::IsInitialized() const { + return true; +} + +void Authenticate::InternalSwap(Authenticate* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + tokens_.InternalSwap(&other->tokens_); + celt_versions_.InternalSwap(&other->celt_versions_); + username_.Swap(&other->username_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + password_.Swap(&other->password_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + swap(opus_, other->opus_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Authenticate::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void Ping::InitAsDefaultInstance() { +} +class Ping::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_timestamp(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_good(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_late(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_lost(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_resync(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_udp_packets(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_tcp_packets(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_udp_ping_avg(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static void set_has_udp_ping_var(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static void set_has_tcp_ping_avg(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } + static void set_has_tcp_ping_var(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } +}; + +Ping::Ping(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:MumbleProto.Ping) +} +Ping::Ping(const Ping& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(×tamp_, &from.timestamp_, + static_cast(reinterpret_cast(&tcp_ping_var_) - + reinterpret_cast(×tamp_)) + sizeof(tcp_ping_var_)); + // @@protoc_insertion_point(copy_constructor:MumbleProto.Ping) +} + +void Ping::SharedCtor() { + ::memset(×tamp_, 0, static_cast( + reinterpret_cast(&tcp_ping_var_) - + reinterpret_cast(×tamp_)) + sizeof(tcp_ping_var_)); +} + +Ping::~Ping() { + // @@protoc_insertion_point(destructor:MumbleProto.Ping) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Ping::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void Ping::ArenaDtor(void* object) { + Ping* _this = reinterpret_cast< Ping* >(object); + (void)_this; +} +void Ping::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Ping::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const Ping& Ping::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Ping_Mumble_2eproto.base); + return *internal_default_instance(); +} + + +void Ping::Clear() { +// @@protoc_insertion_point(message_clear_start:MumbleProto.Ping) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + ::memset(×tamp_, 0, static_cast( + reinterpret_cast(&udp_ping_avg_) - + reinterpret_cast(×tamp_)) + sizeof(udp_ping_avg_)); + } + if (cached_has_bits & 0x00000700u) { + ::memset(&udp_ping_var_, 0, static_cast( + reinterpret_cast(&tcp_ping_var_) - + reinterpret_cast(&udp_ping_var_)) + sizeof(tcp_ping_var_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Ping::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional uint64 timestamp = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + _Internal::set_has_timestamp(&has_bits); + timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 good = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + _Internal::set_has_good(&has_bits); + good_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 late = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + _Internal::set_has_late(&has_bits); + late_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 lost = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + _Internal::set_has_lost(&has_bits); + lost_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 resync = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) { + _Internal::set_has_resync(&has_bits); + resync_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 udp_packets = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) { + _Internal::set_has_udp_packets(&has_bits); + udp_packets_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 tcp_packets = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) { + _Internal::set_has_tcp_packets(&has_bits); + tcp_packets_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional float udp_ping_avg = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 69)) { + _Internal::set_has_udp_ping_avg(&has_bits); + udp_ping_avg_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // optional float udp_ping_var = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 77)) { + _Internal::set_has_udp_ping_var(&has_bits); + udp_ping_var_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // optional float tcp_ping_avg = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 85)) { + _Internal::set_has_tcp_ping_avg(&has_bits); + tcp_ping_avg_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // optional float tcp_ping_var = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 93)) { + _Internal::set_has_tcp_ping_var(&has_bits); + tcp_ping_var_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Ping::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MumbleProto.Ping) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional uint64 timestamp = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->_internal_timestamp(), target); + } + + // optional uint32 good = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_good(), target); + } + + // optional uint32 late = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_late(), target); + } + + // optional uint32 lost = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_lost(), target); + } + + // optional uint32 resync = 5; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(5, this->_internal_resync(), target); + } + + // optional uint32 udp_packets = 6; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(6, this->_internal_udp_packets(), target); + } + + // optional uint32 tcp_packets = 7; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(7, this->_internal_tcp_packets(), target); + } + + // optional float udp_ping_avg = 8; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(8, this->_internal_udp_ping_avg(), target); + } + + // optional float udp_ping_var = 9; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(9, this->_internal_udp_ping_var(), target); + } + + // optional float tcp_ping_avg = 10; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(10, this->_internal_tcp_ping_avg(), target); + } + + // optional float tcp_ping_var = 11; + if (cached_has_bits & 0x00000400u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(11, this->_internal_tcp_ping_var(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MumbleProto.Ping) + return target; +} + +size_t Ping::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MumbleProto.Ping) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional uint64 timestamp = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( + this->_internal_timestamp()); + } + + // optional uint32 good = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_good()); + } + + // optional uint32 late = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_late()); + } + + // optional uint32 lost = 4; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_lost()); + } + + // optional uint32 resync = 5; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_resync()); + } + + // optional uint32 udp_packets = 6; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_udp_packets()); + } + + // optional uint32 tcp_packets = 7; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_tcp_packets()); + } + + // optional float udp_ping_avg = 8; + if (cached_has_bits & 0x00000080u) { + total_size += 1 + 4; + } + + } + if (cached_has_bits & 0x00000700u) { + // optional float udp_ping_var = 9; + if (cached_has_bits & 0x00000100u) { + total_size += 1 + 4; + } + + // optional float tcp_ping_avg = 10; + if (cached_has_bits & 0x00000200u) { + total_size += 1 + 4; + } + + // optional float tcp_ping_var = 11; + if (cached_has_bits & 0x00000400u) { + total_size += 1 + 4; + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Ping::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:MumbleProto.Ping) + GOOGLE_DCHECK_NE(&from, this); + const Ping* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:MumbleProto.Ping) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:MumbleProto.Ping) + MergeFrom(*source); + } +} + +void Ping::MergeFrom(const Ping& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MumbleProto.Ping) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + timestamp_ = from.timestamp_; + } + if (cached_has_bits & 0x00000002u) { + good_ = from.good_; + } + if (cached_has_bits & 0x00000004u) { + late_ = from.late_; + } + if (cached_has_bits & 0x00000008u) { + lost_ = from.lost_; + } + if (cached_has_bits & 0x00000010u) { + resync_ = from.resync_; + } + if (cached_has_bits & 0x00000020u) { + udp_packets_ = from.udp_packets_; + } + if (cached_has_bits & 0x00000040u) { + tcp_packets_ = from.tcp_packets_; + } + if (cached_has_bits & 0x00000080u) { + udp_ping_avg_ = from.udp_ping_avg_; + } + _has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x00000700u) { + if (cached_has_bits & 0x00000100u) { + udp_ping_var_ = from.udp_ping_var_; + } + if (cached_has_bits & 0x00000200u) { + tcp_ping_avg_ = from.tcp_ping_avg_; + } + if (cached_has_bits & 0x00000400u) { + tcp_ping_var_ = from.tcp_ping_var_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void Ping::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:MumbleProto.Ping) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Ping::CopyFrom(const Ping& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MumbleProto.Ping) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Ping::IsInitialized() const { + return true; +} + +void Ping::InternalSwap(Ping* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Ping, tcp_ping_var_) + + sizeof(Ping::tcp_ping_var_) + - PROTOBUF_FIELD_OFFSET(Ping, timestamp_)>( + reinterpret_cast(×tamp_), + reinterpret_cast(&other->timestamp_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Ping::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void Reject::InitAsDefaultInstance() { +} +class Reject::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_type(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_reason(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +Reject::Reject(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:MumbleProto.Reject) +} +Reject::Reject(const Reject& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + reason_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_reason()) { + reason_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_reason(), + GetArena()); + } + type_ = from.type_; + // @@protoc_insertion_point(copy_constructor:MumbleProto.Reject) +} + +void Reject::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Reject_Mumble_2eproto.base); + reason_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + type_ = 0; +} + +Reject::~Reject() { + // @@protoc_insertion_point(destructor:MumbleProto.Reject) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Reject::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + reason_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void Reject::ArenaDtor(void* object) { + Reject* _this = reinterpret_cast< Reject* >(object); + (void)_this; +} +void Reject::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Reject::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const Reject& Reject::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Reject_Mumble_2eproto.base); + return *internal_default_instance(); +} + + +void Reject::Clear() { +// @@protoc_insertion_point(message_clear_start:MumbleProto.Reject) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + reason_.ClearNonDefaultToEmpty(); + } + type_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Reject::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional .MumbleProto.Reject.RejectType type = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::MumbleProto::Reject_RejectType_IsValid(val))) { + _internal_set_type(static_cast<::MumbleProto::Reject_RejectType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + } else goto handle_unusual; + continue; + // optional string reason = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_reason(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MumbleProto.Reject.reason"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Reject::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MumbleProto.Reject) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .MumbleProto.Reject.RejectType type = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->_internal_type(), target); + } + + // optional string reason = 2; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_reason().data(), static_cast(this->_internal_reason().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "MumbleProto.Reject.reason"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_reason(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MumbleProto.Reject) + return target; +} + +size_t Reject::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MumbleProto.Reject) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional string reason = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_reason()); + } + + // optional .MumbleProto.Reject.RejectType type = 1; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Reject::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:MumbleProto.Reject) + GOOGLE_DCHECK_NE(&from, this); + const Reject* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:MumbleProto.Reject) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:MumbleProto.Reject) + MergeFrom(*source); + } +} + +void Reject::MergeFrom(const Reject& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MumbleProto.Reject) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _internal_set_reason(from._internal_reason()); + } + if (cached_has_bits & 0x00000002u) { + type_ = from.type_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void Reject::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:MumbleProto.Reject) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Reject::CopyFrom(const Reject& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MumbleProto.Reject) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Reject::IsInitialized() const { + return true; +} + +void Reject::InternalSwap(Reject* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + reason_.Swap(&other->reason_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + swap(type_, other->type_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Reject::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void ServerSync::InitAsDefaultInstance() { +} +class ServerSync::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_session(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_max_bandwidth(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_welcome_text(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_permissions(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } +}; + +ServerSync::ServerSync(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:MumbleProto.ServerSync) +} +ServerSync::ServerSync(const ServerSync& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + welcome_text_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_welcome_text()) { + welcome_text_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_welcome_text(), + GetArena()); + } + ::memcpy(&session_, &from.session_, + static_cast(reinterpret_cast(&permissions_) - + reinterpret_cast(&session_)) + sizeof(permissions_)); + // @@protoc_insertion_point(copy_constructor:MumbleProto.ServerSync) +} + +void ServerSync::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ServerSync_Mumble_2eproto.base); + welcome_text_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&session_, 0, static_cast( + reinterpret_cast(&permissions_) - + reinterpret_cast(&session_)) + sizeof(permissions_)); +} + +ServerSync::~ServerSync() { + // @@protoc_insertion_point(destructor:MumbleProto.ServerSync) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void ServerSync::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + welcome_text_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ServerSync::ArenaDtor(void* object) { + ServerSync* _this = reinterpret_cast< ServerSync* >(object); + (void)_this; +} +void ServerSync::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ServerSync::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ServerSync& ServerSync::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ServerSync_Mumble_2eproto.base); + return *internal_default_instance(); +} + + +void ServerSync::Clear() { +// @@protoc_insertion_point(message_clear_start:MumbleProto.ServerSync) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + welcome_text_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x0000000eu) { + ::memset(&session_, 0, static_cast( + reinterpret_cast(&permissions_) - + reinterpret_cast(&session_)) + sizeof(permissions_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ServerSync::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional uint32 session = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + _Internal::set_has_session(&has_bits); + session_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 max_bandwidth = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + _Internal::set_has_max_bandwidth(&has_bits); + max_bandwidth_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string welcome_text = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + auto str = _internal_mutable_welcome_text(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MumbleProto.ServerSync.welcome_text"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint64 permissions = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + _Internal::set_has_permissions(&has_bits); + permissions_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ServerSync::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MumbleProto.ServerSync) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional uint32 session = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_session(), target); + } + + // optional uint32 max_bandwidth = 2; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_max_bandwidth(), target); + } + + // optional string welcome_text = 3; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_welcome_text().data(), static_cast(this->_internal_welcome_text().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "MumbleProto.ServerSync.welcome_text"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_welcome_text(), target); + } + + // optional uint64 permissions = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(4, this->_internal_permissions(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MumbleProto.ServerSync) + return target; +} + +size_t ServerSync::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MumbleProto.ServerSync) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + // optional string welcome_text = 3; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_welcome_text()); + } + + // optional uint32 session = 1; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_session()); + } + + // optional uint32 max_bandwidth = 2; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_max_bandwidth()); + } + + // optional uint64 permissions = 4; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( + this->_internal_permissions()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ServerSync::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:MumbleProto.ServerSync) + GOOGLE_DCHECK_NE(&from, this); + const ServerSync* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:MumbleProto.ServerSync) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:MumbleProto.ServerSync) + MergeFrom(*source); + } +} + +void ServerSync::MergeFrom(const ServerSync& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MumbleProto.ServerSync) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_welcome_text(from._internal_welcome_text()); + } + if (cached_has_bits & 0x00000002u) { + session_ = from.session_; + } + if (cached_has_bits & 0x00000004u) { + max_bandwidth_ = from.max_bandwidth_; + } + if (cached_has_bits & 0x00000008u) { + permissions_ = from.permissions_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void ServerSync::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:MumbleProto.ServerSync) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ServerSync::CopyFrom(const ServerSync& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MumbleProto.ServerSync) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ServerSync::IsInitialized() const { + return true; +} + +void ServerSync::InternalSwap(ServerSync* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + welcome_text_.Swap(&other->welcome_text_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ServerSync, permissions_) + + sizeof(ServerSync::permissions_) + - PROTOBUF_FIELD_OFFSET(ServerSync, session_)>( + reinterpret_cast(&session_), + reinterpret_cast(&other->session_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ServerSync::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void ChannelRemove::InitAsDefaultInstance() { +} +class ChannelRemove::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_channel_id(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static bool MissingRequiredFields(const HasBits& has_bits) { + return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0; + } +}; + +ChannelRemove::ChannelRemove(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:MumbleProto.ChannelRemove) +} +ChannelRemove::ChannelRemove(const ChannelRemove& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + channel_id_ = from.channel_id_; + // @@protoc_insertion_point(copy_constructor:MumbleProto.ChannelRemove) +} + +void ChannelRemove::SharedCtor() { + channel_id_ = 0u; +} + +ChannelRemove::~ChannelRemove() { + // @@protoc_insertion_point(destructor:MumbleProto.ChannelRemove) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void ChannelRemove::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void ChannelRemove::ArenaDtor(void* object) { + ChannelRemove* _this = reinterpret_cast< ChannelRemove* >(object); + (void)_this; +} +void ChannelRemove::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ChannelRemove::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ChannelRemove& ChannelRemove::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ChannelRemove_Mumble_2eproto.base); + return *internal_default_instance(); +} + + +void ChannelRemove::Clear() { +// @@protoc_insertion_point(message_clear_start:MumbleProto.ChannelRemove) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + channel_id_ = 0u; + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ChannelRemove::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // required uint32 channel_id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + _Internal::set_has_channel_id(&has_bits); + channel_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ChannelRemove::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MumbleProto.ChannelRemove) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // required uint32 channel_id = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_channel_id(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MumbleProto.ChannelRemove) + return target; +} + +size_t ChannelRemove::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MumbleProto.ChannelRemove) + size_t total_size = 0; + + // required uint32 channel_id = 1; + if (_internal_has_channel_id()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_channel_id()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ChannelRemove::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:MumbleProto.ChannelRemove) + GOOGLE_DCHECK_NE(&from, this); + const ChannelRemove* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:MumbleProto.ChannelRemove) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:MumbleProto.ChannelRemove) + MergeFrom(*source); + } +} + +void ChannelRemove::MergeFrom(const ChannelRemove& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MumbleProto.ChannelRemove) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_channel_id()) { + _internal_set_channel_id(from._internal_channel_id()); + } +} + +void ChannelRemove::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:MumbleProto.ChannelRemove) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ChannelRemove::CopyFrom(const ChannelRemove& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MumbleProto.ChannelRemove) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ChannelRemove::IsInitialized() const { + if (_Internal::MissingRequiredFields(_has_bits_)) return false; + return true; +} + +void ChannelRemove::InternalSwap(ChannelRemove* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + swap(channel_id_, other->channel_id_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ChannelRemove::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void ChannelState::InitAsDefaultInstance() { +} +class ChannelState::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_channel_id(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_parent(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_name(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_description(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_temporary(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_position(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_description_hash(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_max_users(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } +}; + +ChannelState::ChannelState(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + links_(arena), + links_add_(arena), + links_remove_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:MumbleProto.ChannelState) +} +ChannelState::ChannelState(const ChannelState& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_), + links_(from.links_), + links_add_(from.links_add_), + links_remove_(from.links_remove_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_name()) { + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_name(), + GetArena()); + } + description_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_description()) { + description_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_description(), + GetArena()); + } + description_hash_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_description_hash()) { + description_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_description_hash(), + GetArena()); + } + ::memcpy(&channel_id_, &from.channel_id_, + static_cast(reinterpret_cast(&max_users_) - + reinterpret_cast(&channel_id_)) + sizeof(max_users_)); + // @@protoc_insertion_point(copy_constructor:MumbleProto.ChannelState) +} + +void ChannelState::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ChannelState_Mumble_2eproto.base); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + description_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + description_hash_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&channel_id_, 0, static_cast( + reinterpret_cast(&max_users_) - + reinterpret_cast(&channel_id_)) + sizeof(max_users_)); +} + +ChannelState::~ChannelState() { + // @@protoc_insertion_point(destructor:MumbleProto.ChannelState) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void ChannelState::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + description_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + description_hash_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ChannelState::ArenaDtor(void* object) { + ChannelState* _this = reinterpret_cast< ChannelState* >(object); + (void)_this; +} +void ChannelState::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ChannelState::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ChannelState& ChannelState::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ChannelState_Mumble_2eproto.base); + return *internal_default_instance(); +} + + +void ChannelState::Clear() { +// @@protoc_insertion_point(message_clear_start:MumbleProto.ChannelState) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + links_.Clear(); + links_add_.Clear(); + links_remove_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + name_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + description_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + description_hash_.ClearNonDefaultToEmpty(); + } + } + if (cached_has_bits & 0x000000f8u) { + ::memset(&channel_id_, 0, static_cast( + reinterpret_cast(&max_users_) - + reinterpret_cast(&channel_id_)) + sizeof(max_users_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ChannelState::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional uint32 channel_id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + _Internal::set_has_channel_id(&has_bits); + channel_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 parent = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + _Internal::set_has_parent(&has_bits); + parent_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string name = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + auto str = _internal_mutable_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MumbleProto.ChannelState.name"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated uint32 links = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_links(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<32>(ptr)); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_links(), ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string description = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + auto str = _internal_mutable_description(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MumbleProto.ChannelState.description"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated uint32 links_add = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_links_add(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<48>(ptr)); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_links_add(), ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated uint32 links_remove = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_links_remove(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<56>(ptr)); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_links_remove(), ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool temporary = 8 [default = false]; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) { + _Internal::set_has_temporary(&has_bits); + temporary_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional int32 position = 9 [default = 0]; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 72)) { + _Internal::set_has_position(&has_bits); + position_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bytes description_hash = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + auto str = _internal_mutable_description_hash(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 max_users = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 88)) { + _Internal::set_has_max_users(&has_bits); + max_users_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ChannelState::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MumbleProto.ChannelState) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional uint32 channel_id = 1; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_channel_id(), target); + } + + // optional uint32 parent = 2; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_parent(), target); + } + + // optional string name = 3; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_name().data(), static_cast(this->_internal_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "MumbleProto.ChannelState.name"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_name(), target); + } + + // repeated uint32 links = 4; + for (int i = 0, n = this->_internal_links_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_links(i), target); + } + + // optional string description = 5; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_description().data(), static_cast(this->_internal_description().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "MumbleProto.ChannelState.description"); + target = stream->WriteStringMaybeAliased( + 5, this->_internal_description(), target); + } + + // repeated uint32 links_add = 6; + for (int i = 0, n = this->_internal_links_add_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(6, this->_internal_links_add(i), target); + } + + // repeated uint32 links_remove = 7; + for (int i = 0, n = this->_internal_links_remove_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(7, this->_internal_links_remove(i), target); + } + + // optional bool temporary = 8 [default = false]; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(8, this->_internal_temporary(), target); + } + + // optional int32 position = 9 [default = 0]; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(9, this->_internal_position(), target); + } + + // optional bytes description_hash = 10; + if (cached_has_bits & 0x00000004u) { + target = stream->WriteBytesMaybeAliased( + 10, this->_internal_description_hash(), target); + } + + // optional uint32 max_users = 11; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(11, this->_internal_max_users(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MumbleProto.ChannelState) + return target; +} + +size_t ChannelState::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MumbleProto.ChannelState) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated uint32 links = 4; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + UInt32Size(this->links_); + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_links_size()); + total_size += data_size; + } + + // repeated uint32 links_add = 6; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + UInt32Size(this->links_add_); + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_links_add_size()); + total_size += data_size; + } + + // repeated uint32 links_remove = 7; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + UInt32Size(this->links_remove_); + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_links_remove_size()); + total_size += data_size; + } + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional string name = 3; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + // optional string description = 5; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_description()); + } + + // optional bytes description_hash = 10; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_description_hash()); + } + + // optional uint32 channel_id = 1; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_channel_id()); + } + + // optional uint32 parent = 2; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_parent()); + } + + // optional bool temporary = 8 [default = false]; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + 1; + } + + // optional int32 position = 9 [default = 0]; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_position()); + } + + // optional uint32 max_users = 11; + if (cached_has_bits & 0x00000080u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_max_users()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ChannelState::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:MumbleProto.ChannelState) + GOOGLE_DCHECK_NE(&from, this); + const ChannelState* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:MumbleProto.ChannelState) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:MumbleProto.ChannelState) + MergeFrom(*source); + } +} + +void ChannelState::MergeFrom(const ChannelState& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MumbleProto.ChannelState) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + links_.MergeFrom(from.links_); + links_add_.MergeFrom(from.links_add_); + links_remove_.MergeFrom(from.links_remove_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_name(from._internal_name()); + } + if (cached_has_bits & 0x00000002u) { + _internal_set_description(from._internal_description()); + } + if (cached_has_bits & 0x00000004u) { + _internal_set_description_hash(from._internal_description_hash()); + } + if (cached_has_bits & 0x00000008u) { + channel_id_ = from.channel_id_; + } + if (cached_has_bits & 0x00000010u) { + parent_ = from.parent_; + } + if (cached_has_bits & 0x00000020u) { + temporary_ = from.temporary_; + } + if (cached_has_bits & 0x00000040u) { + position_ = from.position_; + } + if (cached_has_bits & 0x00000080u) { + max_users_ = from.max_users_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void ChannelState::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:MumbleProto.ChannelState) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ChannelState::CopyFrom(const ChannelState& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MumbleProto.ChannelState) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ChannelState::IsInitialized() const { + return true; +} + +void ChannelState::InternalSwap(ChannelState* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + links_.InternalSwap(&other->links_); + links_add_.InternalSwap(&other->links_add_); + links_remove_.InternalSwap(&other->links_remove_); + name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + description_.Swap(&other->description_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + description_hash_.Swap(&other->description_hash_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ChannelState, max_users_) + + sizeof(ChannelState::max_users_) + - PROTOBUF_FIELD_OFFSET(ChannelState, channel_id_)>( + reinterpret_cast(&channel_id_), + reinterpret_cast(&other->channel_id_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ChannelState::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void UserRemove::InitAsDefaultInstance() { +} +class UserRemove::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_session(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_actor(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_reason(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_ban(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static bool MissingRequiredFields(const HasBits& has_bits) { + return ((has_bits[0] & 0x00000002) ^ 0x00000002) != 0; + } +}; + +UserRemove::UserRemove(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:MumbleProto.UserRemove) +} +UserRemove::UserRemove(const UserRemove& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + reason_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_reason()) { + reason_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_reason(), + GetArena()); + } + ::memcpy(&session_, &from.session_, + static_cast(reinterpret_cast(&ban_) - + reinterpret_cast(&session_)) + sizeof(ban_)); + // @@protoc_insertion_point(copy_constructor:MumbleProto.UserRemove) +} + +void UserRemove::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_UserRemove_Mumble_2eproto.base); + reason_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&session_, 0, static_cast( + reinterpret_cast(&ban_) - + reinterpret_cast(&session_)) + sizeof(ban_)); +} + +UserRemove::~UserRemove() { + // @@protoc_insertion_point(destructor:MumbleProto.UserRemove) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void UserRemove::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + reason_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void UserRemove::ArenaDtor(void* object) { + UserRemove* _this = reinterpret_cast< UserRemove* >(object); + (void)_this; +} +void UserRemove::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void UserRemove::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const UserRemove& UserRemove::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_UserRemove_Mumble_2eproto.base); + return *internal_default_instance(); +} + + +void UserRemove::Clear() { +// @@protoc_insertion_point(message_clear_start:MumbleProto.UserRemove) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + reason_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x0000000eu) { + ::memset(&session_, 0, static_cast( + reinterpret_cast(&ban_) - + reinterpret_cast(&session_)) + sizeof(ban_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* UserRemove::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // required uint32 session = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + _Internal::set_has_session(&has_bits); + session_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 actor = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + _Internal::set_has_actor(&has_bits); + actor_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string reason = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + auto str = _internal_mutable_reason(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MumbleProto.UserRemove.reason"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool ban = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + _Internal::set_has_ban(&has_bits); + ban_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* UserRemove::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MumbleProto.UserRemove) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // required uint32 session = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_session(), target); + } + + // optional uint32 actor = 2; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_actor(), target); + } + + // optional string reason = 3; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_reason().data(), static_cast(this->_internal_reason().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "MumbleProto.UserRemove.reason"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_reason(), target); + } + + // optional bool ban = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->_internal_ban(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MumbleProto.UserRemove) + return target; +} + +size_t UserRemove::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MumbleProto.UserRemove) + size_t total_size = 0; + + // required uint32 session = 1; + if (_internal_has_session()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_session()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional string reason = 3; + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_reason()); + } + + if (cached_has_bits & 0x0000000cu) { + // optional uint32 actor = 2; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_actor()); + } + + // optional bool ban = 4; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + 1; + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void UserRemove::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:MumbleProto.UserRemove) + GOOGLE_DCHECK_NE(&from, this); + const UserRemove* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:MumbleProto.UserRemove) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:MumbleProto.UserRemove) + MergeFrom(*source); + } +} + +void UserRemove::MergeFrom(const UserRemove& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MumbleProto.UserRemove) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_reason(from._internal_reason()); + } + if (cached_has_bits & 0x00000002u) { + session_ = from.session_; + } + if (cached_has_bits & 0x00000004u) { + actor_ = from.actor_; + } + if (cached_has_bits & 0x00000008u) { + ban_ = from.ban_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void UserRemove::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:MumbleProto.UserRemove) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void UserRemove::CopyFrom(const UserRemove& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MumbleProto.UserRemove) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool UserRemove::IsInitialized() const { + if (_Internal::MissingRequiredFields(_has_bits_)) return false; + return true; +} + +void UserRemove::InternalSwap(UserRemove* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + reason_.Swap(&other->reason_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(UserRemove, ban_) + + sizeof(UserRemove::ban_) + - PROTOBUF_FIELD_OFFSET(UserRemove, session_)>( + reinterpret_cast(&session_), + reinterpret_cast(&other->session_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata UserRemove::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void UserState::InitAsDefaultInstance() { +} +class UserState::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_session(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static void set_has_actor(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } + static void set_has_name(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_user_id(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } + static void set_has_channel_id(HasBits* has_bits) { + (*has_bits)[0] |= 2048u; + } + static void set_has_mute(HasBits* has_bits) { + (*has_bits)[0] |= 4096u; + } + static void set_has_deaf(HasBits* has_bits) { + (*has_bits)[0] |= 8192u; + } + static void set_has_suppress(HasBits* has_bits) { + (*has_bits)[0] |= 16384u; + } + static void set_has_self_mute(HasBits* has_bits) { + (*has_bits)[0] |= 32768u; + } + static void set_has_self_deaf(HasBits* has_bits) { + (*has_bits)[0] |= 65536u; + } + static void set_has_texture(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_plugin_context(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_plugin_identity(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_comment(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_hash(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_comment_hash(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_texture_hash(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static void set_has_priority_speaker(HasBits* has_bits) { + (*has_bits)[0] |= 131072u; + } + static void set_has_recording(HasBits* has_bits) { + (*has_bits)[0] |= 262144u; + } +}; + +UserState::UserState(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:MumbleProto.UserState) +} +UserState::UserState(const UserState& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_name()) { + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_name(), + GetArena()); + } + texture_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_texture()) { + texture_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_texture(), + GetArena()); + } + plugin_context_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_plugin_context()) { + plugin_context_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_plugin_context(), + GetArena()); + } + plugin_identity_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_plugin_identity()) { + plugin_identity_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_plugin_identity(), + GetArena()); + } + comment_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_comment()) { + comment_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_comment(), + GetArena()); + } + hash_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_hash()) { + hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_hash(), + GetArena()); + } + comment_hash_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_comment_hash()) { + comment_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_comment_hash(), + GetArena()); + } + texture_hash_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_texture_hash()) { + texture_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_texture_hash(), + GetArena()); + } + ::memcpy(&session_, &from.session_, + static_cast(reinterpret_cast(&recording_) - + reinterpret_cast(&session_)) + sizeof(recording_)); + // @@protoc_insertion_point(copy_constructor:MumbleProto.UserState) +} + +void UserState::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_UserState_Mumble_2eproto.base); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + texture_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + plugin_context_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + plugin_identity_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + comment_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + hash_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + comment_hash_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + texture_hash_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&session_, 0, static_cast( + reinterpret_cast(&recording_) - + reinterpret_cast(&session_)) + sizeof(recording_)); +} + +UserState::~UserState() { + // @@protoc_insertion_point(destructor:MumbleProto.UserState) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void UserState::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + texture_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + plugin_context_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + plugin_identity_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + comment_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + hash_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + comment_hash_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + texture_hash_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void UserState::ArenaDtor(void* object) { + UserState* _this = reinterpret_cast< UserState* >(object); + (void)_this; +} +void UserState::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void UserState::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const UserState& UserState::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_UserState_Mumble_2eproto.base); + return *internal_default_instance(); +} + + +void UserState::Clear() { +// @@protoc_insertion_point(message_clear_start:MumbleProto.UserState) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + name_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + texture_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + plugin_context_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + plugin_identity_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000010u) { + comment_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000020u) { + hash_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000040u) { + comment_hash_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000080u) { + texture_hash_.ClearNonDefaultToEmpty(); + } + } + if (cached_has_bits & 0x0000ff00u) { + ::memset(&session_, 0, static_cast( + reinterpret_cast(&self_mute_) - + reinterpret_cast(&session_)) + sizeof(self_mute_)); + } + if (cached_has_bits & 0x00070000u) { + ::memset(&self_deaf_, 0, static_cast( + reinterpret_cast(&recording_) - + reinterpret_cast(&self_deaf_)) + sizeof(recording_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* UserState::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional uint32 session = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + _Internal::set_has_session(&has_bits); + session_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 actor = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + _Internal::set_has_actor(&has_bits); + actor_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string name = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + auto str = _internal_mutable_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MumbleProto.UserState.name"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 user_id = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + _Internal::set_has_user_id(&has_bits); + user_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 channel_id = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) { + _Internal::set_has_channel_id(&has_bits); + channel_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool mute = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) { + _Internal::set_has_mute(&has_bits); + mute_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool deaf = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) { + _Internal::set_has_deaf(&has_bits); + deaf_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool suppress = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) { + _Internal::set_has_suppress(&has_bits); + suppress_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool self_mute = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 72)) { + _Internal::set_has_self_mute(&has_bits); + self_mute_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool self_deaf = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 80)) { + _Internal::set_has_self_deaf(&has_bits); + self_deaf_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bytes texture = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) { + auto str = _internal_mutable_texture(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bytes plugin_context = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 98)) { + auto str = _internal_mutable_plugin_context(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string plugin_identity = 13; + case 13: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) { + auto str = _internal_mutable_plugin_identity(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MumbleProto.UserState.plugin_identity"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string comment = 14; + case 14: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 114)) { + auto str = _internal_mutable_comment(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MumbleProto.UserState.comment"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string hash = 15; + case 15: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 122)) { + auto str = _internal_mutable_hash(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MumbleProto.UserState.hash"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bytes comment_hash = 16; + case 16: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 130)) { + auto str = _internal_mutable_comment_hash(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bytes texture_hash = 17; + case 17: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 138)) { + auto str = _internal_mutable_texture_hash(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool priority_speaker = 18; + case 18: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 144)) { + _Internal::set_has_priority_speaker(&has_bits); + priority_speaker_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool recording = 19; + case 19: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 152)) { + _Internal::set_has_recording(&has_bits); + recording_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* UserState::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MumbleProto.UserState) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional uint32 session = 1; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_session(), target); + } + + // optional uint32 actor = 2; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_actor(), target); + } + + // optional string name = 3; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_name().data(), static_cast(this->_internal_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "MumbleProto.UserState.name"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_name(), target); + } + + // optional uint32 user_id = 4; + if (cached_has_bits & 0x00000400u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_user_id(), target); + } + + // optional uint32 channel_id = 5; + if (cached_has_bits & 0x00000800u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(5, this->_internal_channel_id(), target); + } + + // optional bool mute = 6; + if (cached_has_bits & 0x00001000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(6, this->_internal_mute(), target); + } + + // optional bool deaf = 7; + if (cached_has_bits & 0x00002000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(7, this->_internal_deaf(), target); + } + + // optional bool suppress = 8; + if (cached_has_bits & 0x00004000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(8, this->_internal_suppress(), target); + } + + // optional bool self_mute = 9; + if (cached_has_bits & 0x00008000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(9, this->_internal_self_mute(), target); + } + + // optional bool self_deaf = 10; + if (cached_has_bits & 0x00010000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(10, this->_internal_self_deaf(), target); + } + + // optional bytes texture = 11; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 11, this->_internal_texture(), target); + } + + // optional bytes plugin_context = 12; + if (cached_has_bits & 0x00000004u) { + target = stream->WriteBytesMaybeAliased( + 12, this->_internal_plugin_context(), target); + } + + // optional string plugin_identity = 13; + if (cached_has_bits & 0x00000008u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_plugin_identity().data(), static_cast(this->_internal_plugin_identity().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "MumbleProto.UserState.plugin_identity"); + target = stream->WriteStringMaybeAliased( + 13, this->_internal_plugin_identity(), target); + } + + // optional string comment = 14; + if (cached_has_bits & 0x00000010u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_comment().data(), static_cast(this->_internal_comment().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "MumbleProto.UserState.comment"); + target = stream->WriteStringMaybeAliased( + 14, this->_internal_comment(), target); + } + + // optional string hash = 15; + if (cached_has_bits & 0x00000020u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_hash().data(), static_cast(this->_internal_hash().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "MumbleProto.UserState.hash"); + target = stream->WriteStringMaybeAliased( + 15, this->_internal_hash(), target); + } + + // optional bytes comment_hash = 16; + if (cached_has_bits & 0x00000040u) { + target = stream->WriteBytesMaybeAliased( + 16, this->_internal_comment_hash(), target); + } + + // optional bytes texture_hash = 17; + if (cached_has_bits & 0x00000080u) { + target = stream->WriteBytesMaybeAliased( + 17, this->_internal_texture_hash(), target); + } + + // optional bool priority_speaker = 18; + if (cached_has_bits & 0x00020000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(18, this->_internal_priority_speaker(), target); + } + + // optional bool recording = 19; + if (cached_has_bits & 0x00040000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(19, this->_internal_recording(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MumbleProto.UserState) + return target; +} + +size_t UserState::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MumbleProto.UserState) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional string name = 3; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + // optional bytes texture = 11; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_texture()); + } + + // optional bytes plugin_context = 12; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_plugin_context()); + } + + // optional string plugin_identity = 13; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_plugin_identity()); + } + + // optional string comment = 14; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_comment()); + } + + // optional string hash = 15; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_hash()); + } + + // optional bytes comment_hash = 16; + if (cached_has_bits & 0x00000040u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_comment_hash()); + } + + // optional bytes texture_hash = 17; + if (cached_has_bits & 0x00000080u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_texture_hash()); + } + + } + if (cached_has_bits & 0x0000ff00u) { + // optional uint32 session = 1; + if (cached_has_bits & 0x00000100u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_session()); + } + + // optional uint32 actor = 2; + if (cached_has_bits & 0x00000200u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_actor()); + } + + // optional uint32 user_id = 4; + if (cached_has_bits & 0x00000400u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_user_id()); + } + + // optional uint32 channel_id = 5; + if (cached_has_bits & 0x00000800u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_channel_id()); + } + + // optional bool mute = 6; + if (cached_has_bits & 0x00001000u) { + total_size += 1 + 1; + } + + // optional bool deaf = 7; + if (cached_has_bits & 0x00002000u) { + total_size += 1 + 1; + } + + // optional bool suppress = 8; + if (cached_has_bits & 0x00004000u) { + total_size += 1 + 1; + } + + // optional bool self_mute = 9; + if (cached_has_bits & 0x00008000u) { + total_size += 1 + 1; + } + + } + if (cached_has_bits & 0x00070000u) { + // optional bool self_deaf = 10; + if (cached_has_bits & 0x00010000u) { + total_size += 1 + 1; + } + + // optional bool priority_speaker = 18; + if (cached_has_bits & 0x00020000u) { + total_size += 2 + 1; + } + + // optional bool recording = 19; + if (cached_has_bits & 0x00040000u) { + total_size += 2 + 1; + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void UserState::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:MumbleProto.UserState) + GOOGLE_DCHECK_NE(&from, this); + const UserState* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:MumbleProto.UserState) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:MumbleProto.UserState) + MergeFrom(*source); + } +} + +void UserState::MergeFrom(const UserState& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MumbleProto.UserState) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_name(from._internal_name()); + } + if (cached_has_bits & 0x00000002u) { + _internal_set_texture(from._internal_texture()); + } + if (cached_has_bits & 0x00000004u) { + _internal_set_plugin_context(from._internal_plugin_context()); + } + if (cached_has_bits & 0x00000008u) { + _internal_set_plugin_identity(from._internal_plugin_identity()); + } + if (cached_has_bits & 0x00000010u) { + _internal_set_comment(from._internal_comment()); + } + if (cached_has_bits & 0x00000020u) { + _internal_set_hash(from._internal_hash()); + } + if (cached_has_bits & 0x00000040u) { + _internal_set_comment_hash(from._internal_comment_hash()); + } + if (cached_has_bits & 0x00000080u) { + _internal_set_texture_hash(from._internal_texture_hash()); + } + } + if (cached_has_bits & 0x0000ff00u) { + if (cached_has_bits & 0x00000100u) { + session_ = from.session_; + } + if (cached_has_bits & 0x00000200u) { + actor_ = from.actor_; + } + if (cached_has_bits & 0x00000400u) { + user_id_ = from.user_id_; + } + if (cached_has_bits & 0x00000800u) { + channel_id_ = from.channel_id_; + } + if (cached_has_bits & 0x00001000u) { + mute_ = from.mute_; + } + if (cached_has_bits & 0x00002000u) { + deaf_ = from.deaf_; + } + if (cached_has_bits & 0x00004000u) { + suppress_ = from.suppress_; + } + if (cached_has_bits & 0x00008000u) { + self_mute_ = from.self_mute_; + } + _has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x00070000u) { + if (cached_has_bits & 0x00010000u) { + self_deaf_ = from.self_deaf_; + } + if (cached_has_bits & 0x00020000u) { + priority_speaker_ = from.priority_speaker_; + } + if (cached_has_bits & 0x00040000u) { + recording_ = from.recording_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void UserState::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:MumbleProto.UserState) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void UserState::CopyFrom(const UserState& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MumbleProto.UserState) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool UserState::IsInitialized() const { + return true; +} + +void UserState::InternalSwap(UserState* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + texture_.Swap(&other->texture_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + plugin_context_.Swap(&other->plugin_context_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + plugin_identity_.Swap(&other->plugin_identity_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + comment_.Swap(&other->comment_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + hash_.Swap(&other->hash_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + comment_hash_.Swap(&other->comment_hash_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + texture_hash_.Swap(&other->texture_hash_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(UserState, recording_) + + sizeof(UserState::recording_) + - PROTOBUF_FIELD_OFFSET(UserState, session_)>( + reinterpret_cast(&session_), + reinterpret_cast(&other->session_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata UserState::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void BanList_BanEntry::InitAsDefaultInstance() { +} +class BanList_BanEntry::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_address(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_mask(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_name(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_hash(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_reason(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_start(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_duration(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static bool MissingRequiredFields(const HasBits& has_bits) { + return ((has_bits[0] & 0x00000021) ^ 0x00000021) != 0; + } +}; + +BanList_BanEntry::BanList_BanEntry(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:MumbleProto.BanList.BanEntry) +} +BanList_BanEntry::BanList_BanEntry(const BanList_BanEntry& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + address_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_address()) { + address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_address(), + GetArena()); + } + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_name()) { + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_name(), + GetArena()); + } + hash_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_hash()) { + hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_hash(), + GetArena()); + } + reason_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_reason()) { + reason_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_reason(), + GetArena()); + } + start_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_start()) { + start_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_start(), + GetArena()); + } + ::memcpy(&mask_, &from.mask_, + static_cast(reinterpret_cast(&duration_) - + reinterpret_cast(&mask_)) + sizeof(duration_)); + // @@protoc_insertion_point(copy_constructor:MumbleProto.BanList.BanEntry) +} + +void BanList_BanEntry::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_BanList_BanEntry_Mumble_2eproto.base); + address_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + hash_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + reason_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + start_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&mask_, 0, static_cast( + reinterpret_cast(&duration_) - + reinterpret_cast(&mask_)) + sizeof(duration_)); +} + +BanList_BanEntry::~BanList_BanEntry() { + // @@protoc_insertion_point(destructor:MumbleProto.BanList.BanEntry) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void BanList_BanEntry::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + address_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + hash_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + reason_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + start_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void BanList_BanEntry::ArenaDtor(void* object) { + BanList_BanEntry* _this = reinterpret_cast< BanList_BanEntry* >(object); + (void)_this; +} +void BanList_BanEntry::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void BanList_BanEntry::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const BanList_BanEntry& BanList_BanEntry::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_BanList_BanEntry_Mumble_2eproto.base); + return *internal_default_instance(); +} + + +void BanList_BanEntry::Clear() { +// @@protoc_insertion_point(message_clear_start:MumbleProto.BanList.BanEntry) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + address_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + name_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + hash_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + reason_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000010u) { + start_.ClearNonDefaultToEmpty(); + } + } + if (cached_has_bits & 0x00000060u) { + ::memset(&mask_, 0, static_cast( + reinterpret_cast(&duration_) - + reinterpret_cast(&mask_)) + sizeof(duration_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* BanList_BanEntry::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // required bytes address = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_address(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // required uint32 mask = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + _Internal::set_has_mask(&has_bits); + mask_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string name = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + auto str = _internal_mutable_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MumbleProto.BanList.BanEntry.name"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string hash = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + auto str = _internal_mutable_hash(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MumbleProto.BanList.BanEntry.hash"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string reason = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + auto str = _internal_mutable_reason(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MumbleProto.BanList.BanEntry.reason"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string start = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) { + auto str = _internal_mutable_start(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MumbleProto.BanList.BanEntry.start"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 duration = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) { + _Internal::set_has_duration(&has_bits); + duration_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* BanList_BanEntry::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MumbleProto.BanList.BanEntry) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // required bytes address = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_address(), target); + } + + // required uint32 mask = 2; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_mask(), target); + } + + // optional string name = 3; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_name().data(), static_cast(this->_internal_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "MumbleProto.BanList.BanEntry.name"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_name(), target); + } + + // optional string hash = 4; + if (cached_has_bits & 0x00000004u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_hash().data(), static_cast(this->_internal_hash().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "MumbleProto.BanList.BanEntry.hash"); + target = stream->WriteStringMaybeAliased( + 4, this->_internal_hash(), target); + } + + // optional string reason = 5; + if (cached_has_bits & 0x00000008u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_reason().data(), static_cast(this->_internal_reason().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "MumbleProto.BanList.BanEntry.reason"); + target = stream->WriteStringMaybeAliased( + 5, this->_internal_reason(), target); + } + + // optional string start = 6; + if (cached_has_bits & 0x00000010u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_start().data(), static_cast(this->_internal_start().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "MumbleProto.BanList.BanEntry.start"); + target = stream->WriteStringMaybeAliased( + 6, this->_internal_start(), target); + } + + // optional uint32 duration = 7; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(7, this->_internal_duration(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MumbleProto.BanList.BanEntry) + return target; +} + +size_t BanList_BanEntry::RequiredFieldsByteSizeFallback() const { +// @@protoc_insertion_point(required_fields_byte_size_fallback_start:MumbleProto.BanList.BanEntry) + size_t total_size = 0; + + if (_internal_has_address()) { + // required bytes address = 1; + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_address()); + } + + if (_internal_has_mask()) { + // required uint32 mask = 2; + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_mask()); + } + + return total_size; +} +size_t BanList_BanEntry::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MumbleProto.BanList.BanEntry) + size_t total_size = 0; + + if (((_has_bits_[0] & 0x00000021) ^ 0x00000021) == 0) { // All required fields are present. + // required bytes address = 1; + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_address()); + + // required uint32 mask = 2; + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_mask()); + + } else { + total_size += RequiredFieldsByteSizeFallback(); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000001eu) { + // optional string name = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + // optional string hash = 4; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_hash()); + } + + // optional string reason = 5; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_reason()); + } + + // optional string start = 6; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_start()); + } + + } + // optional uint32 duration = 7; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_duration()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void BanList_BanEntry::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:MumbleProto.BanList.BanEntry) + GOOGLE_DCHECK_NE(&from, this); + const BanList_BanEntry* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:MumbleProto.BanList.BanEntry) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:MumbleProto.BanList.BanEntry) + MergeFrom(*source); + } +} + +void BanList_BanEntry::MergeFrom(const BanList_BanEntry& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MumbleProto.BanList.BanEntry) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000007fu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_address(from._internal_address()); + } + if (cached_has_bits & 0x00000002u) { + _internal_set_name(from._internal_name()); + } + if (cached_has_bits & 0x00000004u) { + _internal_set_hash(from._internal_hash()); + } + if (cached_has_bits & 0x00000008u) { + _internal_set_reason(from._internal_reason()); + } + if (cached_has_bits & 0x00000010u) { + _internal_set_start(from._internal_start()); + } + if (cached_has_bits & 0x00000020u) { + mask_ = from.mask_; + } + if (cached_has_bits & 0x00000040u) { + duration_ = from.duration_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void BanList_BanEntry::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:MumbleProto.BanList.BanEntry) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void BanList_BanEntry::CopyFrom(const BanList_BanEntry& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MumbleProto.BanList.BanEntry) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool BanList_BanEntry::IsInitialized() const { + if (_Internal::MissingRequiredFields(_has_bits_)) return false; + return true; +} + +void BanList_BanEntry::InternalSwap(BanList_BanEntry* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + address_.Swap(&other->address_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + hash_.Swap(&other->hash_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + reason_.Swap(&other->reason_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + start_.Swap(&other->start_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(BanList_BanEntry, duration_) + + sizeof(BanList_BanEntry::duration_) + - PROTOBUF_FIELD_OFFSET(BanList_BanEntry, mask_)>( + reinterpret_cast(&mask_), + reinterpret_cast(&other->mask_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata BanList_BanEntry::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void BanList::InitAsDefaultInstance() { +} +class BanList::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_query(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +BanList::BanList(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + bans_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:MumbleProto.BanList) +} +BanList::BanList(const BanList& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_), + bans_(from.bans_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + query_ = from.query_; + // @@protoc_insertion_point(copy_constructor:MumbleProto.BanList) +} + +void BanList::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_BanList_Mumble_2eproto.base); + query_ = false; +} + +BanList::~BanList() { + // @@protoc_insertion_point(destructor:MumbleProto.BanList) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void BanList::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void BanList::ArenaDtor(void* object) { + BanList* _this = reinterpret_cast< BanList* >(object); + (void)_this; +} +void BanList::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void BanList::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const BanList& BanList::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_BanList_Mumble_2eproto.base); + return *internal_default_instance(); +} + + +void BanList::Clear() { +// @@protoc_insertion_point(message_clear_start:MumbleProto.BanList) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + bans_.Clear(); + query_ = false; + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* BanList::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // repeated .MumbleProto.BanList.BanEntry bans = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_bans(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else goto handle_unusual; + continue; + // optional bool query = 2 [default = false]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + _Internal::set_has_query(&has_bits); + query_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* BanList::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MumbleProto.BanList) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .MumbleProto.BanList.BanEntry bans = 1; + for (unsigned int i = 0, + n = static_cast(this->_internal_bans_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, this->_internal_bans(i), target, stream); + } + + cached_has_bits = _has_bits_[0]; + // optional bool query = 2 [default = false]; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_query(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MumbleProto.BanList) + return target; +} + +size_t BanList::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MumbleProto.BanList) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .MumbleProto.BanList.BanEntry bans = 1; + total_size += 1UL * this->_internal_bans_size(); + for (const auto& msg : this->bans_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // optional bool query = 2 [default = false]; + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + 1; + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void BanList::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:MumbleProto.BanList) + GOOGLE_DCHECK_NE(&from, this); + const BanList* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:MumbleProto.BanList) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:MumbleProto.BanList) + MergeFrom(*source); + } +} + +void BanList::MergeFrom(const BanList& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MumbleProto.BanList) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + bans_.MergeFrom(from.bans_); + if (from._internal_has_query()) { + _internal_set_query(from._internal_query()); + } +} + +void BanList::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:MumbleProto.BanList) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void BanList::CopyFrom(const BanList& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MumbleProto.BanList) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool BanList::IsInitialized() const { + if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(bans_)) return false; + return true; +} + +void BanList::InternalSwap(BanList* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + bans_.InternalSwap(&other->bans_); + swap(query_, other->query_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata BanList::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void TextMessage::InitAsDefaultInstance() { +} +class TextMessage::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_actor(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_message(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static bool MissingRequiredFields(const HasBits& has_bits) { + return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0; + } +}; + +TextMessage::TextMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + session_(arena), + channel_id_(arena), + tree_id_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:MumbleProto.TextMessage) +} +TextMessage::TextMessage(const TextMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_), + session_(from.session_), + channel_id_(from.channel_id_), + tree_id_(from.tree_id_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + message_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_message()) { + message_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_message(), + GetArena()); + } + actor_ = from.actor_; + // @@protoc_insertion_point(copy_constructor:MumbleProto.TextMessage) +} + +void TextMessage::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TextMessage_Mumble_2eproto.base); + message_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + actor_ = 0u; +} + +TextMessage::~TextMessage() { + // @@protoc_insertion_point(destructor:MumbleProto.TextMessage) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void TextMessage::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + message_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void TextMessage::ArenaDtor(void* object) { + TextMessage* _this = reinterpret_cast< TextMessage* >(object); + (void)_this; +} +void TextMessage::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void TextMessage::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const TextMessage& TextMessage::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TextMessage_Mumble_2eproto.base); + return *internal_default_instance(); +} + + +void TextMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:MumbleProto.TextMessage) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + session_.Clear(); + channel_id_.Clear(); + tree_id_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + message_.ClearNonDefaultToEmpty(); + } + actor_ = 0u; + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* TextMessage::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional uint32 actor = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + _Internal::set_has_actor(&has_bits); + actor_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated uint32 session = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_session(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<16>(ptr)); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_session(), ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated uint32 channel_id = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_channel_id(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<24>(ptr)); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_channel_id(), ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated uint32 tree_id = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_tree_id(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<32>(ptr)); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_tree_id(), ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // required string message = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + auto str = _internal_mutable_message(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MumbleProto.TextMessage.message"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* TextMessage::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MumbleProto.TextMessage) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional uint32 actor = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_actor(), target); + } + + // repeated uint32 session = 2; + for (int i = 0, n = this->_internal_session_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_session(i), target); + } + + // repeated uint32 channel_id = 3; + for (int i = 0, n = this->_internal_channel_id_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_channel_id(i), target); + } + + // repeated uint32 tree_id = 4; + for (int i = 0, n = this->_internal_tree_id_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_tree_id(i), target); + } + + // required string message = 5; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_message().data(), static_cast(this->_internal_message().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "MumbleProto.TextMessage.message"); + target = stream->WriteStringMaybeAliased( + 5, this->_internal_message(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MumbleProto.TextMessage) + return target; +} + +size_t TextMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MumbleProto.TextMessage) + size_t total_size = 0; + + // required string message = 5; + if (_internal_has_message()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_message()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated uint32 session = 2; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + UInt32Size(this->session_); + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_session_size()); + total_size += data_size; + } + + // repeated uint32 channel_id = 3; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + UInt32Size(this->channel_id_); + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_channel_id_size()); + total_size += data_size; + } + + // repeated uint32 tree_id = 4; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + UInt32Size(this->tree_id_); + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_tree_id_size()); + total_size += data_size; + } + + // optional uint32 actor = 1; + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_actor()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void TextMessage::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:MumbleProto.TextMessage) + GOOGLE_DCHECK_NE(&from, this); + const TextMessage* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:MumbleProto.TextMessage) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:MumbleProto.TextMessage) + MergeFrom(*source); + } +} + +void TextMessage::MergeFrom(const TextMessage& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MumbleProto.TextMessage) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + session_.MergeFrom(from.session_); + channel_id_.MergeFrom(from.channel_id_); + tree_id_.MergeFrom(from.tree_id_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _internal_set_message(from._internal_message()); + } + if (cached_has_bits & 0x00000002u) { + actor_ = from.actor_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void TextMessage::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:MumbleProto.TextMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void TextMessage::CopyFrom(const TextMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MumbleProto.TextMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool TextMessage::IsInitialized() const { + if (_Internal::MissingRequiredFields(_has_bits_)) return false; + return true; +} + +void TextMessage::InternalSwap(TextMessage* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + session_.InternalSwap(&other->session_); + channel_id_.InternalSwap(&other->channel_id_); + tree_id_.InternalSwap(&other->tree_id_); + message_.Swap(&other->message_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + swap(actor_, other->actor_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata TextMessage::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void PermissionDenied::InitAsDefaultInstance() { +} +class PermissionDenied::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_permission(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_channel_id(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_session(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_reason(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_type(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_name(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +PermissionDenied::PermissionDenied(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:MumbleProto.PermissionDenied) +} +PermissionDenied::PermissionDenied(const PermissionDenied& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + reason_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_reason()) { + reason_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_reason(), + GetArena()); + } + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_name()) { + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_name(), + GetArena()); + } + ::memcpy(&permission_, &from.permission_, + static_cast(reinterpret_cast(&type_) - + reinterpret_cast(&permission_)) + sizeof(type_)); + // @@protoc_insertion_point(copy_constructor:MumbleProto.PermissionDenied) +} + +void PermissionDenied::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_PermissionDenied_Mumble_2eproto.base); + reason_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&permission_, 0, static_cast( + reinterpret_cast(&type_) - + reinterpret_cast(&permission_)) + sizeof(type_)); +} + +PermissionDenied::~PermissionDenied() { + // @@protoc_insertion_point(destructor:MumbleProto.PermissionDenied) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void PermissionDenied::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + reason_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void PermissionDenied::ArenaDtor(void* object) { + PermissionDenied* _this = reinterpret_cast< PermissionDenied* >(object); + (void)_this; +} +void PermissionDenied::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void PermissionDenied::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const PermissionDenied& PermissionDenied::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_PermissionDenied_Mumble_2eproto.base); + return *internal_default_instance(); +} + + +void PermissionDenied::Clear() { +// @@protoc_insertion_point(message_clear_start:MumbleProto.PermissionDenied) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + reason_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + name_.ClearNonDefaultToEmpty(); + } + } + if (cached_has_bits & 0x0000003cu) { + ::memset(&permission_, 0, static_cast( + reinterpret_cast(&type_) - + reinterpret_cast(&permission_)) + sizeof(type_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* PermissionDenied::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional uint32 permission = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + _Internal::set_has_permission(&has_bits); + permission_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 channel_id = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + _Internal::set_has_channel_id(&has_bits); + channel_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 session = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + _Internal::set_has_session(&has_bits); + session_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string reason = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + auto str = _internal_mutable_reason(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MumbleProto.PermissionDenied.reason"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional .MumbleProto.PermissionDenied.DenyType type = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::MumbleProto::PermissionDenied_DenyType_IsValid(val))) { + _internal_set_type(static_cast<::MumbleProto::PermissionDenied_DenyType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(5, val, mutable_unknown_fields()); + } + } else goto handle_unusual; + continue; + // optional string name = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) { + auto str = _internal_mutable_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MumbleProto.PermissionDenied.name"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* PermissionDenied::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MumbleProto.PermissionDenied) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional uint32 permission = 1; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_permission(), target); + } + + // optional uint32 channel_id = 2; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_channel_id(), target); + } + + // optional uint32 session = 3; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_session(), target); + } + + // optional string reason = 4; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_reason().data(), static_cast(this->_internal_reason().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "MumbleProto.PermissionDenied.reason"); + target = stream->WriteStringMaybeAliased( + 4, this->_internal_reason(), target); + } + + // optional .MumbleProto.PermissionDenied.DenyType type = 5; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 5, this->_internal_type(), target); + } + + // optional string name = 6; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_name().data(), static_cast(this->_internal_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "MumbleProto.PermissionDenied.name"); + target = stream->WriteStringMaybeAliased( + 6, this->_internal_name(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MumbleProto.PermissionDenied) + return target; +} + +size_t PermissionDenied::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MumbleProto.PermissionDenied) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + // optional string reason = 4; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_reason()); + } + + // optional string name = 6; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + // optional uint32 permission = 1; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_permission()); + } + + // optional uint32 channel_id = 2; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_channel_id()); + } + + // optional uint32 session = 3; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_session()); + } + + // optional .MumbleProto.PermissionDenied.DenyType type = 5; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void PermissionDenied::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:MumbleProto.PermissionDenied) + GOOGLE_DCHECK_NE(&from, this); + const PermissionDenied* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:MumbleProto.PermissionDenied) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:MumbleProto.PermissionDenied) + MergeFrom(*source); + } +} + +void PermissionDenied::MergeFrom(const PermissionDenied& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MumbleProto.PermissionDenied) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_reason(from._internal_reason()); + } + if (cached_has_bits & 0x00000002u) { + _internal_set_name(from._internal_name()); + } + if (cached_has_bits & 0x00000004u) { + permission_ = from.permission_; + } + if (cached_has_bits & 0x00000008u) { + channel_id_ = from.channel_id_; + } + if (cached_has_bits & 0x00000010u) { + session_ = from.session_; + } + if (cached_has_bits & 0x00000020u) { + type_ = from.type_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void PermissionDenied::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:MumbleProto.PermissionDenied) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void PermissionDenied::CopyFrom(const PermissionDenied& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MumbleProto.PermissionDenied) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PermissionDenied::IsInitialized() const { + return true; +} + +void PermissionDenied::InternalSwap(PermissionDenied* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + reason_.Swap(&other->reason_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(PermissionDenied, type_) + + sizeof(PermissionDenied::type_) + - PROTOBUF_FIELD_OFFSET(PermissionDenied, permission_)>( + reinterpret_cast(&permission_), + reinterpret_cast(&other->permission_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata PermissionDenied::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void ACL_ChanGroup::InitAsDefaultInstance() { +} +class ACL_ChanGroup::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_name(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_inherited(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_inherit(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_inheritable(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static bool MissingRequiredFields(const HasBits& has_bits) { + return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0; + } +}; + +ACL_ChanGroup::ACL_ChanGroup(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + add_(arena), + remove_(arena), + inherited_members_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:MumbleProto.ACL.ChanGroup) +} +ACL_ChanGroup::ACL_ChanGroup(const ACL_ChanGroup& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_), + add_(from.add_), + remove_(from.remove_), + inherited_members_(from.inherited_members_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_name()) { + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_name(), + GetArena()); + } + ::memcpy(&inherited_, &from.inherited_, + static_cast(reinterpret_cast(&inheritable_) - + reinterpret_cast(&inherited_)) + sizeof(inheritable_)); + // @@protoc_insertion_point(copy_constructor:MumbleProto.ACL.ChanGroup) +} + +void ACL_ChanGroup::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ACL_ChanGroup_Mumble_2eproto.base); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + inherited_ = true; + inherit_ = true; + inheritable_ = true; +} + +ACL_ChanGroup::~ACL_ChanGroup() { + // @@protoc_insertion_point(destructor:MumbleProto.ACL.ChanGroup) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void ACL_ChanGroup::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ACL_ChanGroup::ArenaDtor(void* object) { + ACL_ChanGroup* _this = reinterpret_cast< ACL_ChanGroup* >(object); + (void)_this; +} +void ACL_ChanGroup::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ACL_ChanGroup::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ACL_ChanGroup& ACL_ChanGroup::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ACL_ChanGroup_Mumble_2eproto.base); + return *internal_default_instance(); +} + + +void ACL_ChanGroup::Clear() { +// @@protoc_insertion_point(message_clear_start:MumbleProto.ACL.ChanGroup) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + add_.Clear(); + remove_.Clear(); + inherited_members_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + name_.ClearNonDefaultToEmpty(); + } + inherited_ = true; + inherit_ = true; + inheritable_ = true; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ACL_ChanGroup::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // required string name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MumbleProto.ACL.ChanGroup.name"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool inherited = 2 [default = true]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + _Internal::set_has_inherited(&has_bits); + inherited_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool inherit = 3 [default = true]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + _Internal::set_has_inherit(&has_bits); + inherit_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool inheritable = 4 [default = true]; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + _Internal::set_has_inheritable(&has_bits); + inheritable_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated uint32 add = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_add(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<40>(ptr)); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_add(), ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated uint32 remove = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_remove(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<48>(ptr)); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_remove(), ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated uint32 inherited_members = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_inherited_members(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<56>(ptr)); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_inherited_members(), ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ACL_ChanGroup::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MumbleProto.ACL.ChanGroup) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // required string name = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_name().data(), static_cast(this->_internal_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "MumbleProto.ACL.ChanGroup.name"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_name(), target); + } + + // optional bool inherited = 2 [default = true]; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_inherited(), target); + } + + // optional bool inherit = 3 [default = true]; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->_internal_inherit(), target); + } + + // optional bool inheritable = 4 [default = true]; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->_internal_inheritable(), target); + } + + // repeated uint32 add = 5; + for (int i = 0, n = this->_internal_add_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(5, this->_internal_add(i), target); + } + + // repeated uint32 remove = 6; + for (int i = 0, n = this->_internal_remove_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(6, this->_internal_remove(i), target); + } + + // repeated uint32 inherited_members = 7; + for (int i = 0, n = this->_internal_inherited_members_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(7, this->_internal_inherited_members(i), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MumbleProto.ACL.ChanGroup) + return target; +} + +size_t ACL_ChanGroup::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MumbleProto.ACL.ChanGroup) + size_t total_size = 0; + + // required string name = 1; + if (_internal_has_name()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated uint32 add = 5; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + UInt32Size(this->add_); + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_add_size()); + total_size += data_size; + } + + // repeated uint32 remove = 6; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + UInt32Size(this->remove_); + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_remove_size()); + total_size += data_size; + } + + // repeated uint32 inherited_members = 7; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + UInt32Size(this->inherited_members_); + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_inherited_members_size()); + total_size += data_size; + } + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000000eu) { + // optional bool inherited = 2 [default = true]; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + 1; + } + + // optional bool inherit = 3 [default = true]; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + 1; + } + + // optional bool inheritable = 4 [default = true]; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + 1; + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ACL_ChanGroup::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:MumbleProto.ACL.ChanGroup) + GOOGLE_DCHECK_NE(&from, this); + const ACL_ChanGroup* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:MumbleProto.ACL.ChanGroup) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:MumbleProto.ACL.ChanGroup) + MergeFrom(*source); + } +} + +void ACL_ChanGroup::MergeFrom(const ACL_ChanGroup& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MumbleProto.ACL.ChanGroup) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + add_.MergeFrom(from.add_); + remove_.MergeFrom(from.remove_); + inherited_members_.MergeFrom(from.inherited_members_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_name(from._internal_name()); + } + if (cached_has_bits & 0x00000002u) { + inherited_ = from.inherited_; + } + if (cached_has_bits & 0x00000004u) { + inherit_ = from.inherit_; + } + if (cached_has_bits & 0x00000008u) { + inheritable_ = from.inheritable_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void ACL_ChanGroup::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:MumbleProto.ACL.ChanGroup) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ACL_ChanGroup::CopyFrom(const ACL_ChanGroup& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MumbleProto.ACL.ChanGroup) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ACL_ChanGroup::IsInitialized() const { + if (_Internal::MissingRequiredFields(_has_bits_)) return false; + return true; +} + +void ACL_ChanGroup::InternalSwap(ACL_ChanGroup* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + add_.InternalSwap(&other->add_); + remove_.InternalSwap(&other->remove_); + inherited_members_.InternalSwap(&other->inherited_members_); + name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + swap(inherited_, other->inherited_); + swap(inherit_, other->inherit_); + swap(inheritable_, other->inheritable_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ACL_ChanGroup::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void ACL_ChanACL::InitAsDefaultInstance() { +} +class ACL_ChanACL::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_apply_here(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_apply_subs(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_inherited(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_user_id(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_group(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_grant(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_deny(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } +}; + +ACL_ChanACL::ACL_ChanACL(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:MumbleProto.ACL.ChanACL) +} +ACL_ChanACL::ACL_ChanACL(const ACL_ChanACL& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + group_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_group()) { + group_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_group(), + GetArena()); + } + ::memcpy(&user_id_, &from.user_id_, + static_cast(reinterpret_cast(&inherited_) - + reinterpret_cast(&user_id_)) + sizeof(inherited_)); + // @@protoc_insertion_point(copy_constructor:MumbleProto.ACL.ChanACL) +} + +void ACL_ChanACL::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ACL_ChanACL_Mumble_2eproto.base); + group_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&user_id_, 0, static_cast( + reinterpret_cast(&deny_) - + reinterpret_cast(&user_id_)) + sizeof(deny_)); + apply_here_ = true; + apply_subs_ = true; + inherited_ = true; +} + +ACL_ChanACL::~ACL_ChanACL() { + // @@protoc_insertion_point(destructor:MumbleProto.ACL.ChanACL) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void ACL_ChanACL::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + group_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ACL_ChanACL::ArenaDtor(void* object) { + ACL_ChanACL* _this = reinterpret_cast< ACL_ChanACL* >(object); + (void)_this; +} +void ACL_ChanACL::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ACL_ChanACL::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ACL_ChanACL& ACL_ChanACL::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ACL_ChanACL_Mumble_2eproto.base); + return *internal_default_instance(); +} + + +void ACL_ChanACL::Clear() { +// @@protoc_insertion_point(message_clear_start:MumbleProto.ACL.ChanACL) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + group_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x0000007eu) { + ::memset(&user_id_, 0, static_cast( + reinterpret_cast(&deny_) - + reinterpret_cast(&user_id_)) + sizeof(deny_)); + apply_here_ = true; + apply_subs_ = true; + inherited_ = true; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ACL_ChanACL::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional bool apply_here = 1 [default = true]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + _Internal::set_has_apply_here(&has_bits); + apply_here_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool apply_subs = 2 [default = true]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + _Internal::set_has_apply_subs(&has_bits); + apply_subs_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool inherited = 3 [default = true]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + _Internal::set_has_inherited(&has_bits); + inherited_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 user_id = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + _Internal::set_has_user_id(&has_bits); + user_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string group = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + auto str = _internal_mutable_group(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MumbleProto.ACL.ChanACL.group"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 grant = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) { + _Internal::set_has_grant(&has_bits); + grant_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 deny = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) { + _Internal::set_has_deny(&has_bits); + deny_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ACL_ChanACL::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MumbleProto.ACL.ChanACL) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional bool apply_here = 1 [default = true]; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->_internal_apply_here(), target); + } + + // optional bool apply_subs = 2 [default = true]; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_apply_subs(), target); + } + + // optional bool inherited = 3 [default = true]; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->_internal_inherited(), target); + } + + // optional uint32 user_id = 4; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_user_id(), target); + } + + // optional string group = 5; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_group().data(), static_cast(this->_internal_group().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "MumbleProto.ACL.ChanACL.group"); + target = stream->WriteStringMaybeAliased( + 5, this->_internal_group(), target); + } + + // optional uint32 grant = 6; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(6, this->_internal_grant(), target); + } + + // optional uint32 deny = 7; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(7, this->_internal_deny(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MumbleProto.ACL.ChanACL) + return target; +} + +size_t ACL_ChanACL::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MumbleProto.ACL.ChanACL) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000007fu) { + // optional string group = 5; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_group()); + } + + // optional uint32 user_id = 4; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_user_id()); + } + + // optional uint32 grant = 6; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_grant()); + } + + // optional uint32 deny = 7; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_deny()); + } + + // optional bool apply_here = 1 [default = true]; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + 1; + } + + // optional bool apply_subs = 2 [default = true]; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + 1; + } + + // optional bool inherited = 3 [default = true]; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + 1; + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ACL_ChanACL::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:MumbleProto.ACL.ChanACL) + GOOGLE_DCHECK_NE(&from, this); + const ACL_ChanACL* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:MumbleProto.ACL.ChanACL) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:MumbleProto.ACL.ChanACL) + MergeFrom(*source); + } +} + +void ACL_ChanACL::MergeFrom(const ACL_ChanACL& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MumbleProto.ACL.ChanACL) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000007fu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_group(from._internal_group()); + } + if (cached_has_bits & 0x00000002u) { + user_id_ = from.user_id_; + } + if (cached_has_bits & 0x00000004u) { + grant_ = from.grant_; + } + if (cached_has_bits & 0x00000008u) { + deny_ = from.deny_; + } + if (cached_has_bits & 0x00000010u) { + apply_here_ = from.apply_here_; + } + if (cached_has_bits & 0x00000020u) { + apply_subs_ = from.apply_subs_; + } + if (cached_has_bits & 0x00000040u) { + inherited_ = from.inherited_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void ACL_ChanACL::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:MumbleProto.ACL.ChanACL) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ACL_ChanACL::CopyFrom(const ACL_ChanACL& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MumbleProto.ACL.ChanACL) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ACL_ChanACL::IsInitialized() const { + return true; +} + +void ACL_ChanACL::InternalSwap(ACL_ChanACL* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + group_.Swap(&other->group_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ACL_ChanACL, deny_) + + sizeof(ACL_ChanACL::deny_) + - PROTOBUF_FIELD_OFFSET(ACL_ChanACL, user_id_)>( + reinterpret_cast(&user_id_), + reinterpret_cast(&other->user_id_)); + swap(apply_here_, other->apply_here_); + swap(apply_subs_, other->apply_subs_); + swap(inherited_, other->inherited_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ACL_ChanACL::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void ACL::InitAsDefaultInstance() { +} +class ACL::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_channel_id(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_inherit_acls(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_query(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static bool MissingRequiredFields(const HasBits& has_bits) { + return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0; + } +}; + +ACL::ACL(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + groups_(arena), + acls_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:MumbleProto.ACL) +} +ACL::ACL(const ACL& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_), + groups_(from.groups_), + acls_(from.acls_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&channel_id_, &from.channel_id_, + static_cast(reinterpret_cast(&inherit_acls_) - + reinterpret_cast(&channel_id_)) + sizeof(inherit_acls_)); + // @@protoc_insertion_point(copy_constructor:MumbleProto.ACL) +} + +void ACL::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ACL_Mumble_2eproto.base); + ::memset(&channel_id_, 0, static_cast( + reinterpret_cast(&query_) - + reinterpret_cast(&channel_id_)) + sizeof(query_)); + inherit_acls_ = true; +} + +ACL::~ACL() { + // @@protoc_insertion_point(destructor:MumbleProto.ACL) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void ACL::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void ACL::ArenaDtor(void* object) { + ACL* _this = reinterpret_cast< ACL* >(object); + (void)_this; +} +void ACL::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ACL::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ACL& ACL::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ACL_Mumble_2eproto.base); + return *internal_default_instance(); +} + + +void ACL::Clear() { +// @@protoc_insertion_point(message_clear_start:MumbleProto.ACL) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + groups_.Clear(); + acls_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + ::memset(&channel_id_, 0, static_cast( + reinterpret_cast(&query_) - + reinterpret_cast(&channel_id_)) + sizeof(query_)); + inherit_acls_ = true; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ACL::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // required uint32 channel_id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + _Internal::set_has_channel_id(&has_bits); + channel_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool inherit_acls = 2 [default = true]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + _Internal::set_has_inherit_acls(&has_bits); + inherit_acls_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .MumbleProto.ACL.ChanGroup groups = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_groups(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); + } else goto handle_unusual; + continue; + // repeated .MumbleProto.ACL.ChanACL acls = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_acls(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr)); + } else goto handle_unusual; + continue; + // optional bool query = 5 [default = false]; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) { + _Internal::set_has_query(&has_bits); + query_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ACL::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MumbleProto.ACL) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // required uint32 channel_id = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_channel_id(), target); + } + + // optional bool inherit_acls = 2 [default = true]; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_inherit_acls(), target); + } + + // repeated .MumbleProto.ACL.ChanGroup groups = 3; + for (unsigned int i = 0, + n = static_cast(this->_internal_groups_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, this->_internal_groups(i), target, stream); + } + + // repeated .MumbleProto.ACL.ChanACL acls = 4; + for (unsigned int i = 0, + n = static_cast(this->_internal_acls_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(4, this->_internal_acls(i), target, stream); + } + + // optional bool query = 5 [default = false]; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(5, this->_internal_query(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MumbleProto.ACL) + return target; +} + +size_t ACL::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MumbleProto.ACL) + size_t total_size = 0; + + // required uint32 channel_id = 1; + if (_internal_has_channel_id()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_channel_id()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .MumbleProto.ACL.ChanGroup groups = 3; + total_size += 1UL * this->_internal_groups_size(); + for (const auto& msg : this->groups_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .MumbleProto.ACL.ChanACL acls = 4; + total_size += 1UL * this->_internal_acls_size(); + for (const auto& msg : this->acls_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000006u) { + // optional bool query = 5 [default = false]; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + 1; + } + + // optional bool inherit_acls = 2 [default = true]; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + 1; + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ACL::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:MumbleProto.ACL) + GOOGLE_DCHECK_NE(&from, this); + const ACL* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:MumbleProto.ACL) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:MumbleProto.ACL) + MergeFrom(*source); + } +} + +void ACL::MergeFrom(const ACL& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MumbleProto.ACL) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + groups_.MergeFrom(from.groups_); + acls_.MergeFrom(from.acls_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + channel_id_ = from.channel_id_; + } + if (cached_has_bits & 0x00000002u) { + query_ = from.query_; + } + if (cached_has_bits & 0x00000004u) { + inherit_acls_ = from.inherit_acls_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void ACL::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:MumbleProto.ACL) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ACL::CopyFrom(const ACL& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MumbleProto.ACL) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ACL::IsInitialized() const { + if (_Internal::MissingRequiredFields(_has_bits_)) return false; + if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(groups_)) return false; + return true; +} + +void ACL::InternalSwap(ACL* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + groups_.InternalSwap(&other->groups_); + acls_.InternalSwap(&other->acls_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ACL, query_) + + sizeof(ACL::query_) + - PROTOBUF_FIELD_OFFSET(ACL, channel_id_)>( + reinterpret_cast(&channel_id_), + reinterpret_cast(&other->channel_id_)); + swap(inherit_acls_, other->inherit_acls_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ACL::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void QueryUsers::InitAsDefaultInstance() { +} +class QueryUsers::_Internal { + public: +}; + +QueryUsers::QueryUsers(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + ids_(arena), + names_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:MumbleProto.QueryUsers) +} +QueryUsers::QueryUsers(const QueryUsers& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + ids_(from.ids_), + names_(from.names_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:MumbleProto.QueryUsers) +} + +void QueryUsers::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_QueryUsers_Mumble_2eproto.base); +} + +QueryUsers::~QueryUsers() { + // @@protoc_insertion_point(destructor:MumbleProto.QueryUsers) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void QueryUsers::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void QueryUsers::ArenaDtor(void* object) { + QueryUsers* _this = reinterpret_cast< QueryUsers* >(object); + (void)_this; +} +void QueryUsers::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void QueryUsers::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const QueryUsers& QueryUsers::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_QueryUsers_Mumble_2eproto.base); + return *internal_default_instance(); +} + + +void QueryUsers::Clear() { +// @@protoc_insertion_point(message_clear_start:MumbleProto.QueryUsers) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ids_.Clear(); + names_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* QueryUsers::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // repeated uint32 ids = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_ids(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<8>(ptr)); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_ids(), ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated string names = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_names(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MumbleProto.QueryUsers.names"); + #endif // !NDEBUG + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* QueryUsers::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MumbleProto.QueryUsers) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated uint32 ids = 1; + for (int i = 0, n = this->_internal_ids_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_ids(i), target); + } + + // repeated string names = 2; + for (int i = 0, n = this->_internal_names_size(); i < n; i++) { + const auto& s = this->_internal_names(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "MumbleProto.QueryUsers.names"); + target = stream->WriteString(2, s, target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MumbleProto.QueryUsers) + return target; +} + +size_t QueryUsers::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MumbleProto.QueryUsers) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated uint32 ids = 1; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + UInt32Size(this->ids_); + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_ids_size()); + total_size += data_size; + } + + // repeated string names = 2; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(names_.size()); + for (int i = 0, n = names_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + names_.Get(i)); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void QueryUsers::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:MumbleProto.QueryUsers) + GOOGLE_DCHECK_NE(&from, this); + const QueryUsers* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:MumbleProto.QueryUsers) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:MumbleProto.QueryUsers) + MergeFrom(*source); + } +} + +void QueryUsers::MergeFrom(const QueryUsers& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MumbleProto.QueryUsers) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + ids_.MergeFrom(from.ids_); + names_.MergeFrom(from.names_); +} + +void QueryUsers::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:MumbleProto.QueryUsers) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void QueryUsers::CopyFrom(const QueryUsers& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MumbleProto.QueryUsers) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool QueryUsers::IsInitialized() const { + return true; +} + +void QueryUsers::InternalSwap(QueryUsers* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ids_.InternalSwap(&other->ids_); + names_.InternalSwap(&other->names_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata QueryUsers::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void CryptSetup::InitAsDefaultInstance() { +} +class CryptSetup::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_key(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_client_nonce(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_server_nonce(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +CryptSetup::CryptSetup(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:MumbleProto.CryptSetup) +} +CryptSetup::CryptSetup(const CryptSetup& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_key()) { + key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_key(), + GetArena()); + } + client_nonce_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_client_nonce()) { + client_nonce_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_client_nonce(), + GetArena()); + } + server_nonce_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_server_nonce()) { + server_nonce_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_server_nonce(), + GetArena()); + } + // @@protoc_insertion_point(copy_constructor:MumbleProto.CryptSetup) +} + +void CryptSetup::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_CryptSetup_Mumble_2eproto.base); + key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + client_nonce_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + server_nonce_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +CryptSetup::~CryptSetup() { + // @@protoc_insertion_point(destructor:MumbleProto.CryptSetup) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void CryptSetup::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + key_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + client_nonce_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + server_nonce_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void CryptSetup::ArenaDtor(void* object) { + CryptSetup* _this = reinterpret_cast< CryptSetup* >(object); + (void)_this; +} +void CryptSetup::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void CryptSetup::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const CryptSetup& CryptSetup::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_CryptSetup_Mumble_2eproto.base); + return *internal_default_instance(); +} + + +void CryptSetup::Clear() { +// @@protoc_insertion_point(message_clear_start:MumbleProto.CryptSetup) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + key_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + client_nonce_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + server_nonce_.ClearNonDefaultToEmpty(); + } + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* CryptSetup::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional bytes key = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_key(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bytes client_nonce = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_client_nonce(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bytes server_nonce = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + auto str = _internal_mutable_server_nonce(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* CryptSetup::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MumbleProto.CryptSetup) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional bytes key = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_key(), target); + } + + // optional bytes client_nonce = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 2, this->_internal_client_nonce(), target); + } + + // optional bytes server_nonce = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->WriteBytesMaybeAliased( + 3, this->_internal_server_nonce(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MumbleProto.CryptSetup) + return target; +} + +size_t CryptSetup::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MumbleProto.CryptSetup) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional bytes key = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_key()); + } + + // optional bytes client_nonce = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_client_nonce()); + } + + // optional bytes server_nonce = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_server_nonce()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void CryptSetup::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:MumbleProto.CryptSetup) + GOOGLE_DCHECK_NE(&from, this); + const CryptSetup* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:MumbleProto.CryptSetup) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:MumbleProto.CryptSetup) + MergeFrom(*source); + } +} + +void CryptSetup::MergeFrom(const CryptSetup& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MumbleProto.CryptSetup) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _internal_set_key(from._internal_key()); + } + if (cached_has_bits & 0x00000002u) { + _internal_set_client_nonce(from._internal_client_nonce()); + } + if (cached_has_bits & 0x00000004u) { + _internal_set_server_nonce(from._internal_server_nonce()); + } + } +} + +void CryptSetup::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:MumbleProto.CryptSetup) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void CryptSetup::CopyFrom(const CryptSetup& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MumbleProto.CryptSetup) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CryptSetup::IsInitialized() const { + return true; +} + +void CryptSetup::InternalSwap(CryptSetup* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + key_.Swap(&other->key_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + client_nonce_.Swap(&other->client_nonce_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + server_nonce_.Swap(&other->server_nonce_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata CryptSetup::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void ContextActionModify::InitAsDefaultInstance() { +} +class ContextActionModify::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_action(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_text(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_context(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_operation(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static bool MissingRequiredFields(const HasBits& has_bits) { + return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0; + } +}; + +ContextActionModify::ContextActionModify(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:MumbleProto.ContextActionModify) +} +ContextActionModify::ContextActionModify(const ContextActionModify& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + action_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_action()) { + action_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_action(), + GetArena()); + } + text_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_text()) { + text_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_text(), + GetArena()); + } + ::memcpy(&context_, &from.context_, + static_cast(reinterpret_cast(&operation_) - + reinterpret_cast(&context_)) + sizeof(operation_)); + // @@protoc_insertion_point(copy_constructor:MumbleProto.ContextActionModify) +} + +void ContextActionModify::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ContextActionModify_Mumble_2eproto.base); + action_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + text_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&context_, 0, static_cast( + reinterpret_cast(&operation_) - + reinterpret_cast(&context_)) + sizeof(operation_)); +} + +ContextActionModify::~ContextActionModify() { + // @@protoc_insertion_point(destructor:MumbleProto.ContextActionModify) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void ContextActionModify::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + action_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + text_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ContextActionModify::ArenaDtor(void* object) { + ContextActionModify* _this = reinterpret_cast< ContextActionModify* >(object); + (void)_this; +} +void ContextActionModify::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ContextActionModify::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ContextActionModify& ContextActionModify::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ContextActionModify_Mumble_2eproto.base); + return *internal_default_instance(); +} + + +void ContextActionModify::Clear() { +// @@protoc_insertion_point(message_clear_start:MumbleProto.ContextActionModify) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + action_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + text_.ClearNonDefaultToEmpty(); + } + } + if (cached_has_bits & 0x0000000cu) { + ::memset(&context_, 0, static_cast( + reinterpret_cast(&operation_) - + reinterpret_cast(&context_)) + sizeof(operation_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ContextActionModify::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // required string action = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_action(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MumbleProto.ContextActionModify.action"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string text = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_text(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MumbleProto.ContextActionModify.text"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 context = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + _Internal::set_has_context(&has_bits); + context_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional .MumbleProto.ContextActionModify.Operation operation = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::MumbleProto::ContextActionModify_Operation_IsValid(val))) { + _internal_set_operation(static_cast<::MumbleProto::ContextActionModify_Operation>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields()); + } + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ContextActionModify::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MumbleProto.ContextActionModify) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // required string action = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_action().data(), static_cast(this->_internal_action().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "MumbleProto.ContextActionModify.action"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_action(), target); + } + + // optional string text = 2; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_text().data(), static_cast(this->_internal_text().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "MumbleProto.ContextActionModify.text"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_text(), target); + } + + // optional uint32 context = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_context(), target); + } + + // optional .MumbleProto.ContextActionModify.Operation operation = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 4, this->_internal_operation(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MumbleProto.ContextActionModify) + return target; +} + +size_t ContextActionModify::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MumbleProto.ContextActionModify) + size_t total_size = 0; + + // required string action = 1; + if (_internal_has_action()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_action()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000000eu) { + // optional string text = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_text()); + } + + // optional uint32 context = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_context()); + } + + // optional .MumbleProto.ContextActionModify.Operation operation = 4; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_operation()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ContextActionModify::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:MumbleProto.ContextActionModify) + GOOGLE_DCHECK_NE(&from, this); + const ContextActionModify* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:MumbleProto.ContextActionModify) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:MumbleProto.ContextActionModify) + MergeFrom(*source); + } +} + +void ContextActionModify::MergeFrom(const ContextActionModify& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MumbleProto.ContextActionModify) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_action(from._internal_action()); + } + if (cached_has_bits & 0x00000002u) { + _internal_set_text(from._internal_text()); + } + if (cached_has_bits & 0x00000004u) { + context_ = from.context_; + } + if (cached_has_bits & 0x00000008u) { + operation_ = from.operation_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void ContextActionModify::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:MumbleProto.ContextActionModify) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ContextActionModify::CopyFrom(const ContextActionModify& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MumbleProto.ContextActionModify) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ContextActionModify::IsInitialized() const { + if (_Internal::MissingRequiredFields(_has_bits_)) return false; + return true; +} + +void ContextActionModify::InternalSwap(ContextActionModify* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + action_.Swap(&other->action_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + text_.Swap(&other->text_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ContextActionModify, operation_) + + sizeof(ContextActionModify::operation_) + - PROTOBUF_FIELD_OFFSET(ContextActionModify, context_)>( + reinterpret_cast(&context_), + reinterpret_cast(&other->context_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ContextActionModify::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void ContextAction::InitAsDefaultInstance() { +} +class ContextAction::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_session(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_channel_id(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_action(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static bool MissingRequiredFields(const HasBits& has_bits) { + return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0; + } +}; + +ContextAction::ContextAction(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:MumbleProto.ContextAction) +} +ContextAction::ContextAction(const ContextAction& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + action_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_action()) { + action_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_action(), + GetArena()); + } + ::memcpy(&session_, &from.session_, + static_cast(reinterpret_cast(&channel_id_) - + reinterpret_cast(&session_)) + sizeof(channel_id_)); + // @@protoc_insertion_point(copy_constructor:MumbleProto.ContextAction) +} + +void ContextAction::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ContextAction_Mumble_2eproto.base); + action_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&session_, 0, static_cast( + reinterpret_cast(&channel_id_) - + reinterpret_cast(&session_)) + sizeof(channel_id_)); +} + +ContextAction::~ContextAction() { + // @@protoc_insertion_point(destructor:MumbleProto.ContextAction) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void ContextAction::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + action_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ContextAction::ArenaDtor(void* object) { + ContextAction* _this = reinterpret_cast< ContextAction* >(object); + (void)_this; +} +void ContextAction::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ContextAction::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ContextAction& ContextAction::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ContextAction_Mumble_2eproto.base); + return *internal_default_instance(); +} + + +void ContextAction::Clear() { +// @@protoc_insertion_point(message_clear_start:MumbleProto.ContextAction) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + action_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000006u) { + ::memset(&session_, 0, static_cast( + reinterpret_cast(&channel_id_) - + reinterpret_cast(&session_)) + sizeof(channel_id_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ContextAction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional uint32 session = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + _Internal::set_has_session(&has_bits); + session_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 channel_id = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + _Internal::set_has_channel_id(&has_bits); + channel_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // required string action = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + auto str = _internal_mutable_action(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MumbleProto.ContextAction.action"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ContextAction::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MumbleProto.ContextAction) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional uint32 session = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_session(), target); + } + + // optional uint32 channel_id = 2; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_channel_id(), target); + } + + // required string action = 3; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_action().data(), static_cast(this->_internal_action().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "MumbleProto.ContextAction.action"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_action(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MumbleProto.ContextAction) + return target; +} + +size_t ContextAction::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MumbleProto.ContextAction) + size_t total_size = 0; + + // required string action = 3; + if (_internal_has_action()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_action()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000006u) { + // optional uint32 session = 1; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_session()); + } + + // optional uint32 channel_id = 2; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_channel_id()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ContextAction::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:MumbleProto.ContextAction) + GOOGLE_DCHECK_NE(&from, this); + const ContextAction* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:MumbleProto.ContextAction) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:MumbleProto.ContextAction) + MergeFrom(*source); + } +} + +void ContextAction::MergeFrom(const ContextAction& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MumbleProto.ContextAction) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _internal_set_action(from._internal_action()); + } + if (cached_has_bits & 0x00000002u) { + session_ = from.session_; + } + if (cached_has_bits & 0x00000004u) { + channel_id_ = from.channel_id_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void ContextAction::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:MumbleProto.ContextAction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ContextAction::CopyFrom(const ContextAction& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MumbleProto.ContextAction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ContextAction::IsInitialized() const { + if (_Internal::MissingRequiredFields(_has_bits_)) return false; + return true; +} + +void ContextAction::InternalSwap(ContextAction* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + action_.Swap(&other->action_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ContextAction, channel_id_) + + sizeof(ContextAction::channel_id_) + - PROTOBUF_FIELD_OFFSET(ContextAction, session_)>( + reinterpret_cast(&session_), + reinterpret_cast(&other->session_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ContextAction::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void UserList_User::InitAsDefaultInstance() { +} +class UserList_User::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_user_id(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_name(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_last_seen(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_last_channel(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static bool MissingRequiredFields(const HasBits& has_bits) { + return ((has_bits[0] & 0x00000004) ^ 0x00000004) != 0; + } +}; + +UserList_User::UserList_User(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:MumbleProto.UserList.User) +} +UserList_User::UserList_User(const UserList_User& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_name()) { + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_name(), + GetArena()); + } + last_seen_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_last_seen()) { + last_seen_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_last_seen(), + GetArena()); + } + ::memcpy(&user_id_, &from.user_id_, + static_cast(reinterpret_cast(&last_channel_) - + reinterpret_cast(&user_id_)) + sizeof(last_channel_)); + // @@protoc_insertion_point(copy_constructor:MumbleProto.UserList.User) +} + +void UserList_User::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_UserList_User_Mumble_2eproto.base); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + last_seen_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&user_id_, 0, static_cast( + reinterpret_cast(&last_channel_) - + reinterpret_cast(&user_id_)) + sizeof(last_channel_)); +} + +UserList_User::~UserList_User() { + // @@protoc_insertion_point(destructor:MumbleProto.UserList.User) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void UserList_User::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + last_seen_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void UserList_User::ArenaDtor(void* object) { + UserList_User* _this = reinterpret_cast< UserList_User* >(object); + (void)_this; +} +void UserList_User::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void UserList_User::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const UserList_User& UserList_User::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_UserList_User_Mumble_2eproto.base); + return *internal_default_instance(); +} + + +void UserList_User::Clear() { +// @@protoc_insertion_point(message_clear_start:MumbleProto.UserList.User) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + name_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + last_seen_.ClearNonDefaultToEmpty(); + } + } + if (cached_has_bits & 0x0000000cu) { + ::memset(&user_id_, 0, static_cast( + reinterpret_cast(&last_channel_) - + reinterpret_cast(&user_id_)) + sizeof(last_channel_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* UserList_User::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // required uint32 user_id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + _Internal::set_has_user_id(&has_bits); + user_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string name = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MumbleProto.UserList.User.name"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string last_seen = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + auto str = _internal_mutable_last_seen(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MumbleProto.UserList.User.last_seen"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 last_channel = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + _Internal::set_has_last_channel(&has_bits); + last_channel_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* UserList_User::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MumbleProto.UserList.User) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // required uint32 user_id = 1; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_user_id(), target); + } + + // optional string name = 2; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_name().data(), static_cast(this->_internal_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "MumbleProto.UserList.User.name"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_name(), target); + } + + // optional string last_seen = 3; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_last_seen().data(), static_cast(this->_internal_last_seen().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "MumbleProto.UserList.User.last_seen"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_last_seen(), target); + } + + // optional uint32 last_channel = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_last_channel(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MumbleProto.UserList.User) + return target; +} + +size_t UserList_User::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MumbleProto.UserList.User) + size_t total_size = 0; + + // required uint32 user_id = 1; + if (_internal_has_user_id()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_user_id()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional string name = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + // optional string last_seen = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_last_seen()); + } + + } + // optional uint32 last_channel = 4; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_last_channel()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void UserList_User::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:MumbleProto.UserList.User) + GOOGLE_DCHECK_NE(&from, this); + const UserList_User* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:MumbleProto.UserList.User) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:MumbleProto.UserList.User) + MergeFrom(*source); + } +} + +void UserList_User::MergeFrom(const UserList_User& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MumbleProto.UserList.User) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_name(from._internal_name()); + } + if (cached_has_bits & 0x00000002u) { + _internal_set_last_seen(from._internal_last_seen()); + } + if (cached_has_bits & 0x00000004u) { + user_id_ = from.user_id_; + } + if (cached_has_bits & 0x00000008u) { + last_channel_ = from.last_channel_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void UserList_User::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:MumbleProto.UserList.User) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void UserList_User::CopyFrom(const UserList_User& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MumbleProto.UserList.User) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool UserList_User::IsInitialized() const { + if (_Internal::MissingRequiredFields(_has_bits_)) return false; + return true; +} + +void UserList_User::InternalSwap(UserList_User* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + last_seen_.Swap(&other->last_seen_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(UserList_User, last_channel_) + + sizeof(UserList_User::last_channel_) + - PROTOBUF_FIELD_OFFSET(UserList_User, user_id_)>( + reinterpret_cast(&user_id_), + reinterpret_cast(&other->user_id_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata UserList_User::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void UserList::InitAsDefaultInstance() { +} +class UserList::_Internal { + public: +}; + +UserList::UserList(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + users_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:MumbleProto.UserList) +} +UserList::UserList(const UserList& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + users_(from.users_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:MumbleProto.UserList) +} + +void UserList::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_UserList_Mumble_2eproto.base); +} + +UserList::~UserList() { + // @@protoc_insertion_point(destructor:MumbleProto.UserList) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void UserList::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void UserList::ArenaDtor(void* object) { + UserList* _this = reinterpret_cast< UserList* >(object); + (void)_this; +} +void UserList::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void UserList::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const UserList& UserList::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_UserList_Mumble_2eproto.base); + return *internal_default_instance(); +} + + +void UserList::Clear() { +// @@protoc_insertion_point(message_clear_start:MumbleProto.UserList) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + users_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* UserList::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // repeated .MumbleProto.UserList.User users = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_users(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* UserList::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MumbleProto.UserList) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .MumbleProto.UserList.User users = 1; + for (unsigned int i = 0, + n = static_cast(this->_internal_users_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, this->_internal_users(i), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MumbleProto.UserList) + return target; +} + +size_t UserList::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MumbleProto.UserList) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .MumbleProto.UserList.User users = 1; + total_size += 1UL * this->_internal_users_size(); + for (const auto& msg : this->users_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void UserList::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:MumbleProto.UserList) + GOOGLE_DCHECK_NE(&from, this); + const UserList* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:MumbleProto.UserList) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:MumbleProto.UserList) + MergeFrom(*source); + } +} + +void UserList::MergeFrom(const UserList& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MumbleProto.UserList) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + users_.MergeFrom(from.users_); +} + +void UserList::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:MumbleProto.UserList) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void UserList::CopyFrom(const UserList& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MumbleProto.UserList) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool UserList::IsInitialized() const { + if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(users_)) return false; + return true; +} + +void UserList::InternalSwap(UserList* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + users_.InternalSwap(&other->users_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata UserList::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void VoiceTarget_Target::InitAsDefaultInstance() { +} +class VoiceTarget_Target::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_channel_id(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_group(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_links(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_children(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } +}; + +VoiceTarget_Target::VoiceTarget_Target(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + session_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:MumbleProto.VoiceTarget.Target) +} +VoiceTarget_Target::VoiceTarget_Target(const VoiceTarget_Target& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_), + session_(from.session_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + group_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_group()) { + group_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_group(), + GetArena()); + } + ::memcpy(&channel_id_, &from.channel_id_, + static_cast(reinterpret_cast(&children_) - + reinterpret_cast(&channel_id_)) + sizeof(children_)); + // @@protoc_insertion_point(copy_constructor:MumbleProto.VoiceTarget.Target) +} + +void VoiceTarget_Target::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_VoiceTarget_Target_Mumble_2eproto.base); + group_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&channel_id_, 0, static_cast( + reinterpret_cast(&children_) - + reinterpret_cast(&channel_id_)) + sizeof(children_)); +} + +VoiceTarget_Target::~VoiceTarget_Target() { + // @@protoc_insertion_point(destructor:MumbleProto.VoiceTarget.Target) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void VoiceTarget_Target::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + group_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void VoiceTarget_Target::ArenaDtor(void* object) { + VoiceTarget_Target* _this = reinterpret_cast< VoiceTarget_Target* >(object); + (void)_this; +} +void VoiceTarget_Target::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void VoiceTarget_Target::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const VoiceTarget_Target& VoiceTarget_Target::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_VoiceTarget_Target_Mumble_2eproto.base); + return *internal_default_instance(); +} + + +void VoiceTarget_Target::Clear() { +// @@protoc_insertion_point(message_clear_start:MumbleProto.VoiceTarget.Target) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + session_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + group_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x0000000eu) { + ::memset(&channel_id_, 0, static_cast( + reinterpret_cast(&children_) - + reinterpret_cast(&channel_id_)) + sizeof(children_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* VoiceTarget_Target::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // repeated uint32 session = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_session(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<8>(ptr)); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_session(), ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 channel_id = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + _Internal::set_has_channel_id(&has_bits); + channel_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string group = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + auto str = _internal_mutable_group(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MumbleProto.VoiceTarget.Target.group"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool links = 4 [default = false]; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + _Internal::set_has_links(&has_bits); + links_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool children = 5 [default = false]; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) { + _Internal::set_has_children(&has_bits); + children_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* VoiceTarget_Target::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MumbleProto.VoiceTarget.Target) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated uint32 session = 1; + for (int i = 0, n = this->_internal_session_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_session(i), target); + } + + cached_has_bits = _has_bits_[0]; + // optional uint32 channel_id = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_channel_id(), target); + } + + // optional string group = 3; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_group().data(), static_cast(this->_internal_group().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "MumbleProto.VoiceTarget.Target.group"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_group(), target); + } + + // optional bool links = 4 [default = false]; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->_internal_links(), target); + } + + // optional bool children = 5 [default = false]; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(5, this->_internal_children(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MumbleProto.VoiceTarget.Target) + return target; +} + +size_t VoiceTarget_Target::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MumbleProto.VoiceTarget.Target) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated uint32 session = 1; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + UInt32Size(this->session_); + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_session_size()); + total_size += data_size; + } + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + // optional string group = 3; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_group()); + } + + // optional uint32 channel_id = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_channel_id()); + } + + // optional bool links = 4 [default = false]; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + 1; + } + + // optional bool children = 5 [default = false]; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + 1; + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void VoiceTarget_Target::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:MumbleProto.VoiceTarget.Target) + GOOGLE_DCHECK_NE(&from, this); + const VoiceTarget_Target* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:MumbleProto.VoiceTarget.Target) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:MumbleProto.VoiceTarget.Target) + MergeFrom(*source); + } +} + +void VoiceTarget_Target::MergeFrom(const VoiceTarget_Target& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MumbleProto.VoiceTarget.Target) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + session_.MergeFrom(from.session_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_group(from._internal_group()); + } + if (cached_has_bits & 0x00000002u) { + channel_id_ = from.channel_id_; + } + if (cached_has_bits & 0x00000004u) { + links_ = from.links_; + } + if (cached_has_bits & 0x00000008u) { + children_ = from.children_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void VoiceTarget_Target::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:MumbleProto.VoiceTarget.Target) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void VoiceTarget_Target::CopyFrom(const VoiceTarget_Target& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MumbleProto.VoiceTarget.Target) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool VoiceTarget_Target::IsInitialized() const { + return true; +} + +void VoiceTarget_Target::InternalSwap(VoiceTarget_Target* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + session_.InternalSwap(&other->session_); + group_.Swap(&other->group_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(VoiceTarget_Target, children_) + + sizeof(VoiceTarget_Target::children_) + - PROTOBUF_FIELD_OFFSET(VoiceTarget_Target, channel_id_)>( + reinterpret_cast(&channel_id_), + reinterpret_cast(&other->channel_id_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata VoiceTarget_Target::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void VoiceTarget::InitAsDefaultInstance() { +} +class VoiceTarget::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_id(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +VoiceTarget::VoiceTarget(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + targets_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:MumbleProto.VoiceTarget) +} +VoiceTarget::VoiceTarget(const VoiceTarget& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_), + targets_(from.targets_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + id_ = from.id_; + // @@protoc_insertion_point(copy_constructor:MumbleProto.VoiceTarget) +} + +void VoiceTarget::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_VoiceTarget_Mumble_2eproto.base); + id_ = 0u; +} + +VoiceTarget::~VoiceTarget() { + // @@protoc_insertion_point(destructor:MumbleProto.VoiceTarget) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void VoiceTarget::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void VoiceTarget::ArenaDtor(void* object) { + VoiceTarget* _this = reinterpret_cast< VoiceTarget* >(object); + (void)_this; +} +void VoiceTarget::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void VoiceTarget::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const VoiceTarget& VoiceTarget::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_VoiceTarget_Mumble_2eproto.base); + return *internal_default_instance(); +} + + +void VoiceTarget::Clear() { +// @@protoc_insertion_point(message_clear_start:MumbleProto.VoiceTarget) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + targets_.Clear(); + id_ = 0u; + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* VoiceTarget::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional uint32 id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + _Internal::set_has_id(&has_bits); + id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .MumbleProto.VoiceTarget.Target targets = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_targets(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* VoiceTarget::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MumbleProto.VoiceTarget) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional uint32 id = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_id(), target); + } + + // repeated .MumbleProto.VoiceTarget.Target targets = 2; + for (unsigned int i = 0, + n = static_cast(this->_internal_targets_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, this->_internal_targets(i), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MumbleProto.VoiceTarget) + return target; +} + +size_t VoiceTarget::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MumbleProto.VoiceTarget) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .MumbleProto.VoiceTarget.Target targets = 2; + total_size += 1UL * this->_internal_targets_size(); + for (const auto& msg : this->targets_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // optional uint32 id = 1; + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_id()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void VoiceTarget::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:MumbleProto.VoiceTarget) + GOOGLE_DCHECK_NE(&from, this); + const VoiceTarget* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:MumbleProto.VoiceTarget) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:MumbleProto.VoiceTarget) + MergeFrom(*source); + } +} + +void VoiceTarget::MergeFrom(const VoiceTarget& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MumbleProto.VoiceTarget) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + targets_.MergeFrom(from.targets_); + if (from._internal_has_id()) { + _internal_set_id(from._internal_id()); + } +} + +void VoiceTarget::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:MumbleProto.VoiceTarget) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void VoiceTarget::CopyFrom(const VoiceTarget& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MumbleProto.VoiceTarget) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool VoiceTarget::IsInitialized() const { + return true; +} + +void VoiceTarget::InternalSwap(VoiceTarget* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + targets_.InternalSwap(&other->targets_); + swap(id_, other->id_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata VoiceTarget::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void PermissionQuery::InitAsDefaultInstance() { +} +class PermissionQuery::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_channel_id(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_permissions(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_flush(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +PermissionQuery::PermissionQuery(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:MumbleProto.PermissionQuery) +} +PermissionQuery::PermissionQuery(const PermissionQuery& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&channel_id_, &from.channel_id_, + static_cast(reinterpret_cast(&flush_) - + reinterpret_cast(&channel_id_)) + sizeof(flush_)); + // @@protoc_insertion_point(copy_constructor:MumbleProto.PermissionQuery) +} + +void PermissionQuery::SharedCtor() { + ::memset(&channel_id_, 0, static_cast( + reinterpret_cast(&flush_) - + reinterpret_cast(&channel_id_)) + sizeof(flush_)); +} + +PermissionQuery::~PermissionQuery() { + // @@protoc_insertion_point(destructor:MumbleProto.PermissionQuery) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void PermissionQuery::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void PermissionQuery::ArenaDtor(void* object) { + PermissionQuery* _this = reinterpret_cast< PermissionQuery* >(object); + (void)_this; +} +void PermissionQuery::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void PermissionQuery::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const PermissionQuery& PermissionQuery::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_PermissionQuery_Mumble_2eproto.base); + return *internal_default_instance(); +} + + +void PermissionQuery::Clear() { +// @@protoc_insertion_point(message_clear_start:MumbleProto.PermissionQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + ::memset(&channel_id_, 0, static_cast( + reinterpret_cast(&flush_) - + reinterpret_cast(&channel_id_)) + sizeof(flush_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* PermissionQuery::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional uint32 channel_id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + _Internal::set_has_channel_id(&has_bits); + channel_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 permissions = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + _Internal::set_has_permissions(&has_bits); + permissions_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool flush = 3 [default = false]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + _Internal::set_has_flush(&has_bits); + flush_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* PermissionQuery::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MumbleProto.PermissionQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional uint32 channel_id = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_channel_id(), target); + } + + // optional uint32 permissions = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_permissions(), target); + } + + // optional bool flush = 3 [default = false]; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->_internal_flush(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MumbleProto.PermissionQuery) + return target; +} + +size_t PermissionQuery::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MumbleProto.PermissionQuery) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional uint32 channel_id = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_channel_id()); + } + + // optional uint32 permissions = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_permissions()); + } + + // optional bool flush = 3 [default = false]; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + 1; + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void PermissionQuery::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:MumbleProto.PermissionQuery) + GOOGLE_DCHECK_NE(&from, this); + const PermissionQuery* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:MumbleProto.PermissionQuery) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:MumbleProto.PermissionQuery) + MergeFrom(*source); + } +} + +void PermissionQuery::MergeFrom(const PermissionQuery& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MumbleProto.PermissionQuery) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + channel_id_ = from.channel_id_; + } + if (cached_has_bits & 0x00000002u) { + permissions_ = from.permissions_; + } + if (cached_has_bits & 0x00000004u) { + flush_ = from.flush_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void PermissionQuery::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:MumbleProto.PermissionQuery) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void PermissionQuery::CopyFrom(const PermissionQuery& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MumbleProto.PermissionQuery) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PermissionQuery::IsInitialized() const { + return true; +} + +void PermissionQuery::InternalSwap(PermissionQuery* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(PermissionQuery, flush_) + + sizeof(PermissionQuery::flush_) + - PROTOBUF_FIELD_OFFSET(PermissionQuery, channel_id_)>( + reinterpret_cast(&channel_id_), + reinterpret_cast(&other->channel_id_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata PermissionQuery::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void CodecVersion::InitAsDefaultInstance() { +} +class CodecVersion::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_alpha(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_beta(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_prefer_alpha(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_opus(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static bool MissingRequiredFields(const HasBits& has_bits) { + return ((has_bits[0] & 0x0000000b) ^ 0x0000000b) != 0; + } +}; + +CodecVersion::CodecVersion(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:MumbleProto.CodecVersion) +} +CodecVersion::CodecVersion(const CodecVersion& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&alpha_, &from.alpha_, + static_cast(reinterpret_cast(&prefer_alpha_) - + reinterpret_cast(&alpha_)) + sizeof(prefer_alpha_)); + // @@protoc_insertion_point(copy_constructor:MumbleProto.CodecVersion) +} + +void CodecVersion::SharedCtor() { + ::memset(&alpha_, 0, static_cast( + reinterpret_cast(&opus_) - + reinterpret_cast(&alpha_)) + sizeof(opus_)); + prefer_alpha_ = true; +} + +CodecVersion::~CodecVersion() { + // @@protoc_insertion_point(destructor:MumbleProto.CodecVersion) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void CodecVersion::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void CodecVersion::ArenaDtor(void* object) { + CodecVersion* _this = reinterpret_cast< CodecVersion* >(object); + (void)_this; +} +void CodecVersion::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void CodecVersion::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const CodecVersion& CodecVersion::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_CodecVersion_Mumble_2eproto.base); + return *internal_default_instance(); +} + + +void CodecVersion::Clear() { +// @@protoc_insertion_point(message_clear_start:MumbleProto.CodecVersion) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + ::memset(&alpha_, 0, static_cast( + reinterpret_cast(&opus_) - + reinterpret_cast(&alpha_)) + sizeof(opus_)); + prefer_alpha_ = true; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* CodecVersion::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // required int32 alpha = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + _Internal::set_has_alpha(&has_bits); + alpha_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // required int32 beta = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + _Internal::set_has_beta(&has_bits); + beta_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // required bool prefer_alpha = 3 [default = true]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + _Internal::set_has_prefer_alpha(&has_bits); + prefer_alpha_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool opus = 4 [default = false]; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + _Internal::set_has_opus(&has_bits); + opus_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* CodecVersion::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MumbleProto.CodecVersion) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // required int32 alpha = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_alpha(), target); + } + + // required int32 beta = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_beta(), target); + } + + // required bool prefer_alpha = 3 [default = true]; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->_internal_prefer_alpha(), target); + } + + // optional bool opus = 4 [default = false]; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->_internal_opus(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MumbleProto.CodecVersion) + return target; +} + +size_t CodecVersion::RequiredFieldsByteSizeFallback() const { +// @@protoc_insertion_point(required_fields_byte_size_fallback_start:MumbleProto.CodecVersion) + size_t total_size = 0; + + if (_internal_has_alpha()) { + // required int32 alpha = 1; + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_alpha()); + } + + if (_internal_has_beta()) { + // required int32 beta = 2; + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_beta()); + } + + if (_internal_has_prefer_alpha()) { + // required bool prefer_alpha = 3 [default = true]; + total_size += 1 + 1; + } + + return total_size; +} +size_t CodecVersion::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MumbleProto.CodecVersion) + size_t total_size = 0; + + if (((_has_bits_[0] & 0x0000000b) ^ 0x0000000b) == 0) { // All required fields are present. + // required int32 alpha = 1; + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_alpha()); + + // required int32 beta = 2; + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_beta()); + + // required bool prefer_alpha = 3 [default = true]; + total_size += 1 + 1; + + } else { + total_size += RequiredFieldsByteSizeFallback(); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional bool opus = 4 [default = false]; + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + 1; + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void CodecVersion::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:MumbleProto.CodecVersion) + GOOGLE_DCHECK_NE(&from, this); + const CodecVersion* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:MumbleProto.CodecVersion) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:MumbleProto.CodecVersion) + MergeFrom(*source); + } +} + +void CodecVersion::MergeFrom(const CodecVersion& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MumbleProto.CodecVersion) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + alpha_ = from.alpha_; + } + if (cached_has_bits & 0x00000002u) { + beta_ = from.beta_; + } + if (cached_has_bits & 0x00000004u) { + opus_ = from.opus_; + } + if (cached_has_bits & 0x00000008u) { + prefer_alpha_ = from.prefer_alpha_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void CodecVersion::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:MumbleProto.CodecVersion) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void CodecVersion::CopyFrom(const CodecVersion& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MumbleProto.CodecVersion) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CodecVersion::IsInitialized() const { + if (_Internal::MissingRequiredFields(_has_bits_)) return false; + return true; +} + +void CodecVersion::InternalSwap(CodecVersion* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(CodecVersion, opus_) + + sizeof(CodecVersion::opus_) + - PROTOBUF_FIELD_OFFSET(CodecVersion, alpha_)>( + reinterpret_cast(&alpha_), + reinterpret_cast(&other->alpha_)); + swap(prefer_alpha_, other->prefer_alpha_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata CodecVersion::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void UserStats_Stats::InitAsDefaultInstance() { +} +class UserStats_Stats::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_good(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_late(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_lost(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_resync(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } +}; + +UserStats_Stats::UserStats_Stats(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:MumbleProto.UserStats.Stats) +} +UserStats_Stats::UserStats_Stats(const UserStats_Stats& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&good_, &from.good_, + static_cast(reinterpret_cast(&resync_) - + reinterpret_cast(&good_)) + sizeof(resync_)); + // @@protoc_insertion_point(copy_constructor:MumbleProto.UserStats.Stats) +} + +void UserStats_Stats::SharedCtor() { + ::memset(&good_, 0, static_cast( + reinterpret_cast(&resync_) - + reinterpret_cast(&good_)) + sizeof(resync_)); +} + +UserStats_Stats::~UserStats_Stats() { + // @@protoc_insertion_point(destructor:MumbleProto.UserStats.Stats) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void UserStats_Stats::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void UserStats_Stats::ArenaDtor(void* object) { + UserStats_Stats* _this = reinterpret_cast< UserStats_Stats* >(object); + (void)_this; +} +void UserStats_Stats::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void UserStats_Stats::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const UserStats_Stats& UserStats_Stats::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_UserStats_Stats_Mumble_2eproto.base); + return *internal_default_instance(); +} + + +void UserStats_Stats::Clear() { +// @@protoc_insertion_point(message_clear_start:MumbleProto.UserStats.Stats) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + ::memset(&good_, 0, static_cast( + reinterpret_cast(&resync_) - + reinterpret_cast(&good_)) + sizeof(resync_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* UserStats_Stats::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional uint32 good = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + _Internal::set_has_good(&has_bits); + good_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 late = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + _Internal::set_has_late(&has_bits); + late_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 lost = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + _Internal::set_has_lost(&has_bits); + lost_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 resync = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + _Internal::set_has_resync(&has_bits); + resync_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* UserStats_Stats::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MumbleProto.UserStats.Stats) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional uint32 good = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_good(), target); + } + + // optional uint32 late = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_late(), target); + } + + // optional uint32 lost = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_lost(), target); + } + + // optional uint32 resync = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_resync(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MumbleProto.UserStats.Stats) + return target; +} + +size_t UserStats_Stats::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MumbleProto.UserStats.Stats) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + // optional uint32 good = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_good()); + } + + // optional uint32 late = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_late()); + } + + // optional uint32 lost = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_lost()); + } + + // optional uint32 resync = 4; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_resync()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void UserStats_Stats::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:MumbleProto.UserStats.Stats) + GOOGLE_DCHECK_NE(&from, this); + const UserStats_Stats* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:MumbleProto.UserStats.Stats) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:MumbleProto.UserStats.Stats) + MergeFrom(*source); + } +} + +void UserStats_Stats::MergeFrom(const UserStats_Stats& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MumbleProto.UserStats.Stats) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + good_ = from.good_; + } + if (cached_has_bits & 0x00000002u) { + late_ = from.late_; + } + if (cached_has_bits & 0x00000004u) { + lost_ = from.lost_; + } + if (cached_has_bits & 0x00000008u) { + resync_ = from.resync_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void UserStats_Stats::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:MumbleProto.UserStats.Stats) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void UserStats_Stats::CopyFrom(const UserStats_Stats& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MumbleProto.UserStats.Stats) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool UserStats_Stats::IsInitialized() const { + return true; +} + +void UserStats_Stats::InternalSwap(UserStats_Stats* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(UserStats_Stats, resync_) + + sizeof(UserStats_Stats::resync_) + - PROTOBUF_FIELD_OFFSET(UserStats_Stats, good_)>( + reinterpret_cast(&good_), + reinterpret_cast(&other->good_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata UserStats_Stats::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void UserStats::InitAsDefaultInstance() { + ::MumbleProto::_UserStats_default_instance_._instance.get_mutable()->from_client_ = const_cast< ::MumbleProto::UserStats_Stats*>( + ::MumbleProto::UserStats_Stats::internal_default_instance()); + ::MumbleProto::_UserStats_default_instance_._instance.get_mutable()->from_server_ = const_cast< ::MumbleProto::UserStats_Stats*>( + ::MumbleProto::UserStats_Stats::internal_default_instance()); + ::MumbleProto::_UserStats_default_instance_._instance.get_mutable()->version_ = const_cast< ::MumbleProto::Version*>( + ::MumbleProto::Version::internal_default_instance()); +} +class UserStats::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_session(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_stats_only(HasBits* has_bits) { + (*has_bits)[0] |= 2048u; + } + static const ::MumbleProto::UserStats_Stats& from_client(const UserStats* msg); + static void set_has_from_client(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::MumbleProto::UserStats_Stats& from_server(const UserStats* msg); + static void set_has_from_server(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_udp_packets(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_tcp_packets(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_udp_ping_avg(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static void set_has_udp_ping_var(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static void set_has_tcp_ping_avg(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } + static void set_has_tcp_ping_var(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } + static const ::MumbleProto::Version& version(const UserStats* msg); + static void set_has_version(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_address(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_bandwidth(HasBits* has_bits) { + (*has_bits)[0] |= 16384u; + } + static void set_has_onlinesecs(HasBits* has_bits) { + (*has_bits)[0] |= 32768u; + } + static void set_has_idlesecs(HasBits* has_bits) { + (*has_bits)[0] |= 65536u; + } + static void set_has_strong_certificate(HasBits* has_bits) { + (*has_bits)[0] |= 4096u; + } + static void set_has_opus(HasBits* has_bits) { + (*has_bits)[0] |= 8192u; + } +}; + +const ::MumbleProto::UserStats_Stats& +UserStats::_Internal::from_client(const UserStats* msg) { + return *msg->from_client_; +} +const ::MumbleProto::UserStats_Stats& +UserStats::_Internal::from_server(const UserStats* msg) { + return *msg->from_server_; +} +const ::MumbleProto::Version& +UserStats::_Internal::version(const UserStats* msg) { + return *msg->version_; +} +UserStats::UserStats(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + certificates_(arena), + celt_versions_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:MumbleProto.UserStats) +} +UserStats::UserStats(const UserStats& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_), + certificates_(from.certificates_), + celt_versions_(from.celt_versions_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + address_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_address()) { + address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_address(), + GetArena()); + } + if (from._internal_has_from_client()) { + from_client_ = new ::MumbleProto::UserStats_Stats(*from.from_client_); + } else { + from_client_ = nullptr; + } + if (from._internal_has_from_server()) { + from_server_ = new ::MumbleProto::UserStats_Stats(*from.from_server_); + } else { + from_server_ = nullptr; + } + if (from._internal_has_version()) { + version_ = new ::MumbleProto::Version(*from.version_); + } else { + version_ = nullptr; + } + ::memcpy(&session_, &from.session_, + static_cast(reinterpret_cast(&idlesecs_) - + reinterpret_cast(&session_)) + sizeof(idlesecs_)); + // @@protoc_insertion_point(copy_constructor:MumbleProto.UserStats) +} + +void UserStats::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_UserStats_Mumble_2eproto.base); + address_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&from_client_, 0, static_cast( + reinterpret_cast(&idlesecs_) - + reinterpret_cast(&from_client_)) + sizeof(idlesecs_)); +} + +UserStats::~UserStats() { + // @@protoc_insertion_point(destructor:MumbleProto.UserStats) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void UserStats::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + address_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete from_client_; + if (this != internal_default_instance()) delete from_server_; + if (this != internal_default_instance()) delete version_; +} + +void UserStats::ArenaDtor(void* object) { + UserStats* _this = reinterpret_cast< UserStats* >(object); + (void)_this; +} +void UserStats::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void UserStats::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const UserStats& UserStats::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_UserStats_Mumble_2eproto.base); + return *internal_default_instance(); +} + + +void UserStats::Clear() { +// @@protoc_insertion_point(message_clear_start:MumbleProto.UserStats) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + certificates_.Clear(); + celt_versions_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + address_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(from_client_ != nullptr); + from_client_->Clear(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(from_server_ != nullptr); + from_server_->Clear(); + } + if (cached_has_bits & 0x00000008u) { + GOOGLE_DCHECK(version_ != nullptr); + version_->Clear(); + } + } + if (cached_has_bits & 0x000000f0u) { + ::memset(&session_, 0, static_cast( + reinterpret_cast(&udp_ping_avg_) - + reinterpret_cast(&session_)) + sizeof(udp_ping_avg_)); + } + if (cached_has_bits & 0x0000ff00u) { + ::memset(&udp_ping_var_, 0, static_cast( + reinterpret_cast(&onlinesecs_) - + reinterpret_cast(&udp_ping_var_)) + sizeof(onlinesecs_)); + } + idlesecs_ = 0u; + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* UserStats::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional uint32 session = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + _Internal::set_has_session(&has_bits); + session_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool stats_only = 2 [default = false]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + _Internal::set_has_stats_only(&has_bits); + stats_only_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated bytes certificates = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_certificates(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); + } else goto handle_unusual; + continue; + // optional .MumbleProto.UserStats.Stats from_client = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_from_client(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional .MumbleProto.UserStats.Stats from_server = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_from_server(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 udp_packets = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) { + _Internal::set_has_udp_packets(&has_bits); + udp_packets_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 tcp_packets = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) { + _Internal::set_has_tcp_packets(&has_bits); + tcp_packets_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional float udp_ping_avg = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 69)) { + _Internal::set_has_udp_ping_avg(&has_bits); + udp_ping_avg_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // optional float udp_ping_var = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 77)) { + _Internal::set_has_udp_ping_var(&has_bits); + udp_ping_var_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // optional float tcp_ping_avg = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 85)) { + _Internal::set_has_tcp_ping_avg(&has_bits); + tcp_ping_avg_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // optional float tcp_ping_var = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 93)) { + _Internal::set_has_tcp_ping_var(&has_bits); + tcp_ping_var_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // optional .MumbleProto.Version version = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 98)) { + ptr = ctx->ParseMessage(_internal_mutable_version(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated int32 celt_versions = 13; + case 13: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 104)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_celt_versions(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<104>(ptr)); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_celt_versions(), ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bytes address = 14; + case 14: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 114)) { + auto str = _internal_mutable_address(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 bandwidth = 15; + case 15: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 120)) { + _Internal::set_has_bandwidth(&has_bits); + bandwidth_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 onlinesecs = 16; + case 16: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 128)) { + _Internal::set_has_onlinesecs(&has_bits); + onlinesecs_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 idlesecs = 17; + case 17: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 136)) { + _Internal::set_has_idlesecs(&has_bits); + idlesecs_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool strong_certificate = 18 [default = false]; + case 18: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 144)) { + _Internal::set_has_strong_certificate(&has_bits); + strong_certificate_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool opus = 19 [default = false]; + case 19: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 152)) { + _Internal::set_has_opus(&has_bits); + opus_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* UserStats::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MumbleProto.UserStats) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional uint32 session = 1; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_session(), target); + } + + // optional bool stats_only = 2 [default = false]; + if (cached_has_bits & 0x00000800u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_stats_only(), target); + } + + // repeated bytes certificates = 3; + for (int i = 0, n = this->_internal_certificates_size(); i < n; i++) { + const auto& s = this->_internal_certificates(i); + target = stream->WriteBytes(3, s, target); + } + + // optional .MumbleProto.UserStats.Stats from_client = 4; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 4, _Internal::from_client(this), target, stream); + } + + // optional .MumbleProto.UserStats.Stats from_server = 5; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 5, _Internal::from_server(this), target, stream); + } + + // optional uint32 udp_packets = 6; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(6, this->_internal_udp_packets(), target); + } + + // optional uint32 tcp_packets = 7; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(7, this->_internal_tcp_packets(), target); + } + + // optional float udp_ping_avg = 8; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(8, this->_internal_udp_ping_avg(), target); + } + + // optional float udp_ping_var = 9; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(9, this->_internal_udp_ping_var(), target); + } + + // optional float tcp_ping_avg = 10; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(10, this->_internal_tcp_ping_avg(), target); + } + + // optional float tcp_ping_var = 11; + if (cached_has_bits & 0x00000400u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(11, this->_internal_tcp_ping_var(), target); + } + + // optional .MumbleProto.Version version = 12; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 12, _Internal::version(this), target, stream); + } + + // repeated int32 celt_versions = 13; + for (int i = 0, n = this->_internal_celt_versions_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(13, this->_internal_celt_versions(i), target); + } + + // optional bytes address = 14; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 14, this->_internal_address(), target); + } + + // optional uint32 bandwidth = 15; + if (cached_has_bits & 0x00004000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(15, this->_internal_bandwidth(), target); + } + + // optional uint32 onlinesecs = 16; + if (cached_has_bits & 0x00008000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(16, this->_internal_onlinesecs(), target); + } + + // optional uint32 idlesecs = 17; + if (cached_has_bits & 0x00010000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(17, this->_internal_idlesecs(), target); + } + + // optional bool strong_certificate = 18 [default = false]; + if (cached_has_bits & 0x00001000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(18, this->_internal_strong_certificate(), target); + } + + // optional bool opus = 19 [default = false]; + if (cached_has_bits & 0x00002000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(19, this->_internal_opus(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MumbleProto.UserStats) + return target; +} + +size_t UserStats::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MumbleProto.UserStats) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated bytes certificates = 3; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(certificates_.size()); + for (int i = 0, n = certificates_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + certificates_.Get(i)); + } + + // repeated int32 celt_versions = 13; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + Int32Size(this->celt_versions_); + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_celt_versions_size()); + total_size += data_size; + } + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional bytes address = 14; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_address()); + } + + // optional .MumbleProto.UserStats.Stats from_client = 4; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *from_client_); + } + + // optional .MumbleProto.UserStats.Stats from_server = 5; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *from_server_); + } + + // optional .MumbleProto.Version version = 12; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *version_); + } + + // optional uint32 session = 1; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_session()); + } + + // optional uint32 udp_packets = 6; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_udp_packets()); + } + + // optional uint32 tcp_packets = 7; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_tcp_packets()); + } + + // optional float udp_ping_avg = 8; + if (cached_has_bits & 0x00000080u) { + total_size += 1 + 4; + } + + } + if (cached_has_bits & 0x0000ff00u) { + // optional float udp_ping_var = 9; + if (cached_has_bits & 0x00000100u) { + total_size += 1 + 4; + } + + // optional float tcp_ping_avg = 10; + if (cached_has_bits & 0x00000200u) { + total_size += 1 + 4; + } + + // optional float tcp_ping_var = 11; + if (cached_has_bits & 0x00000400u) { + total_size += 1 + 4; + } + + // optional bool stats_only = 2 [default = false]; + if (cached_has_bits & 0x00000800u) { + total_size += 1 + 1; + } + + // optional bool strong_certificate = 18 [default = false]; + if (cached_has_bits & 0x00001000u) { + total_size += 2 + 1; + } + + // optional bool opus = 19 [default = false]; + if (cached_has_bits & 0x00002000u) { + total_size += 2 + 1; + } + + // optional uint32 bandwidth = 15; + if (cached_has_bits & 0x00004000u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_bandwidth()); + } + + // optional uint32 onlinesecs = 16; + if (cached_has_bits & 0x00008000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_onlinesecs()); + } + + } + // optional uint32 idlesecs = 17; + if (cached_has_bits & 0x00010000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_idlesecs()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void UserStats::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:MumbleProto.UserStats) + GOOGLE_DCHECK_NE(&from, this); + const UserStats* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:MumbleProto.UserStats) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:MumbleProto.UserStats) + MergeFrom(*source); + } +} + +void UserStats::MergeFrom(const UserStats& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MumbleProto.UserStats) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + certificates_.MergeFrom(from.certificates_); + celt_versions_.MergeFrom(from.celt_versions_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_address(from._internal_address()); + } + if (cached_has_bits & 0x00000002u) { + _internal_mutable_from_client()->::MumbleProto::UserStats_Stats::MergeFrom(from._internal_from_client()); + } + if (cached_has_bits & 0x00000004u) { + _internal_mutable_from_server()->::MumbleProto::UserStats_Stats::MergeFrom(from._internal_from_server()); + } + if (cached_has_bits & 0x00000008u) { + _internal_mutable_version()->::MumbleProto::Version::MergeFrom(from._internal_version()); + } + if (cached_has_bits & 0x00000010u) { + session_ = from.session_; + } + if (cached_has_bits & 0x00000020u) { + udp_packets_ = from.udp_packets_; + } + if (cached_has_bits & 0x00000040u) { + tcp_packets_ = from.tcp_packets_; + } + if (cached_has_bits & 0x00000080u) { + udp_ping_avg_ = from.udp_ping_avg_; + } + _has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x0000ff00u) { + if (cached_has_bits & 0x00000100u) { + udp_ping_var_ = from.udp_ping_var_; + } + if (cached_has_bits & 0x00000200u) { + tcp_ping_avg_ = from.tcp_ping_avg_; + } + if (cached_has_bits & 0x00000400u) { + tcp_ping_var_ = from.tcp_ping_var_; + } + if (cached_has_bits & 0x00000800u) { + stats_only_ = from.stats_only_; + } + if (cached_has_bits & 0x00001000u) { + strong_certificate_ = from.strong_certificate_; + } + if (cached_has_bits & 0x00002000u) { + opus_ = from.opus_; + } + if (cached_has_bits & 0x00004000u) { + bandwidth_ = from.bandwidth_; + } + if (cached_has_bits & 0x00008000u) { + onlinesecs_ = from.onlinesecs_; + } + _has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x00010000u) { + _internal_set_idlesecs(from._internal_idlesecs()); + } +} + +void UserStats::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:MumbleProto.UserStats) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void UserStats::CopyFrom(const UserStats& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MumbleProto.UserStats) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool UserStats::IsInitialized() const { + return true; +} + +void UserStats::InternalSwap(UserStats* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + certificates_.InternalSwap(&other->certificates_); + celt_versions_.InternalSwap(&other->celt_versions_); + address_.Swap(&other->address_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(UserStats, idlesecs_) + + sizeof(UserStats::idlesecs_) + - PROTOBUF_FIELD_OFFSET(UserStats, from_client_)>( + reinterpret_cast(&from_client_), + reinterpret_cast(&other->from_client_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata UserStats::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void RequestBlob::InitAsDefaultInstance() { +} +class RequestBlob::_Internal { + public: +}; + +RequestBlob::RequestBlob(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + session_texture_(arena), + session_comment_(arena), + channel_description_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:MumbleProto.RequestBlob) +} +RequestBlob::RequestBlob(const RequestBlob& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + session_texture_(from.session_texture_), + session_comment_(from.session_comment_), + channel_description_(from.channel_description_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:MumbleProto.RequestBlob) +} + +void RequestBlob::SharedCtor() { +} + +RequestBlob::~RequestBlob() { + // @@protoc_insertion_point(destructor:MumbleProto.RequestBlob) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void RequestBlob::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void RequestBlob::ArenaDtor(void* object) { + RequestBlob* _this = reinterpret_cast< RequestBlob* >(object); + (void)_this; +} +void RequestBlob::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void RequestBlob::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const RequestBlob& RequestBlob::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_RequestBlob_Mumble_2eproto.base); + return *internal_default_instance(); +} + + +void RequestBlob::Clear() { +// @@protoc_insertion_point(message_clear_start:MumbleProto.RequestBlob) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + session_texture_.Clear(); + session_comment_.Clear(); + channel_description_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* RequestBlob::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // repeated uint32 session_texture = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_session_texture(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<8>(ptr)); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_session_texture(), ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated uint32 session_comment = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_session_comment(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<16>(ptr)); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_session_comment(), ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated uint32 channel_description = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_channel_description(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<24>(ptr)); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_channel_description(), ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* RequestBlob::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MumbleProto.RequestBlob) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated uint32 session_texture = 1; + for (int i = 0, n = this->_internal_session_texture_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_session_texture(i), target); + } + + // repeated uint32 session_comment = 2; + for (int i = 0, n = this->_internal_session_comment_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_session_comment(i), target); + } + + // repeated uint32 channel_description = 3; + for (int i = 0, n = this->_internal_channel_description_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_channel_description(i), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MumbleProto.RequestBlob) + return target; +} + +size_t RequestBlob::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MumbleProto.RequestBlob) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated uint32 session_texture = 1; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + UInt32Size(this->session_texture_); + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_session_texture_size()); + total_size += data_size; + } + + // repeated uint32 session_comment = 2; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + UInt32Size(this->session_comment_); + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_session_comment_size()); + total_size += data_size; + } + + // repeated uint32 channel_description = 3; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + UInt32Size(this->channel_description_); + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_channel_description_size()); + total_size += data_size; + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void RequestBlob::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:MumbleProto.RequestBlob) + GOOGLE_DCHECK_NE(&from, this); + const RequestBlob* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:MumbleProto.RequestBlob) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:MumbleProto.RequestBlob) + MergeFrom(*source); + } +} + +void RequestBlob::MergeFrom(const RequestBlob& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MumbleProto.RequestBlob) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + session_texture_.MergeFrom(from.session_texture_); + session_comment_.MergeFrom(from.session_comment_); + channel_description_.MergeFrom(from.channel_description_); +} + +void RequestBlob::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:MumbleProto.RequestBlob) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void RequestBlob::CopyFrom(const RequestBlob& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MumbleProto.RequestBlob) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RequestBlob::IsInitialized() const { + return true; +} + +void RequestBlob::InternalSwap(RequestBlob* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + session_texture_.InternalSwap(&other->session_texture_); + session_comment_.InternalSwap(&other->session_comment_); + channel_description_.InternalSwap(&other->channel_description_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata RequestBlob::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void ServerConfig::InitAsDefaultInstance() { +} +class ServerConfig::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_max_bandwidth(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_welcome_text(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_allow_html(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_message_length(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_image_message_length(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_max_users(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } +}; + +ServerConfig::ServerConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:MumbleProto.ServerConfig) +} +ServerConfig::ServerConfig(const ServerConfig& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + welcome_text_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_welcome_text()) { + welcome_text_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_welcome_text(), + GetArena()); + } + ::memcpy(&max_bandwidth_, &from.max_bandwidth_, + static_cast(reinterpret_cast(&max_users_) - + reinterpret_cast(&max_bandwidth_)) + sizeof(max_users_)); + // @@protoc_insertion_point(copy_constructor:MumbleProto.ServerConfig) +} + +void ServerConfig::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ServerConfig_Mumble_2eproto.base); + welcome_text_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&max_bandwidth_, 0, static_cast( + reinterpret_cast(&max_users_) - + reinterpret_cast(&max_bandwidth_)) + sizeof(max_users_)); +} + +ServerConfig::~ServerConfig() { + // @@protoc_insertion_point(destructor:MumbleProto.ServerConfig) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void ServerConfig::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + welcome_text_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ServerConfig::ArenaDtor(void* object) { + ServerConfig* _this = reinterpret_cast< ServerConfig* >(object); + (void)_this; +} +void ServerConfig::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ServerConfig::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ServerConfig& ServerConfig::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ServerConfig_Mumble_2eproto.base); + return *internal_default_instance(); +} + + +void ServerConfig::Clear() { +// @@protoc_insertion_point(message_clear_start:MumbleProto.ServerConfig) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + welcome_text_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x0000003eu) { + ::memset(&max_bandwidth_, 0, static_cast( + reinterpret_cast(&max_users_) - + reinterpret_cast(&max_bandwidth_)) + sizeof(max_users_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ServerConfig::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional uint32 max_bandwidth = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + _Internal::set_has_max_bandwidth(&has_bits); + max_bandwidth_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string welcome_text = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_welcome_text(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MumbleProto.ServerConfig.welcome_text"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool allow_html = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + _Internal::set_has_allow_html(&has_bits); + allow_html_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 message_length = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + _Internal::set_has_message_length(&has_bits); + message_length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 image_message_length = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) { + _Internal::set_has_image_message_length(&has_bits); + image_message_length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 max_users = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) { + _Internal::set_has_max_users(&has_bits); + max_users_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ServerConfig::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MumbleProto.ServerConfig) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional uint32 max_bandwidth = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_max_bandwidth(), target); + } + + // optional string welcome_text = 2; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_welcome_text().data(), static_cast(this->_internal_welcome_text().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "MumbleProto.ServerConfig.welcome_text"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_welcome_text(), target); + } + + // optional bool allow_html = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->_internal_allow_html(), target); + } + + // optional uint32 message_length = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_message_length(), target); + } + + // optional uint32 image_message_length = 5; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(5, this->_internal_image_message_length(), target); + } + + // optional uint32 max_users = 6; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(6, this->_internal_max_users(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MumbleProto.ServerConfig) + return target; +} + +size_t ServerConfig::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MumbleProto.ServerConfig) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + // optional string welcome_text = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_welcome_text()); + } + + // optional uint32 max_bandwidth = 1; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_max_bandwidth()); + } + + // optional bool allow_html = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + 1; + } + + // optional uint32 message_length = 4; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_message_length()); + } + + // optional uint32 image_message_length = 5; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_image_message_length()); + } + + // optional uint32 max_users = 6; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_max_users()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ServerConfig::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:MumbleProto.ServerConfig) + GOOGLE_DCHECK_NE(&from, this); + const ServerConfig* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:MumbleProto.ServerConfig) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:MumbleProto.ServerConfig) + MergeFrom(*source); + } +} + +void ServerConfig::MergeFrom(const ServerConfig& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MumbleProto.ServerConfig) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_welcome_text(from._internal_welcome_text()); + } + if (cached_has_bits & 0x00000002u) { + max_bandwidth_ = from.max_bandwidth_; + } + if (cached_has_bits & 0x00000004u) { + allow_html_ = from.allow_html_; + } + if (cached_has_bits & 0x00000008u) { + message_length_ = from.message_length_; + } + if (cached_has_bits & 0x00000010u) { + image_message_length_ = from.image_message_length_; + } + if (cached_has_bits & 0x00000020u) { + max_users_ = from.max_users_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void ServerConfig::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:MumbleProto.ServerConfig) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ServerConfig::CopyFrom(const ServerConfig& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MumbleProto.ServerConfig) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ServerConfig::IsInitialized() const { + return true; +} + +void ServerConfig::InternalSwap(ServerConfig* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + welcome_text_.Swap(&other->welcome_text_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ServerConfig, max_users_) + + sizeof(ServerConfig::max_users_) + - PROTOBUF_FIELD_OFFSET(ServerConfig, max_bandwidth_)>( + reinterpret_cast(&max_bandwidth_), + reinterpret_cast(&other->max_bandwidth_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ServerConfig::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void SuggestConfig::InitAsDefaultInstance() { +} +class SuggestConfig::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_version(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_positional(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_push_to_talk(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +SuggestConfig::SuggestConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:MumbleProto.SuggestConfig) +} +SuggestConfig::SuggestConfig(const SuggestConfig& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&version_, &from.version_, + static_cast(reinterpret_cast(&push_to_talk_) - + reinterpret_cast(&version_)) + sizeof(push_to_talk_)); + // @@protoc_insertion_point(copy_constructor:MumbleProto.SuggestConfig) +} + +void SuggestConfig::SharedCtor() { + ::memset(&version_, 0, static_cast( + reinterpret_cast(&push_to_talk_) - + reinterpret_cast(&version_)) + sizeof(push_to_talk_)); +} + +SuggestConfig::~SuggestConfig() { + // @@protoc_insertion_point(destructor:MumbleProto.SuggestConfig) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void SuggestConfig::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void SuggestConfig::ArenaDtor(void* object) { + SuggestConfig* _this = reinterpret_cast< SuggestConfig* >(object); + (void)_this; +} +void SuggestConfig::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void SuggestConfig::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const SuggestConfig& SuggestConfig::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_SuggestConfig_Mumble_2eproto.base); + return *internal_default_instance(); +} + + +void SuggestConfig::Clear() { +// @@protoc_insertion_point(message_clear_start:MumbleProto.SuggestConfig) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + ::memset(&version_, 0, static_cast( + reinterpret_cast(&push_to_talk_) - + reinterpret_cast(&version_)) + sizeof(push_to_talk_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SuggestConfig::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional uint32 version = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + _Internal::set_has_version(&has_bits); + version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool positional = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + _Internal::set_has_positional(&has_bits); + positional_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool push_to_talk = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + _Internal::set_has_push_to_talk(&has_bits); + push_to_talk_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* SuggestConfig::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MumbleProto.SuggestConfig) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional uint32 version = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_version(), target); + } + + // optional bool positional = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_positional(), target); + } + + // optional bool push_to_talk = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->_internal_push_to_talk(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MumbleProto.SuggestConfig) + return target; +} + +size_t SuggestConfig::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MumbleProto.SuggestConfig) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional uint32 version = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_version()); + } + + // optional bool positional = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + 1; + } + + // optional bool push_to_talk = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + 1; + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void SuggestConfig::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:MumbleProto.SuggestConfig) + GOOGLE_DCHECK_NE(&from, this); + const SuggestConfig* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:MumbleProto.SuggestConfig) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:MumbleProto.SuggestConfig) + MergeFrom(*source); + } +} + +void SuggestConfig::MergeFrom(const SuggestConfig& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MumbleProto.SuggestConfig) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + version_ = from.version_; + } + if (cached_has_bits & 0x00000002u) { + positional_ = from.positional_; + } + if (cached_has_bits & 0x00000004u) { + push_to_talk_ = from.push_to_talk_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void SuggestConfig::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:MumbleProto.SuggestConfig) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SuggestConfig::CopyFrom(const SuggestConfig& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MumbleProto.SuggestConfig) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SuggestConfig::IsInitialized() const { + return true; +} + +void SuggestConfig::InternalSwap(SuggestConfig* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(SuggestConfig, push_to_talk_) + + sizeof(SuggestConfig::push_to_talk_) + - PROTOBUF_FIELD_OFFSET(SuggestConfig, version_)>( + reinterpret_cast(&version_), + reinterpret_cast(&other->version_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SuggestConfig::GetMetadata() const { + return GetMetadataStatic(); +} + + +// @@protoc_insertion_point(namespace_scope) +} // namespace MumbleProto +PROTOBUF_NAMESPACE_OPEN +template<> PROTOBUF_NOINLINE ::MumbleProto::Version* Arena::CreateMaybeMessage< ::MumbleProto::Version >(Arena* arena) { + return Arena::CreateMessageInternal< ::MumbleProto::Version >(arena); +} +template<> PROTOBUF_NOINLINE ::MumbleProto::UDPTunnel* Arena::CreateMaybeMessage< ::MumbleProto::UDPTunnel >(Arena* arena) { + return Arena::CreateMessageInternal< ::MumbleProto::UDPTunnel >(arena); +} +template<> PROTOBUF_NOINLINE ::MumbleProto::Authenticate* Arena::CreateMaybeMessage< ::MumbleProto::Authenticate >(Arena* arena) { + return Arena::CreateMessageInternal< ::MumbleProto::Authenticate >(arena); +} +template<> PROTOBUF_NOINLINE ::MumbleProto::Ping* Arena::CreateMaybeMessage< ::MumbleProto::Ping >(Arena* arena) { + return Arena::CreateMessageInternal< ::MumbleProto::Ping >(arena); +} +template<> PROTOBUF_NOINLINE ::MumbleProto::Reject* Arena::CreateMaybeMessage< ::MumbleProto::Reject >(Arena* arena) { + return Arena::CreateMessageInternal< ::MumbleProto::Reject >(arena); +} +template<> PROTOBUF_NOINLINE ::MumbleProto::ServerSync* Arena::CreateMaybeMessage< ::MumbleProto::ServerSync >(Arena* arena) { + return Arena::CreateMessageInternal< ::MumbleProto::ServerSync >(arena); +} +template<> PROTOBUF_NOINLINE ::MumbleProto::ChannelRemove* Arena::CreateMaybeMessage< ::MumbleProto::ChannelRemove >(Arena* arena) { + return Arena::CreateMessageInternal< ::MumbleProto::ChannelRemove >(arena); +} +template<> PROTOBUF_NOINLINE ::MumbleProto::ChannelState* Arena::CreateMaybeMessage< ::MumbleProto::ChannelState >(Arena* arena) { + return Arena::CreateMessageInternal< ::MumbleProto::ChannelState >(arena); +} +template<> PROTOBUF_NOINLINE ::MumbleProto::UserRemove* Arena::CreateMaybeMessage< ::MumbleProto::UserRemove >(Arena* arena) { + return Arena::CreateMessageInternal< ::MumbleProto::UserRemove >(arena); +} +template<> PROTOBUF_NOINLINE ::MumbleProto::UserState* Arena::CreateMaybeMessage< ::MumbleProto::UserState >(Arena* arena) { + return Arena::CreateMessageInternal< ::MumbleProto::UserState >(arena); +} +template<> PROTOBUF_NOINLINE ::MumbleProto::BanList_BanEntry* Arena::CreateMaybeMessage< ::MumbleProto::BanList_BanEntry >(Arena* arena) { + return Arena::CreateMessageInternal< ::MumbleProto::BanList_BanEntry >(arena); +} +template<> PROTOBUF_NOINLINE ::MumbleProto::BanList* Arena::CreateMaybeMessage< ::MumbleProto::BanList >(Arena* arena) { + return Arena::CreateMessageInternal< ::MumbleProto::BanList >(arena); +} +template<> PROTOBUF_NOINLINE ::MumbleProto::TextMessage* Arena::CreateMaybeMessage< ::MumbleProto::TextMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::MumbleProto::TextMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::MumbleProto::PermissionDenied* Arena::CreateMaybeMessage< ::MumbleProto::PermissionDenied >(Arena* arena) { + return Arena::CreateMessageInternal< ::MumbleProto::PermissionDenied >(arena); +} +template<> PROTOBUF_NOINLINE ::MumbleProto::ACL_ChanGroup* Arena::CreateMaybeMessage< ::MumbleProto::ACL_ChanGroup >(Arena* arena) { + return Arena::CreateMessageInternal< ::MumbleProto::ACL_ChanGroup >(arena); +} +template<> PROTOBUF_NOINLINE ::MumbleProto::ACL_ChanACL* Arena::CreateMaybeMessage< ::MumbleProto::ACL_ChanACL >(Arena* arena) { + return Arena::CreateMessageInternal< ::MumbleProto::ACL_ChanACL >(arena); +} +template<> PROTOBUF_NOINLINE ::MumbleProto::ACL* Arena::CreateMaybeMessage< ::MumbleProto::ACL >(Arena* arena) { + return Arena::CreateMessageInternal< ::MumbleProto::ACL >(arena); +} +template<> PROTOBUF_NOINLINE ::MumbleProto::QueryUsers* Arena::CreateMaybeMessage< ::MumbleProto::QueryUsers >(Arena* arena) { + return Arena::CreateMessageInternal< ::MumbleProto::QueryUsers >(arena); +} +template<> PROTOBUF_NOINLINE ::MumbleProto::CryptSetup* Arena::CreateMaybeMessage< ::MumbleProto::CryptSetup >(Arena* arena) { + return Arena::CreateMessageInternal< ::MumbleProto::CryptSetup >(arena); +} +template<> PROTOBUF_NOINLINE ::MumbleProto::ContextActionModify* Arena::CreateMaybeMessage< ::MumbleProto::ContextActionModify >(Arena* arena) { + return Arena::CreateMessageInternal< ::MumbleProto::ContextActionModify >(arena); +} +template<> PROTOBUF_NOINLINE ::MumbleProto::ContextAction* Arena::CreateMaybeMessage< ::MumbleProto::ContextAction >(Arena* arena) { + return Arena::CreateMessageInternal< ::MumbleProto::ContextAction >(arena); +} +template<> PROTOBUF_NOINLINE ::MumbleProto::UserList_User* Arena::CreateMaybeMessage< ::MumbleProto::UserList_User >(Arena* arena) { + return Arena::CreateMessageInternal< ::MumbleProto::UserList_User >(arena); +} +template<> PROTOBUF_NOINLINE ::MumbleProto::UserList* Arena::CreateMaybeMessage< ::MumbleProto::UserList >(Arena* arena) { + return Arena::CreateMessageInternal< ::MumbleProto::UserList >(arena); +} +template<> PROTOBUF_NOINLINE ::MumbleProto::VoiceTarget_Target* Arena::CreateMaybeMessage< ::MumbleProto::VoiceTarget_Target >(Arena* arena) { + return Arena::CreateMessageInternal< ::MumbleProto::VoiceTarget_Target >(arena); +} +template<> PROTOBUF_NOINLINE ::MumbleProto::VoiceTarget* Arena::CreateMaybeMessage< ::MumbleProto::VoiceTarget >(Arena* arena) { + return Arena::CreateMessageInternal< ::MumbleProto::VoiceTarget >(arena); +} +template<> PROTOBUF_NOINLINE ::MumbleProto::PermissionQuery* Arena::CreateMaybeMessage< ::MumbleProto::PermissionQuery >(Arena* arena) { + return Arena::CreateMessageInternal< ::MumbleProto::PermissionQuery >(arena); +} +template<> PROTOBUF_NOINLINE ::MumbleProto::CodecVersion* Arena::CreateMaybeMessage< ::MumbleProto::CodecVersion >(Arena* arena) { + return Arena::CreateMessageInternal< ::MumbleProto::CodecVersion >(arena); +} +template<> PROTOBUF_NOINLINE ::MumbleProto::UserStats_Stats* Arena::CreateMaybeMessage< ::MumbleProto::UserStats_Stats >(Arena* arena) { + return Arena::CreateMessageInternal< ::MumbleProto::UserStats_Stats >(arena); +} +template<> PROTOBUF_NOINLINE ::MumbleProto::UserStats* Arena::CreateMaybeMessage< ::MumbleProto::UserStats >(Arena* arena) { + return Arena::CreateMessageInternal< ::MumbleProto::UserStats >(arena); +} +template<> PROTOBUF_NOINLINE ::MumbleProto::RequestBlob* Arena::CreateMaybeMessage< ::MumbleProto::RequestBlob >(Arena* arena) { + return Arena::CreateMessageInternal< ::MumbleProto::RequestBlob >(arena); +} +template<> PROTOBUF_NOINLINE ::MumbleProto::ServerConfig* Arena::CreateMaybeMessage< ::MumbleProto::ServerConfig >(Arena* arena) { + return Arena::CreateMessageInternal< ::MumbleProto::ServerConfig >(arena); +} +template<> PROTOBUF_NOINLINE ::MumbleProto::SuggestConfig* Arena::CreateMaybeMessage< ::MumbleProto::SuggestConfig >(Arena* arena) { + return Arena::CreateMessageInternal< ::MumbleProto::SuggestConfig >(arena); +} +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) +#include diff --git a/Mumble.pb.h b/Mumble.pb.h new file mode 100644 index 0000000..a23152b --- /dev/null +++ b/Mumble.pb.h @@ -0,0 +1,15226 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: Mumble.proto + +#ifndef GOOGLE_PROTOBUF_INCLUDED_Mumble_2eproto +#define GOOGLE_PROTOBUF_INCLUDED_Mumble_2eproto + +#include +#include + +#include +#if PROTOBUF_VERSION < 3012000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 3012003 < PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include // IWYU pragma: export +#include // IWYU pragma: export +#include +#include +// @@protoc_insertion_point(includes) +#include +#define PROTOBUF_INTERNAL_EXPORT_Mumble_2eproto +PROTOBUF_NAMESPACE_OPEN +namespace internal { +class AnyMetadata; +} // namespace internal +PROTOBUF_NAMESPACE_CLOSE + +// Internal implementation detail -- do not use these members. +struct TableStruct_Mumble_2eproto { + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[32] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; + static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; + static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[]; +}; +extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_Mumble_2eproto; +namespace MumbleProto { +class ACL; +class ACLDefaultTypeInternal; +extern ACLDefaultTypeInternal _ACL_default_instance_; +class ACL_ChanACL; +class ACL_ChanACLDefaultTypeInternal; +extern ACL_ChanACLDefaultTypeInternal _ACL_ChanACL_default_instance_; +class ACL_ChanGroup; +class ACL_ChanGroupDefaultTypeInternal; +extern ACL_ChanGroupDefaultTypeInternal _ACL_ChanGroup_default_instance_; +class Authenticate; +class AuthenticateDefaultTypeInternal; +extern AuthenticateDefaultTypeInternal _Authenticate_default_instance_; +class BanList; +class BanListDefaultTypeInternal; +extern BanListDefaultTypeInternal _BanList_default_instance_; +class BanList_BanEntry; +class BanList_BanEntryDefaultTypeInternal; +extern BanList_BanEntryDefaultTypeInternal _BanList_BanEntry_default_instance_; +class ChannelRemove; +class ChannelRemoveDefaultTypeInternal; +extern ChannelRemoveDefaultTypeInternal _ChannelRemove_default_instance_; +class ChannelState; +class ChannelStateDefaultTypeInternal; +extern ChannelStateDefaultTypeInternal _ChannelState_default_instance_; +class CodecVersion; +class CodecVersionDefaultTypeInternal; +extern CodecVersionDefaultTypeInternal _CodecVersion_default_instance_; +class ContextAction; +class ContextActionDefaultTypeInternal; +extern ContextActionDefaultTypeInternal _ContextAction_default_instance_; +class ContextActionModify; +class ContextActionModifyDefaultTypeInternal; +extern ContextActionModifyDefaultTypeInternal _ContextActionModify_default_instance_; +class CryptSetup; +class CryptSetupDefaultTypeInternal; +extern CryptSetupDefaultTypeInternal _CryptSetup_default_instance_; +class PermissionDenied; +class PermissionDeniedDefaultTypeInternal; +extern PermissionDeniedDefaultTypeInternal _PermissionDenied_default_instance_; +class PermissionQuery; +class PermissionQueryDefaultTypeInternal; +extern PermissionQueryDefaultTypeInternal _PermissionQuery_default_instance_; +class Ping; +class PingDefaultTypeInternal; +extern PingDefaultTypeInternal _Ping_default_instance_; +class QueryUsers; +class QueryUsersDefaultTypeInternal; +extern QueryUsersDefaultTypeInternal _QueryUsers_default_instance_; +class Reject; +class RejectDefaultTypeInternal; +extern RejectDefaultTypeInternal _Reject_default_instance_; +class RequestBlob; +class RequestBlobDefaultTypeInternal; +extern RequestBlobDefaultTypeInternal _RequestBlob_default_instance_; +class ServerConfig; +class ServerConfigDefaultTypeInternal; +extern ServerConfigDefaultTypeInternal _ServerConfig_default_instance_; +class ServerSync; +class ServerSyncDefaultTypeInternal; +extern ServerSyncDefaultTypeInternal _ServerSync_default_instance_; +class SuggestConfig; +class SuggestConfigDefaultTypeInternal; +extern SuggestConfigDefaultTypeInternal _SuggestConfig_default_instance_; +class TextMessage; +class TextMessageDefaultTypeInternal; +extern TextMessageDefaultTypeInternal _TextMessage_default_instance_; +class UDPTunnel; +class UDPTunnelDefaultTypeInternal; +extern UDPTunnelDefaultTypeInternal _UDPTunnel_default_instance_; +class UserList; +class UserListDefaultTypeInternal; +extern UserListDefaultTypeInternal _UserList_default_instance_; +class UserList_User; +class UserList_UserDefaultTypeInternal; +extern UserList_UserDefaultTypeInternal _UserList_User_default_instance_; +class UserRemove; +class UserRemoveDefaultTypeInternal; +extern UserRemoveDefaultTypeInternal _UserRemove_default_instance_; +class UserState; +class UserStateDefaultTypeInternal; +extern UserStateDefaultTypeInternal _UserState_default_instance_; +class UserStats; +class UserStatsDefaultTypeInternal; +extern UserStatsDefaultTypeInternal _UserStats_default_instance_; +class UserStats_Stats; +class UserStats_StatsDefaultTypeInternal; +extern UserStats_StatsDefaultTypeInternal _UserStats_Stats_default_instance_; +class Version; +class VersionDefaultTypeInternal; +extern VersionDefaultTypeInternal _Version_default_instance_; +class VoiceTarget; +class VoiceTargetDefaultTypeInternal; +extern VoiceTargetDefaultTypeInternal _VoiceTarget_default_instance_; +class VoiceTarget_Target; +class VoiceTarget_TargetDefaultTypeInternal; +extern VoiceTarget_TargetDefaultTypeInternal _VoiceTarget_Target_default_instance_; +} // namespace MumbleProto +PROTOBUF_NAMESPACE_OPEN +template<> ::MumbleProto::ACL* Arena::CreateMaybeMessage<::MumbleProto::ACL>(Arena*); +template<> ::MumbleProto::ACL_ChanACL* Arena::CreateMaybeMessage<::MumbleProto::ACL_ChanACL>(Arena*); +template<> ::MumbleProto::ACL_ChanGroup* Arena::CreateMaybeMessage<::MumbleProto::ACL_ChanGroup>(Arena*); +template<> ::MumbleProto::Authenticate* Arena::CreateMaybeMessage<::MumbleProto::Authenticate>(Arena*); +template<> ::MumbleProto::BanList* Arena::CreateMaybeMessage<::MumbleProto::BanList>(Arena*); +template<> ::MumbleProto::BanList_BanEntry* Arena::CreateMaybeMessage<::MumbleProto::BanList_BanEntry>(Arena*); +template<> ::MumbleProto::ChannelRemove* Arena::CreateMaybeMessage<::MumbleProto::ChannelRemove>(Arena*); +template<> ::MumbleProto::ChannelState* Arena::CreateMaybeMessage<::MumbleProto::ChannelState>(Arena*); +template<> ::MumbleProto::CodecVersion* Arena::CreateMaybeMessage<::MumbleProto::CodecVersion>(Arena*); +template<> ::MumbleProto::ContextAction* Arena::CreateMaybeMessage<::MumbleProto::ContextAction>(Arena*); +template<> ::MumbleProto::ContextActionModify* Arena::CreateMaybeMessage<::MumbleProto::ContextActionModify>(Arena*); +template<> ::MumbleProto::CryptSetup* Arena::CreateMaybeMessage<::MumbleProto::CryptSetup>(Arena*); +template<> ::MumbleProto::PermissionDenied* Arena::CreateMaybeMessage<::MumbleProto::PermissionDenied>(Arena*); +template<> ::MumbleProto::PermissionQuery* Arena::CreateMaybeMessage<::MumbleProto::PermissionQuery>(Arena*); +template<> ::MumbleProto::Ping* Arena::CreateMaybeMessage<::MumbleProto::Ping>(Arena*); +template<> ::MumbleProto::QueryUsers* Arena::CreateMaybeMessage<::MumbleProto::QueryUsers>(Arena*); +template<> ::MumbleProto::Reject* Arena::CreateMaybeMessage<::MumbleProto::Reject>(Arena*); +template<> ::MumbleProto::RequestBlob* Arena::CreateMaybeMessage<::MumbleProto::RequestBlob>(Arena*); +template<> ::MumbleProto::ServerConfig* Arena::CreateMaybeMessage<::MumbleProto::ServerConfig>(Arena*); +template<> ::MumbleProto::ServerSync* Arena::CreateMaybeMessage<::MumbleProto::ServerSync>(Arena*); +template<> ::MumbleProto::SuggestConfig* Arena::CreateMaybeMessage<::MumbleProto::SuggestConfig>(Arena*); +template<> ::MumbleProto::TextMessage* Arena::CreateMaybeMessage<::MumbleProto::TextMessage>(Arena*); +template<> ::MumbleProto::UDPTunnel* Arena::CreateMaybeMessage<::MumbleProto::UDPTunnel>(Arena*); +template<> ::MumbleProto::UserList* Arena::CreateMaybeMessage<::MumbleProto::UserList>(Arena*); +template<> ::MumbleProto::UserList_User* Arena::CreateMaybeMessage<::MumbleProto::UserList_User>(Arena*); +template<> ::MumbleProto::UserRemove* Arena::CreateMaybeMessage<::MumbleProto::UserRemove>(Arena*); +template<> ::MumbleProto::UserState* Arena::CreateMaybeMessage<::MumbleProto::UserState>(Arena*); +template<> ::MumbleProto::UserStats* Arena::CreateMaybeMessage<::MumbleProto::UserStats>(Arena*); +template<> ::MumbleProto::UserStats_Stats* Arena::CreateMaybeMessage<::MumbleProto::UserStats_Stats>(Arena*); +template<> ::MumbleProto::Version* Arena::CreateMaybeMessage<::MumbleProto::Version>(Arena*); +template<> ::MumbleProto::VoiceTarget* Arena::CreateMaybeMessage<::MumbleProto::VoiceTarget>(Arena*); +template<> ::MumbleProto::VoiceTarget_Target* Arena::CreateMaybeMessage<::MumbleProto::VoiceTarget_Target>(Arena*); +PROTOBUF_NAMESPACE_CLOSE +namespace MumbleProto { + +enum Reject_RejectType : int { + Reject_RejectType_None = 0, + Reject_RejectType_WrongVersion = 1, + Reject_RejectType_InvalidUsername = 2, + Reject_RejectType_WrongUserPW = 3, + Reject_RejectType_WrongServerPW = 4, + Reject_RejectType_UsernameInUse = 5, + Reject_RejectType_ServerFull = 6, + Reject_RejectType_NoCertificate = 7, + Reject_RejectType_AuthenticatorFail = 8 +}; +bool Reject_RejectType_IsValid(int value); +constexpr Reject_RejectType Reject_RejectType_RejectType_MIN = Reject_RejectType_None; +constexpr Reject_RejectType Reject_RejectType_RejectType_MAX = Reject_RejectType_AuthenticatorFail; +constexpr int Reject_RejectType_RejectType_ARRAYSIZE = Reject_RejectType_RejectType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Reject_RejectType_descriptor(); +template +inline const std::string& Reject_RejectType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Reject_RejectType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + Reject_RejectType_descriptor(), enum_t_value); +} +inline bool Reject_RejectType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Reject_RejectType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + Reject_RejectType_descriptor(), name, value); +} +enum PermissionDenied_DenyType : int { + PermissionDenied_DenyType_Text = 0, + PermissionDenied_DenyType_Permission = 1, + PermissionDenied_DenyType_SuperUser = 2, + PermissionDenied_DenyType_ChannelName = 3, + PermissionDenied_DenyType_TextTooLong = 4, + PermissionDenied_DenyType_H9K = 5, + PermissionDenied_DenyType_TemporaryChannel = 6, + PermissionDenied_DenyType_MissingCertificate = 7, + PermissionDenied_DenyType_UserName = 8, + PermissionDenied_DenyType_ChannelFull = 9, + PermissionDenied_DenyType_NestingLimit = 10 +}; +bool PermissionDenied_DenyType_IsValid(int value); +constexpr PermissionDenied_DenyType PermissionDenied_DenyType_DenyType_MIN = PermissionDenied_DenyType_Text; +constexpr PermissionDenied_DenyType PermissionDenied_DenyType_DenyType_MAX = PermissionDenied_DenyType_NestingLimit; +constexpr int PermissionDenied_DenyType_DenyType_ARRAYSIZE = PermissionDenied_DenyType_DenyType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PermissionDenied_DenyType_descriptor(); +template +inline const std::string& PermissionDenied_DenyType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function PermissionDenied_DenyType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + PermissionDenied_DenyType_descriptor(), enum_t_value); +} +inline bool PermissionDenied_DenyType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PermissionDenied_DenyType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + PermissionDenied_DenyType_descriptor(), name, value); +} +enum ContextActionModify_Context : int { + ContextActionModify_Context_Server = 1, + ContextActionModify_Context_Channel = 2, + ContextActionModify_Context_User = 4 +}; +bool ContextActionModify_Context_IsValid(int value); +constexpr ContextActionModify_Context ContextActionModify_Context_Context_MIN = ContextActionModify_Context_Server; +constexpr ContextActionModify_Context ContextActionModify_Context_Context_MAX = ContextActionModify_Context_User; +constexpr int ContextActionModify_Context_Context_ARRAYSIZE = ContextActionModify_Context_Context_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ContextActionModify_Context_descriptor(); +template +inline const std::string& ContextActionModify_Context_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function ContextActionModify_Context_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + ContextActionModify_Context_descriptor(), enum_t_value); +} +inline bool ContextActionModify_Context_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ContextActionModify_Context* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + ContextActionModify_Context_descriptor(), name, value); +} +enum ContextActionModify_Operation : int { + ContextActionModify_Operation_Add = 0, + ContextActionModify_Operation_Remove = 1 +}; +bool ContextActionModify_Operation_IsValid(int value); +constexpr ContextActionModify_Operation ContextActionModify_Operation_Operation_MIN = ContextActionModify_Operation_Add; +constexpr ContextActionModify_Operation ContextActionModify_Operation_Operation_MAX = ContextActionModify_Operation_Remove; +constexpr int ContextActionModify_Operation_Operation_ARRAYSIZE = ContextActionModify_Operation_Operation_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ContextActionModify_Operation_descriptor(); +template +inline const std::string& ContextActionModify_Operation_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function ContextActionModify_Operation_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + ContextActionModify_Operation_descriptor(), enum_t_value); +} +inline bool ContextActionModify_Operation_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ContextActionModify_Operation* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + ContextActionModify_Operation_descriptor(), name, value); +} +// =================================================================== + +class Version PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MumbleProto.Version) */ { + public: + inline Version() : Version(nullptr) {}; + virtual ~Version(); + + Version(const Version& from); + Version(Version&& from) noexcept + : Version() { + *this = ::std::move(from); + } + + inline Version& operator=(const Version& from) { + CopyFrom(from); + return *this; + } + inline Version& operator=(Version&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const Version& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const Version* internal_default_instance() { + return reinterpret_cast( + &_Version_default_instance_); + } + static constexpr int kIndexInFileMessages = + 0; + + friend void swap(Version& a, Version& b) { + a.Swap(&b); + } + inline void Swap(Version* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Version* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Version* New() const final { + return CreateMaybeMessage(nullptr); + } + + Version* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Version& from); + void MergeFrom(const Version& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Version* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MumbleProto.Version"; + } + protected: + explicit Version(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_Mumble_2eproto); + return ::descriptor_table_Mumble_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kReleaseFieldNumber = 2, + kOsFieldNumber = 3, + kOsVersionFieldNumber = 4, + kVersionFieldNumber = 1, + }; + // optional string release = 2; + bool has_release() const; + private: + bool _internal_has_release() const; + public: + void clear_release(); + const std::string& release() const; + void set_release(const std::string& value); + void set_release(std::string&& value); + void set_release(const char* value); + void set_release(const char* value, size_t size); + std::string* mutable_release(); + std::string* release_release(); + void set_allocated_release(std::string* release); + private: + const std::string& _internal_release() const; + void _internal_set_release(const std::string& value); + std::string* _internal_mutable_release(); + public: + + // optional string os = 3; + bool has_os() const; + private: + bool _internal_has_os() const; + public: + void clear_os(); + const std::string& os() const; + void set_os(const std::string& value); + void set_os(std::string&& value); + void set_os(const char* value); + void set_os(const char* value, size_t size); + std::string* mutable_os(); + std::string* release_os(); + void set_allocated_os(std::string* os); + private: + const std::string& _internal_os() const; + void _internal_set_os(const std::string& value); + std::string* _internal_mutable_os(); + public: + + // optional string os_version = 4; + bool has_os_version() const; + private: + bool _internal_has_os_version() const; + public: + void clear_os_version(); + const std::string& os_version() const; + void set_os_version(const std::string& value); + void set_os_version(std::string&& value); + void set_os_version(const char* value); + void set_os_version(const char* value, size_t size); + std::string* mutable_os_version(); + std::string* release_os_version(); + void set_allocated_os_version(std::string* os_version); + private: + const std::string& _internal_os_version() const; + void _internal_set_os_version(const std::string& value); + std::string* _internal_mutable_os_version(); + public: + + // optional uint32 version = 1; + bool has_version() const; + private: + bool _internal_has_version() const; + public: + void clear_version(); + ::PROTOBUF_NAMESPACE_ID::uint32 version() const; + void set_version(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_version() const; + void _internal_set_version(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // @@protoc_insertion_point(class_scope:MumbleProto.Version) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr release_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr os_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr os_version_; + ::PROTOBUF_NAMESPACE_ID::uint32 version_; + friend struct ::TableStruct_Mumble_2eproto; +}; +// ------------------------------------------------------------------- + +class UDPTunnel PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MumbleProto.UDPTunnel) */ { + public: + inline UDPTunnel() : UDPTunnel(nullptr) {}; + virtual ~UDPTunnel(); + + UDPTunnel(const UDPTunnel& from); + UDPTunnel(UDPTunnel&& from) noexcept + : UDPTunnel() { + *this = ::std::move(from); + } + + inline UDPTunnel& operator=(const UDPTunnel& from) { + CopyFrom(from); + return *this; + } + inline UDPTunnel& operator=(UDPTunnel&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const UDPTunnel& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const UDPTunnel* internal_default_instance() { + return reinterpret_cast( + &_UDPTunnel_default_instance_); + } + static constexpr int kIndexInFileMessages = + 1; + + friend void swap(UDPTunnel& a, UDPTunnel& b) { + a.Swap(&b); + } + inline void Swap(UDPTunnel* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(UDPTunnel* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline UDPTunnel* New() const final { + return CreateMaybeMessage(nullptr); + } + + UDPTunnel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const UDPTunnel& from); + void MergeFrom(const UDPTunnel& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(UDPTunnel* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MumbleProto.UDPTunnel"; + } + protected: + explicit UDPTunnel(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_Mumble_2eproto); + return ::descriptor_table_Mumble_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kPacketFieldNumber = 1, + }; + // required bytes packet = 1; + bool has_packet() const; + private: + bool _internal_has_packet() const; + public: + void clear_packet(); + const std::string& packet() const; + void set_packet(const std::string& value); + void set_packet(std::string&& value); + void set_packet(const char* value); + void set_packet(const void* value, size_t size); + std::string* mutable_packet(); + std::string* release_packet(); + void set_allocated_packet(std::string* packet); + private: + const std::string& _internal_packet() const; + void _internal_set_packet(const std::string& value); + std::string* _internal_mutable_packet(); + public: + + // @@protoc_insertion_point(class_scope:MumbleProto.UDPTunnel) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr packet_; + friend struct ::TableStruct_Mumble_2eproto; +}; +// ------------------------------------------------------------------- + +class Authenticate PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MumbleProto.Authenticate) */ { + public: + inline Authenticate() : Authenticate(nullptr) {}; + virtual ~Authenticate(); + + Authenticate(const Authenticate& from); + Authenticate(Authenticate&& from) noexcept + : Authenticate() { + *this = ::std::move(from); + } + + inline Authenticate& operator=(const Authenticate& from) { + CopyFrom(from); + return *this; + } + inline Authenticate& operator=(Authenticate&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const Authenticate& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const Authenticate* internal_default_instance() { + return reinterpret_cast( + &_Authenticate_default_instance_); + } + static constexpr int kIndexInFileMessages = + 2; + + friend void swap(Authenticate& a, Authenticate& b) { + a.Swap(&b); + } + inline void Swap(Authenticate* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Authenticate* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Authenticate* New() const final { + return CreateMaybeMessage(nullptr); + } + + Authenticate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Authenticate& from); + void MergeFrom(const Authenticate& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Authenticate* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MumbleProto.Authenticate"; + } + protected: + explicit Authenticate(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_Mumble_2eproto); + return ::descriptor_table_Mumble_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kTokensFieldNumber = 3, + kCeltVersionsFieldNumber = 4, + kUsernameFieldNumber = 1, + kPasswordFieldNumber = 2, + kOpusFieldNumber = 5, + }; + // repeated string tokens = 3; + int tokens_size() const; + private: + int _internal_tokens_size() const; + public: + void clear_tokens(); + const std::string& tokens(int index) const; + std::string* mutable_tokens(int index); + void set_tokens(int index, const std::string& value); + void set_tokens(int index, std::string&& value); + void set_tokens(int index, const char* value); + void set_tokens(int index, const char* value, size_t size); + std::string* add_tokens(); + void add_tokens(const std::string& value); + void add_tokens(std::string&& value); + void add_tokens(const char* value); + void add_tokens(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& tokens() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_tokens(); + private: + const std::string& _internal_tokens(int index) const; + std::string* _internal_add_tokens(); + public: + + // repeated int32 celt_versions = 4; + int celt_versions_size() const; + private: + int _internal_celt_versions_size() const; + public: + void clear_celt_versions(); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_celt_versions(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& + _internal_celt_versions() const; + void _internal_add_celt_versions(::PROTOBUF_NAMESPACE_ID::int32 value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* + _internal_mutable_celt_versions(); + public: + ::PROTOBUF_NAMESPACE_ID::int32 celt_versions(int index) const; + void set_celt_versions(int index, ::PROTOBUF_NAMESPACE_ID::int32 value); + void add_celt_versions(::PROTOBUF_NAMESPACE_ID::int32 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& + celt_versions() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* + mutable_celt_versions(); + + // optional string username = 1; + bool has_username() const; + private: + bool _internal_has_username() const; + public: + void clear_username(); + const std::string& username() const; + void set_username(const std::string& value); + void set_username(std::string&& value); + void set_username(const char* value); + void set_username(const char* value, size_t size); + std::string* mutable_username(); + std::string* release_username(); + void set_allocated_username(std::string* username); + private: + const std::string& _internal_username() const; + void _internal_set_username(const std::string& value); + std::string* _internal_mutable_username(); + public: + + // optional string password = 2; + bool has_password() const; + private: + bool _internal_has_password() const; + public: + void clear_password(); + const std::string& password() const; + void set_password(const std::string& value); + void set_password(std::string&& value); + void set_password(const char* value); + void set_password(const char* value, size_t size); + std::string* mutable_password(); + std::string* release_password(); + void set_allocated_password(std::string* password); + private: + const std::string& _internal_password() const; + void _internal_set_password(const std::string& value); + std::string* _internal_mutable_password(); + public: + + // optional bool opus = 5 [default = false]; + bool has_opus() const; + private: + bool _internal_has_opus() const; + public: + void clear_opus(); + bool opus() const; + void set_opus(bool value); + private: + bool _internal_opus() const; + void _internal_set_opus(bool value); + public: + + // @@protoc_insertion_point(class_scope:MumbleProto.Authenticate) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField tokens_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > celt_versions_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr username_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr password_; + bool opus_; + friend struct ::TableStruct_Mumble_2eproto; +}; +// ------------------------------------------------------------------- + +class Ping PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MumbleProto.Ping) */ { + public: + inline Ping() : Ping(nullptr) {}; + virtual ~Ping(); + + Ping(const Ping& from); + Ping(Ping&& from) noexcept + : Ping() { + *this = ::std::move(from); + } + + inline Ping& operator=(const Ping& from) { + CopyFrom(from); + return *this; + } + inline Ping& operator=(Ping&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const Ping& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const Ping* internal_default_instance() { + return reinterpret_cast( + &_Ping_default_instance_); + } + static constexpr int kIndexInFileMessages = + 3; + + friend void swap(Ping& a, Ping& b) { + a.Swap(&b); + } + inline void Swap(Ping* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Ping* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Ping* New() const final { + return CreateMaybeMessage(nullptr); + } + + Ping* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Ping& from); + void MergeFrom(const Ping& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Ping* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MumbleProto.Ping"; + } + protected: + explicit Ping(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_Mumble_2eproto); + return ::descriptor_table_Mumble_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kTimestampFieldNumber = 1, + kGoodFieldNumber = 2, + kLateFieldNumber = 3, + kLostFieldNumber = 4, + kResyncFieldNumber = 5, + kUdpPacketsFieldNumber = 6, + kTcpPacketsFieldNumber = 7, + kUdpPingAvgFieldNumber = 8, + kUdpPingVarFieldNumber = 9, + kTcpPingAvgFieldNumber = 10, + kTcpPingVarFieldNumber = 11, + }; + // optional uint64 timestamp = 1; + bool has_timestamp() const; + private: + bool _internal_has_timestamp() const; + public: + void clear_timestamp(); + ::PROTOBUF_NAMESPACE_ID::uint64 timestamp() const; + void set_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint64 _internal_timestamp() const; + void _internal_set_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value); + public: + + // optional uint32 good = 2; + bool has_good() const; + private: + bool _internal_has_good() const; + public: + void clear_good(); + ::PROTOBUF_NAMESPACE_ID::uint32 good() const; + void set_good(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_good() const; + void _internal_set_good(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional uint32 late = 3; + bool has_late() const; + private: + bool _internal_has_late() const; + public: + void clear_late(); + ::PROTOBUF_NAMESPACE_ID::uint32 late() const; + void set_late(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_late() const; + void _internal_set_late(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional uint32 lost = 4; + bool has_lost() const; + private: + bool _internal_has_lost() const; + public: + void clear_lost(); + ::PROTOBUF_NAMESPACE_ID::uint32 lost() const; + void set_lost(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_lost() const; + void _internal_set_lost(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional uint32 resync = 5; + bool has_resync() const; + private: + bool _internal_has_resync() const; + public: + void clear_resync(); + ::PROTOBUF_NAMESPACE_ID::uint32 resync() const; + void set_resync(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_resync() const; + void _internal_set_resync(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional uint32 udp_packets = 6; + bool has_udp_packets() const; + private: + bool _internal_has_udp_packets() const; + public: + void clear_udp_packets(); + ::PROTOBUF_NAMESPACE_ID::uint32 udp_packets() const; + void set_udp_packets(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_udp_packets() const; + void _internal_set_udp_packets(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional uint32 tcp_packets = 7; + bool has_tcp_packets() const; + private: + bool _internal_has_tcp_packets() const; + public: + void clear_tcp_packets(); + ::PROTOBUF_NAMESPACE_ID::uint32 tcp_packets() const; + void set_tcp_packets(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_tcp_packets() const; + void _internal_set_tcp_packets(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional float udp_ping_avg = 8; + bool has_udp_ping_avg() const; + private: + bool _internal_has_udp_ping_avg() const; + public: + void clear_udp_ping_avg(); + float udp_ping_avg() const; + void set_udp_ping_avg(float value); + private: + float _internal_udp_ping_avg() const; + void _internal_set_udp_ping_avg(float value); + public: + + // optional float udp_ping_var = 9; + bool has_udp_ping_var() const; + private: + bool _internal_has_udp_ping_var() const; + public: + void clear_udp_ping_var(); + float udp_ping_var() const; + void set_udp_ping_var(float value); + private: + float _internal_udp_ping_var() const; + void _internal_set_udp_ping_var(float value); + public: + + // optional float tcp_ping_avg = 10; + bool has_tcp_ping_avg() const; + private: + bool _internal_has_tcp_ping_avg() const; + public: + void clear_tcp_ping_avg(); + float tcp_ping_avg() const; + void set_tcp_ping_avg(float value); + private: + float _internal_tcp_ping_avg() const; + void _internal_set_tcp_ping_avg(float value); + public: + + // optional float tcp_ping_var = 11; + bool has_tcp_ping_var() const; + private: + bool _internal_has_tcp_ping_var() const; + public: + void clear_tcp_ping_var(); + float tcp_ping_var() const; + void set_tcp_ping_var(float value); + private: + float _internal_tcp_ping_var() const; + void _internal_set_tcp_ping_var(float value); + public: + + // @@protoc_insertion_point(class_scope:MumbleProto.Ping) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint64 timestamp_; + ::PROTOBUF_NAMESPACE_ID::uint32 good_; + ::PROTOBUF_NAMESPACE_ID::uint32 late_; + ::PROTOBUF_NAMESPACE_ID::uint32 lost_; + ::PROTOBUF_NAMESPACE_ID::uint32 resync_; + ::PROTOBUF_NAMESPACE_ID::uint32 udp_packets_; + ::PROTOBUF_NAMESPACE_ID::uint32 tcp_packets_; + float udp_ping_avg_; + float udp_ping_var_; + float tcp_ping_avg_; + float tcp_ping_var_; + friend struct ::TableStruct_Mumble_2eproto; +}; +// ------------------------------------------------------------------- + +class Reject PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MumbleProto.Reject) */ { + public: + inline Reject() : Reject(nullptr) {}; + virtual ~Reject(); + + Reject(const Reject& from); + Reject(Reject&& from) noexcept + : Reject() { + *this = ::std::move(from); + } + + inline Reject& operator=(const Reject& from) { + CopyFrom(from); + return *this; + } + inline Reject& operator=(Reject&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const Reject& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const Reject* internal_default_instance() { + return reinterpret_cast( + &_Reject_default_instance_); + } + static constexpr int kIndexInFileMessages = + 4; + + friend void swap(Reject& a, Reject& b) { + a.Swap(&b); + } + inline void Swap(Reject* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Reject* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Reject* New() const final { + return CreateMaybeMessage(nullptr); + } + + Reject* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Reject& from); + void MergeFrom(const Reject& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Reject* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MumbleProto.Reject"; + } + protected: + explicit Reject(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_Mumble_2eproto); + return ::descriptor_table_Mumble_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + typedef Reject_RejectType RejectType; + static constexpr RejectType None = + Reject_RejectType_None; + static constexpr RejectType WrongVersion = + Reject_RejectType_WrongVersion; + static constexpr RejectType InvalidUsername = + Reject_RejectType_InvalidUsername; + static constexpr RejectType WrongUserPW = + Reject_RejectType_WrongUserPW; + static constexpr RejectType WrongServerPW = + Reject_RejectType_WrongServerPW; + static constexpr RejectType UsernameInUse = + Reject_RejectType_UsernameInUse; + static constexpr RejectType ServerFull = + Reject_RejectType_ServerFull; + static constexpr RejectType NoCertificate = + Reject_RejectType_NoCertificate; + static constexpr RejectType AuthenticatorFail = + Reject_RejectType_AuthenticatorFail; + static inline bool RejectType_IsValid(int value) { + return Reject_RejectType_IsValid(value); + } + static constexpr RejectType RejectType_MIN = + Reject_RejectType_RejectType_MIN; + static constexpr RejectType RejectType_MAX = + Reject_RejectType_RejectType_MAX; + static constexpr int RejectType_ARRAYSIZE = + Reject_RejectType_RejectType_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + RejectType_descriptor() { + return Reject_RejectType_descriptor(); + } + template + static inline const std::string& RejectType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function RejectType_Name."); + return Reject_RejectType_Name(enum_t_value); + } + static inline bool RejectType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + RejectType* value) { + return Reject_RejectType_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kReasonFieldNumber = 2, + kTypeFieldNumber = 1, + }; + // optional string reason = 2; + bool has_reason() const; + private: + bool _internal_has_reason() const; + public: + void clear_reason(); + const std::string& reason() const; + void set_reason(const std::string& value); + void set_reason(std::string&& value); + void set_reason(const char* value); + void set_reason(const char* value, size_t size); + std::string* mutable_reason(); + std::string* release_reason(); + void set_allocated_reason(std::string* reason); + private: + const std::string& _internal_reason() const; + void _internal_set_reason(const std::string& value); + std::string* _internal_mutable_reason(); + public: + + // optional .MumbleProto.Reject.RejectType type = 1; + bool has_type() const; + private: + bool _internal_has_type() const; + public: + void clear_type(); + ::MumbleProto::Reject_RejectType type() const; + void set_type(::MumbleProto::Reject_RejectType value); + private: + ::MumbleProto::Reject_RejectType _internal_type() const; + void _internal_set_type(::MumbleProto::Reject_RejectType value); + public: + + // @@protoc_insertion_point(class_scope:MumbleProto.Reject) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr reason_; + int type_; + friend struct ::TableStruct_Mumble_2eproto; +}; +// ------------------------------------------------------------------- + +class ServerSync PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MumbleProto.ServerSync) */ { + public: + inline ServerSync() : ServerSync(nullptr) {}; + virtual ~ServerSync(); + + ServerSync(const ServerSync& from); + ServerSync(ServerSync&& from) noexcept + : ServerSync() { + *this = ::std::move(from); + } + + inline ServerSync& operator=(const ServerSync& from) { + CopyFrom(from); + return *this; + } + inline ServerSync& operator=(ServerSync&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const ServerSync& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const ServerSync* internal_default_instance() { + return reinterpret_cast( + &_ServerSync_default_instance_); + } + static constexpr int kIndexInFileMessages = + 5; + + friend void swap(ServerSync& a, ServerSync& b) { + a.Swap(&b); + } + inline void Swap(ServerSync* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ServerSync* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ServerSync* New() const final { + return CreateMaybeMessage(nullptr); + } + + ServerSync* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const ServerSync& from); + void MergeFrom(const ServerSync& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ServerSync* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MumbleProto.ServerSync"; + } + protected: + explicit ServerSync(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_Mumble_2eproto); + return ::descriptor_table_Mumble_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kWelcomeTextFieldNumber = 3, + kSessionFieldNumber = 1, + kMaxBandwidthFieldNumber = 2, + kPermissionsFieldNumber = 4, + }; + // optional string welcome_text = 3; + bool has_welcome_text() const; + private: + bool _internal_has_welcome_text() const; + public: + void clear_welcome_text(); + const std::string& welcome_text() const; + void set_welcome_text(const std::string& value); + void set_welcome_text(std::string&& value); + void set_welcome_text(const char* value); + void set_welcome_text(const char* value, size_t size); + std::string* mutable_welcome_text(); + std::string* release_welcome_text(); + void set_allocated_welcome_text(std::string* welcome_text); + private: + const std::string& _internal_welcome_text() const; + void _internal_set_welcome_text(const std::string& value); + std::string* _internal_mutable_welcome_text(); + public: + + // optional uint32 session = 1; + bool has_session() const; + private: + bool _internal_has_session() const; + public: + void clear_session(); + ::PROTOBUF_NAMESPACE_ID::uint32 session() const; + void set_session(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_session() const; + void _internal_set_session(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional uint32 max_bandwidth = 2; + bool has_max_bandwidth() const; + private: + bool _internal_has_max_bandwidth() const; + public: + void clear_max_bandwidth(); + ::PROTOBUF_NAMESPACE_ID::uint32 max_bandwidth() const; + void set_max_bandwidth(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_max_bandwidth() const; + void _internal_set_max_bandwidth(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional uint64 permissions = 4; + bool has_permissions() const; + private: + bool _internal_has_permissions() const; + public: + void clear_permissions(); + ::PROTOBUF_NAMESPACE_ID::uint64 permissions() const; + void set_permissions(::PROTOBUF_NAMESPACE_ID::uint64 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint64 _internal_permissions() const; + void _internal_set_permissions(::PROTOBUF_NAMESPACE_ID::uint64 value); + public: + + // @@protoc_insertion_point(class_scope:MumbleProto.ServerSync) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr welcome_text_; + ::PROTOBUF_NAMESPACE_ID::uint32 session_; + ::PROTOBUF_NAMESPACE_ID::uint32 max_bandwidth_; + ::PROTOBUF_NAMESPACE_ID::uint64 permissions_; + friend struct ::TableStruct_Mumble_2eproto; +}; +// ------------------------------------------------------------------- + +class ChannelRemove PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MumbleProto.ChannelRemove) */ { + public: + inline ChannelRemove() : ChannelRemove(nullptr) {}; + virtual ~ChannelRemove(); + + ChannelRemove(const ChannelRemove& from); + ChannelRemove(ChannelRemove&& from) noexcept + : ChannelRemove() { + *this = ::std::move(from); + } + + inline ChannelRemove& operator=(const ChannelRemove& from) { + CopyFrom(from); + return *this; + } + inline ChannelRemove& operator=(ChannelRemove&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const ChannelRemove& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const ChannelRemove* internal_default_instance() { + return reinterpret_cast( + &_ChannelRemove_default_instance_); + } + static constexpr int kIndexInFileMessages = + 6; + + friend void swap(ChannelRemove& a, ChannelRemove& b) { + a.Swap(&b); + } + inline void Swap(ChannelRemove* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ChannelRemove* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ChannelRemove* New() const final { + return CreateMaybeMessage(nullptr); + } + + ChannelRemove* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const ChannelRemove& from); + void MergeFrom(const ChannelRemove& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ChannelRemove* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MumbleProto.ChannelRemove"; + } + protected: + explicit ChannelRemove(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_Mumble_2eproto); + return ::descriptor_table_Mumble_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kChannelIdFieldNumber = 1, + }; + // required uint32 channel_id = 1; + bool has_channel_id() const; + private: + bool _internal_has_channel_id() const; + public: + void clear_channel_id(); + ::PROTOBUF_NAMESPACE_ID::uint32 channel_id() const; + void set_channel_id(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_channel_id() const; + void _internal_set_channel_id(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // @@protoc_insertion_point(class_scope:MumbleProto.ChannelRemove) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 channel_id_; + friend struct ::TableStruct_Mumble_2eproto; +}; +// ------------------------------------------------------------------- + +class ChannelState PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MumbleProto.ChannelState) */ { + public: + inline ChannelState() : ChannelState(nullptr) {}; + virtual ~ChannelState(); + + ChannelState(const ChannelState& from); + ChannelState(ChannelState&& from) noexcept + : ChannelState() { + *this = ::std::move(from); + } + + inline ChannelState& operator=(const ChannelState& from) { + CopyFrom(from); + return *this; + } + inline ChannelState& operator=(ChannelState&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const ChannelState& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const ChannelState* internal_default_instance() { + return reinterpret_cast( + &_ChannelState_default_instance_); + } + static constexpr int kIndexInFileMessages = + 7; + + friend void swap(ChannelState& a, ChannelState& b) { + a.Swap(&b); + } + inline void Swap(ChannelState* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ChannelState* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ChannelState* New() const final { + return CreateMaybeMessage(nullptr); + } + + ChannelState* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const ChannelState& from); + void MergeFrom(const ChannelState& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ChannelState* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MumbleProto.ChannelState"; + } + protected: + explicit ChannelState(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_Mumble_2eproto); + return ::descriptor_table_Mumble_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kLinksFieldNumber = 4, + kLinksAddFieldNumber = 6, + kLinksRemoveFieldNumber = 7, + kNameFieldNumber = 3, + kDescriptionFieldNumber = 5, + kDescriptionHashFieldNumber = 10, + kChannelIdFieldNumber = 1, + kParentFieldNumber = 2, + kTemporaryFieldNumber = 8, + kPositionFieldNumber = 9, + kMaxUsersFieldNumber = 11, + }; + // repeated uint32 links = 4; + int links_size() const; + private: + int _internal_links_size() const; + public: + void clear_links(); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_links(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& + _internal_links() const; + void _internal_add_links(::PROTOBUF_NAMESPACE_ID::uint32 value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* + _internal_mutable_links(); + public: + ::PROTOBUF_NAMESPACE_ID::uint32 links(int index) const; + void set_links(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value); + void add_links(::PROTOBUF_NAMESPACE_ID::uint32 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& + links() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* + mutable_links(); + + // repeated uint32 links_add = 6; + int links_add_size() const; + private: + int _internal_links_add_size() const; + public: + void clear_links_add(); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_links_add(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& + _internal_links_add() const; + void _internal_add_links_add(::PROTOBUF_NAMESPACE_ID::uint32 value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* + _internal_mutable_links_add(); + public: + ::PROTOBUF_NAMESPACE_ID::uint32 links_add(int index) const; + void set_links_add(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value); + void add_links_add(::PROTOBUF_NAMESPACE_ID::uint32 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& + links_add() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* + mutable_links_add(); + + // repeated uint32 links_remove = 7; + int links_remove_size() const; + private: + int _internal_links_remove_size() const; + public: + void clear_links_remove(); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_links_remove(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& + _internal_links_remove() const; + void _internal_add_links_remove(::PROTOBUF_NAMESPACE_ID::uint32 value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* + _internal_mutable_links_remove(); + public: + ::PROTOBUF_NAMESPACE_ID::uint32 links_remove(int index) const; + void set_links_remove(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value); + void add_links_remove(::PROTOBUF_NAMESPACE_ID::uint32 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& + links_remove() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* + mutable_links_remove(); + + // optional string name = 3; + bool has_name() const; + private: + bool _internal_has_name() const; + public: + void clear_name(); + const std::string& name() const; + void set_name(const std::string& value); + void set_name(std::string&& value); + void set_name(const char* value); + void set_name(const char* value, size_t size); + std::string* mutable_name(); + std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); + public: + + // optional string description = 5; + bool has_description() const; + private: + bool _internal_has_description() const; + public: + void clear_description(); + const std::string& description() const; + void set_description(const std::string& value); + void set_description(std::string&& value); + void set_description(const char* value); + void set_description(const char* value, size_t size); + std::string* mutable_description(); + std::string* release_description(); + void set_allocated_description(std::string* description); + private: + const std::string& _internal_description() const; + void _internal_set_description(const std::string& value); + std::string* _internal_mutable_description(); + public: + + // optional bytes description_hash = 10; + bool has_description_hash() const; + private: + bool _internal_has_description_hash() const; + public: + void clear_description_hash(); + const std::string& description_hash() const; + void set_description_hash(const std::string& value); + void set_description_hash(std::string&& value); + void set_description_hash(const char* value); + void set_description_hash(const void* value, size_t size); + std::string* mutable_description_hash(); + std::string* release_description_hash(); + void set_allocated_description_hash(std::string* description_hash); + private: + const std::string& _internal_description_hash() const; + void _internal_set_description_hash(const std::string& value); + std::string* _internal_mutable_description_hash(); + public: + + // optional uint32 channel_id = 1; + bool has_channel_id() const; + private: + bool _internal_has_channel_id() const; + public: + void clear_channel_id(); + ::PROTOBUF_NAMESPACE_ID::uint32 channel_id() const; + void set_channel_id(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_channel_id() const; + void _internal_set_channel_id(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional uint32 parent = 2; + bool has_parent() const; + private: + bool _internal_has_parent() const; + public: + void clear_parent(); + ::PROTOBUF_NAMESPACE_ID::uint32 parent() const; + void set_parent(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_parent() const; + void _internal_set_parent(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional bool temporary = 8 [default = false]; + bool has_temporary() const; + private: + bool _internal_has_temporary() const; + public: + void clear_temporary(); + bool temporary() const; + void set_temporary(bool value); + private: + bool _internal_temporary() const; + void _internal_set_temporary(bool value); + public: + + // optional int32 position = 9 [default = 0]; + bool has_position() const; + private: + bool _internal_has_position() const; + public: + void clear_position(); + ::PROTOBUF_NAMESPACE_ID::int32 position() const; + void set_position(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_position() const; + void _internal_set_position(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // optional uint32 max_users = 11; + bool has_max_users() const; + private: + bool _internal_has_max_users() const; + public: + void clear_max_users(); + ::PROTOBUF_NAMESPACE_ID::uint32 max_users() const; + void set_max_users(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_max_users() const; + void _internal_set_max_users(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // @@protoc_insertion_point(class_scope:MumbleProto.ChannelState) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 > links_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 > links_add_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 > links_remove_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_hash_; + ::PROTOBUF_NAMESPACE_ID::uint32 channel_id_; + ::PROTOBUF_NAMESPACE_ID::uint32 parent_; + bool temporary_; + ::PROTOBUF_NAMESPACE_ID::int32 position_; + ::PROTOBUF_NAMESPACE_ID::uint32 max_users_; + friend struct ::TableStruct_Mumble_2eproto; +}; +// ------------------------------------------------------------------- + +class UserRemove PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MumbleProto.UserRemove) */ { + public: + inline UserRemove() : UserRemove(nullptr) {}; + virtual ~UserRemove(); + + UserRemove(const UserRemove& from); + UserRemove(UserRemove&& from) noexcept + : UserRemove() { + *this = ::std::move(from); + } + + inline UserRemove& operator=(const UserRemove& from) { + CopyFrom(from); + return *this; + } + inline UserRemove& operator=(UserRemove&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const UserRemove& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const UserRemove* internal_default_instance() { + return reinterpret_cast( + &_UserRemove_default_instance_); + } + static constexpr int kIndexInFileMessages = + 8; + + friend void swap(UserRemove& a, UserRemove& b) { + a.Swap(&b); + } + inline void Swap(UserRemove* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(UserRemove* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline UserRemove* New() const final { + return CreateMaybeMessage(nullptr); + } + + UserRemove* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const UserRemove& from); + void MergeFrom(const UserRemove& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(UserRemove* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MumbleProto.UserRemove"; + } + protected: + explicit UserRemove(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_Mumble_2eproto); + return ::descriptor_table_Mumble_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kReasonFieldNumber = 3, + kSessionFieldNumber = 1, + kActorFieldNumber = 2, + kBanFieldNumber = 4, + }; + // optional string reason = 3; + bool has_reason() const; + private: + bool _internal_has_reason() const; + public: + void clear_reason(); + const std::string& reason() const; + void set_reason(const std::string& value); + void set_reason(std::string&& value); + void set_reason(const char* value); + void set_reason(const char* value, size_t size); + std::string* mutable_reason(); + std::string* release_reason(); + void set_allocated_reason(std::string* reason); + private: + const std::string& _internal_reason() const; + void _internal_set_reason(const std::string& value); + std::string* _internal_mutable_reason(); + public: + + // required uint32 session = 1; + bool has_session() const; + private: + bool _internal_has_session() const; + public: + void clear_session(); + ::PROTOBUF_NAMESPACE_ID::uint32 session() const; + void set_session(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_session() const; + void _internal_set_session(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional uint32 actor = 2; + bool has_actor() const; + private: + bool _internal_has_actor() const; + public: + void clear_actor(); + ::PROTOBUF_NAMESPACE_ID::uint32 actor() const; + void set_actor(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_actor() const; + void _internal_set_actor(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional bool ban = 4; + bool has_ban() const; + private: + bool _internal_has_ban() const; + public: + void clear_ban(); + bool ban() const; + void set_ban(bool value); + private: + bool _internal_ban() const; + void _internal_set_ban(bool value); + public: + + // @@protoc_insertion_point(class_scope:MumbleProto.UserRemove) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr reason_; + ::PROTOBUF_NAMESPACE_ID::uint32 session_; + ::PROTOBUF_NAMESPACE_ID::uint32 actor_; + bool ban_; + friend struct ::TableStruct_Mumble_2eproto; +}; +// ------------------------------------------------------------------- + +class UserState PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MumbleProto.UserState) */ { + public: + inline UserState() : UserState(nullptr) {}; + virtual ~UserState(); + + UserState(const UserState& from); + UserState(UserState&& from) noexcept + : UserState() { + *this = ::std::move(from); + } + + inline UserState& operator=(const UserState& from) { + CopyFrom(from); + return *this; + } + inline UserState& operator=(UserState&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const UserState& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const UserState* internal_default_instance() { + return reinterpret_cast( + &_UserState_default_instance_); + } + static constexpr int kIndexInFileMessages = + 9; + + friend void swap(UserState& a, UserState& b) { + a.Swap(&b); + } + inline void Swap(UserState* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(UserState* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline UserState* New() const final { + return CreateMaybeMessage(nullptr); + } + + UserState* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const UserState& from); + void MergeFrom(const UserState& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(UserState* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MumbleProto.UserState"; + } + protected: + explicit UserState(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_Mumble_2eproto); + return ::descriptor_table_Mumble_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kNameFieldNumber = 3, + kTextureFieldNumber = 11, + kPluginContextFieldNumber = 12, + kPluginIdentityFieldNumber = 13, + kCommentFieldNumber = 14, + kHashFieldNumber = 15, + kCommentHashFieldNumber = 16, + kTextureHashFieldNumber = 17, + kSessionFieldNumber = 1, + kActorFieldNumber = 2, + kUserIdFieldNumber = 4, + kChannelIdFieldNumber = 5, + kMuteFieldNumber = 6, + kDeafFieldNumber = 7, + kSuppressFieldNumber = 8, + kSelfMuteFieldNumber = 9, + kSelfDeafFieldNumber = 10, + kPrioritySpeakerFieldNumber = 18, + kRecordingFieldNumber = 19, + }; + // optional string name = 3; + bool has_name() const; + private: + bool _internal_has_name() const; + public: + void clear_name(); + const std::string& name() const; + void set_name(const std::string& value); + void set_name(std::string&& value); + void set_name(const char* value); + void set_name(const char* value, size_t size); + std::string* mutable_name(); + std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); + public: + + // optional bytes texture = 11; + bool has_texture() const; + private: + bool _internal_has_texture() const; + public: + void clear_texture(); + const std::string& texture() const; + void set_texture(const std::string& value); + void set_texture(std::string&& value); + void set_texture(const char* value); + void set_texture(const void* value, size_t size); + std::string* mutable_texture(); + std::string* release_texture(); + void set_allocated_texture(std::string* texture); + private: + const std::string& _internal_texture() const; + void _internal_set_texture(const std::string& value); + std::string* _internal_mutable_texture(); + public: + + // optional bytes plugin_context = 12; + bool has_plugin_context() const; + private: + bool _internal_has_plugin_context() const; + public: + void clear_plugin_context(); + const std::string& plugin_context() const; + void set_plugin_context(const std::string& value); + void set_plugin_context(std::string&& value); + void set_plugin_context(const char* value); + void set_plugin_context(const void* value, size_t size); + std::string* mutable_plugin_context(); + std::string* release_plugin_context(); + void set_allocated_plugin_context(std::string* plugin_context); + private: + const std::string& _internal_plugin_context() const; + void _internal_set_plugin_context(const std::string& value); + std::string* _internal_mutable_plugin_context(); + public: + + // optional string plugin_identity = 13; + bool has_plugin_identity() const; + private: + bool _internal_has_plugin_identity() const; + public: + void clear_plugin_identity(); + const std::string& plugin_identity() const; + void set_plugin_identity(const std::string& value); + void set_plugin_identity(std::string&& value); + void set_plugin_identity(const char* value); + void set_plugin_identity(const char* value, size_t size); + std::string* mutable_plugin_identity(); + std::string* release_plugin_identity(); + void set_allocated_plugin_identity(std::string* plugin_identity); + private: + const std::string& _internal_plugin_identity() const; + void _internal_set_plugin_identity(const std::string& value); + std::string* _internal_mutable_plugin_identity(); + public: + + // optional string comment = 14; + bool has_comment() const; + private: + bool _internal_has_comment() const; + public: + void clear_comment(); + const std::string& comment() const; + void set_comment(const std::string& value); + void set_comment(std::string&& value); + void set_comment(const char* value); + void set_comment(const char* value, size_t size); + std::string* mutable_comment(); + std::string* release_comment(); + void set_allocated_comment(std::string* comment); + private: + const std::string& _internal_comment() const; + void _internal_set_comment(const std::string& value); + std::string* _internal_mutable_comment(); + public: + + // optional string hash = 15; + bool has_hash() const; + private: + bool _internal_has_hash() const; + public: + void clear_hash(); + const std::string& hash() const; + void set_hash(const std::string& value); + void set_hash(std::string&& value); + void set_hash(const char* value); + void set_hash(const char* value, size_t size); + std::string* mutable_hash(); + std::string* release_hash(); + void set_allocated_hash(std::string* hash); + private: + const std::string& _internal_hash() const; + void _internal_set_hash(const std::string& value); + std::string* _internal_mutable_hash(); + public: + + // optional bytes comment_hash = 16; + bool has_comment_hash() const; + private: + bool _internal_has_comment_hash() const; + public: + void clear_comment_hash(); + const std::string& comment_hash() const; + void set_comment_hash(const std::string& value); + void set_comment_hash(std::string&& value); + void set_comment_hash(const char* value); + void set_comment_hash(const void* value, size_t size); + std::string* mutable_comment_hash(); + std::string* release_comment_hash(); + void set_allocated_comment_hash(std::string* comment_hash); + private: + const std::string& _internal_comment_hash() const; + void _internal_set_comment_hash(const std::string& value); + std::string* _internal_mutable_comment_hash(); + public: + + // optional bytes texture_hash = 17; + bool has_texture_hash() const; + private: + bool _internal_has_texture_hash() const; + public: + void clear_texture_hash(); + const std::string& texture_hash() const; + void set_texture_hash(const std::string& value); + void set_texture_hash(std::string&& value); + void set_texture_hash(const char* value); + void set_texture_hash(const void* value, size_t size); + std::string* mutable_texture_hash(); + std::string* release_texture_hash(); + void set_allocated_texture_hash(std::string* texture_hash); + private: + const std::string& _internal_texture_hash() const; + void _internal_set_texture_hash(const std::string& value); + std::string* _internal_mutable_texture_hash(); + public: + + // optional uint32 session = 1; + bool has_session() const; + private: + bool _internal_has_session() const; + public: + void clear_session(); + ::PROTOBUF_NAMESPACE_ID::uint32 session() const; + void set_session(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_session() const; + void _internal_set_session(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional uint32 actor = 2; + bool has_actor() const; + private: + bool _internal_has_actor() const; + public: + void clear_actor(); + ::PROTOBUF_NAMESPACE_ID::uint32 actor() const; + void set_actor(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_actor() const; + void _internal_set_actor(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional uint32 user_id = 4; + bool has_user_id() const; + private: + bool _internal_has_user_id() const; + public: + void clear_user_id(); + ::PROTOBUF_NAMESPACE_ID::uint32 user_id() const; + void set_user_id(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_user_id() const; + void _internal_set_user_id(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional uint32 channel_id = 5; + bool has_channel_id() const; + private: + bool _internal_has_channel_id() const; + public: + void clear_channel_id(); + ::PROTOBUF_NAMESPACE_ID::uint32 channel_id() const; + void set_channel_id(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_channel_id() const; + void _internal_set_channel_id(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional bool mute = 6; + bool has_mute() const; + private: + bool _internal_has_mute() const; + public: + void clear_mute(); + bool mute() const; + void set_mute(bool value); + private: + bool _internal_mute() const; + void _internal_set_mute(bool value); + public: + + // optional bool deaf = 7; + bool has_deaf() const; + private: + bool _internal_has_deaf() const; + public: + void clear_deaf(); + bool deaf() const; + void set_deaf(bool value); + private: + bool _internal_deaf() const; + void _internal_set_deaf(bool value); + public: + + // optional bool suppress = 8; + bool has_suppress() const; + private: + bool _internal_has_suppress() const; + public: + void clear_suppress(); + bool suppress() const; + void set_suppress(bool value); + private: + bool _internal_suppress() const; + void _internal_set_suppress(bool value); + public: + + // optional bool self_mute = 9; + bool has_self_mute() const; + private: + bool _internal_has_self_mute() const; + public: + void clear_self_mute(); + bool self_mute() const; + void set_self_mute(bool value); + private: + bool _internal_self_mute() const; + void _internal_set_self_mute(bool value); + public: + + // optional bool self_deaf = 10; + bool has_self_deaf() const; + private: + bool _internal_has_self_deaf() const; + public: + void clear_self_deaf(); + bool self_deaf() const; + void set_self_deaf(bool value); + private: + bool _internal_self_deaf() const; + void _internal_set_self_deaf(bool value); + public: + + // optional bool priority_speaker = 18; + bool has_priority_speaker() const; + private: + bool _internal_has_priority_speaker() const; + public: + void clear_priority_speaker(); + bool priority_speaker() const; + void set_priority_speaker(bool value); + private: + bool _internal_priority_speaker() const; + void _internal_set_priority_speaker(bool value); + public: + + // optional bool recording = 19; + bool has_recording() const; + private: + bool _internal_has_recording() const; + public: + void clear_recording(); + bool recording() const; + void set_recording(bool value); + private: + bool _internal_recording() const; + void _internal_set_recording(bool value); + public: + + // @@protoc_insertion_point(class_scope:MumbleProto.UserState) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr texture_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr plugin_context_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr plugin_identity_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr comment_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hash_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr comment_hash_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr texture_hash_; + ::PROTOBUF_NAMESPACE_ID::uint32 session_; + ::PROTOBUF_NAMESPACE_ID::uint32 actor_; + ::PROTOBUF_NAMESPACE_ID::uint32 user_id_; + ::PROTOBUF_NAMESPACE_ID::uint32 channel_id_; + bool mute_; + bool deaf_; + bool suppress_; + bool self_mute_; + bool self_deaf_; + bool priority_speaker_; + bool recording_; + friend struct ::TableStruct_Mumble_2eproto; +}; +// ------------------------------------------------------------------- + +class BanList_BanEntry PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MumbleProto.BanList.BanEntry) */ { + public: + inline BanList_BanEntry() : BanList_BanEntry(nullptr) {}; + virtual ~BanList_BanEntry(); + + BanList_BanEntry(const BanList_BanEntry& from); + BanList_BanEntry(BanList_BanEntry&& from) noexcept + : BanList_BanEntry() { + *this = ::std::move(from); + } + + inline BanList_BanEntry& operator=(const BanList_BanEntry& from) { + CopyFrom(from); + return *this; + } + inline BanList_BanEntry& operator=(BanList_BanEntry&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const BanList_BanEntry& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const BanList_BanEntry* internal_default_instance() { + return reinterpret_cast( + &_BanList_BanEntry_default_instance_); + } + static constexpr int kIndexInFileMessages = + 10; + + friend void swap(BanList_BanEntry& a, BanList_BanEntry& b) { + a.Swap(&b); + } + inline void Swap(BanList_BanEntry* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(BanList_BanEntry* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline BanList_BanEntry* New() const final { + return CreateMaybeMessage(nullptr); + } + + BanList_BanEntry* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const BanList_BanEntry& from); + void MergeFrom(const BanList_BanEntry& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(BanList_BanEntry* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MumbleProto.BanList.BanEntry"; + } + protected: + explicit BanList_BanEntry(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_Mumble_2eproto); + return ::descriptor_table_Mumble_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kAddressFieldNumber = 1, + kNameFieldNumber = 3, + kHashFieldNumber = 4, + kReasonFieldNumber = 5, + kStartFieldNumber = 6, + kMaskFieldNumber = 2, + kDurationFieldNumber = 7, + }; + // required bytes address = 1; + bool has_address() const; + private: + bool _internal_has_address() const; + public: + void clear_address(); + const std::string& address() const; + void set_address(const std::string& value); + void set_address(std::string&& value); + void set_address(const char* value); + void set_address(const void* value, size_t size); + std::string* mutable_address(); + std::string* release_address(); + void set_allocated_address(std::string* address); + private: + const std::string& _internal_address() const; + void _internal_set_address(const std::string& value); + std::string* _internal_mutable_address(); + public: + + // optional string name = 3; + bool has_name() const; + private: + bool _internal_has_name() const; + public: + void clear_name(); + const std::string& name() const; + void set_name(const std::string& value); + void set_name(std::string&& value); + void set_name(const char* value); + void set_name(const char* value, size_t size); + std::string* mutable_name(); + std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); + public: + + // optional string hash = 4; + bool has_hash() const; + private: + bool _internal_has_hash() const; + public: + void clear_hash(); + const std::string& hash() const; + void set_hash(const std::string& value); + void set_hash(std::string&& value); + void set_hash(const char* value); + void set_hash(const char* value, size_t size); + std::string* mutable_hash(); + std::string* release_hash(); + void set_allocated_hash(std::string* hash); + private: + const std::string& _internal_hash() const; + void _internal_set_hash(const std::string& value); + std::string* _internal_mutable_hash(); + public: + + // optional string reason = 5; + bool has_reason() const; + private: + bool _internal_has_reason() const; + public: + void clear_reason(); + const std::string& reason() const; + void set_reason(const std::string& value); + void set_reason(std::string&& value); + void set_reason(const char* value); + void set_reason(const char* value, size_t size); + std::string* mutable_reason(); + std::string* release_reason(); + void set_allocated_reason(std::string* reason); + private: + const std::string& _internal_reason() const; + void _internal_set_reason(const std::string& value); + std::string* _internal_mutable_reason(); + public: + + // optional string start = 6; + bool has_start() const; + private: + bool _internal_has_start() const; + public: + void clear_start(); + const std::string& start() const; + void set_start(const std::string& value); + void set_start(std::string&& value); + void set_start(const char* value); + void set_start(const char* value, size_t size); + std::string* mutable_start(); + std::string* release_start(); + void set_allocated_start(std::string* start); + private: + const std::string& _internal_start() const; + void _internal_set_start(const std::string& value); + std::string* _internal_mutable_start(); + public: + + // required uint32 mask = 2; + bool has_mask() const; + private: + bool _internal_has_mask() const; + public: + void clear_mask(); + ::PROTOBUF_NAMESPACE_ID::uint32 mask() const; + void set_mask(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_mask() const; + void _internal_set_mask(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional uint32 duration = 7; + bool has_duration() const; + private: + bool _internal_has_duration() const; + public: + void clear_duration(); + ::PROTOBUF_NAMESPACE_ID::uint32 duration() const; + void set_duration(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_duration() const; + void _internal_set_duration(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // @@protoc_insertion_point(class_scope:MumbleProto.BanList.BanEntry) + private: + class _Internal; + + // helper for ByteSizeLong() + size_t RequiredFieldsByteSizeFallback() const; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr address_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hash_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr reason_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr start_; + ::PROTOBUF_NAMESPACE_ID::uint32 mask_; + ::PROTOBUF_NAMESPACE_ID::uint32 duration_; + friend struct ::TableStruct_Mumble_2eproto; +}; +// ------------------------------------------------------------------- + +class BanList PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MumbleProto.BanList) */ { + public: + inline BanList() : BanList(nullptr) {}; + virtual ~BanList(); + + BanList(const BanList& from); + BanList(BanList&& from) noexcept + : BanList() { + *this = ::std::move(from); + } + + inline BanList& operator=(const BanList& from) { + CopyFrom(from); + return *this; + } + inline BanList& operator=(BanList&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const BanList& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const BanList* internal_default_instance() { + return reinterpret_cast( + &_BanList_default_instance_); + } + static constexpr int kIndexInFileMessages = + 11; + + friend void swap(BanList& a, BanList& b) { + a.Swap(&b); + } + inline void Swap(BanList* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(BanList* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline BanList* New() const final { + return CreateMaybeMessage(nullptr); + } + + BanList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const BanList& from); + void MergeFrom(const BanList& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(BanList* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MumbleProto.BanList"; + } + protected: + explicit BanList(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_Mumble_2eproto); + return ::descriptor_table_Mumble_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + typedef BanList_BanEntry BanEntry; + + // accessors ------------------------------------------------------- + + enum : int { + kBansFieldNumber = 1, + kQueryFieldNumber = 2, + }; + // repeated .MumbleProto.BanList.BanEntry bans = 1; + int bans_size() const; + private: + int _internal_bans_size() const; + public: + void clear_bans(); + ::MumbleProto::BanList_BanEntry* mutable_bans(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MumbleProto::BanList_BanEntry >* + mutable_bans(); + private: + const ::MumbleProto::BanList_BanEntry& _internal_bans(int index) const; + ::MumbleProto::BanList_BanEntry* _internal_add_bans(); + public: + const ::MumbleProto::BanList_BanEntry& bans(int index) const; + ::MumbleProto::BanList_BanEntry* add_bans(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MumbleProto::BanList_BanEntry >& + bans() const; + + // optional bool query = 2 [default = false]; + bool has_query() const; + private: + bool _internal_has_query() const; + public: + void clear_query(); + bool query() const; + void set_query(bool value); + private: + bool _internal_query() const; + void _internal_set_query(bool value); + public: + + // @@protoc_insertion_point(class_scope:MumbleProto.BanList) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MumbleProto::BanList_BanEntry > bans_; + bool query_; + friend struct ::TableStruct_Mumble_2eproto; +}; +// ------------------------------------------------------------------- + +class TextMessage PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MumbleProto.TextMessage) */ { + public: + inline TextMessage() : TextMessage(nullptr) {}; + virtual ~TextMessage(); + + TextMessage(const TextMessage& from); + TextMessage(TextMessage&& from) noexcept + : TextMessage() { + *this = ::std::move(from); + } + + inline TextMessage& operator=(const TextMessage& from) { + CopyFrom(from); + return *this; + } + inline TextMessage& operator=(TextMessage&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const TextMessage& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const TextMessage* internal_default_instance() { + return reinterpret_cast( + &_TextMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 12; + + friend void swap(TextMessage& a, TextMessage& b) { + a.Swap(&b); + } + inline void Swap(TextMessage* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(TextMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline TextMessage* New() const final { + return CreateMaybeMessage(nullptr); + } + + TextMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const TextMessage& from); + void MergeFrom(const TextMessage& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(TextMessage* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MumbleProto.TextMessage"; + } + protected: + explicit TextMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_Mumble_2eproto); + return ::descriptor_table_Mumble_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kSessionFieldNumber = 2, + kChannelIdFieldNumber = 3, + kTreeIdFieldNumber = 4, + kMessageFieldNumber = 5, + kActorFieldNumber = 1, + }; + // repeated uint32 session = 2; + int session_size() const; + private: + int _internal_session_size() const; + public: + void clear_session(); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_session(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& + _internal_session() const; + void _internal_add_session(::PROTOBUF_NAMESPACE_ID::uint32 value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* + _internal_mutable_session(); + public: + ::PROTOBUF_NAMESPACE_ID::uint32 session(int index) const; + void set_session(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value); + void add_session(::PROTOBUF_NAMESPACE_ID::uint32 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& + session() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* + mutable_session(); + + // repeated uint32 channel_id = 3; + int channel_id_size() const; + private: + int _internal_channel_id_size() const; + public: + void clear_channel_id(); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_channel_id(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& + _internal_channel_id() const; + void _internal_add_channel_id(::PROTOBUF_NAMESPACE_ID::uint32 value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* + _internal_mutable_channel_id(); + public: + ::PROTOBUF_NAMESPACE_ID::uint32 channel_id(int index) const; + void set_channel_id(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value); + void add_channel_id(::PROTOBUF_NAMESPACE_ID::uint32 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& + channel_id() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* + mutable_channel_id(); + + // repeated uint32 tree_id = 4; + int tree_id_size() const; + private: + int _internal_tree_id_size() const; + public: + void clear_tree_id(); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_tree_id(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& + _internal_tree_id() const; + void _internal_add_tree_id(::PROTOBUF_NAMESPACE_ID::uint32 value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* + _internal_mutable_tree_id(); + public: + ::PROTOBUF_NAMESPACE_ID::uint32 tree_id(int index) const; + void set_tree_id(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value); + void add_tree_id(::PROTOBUF_NAMESPACE_ID::uint32 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& + tree_id() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* + mutable_tree_id(); + + // required string message = 5; + bool has_message() const; + private: + bool _internal_has_message() const; + public: + void clear_message(); + const std::string& message() const; + void set_message(const std::string& value); + void set_message(std::string&& value); + void set_message(const char* value); + void set_message(const char* value, size_t size); + std::string* mutable_message(); + std::string* release_message(); + void set_allocated_message(std::string* message); + private: + const std::string& _internal_message() const; + void _internal_set_message(const std::string& value); + std::string* _internal_mutable_message(); + public: + + // optional uint32 actor = 1; + bool has_actor() const; + private: + bool _internal_has_actor() const; + public: + void clear_actor(); + ::PROTOBUF_NAMESPACE_ID::uint32 actor() const; + void set_actor(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_actor() const; + void _internal_set_actor(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // @@protoc_insertion_point(class_scope:MumbleProto.TextMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 > session_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 > channel_id_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 > tree_id_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr message_; + ::PROTOBUF_NAMESPACE_ID::uint32 actor_; + friend struct ::TableStruct_Mumble_2eproto; +}; +// ------------------------------------------------------------------- + +class PermissionDenied PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MumbleProto.PermissionDenied) */ { + public: + inline PermissionDenied() : PermissionDenied(nullptr) {}; + virtual ~PermissionDenied(); + + PermissionDenied(const PermissionDenied& from); + PermissionDenied(PermissionDenied&& from) noexcept + : PermissionDenied() { + *this = ::std::move(from); + } + + inline PermissionDenied& operator=(const PermissionDenied& from) { + CopyFrom(from); + return *this; + } + inline PermissionDenied& operator=(PermissionDenied&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const PermissionDenied& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const PermissionDenied* internal_default_instance() { + return reinterpret_cast( + &_PermissionDenied_default_instance_); + } + static constexpr int kIndexInFileMessages = + 13; + + friend void swap(PermissionDenied& a, PermissionDenied& b) { + a.Swap(&b); + } + inline void Swap(PermissionDenied* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(PermissionDenied* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline PermissionDenied* New() const final { + return CreateMaybeMessage(nullptr); + } + + PermissionDenied* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const PermissionDenied& from); + void MergeFrom(const PermissionDenied& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(PermissionDenied* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MumbleProto.PermissionDenied"; + } + protected: + explicit PermissionDenied(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_Mumble_2eproto); + return ::descriptor_table_Mumble_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + typedef PermissionDenied_DenyType DenyType; + static constexpr DenyType Text = + PermissionDenied_DenyType_Text; + static constexpr DenyType Permission = + PermissionDenied_DenyType_Permission; + static constexpr DenyType SuperUser = + PermissionDenied_DenyType_SuperUser; + static constexpr DenyType ChannelName = + PermissionDenied_DenyType_ChannelName; + static constexpr DenyType TextTooLong = + PermissionDenied_DenyType_TextTooLong; + static constexpr DenyType H9K = + PermissionDenied_DenyType_H9K; + static constexpr DenyType TemporaryChannel = + PermissionDenied_DenyType_TemporaryChannel; + static constexpr DenyType MissingCertificate = + PermissionDenied_DenyType_MissingCertificate; + static constexpr DenyType UserName = + PermissionDenied_DenyType_UserName; + static constexpr DenyType ChannelFull = + PermissionDenied_DenyType_ChannelFull; + static constexpr DenyType NestingLimit = + PermissionDenied_DenyType_NestingLimit; + static inline bool DenyType_IsValid(int value) { + return PermissionDenied_DenyType_IsValid(value); + } + static constexpr DenyType DenyType_MIN = + PermissionDenied_DenyType_DenyType_MIN; + static constexpr DenyType DenyType_MAX = + PermissionDenied_DenyType_DenyType_MAX; + static constexpr int DenyType_ARRAYSIZE = + PermissionDenied_DenyType_DenyType_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + DenyType_descriptor() { + return PermissionDenied_DenyType_descriptor(); + } + template + static inline const std::string& DenyType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function DenyType_Name."); + return PermissionDenied_DenyType_Name(enum_t_value); + } + static inline bool DenyType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + DenyType* value) { + return PermissionDenied_DenyType_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kReasonFieldNumber = 4, + kNameFieldNumber = 6, + kPermissionFieldNumber = 1, + kChannelIdFieldNumber = 2, + kSessionFieldNumber = 3, + kTypeFieldNumber = 5, + }; + // optional string reason = 4; + bool has_reason() const; + private: + bool _internal_has_reason() const; + public: + void clear_reason(); + const std::string& reason() const; + void set_reason(const std::string& value); + void set_reason(std::string&& value); + void set_reason(const char* value); + void set_reason(const char* value, size_t size); + std::string* mutable_reason(); + std::string* release_reason(); + void set_allocated_reason(std::string* reason); + private: + const std::string& _internal_reason() const; + void _internal_set_reason(const std::string& value); + std::string* _internal_mutable_reason(); + public: + + // optional string name = 6; + bool has_name() const; + private: + bool _internal_has_name() const; + public: + void clear_name(); + const std::string& name() const; + void set_name(const std::string& value); + void set_name(std::string&& value); + void set_name(const char* value); + void set_name(const char* value, size_t size); + std::string* mutable_name(); + std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); + public: + + // optional uint32 permission = 1; + bool has_permission() const; + private: + bool _internal_has_permission() const; + public: + void clear_permission(); + ::PROTOBUF_NAMESPACE_ID::uint32 permission() const; + void set_permission(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_permission() const; + void _internal_set_permission(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional uint32 channel_id = 2; + bool has_channel_id() const; + private: + bool _internal_has_channel_id() const; + public: + void clear_channel_id(); + ::PROTOBUF_NAMESPACE_ID::uint32 channel_id() const; + void set_channel_id(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_channel_id() const; + void _internal_set_channel_id(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional uint32 session = 3; + bool has_session() const; + private: + bool _internal_has_session() const; + public: + void clear_session(); + ::PROTOBUF_NAMESPACE_ID::uint32 session() const; + void set_session(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_session() const; + void _internal_set_session(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional .MumbleProto.PermissionDenied.DenyType type = 5; + bool has_type() const; + private: + bool _internal_has_type() const; + public: + void clear_type(); + ::MumbleProto::PermissionDenied_DenyType type() const; + void set_type(::MumbleProto::PermissionDenied_DenyType value); + private: + ::MumbleProto::PermissionDenied_DenyType _internal_type() const; + void _internal_set_type(::MumbleProto::PermissionDenied_DenyType value); + public: + + // @@protoc_insertion_point(class_scope:MumbleProto.PermissionDenied) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr reason_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + ::PROTOBUF_NAMESPACE_ID::uint32 permission_; + ::PROTOBUF_NAMESPACE_ID::uint32 channel_id_; + ::PROTOBUF_NAMESPACE_ID::uint32 session_; + int type_; + friend struct ::TableStruct_Mumble_2eproto; +}; +// ------------------------------------------------------------------- + +class ACL_ChanGroup PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MumbleProto.ACL.ChanGroup) */ { + public: + inline ACL_ChanGroup() : ACL_ChanGroup(nullptr) {}; + virtual ~ACL_ChanGroup(); + + ACL_ChanGroup(const ACL_ChanGroup& from); + ACL_ChanGroup(ACL_ChanGroup&& from) noexcept + : ACL_ChanGroup() { + *this = ::std::move(from); + } + + inline ACL_ChanGroup& operator=(const ACL_ChanGroup& from) { + CopyFrom(from); + return *this; + } + inline ACL_ChanGroup& operator=(ACL_ChanGroup&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const ACL_ChanGroup& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const ACL_ChanGroup* internal_default_instance() { + return reinterpret_cast( + &_ACL_ChanGroup_default_instance_); + } + static constexpr int kIndexInFileMessages = + 14; + + friend void swap(ACL_ChanGroup& a, ACL_ChanGroup& b) { + a.Swap(&b); + } + inline void Swap(ACL_ChanGroup* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ACL_ChanGroup* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ACL_ChanGroup* New() const final { + return CreateMaybeMessage(nullptr); + } + + ACL_ChanGroup* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const ACL_ChanGroup& from); + void MergeFrom(const ACL_ChanGroup& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ACL_ChanGroup* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MumbleProto.ACL.ChanGroup"; + } + protected: + explicit ACL_ChanGroup(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_Mumble_2eproto); + return ::descriptor_table_Mumble_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kAddFieldNumber = 5, + kRemoveFieldNumber = 6, + kInheritedMembersFieldNumber = 7, + kNameFieldNumber = 1, + kInheritedFieldNumber = 2, + kInheritFieldNumber = 3, + kInheritableFieldNumber = 4, + }; + // repeated uint32 add = 5; + int add_size() const; + private: + int _internal_add_size() const; + public: + void clear_add(); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_add(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& + _internal_add() const; + void _internal_add_add(::PROTOBUF_NAMESPACE_ID::uint32 value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* + _internal_mutable_add(); + public: + ::PROTOBUF_NAMESPACE_ID::uint32 add(int index) const; + void set_add(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value); + void add_add(::PROTOBUF_NAMESPACE_ID::uint32 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& + add() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* + mutable_add(); + + // repeated uint32 remove = 6; + int remove_size() const; + private: + int _internal_remove_size() const; + public: + void clear_remove(); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_remove(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& + _internal_remove() const; + void _internal_add_remove(::PROTOBUF_NAMESPACE_ID::uint32 value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* + _internal_mutable_remove(); + public: + ::PROTOBUF_NAMESPACE_ID::uint32 remove(int index) const; + void set_remove(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value); + void add_remove(::PROTOBUF_NAMESPACE_ID::uint32 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& + remove() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* + mutable_remove(); + + // repeated uint32 inherited_members = 7; + int inherited_members_size() const; + private: + int _internal_inherited_members_size() const; + public: + void clear_inherited_members(); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_inherited_members(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& + _internal_inherited_members() const; + void _internal_add_inherited_members(::PROTOBUF_NAMESPACE_ID::uint32 value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* + _internal_mutable_inherited_members(); + public: + ::PROTOBUF_NAMESPACE_ID::uint32 inherited_members(int index) const; + void set_inherited_members(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value); + void add_inherited_members(::PROTOBUF_NAMESPACE_ID::uint32 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& + inherited_members() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* + mutable_inherited_members(); + + // required string name = 1; + bool has_name() const; + private: + bool _internal_has_name() const; + public: + void clear_name(); + const std::string& name() const; + void set_name(const std::string& value); + void set_name(std::string&& value); + void set_name(const char* value); + void set_name(const char* value, size_t size); + std::string* mutable_name(); + std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); + public: + + // optional bool inherited = 2 [default = true]; + bool has_inherited() const; + private: + bool _internal_has_inherited() const; + public: + void clear_inherited(); + bool inherited() const; + void set_inherited(bool value); + private: + bool _internal_inherited() const; + void _internal_set_inherited(bool value); + public: + + // optional bool inherit = 3 [default = true]; + bool has_inherit() const; + private: + bool _internal_has_inherit() const; + public: + void clear_inherit(); + bool inherit() const; + void set_inherit(bool value); + private: + bool _internal_inherit() const; + void _internal_set_inherit(bool value); + public: + + // optional bool inheritable = 4 [default = true]; + bool has_inheritable() const; + private: + bool _internal_has_inheritable() const; + public: + void clear_inheritable(); + bool inheritable() const; + void set_inheritable(bool value); + private: + bool _internal_inheritable() const; + void _internal_set_inheritable(bool value); + public: + + // @@protoc_insertion_point(class_scope:MumbleProto.ACL.ChanGroup) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 > add_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 > remove_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 > inherited_members_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + bool inherited_; + bool inherit_; + bool inheritable_; + friend struct ::TableStruct_Mumble_2eproto; +}; +// ------------------------------------------------------------------- + +class ACL_ChanACL PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MumbleProto.ACL.ChanACL) */ { + public: + inline ACL_ChanACL() : ACL_ChanACL(nullptr) {}; + virtual ~ACL_ChanACL(); + + ACL_ChanACL(const ACL_ChanACL& from); + ACL_ChanACL(ACL_ChanACL&& from) noexcept + : ACL_ChanACL() { + *this = ::std::move(from); + } + + inline ACL_ChanACL& operator=(const ACL_ChanACL& from) { + CopyFrom(from); + return *this; + } + inline ACL_ChanACL& operator=(ACL_ChanACL&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const ACL_ChanACL& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const ACL_ChanACL* internal_default_instance() { + return reinterpret_cast( + &_ACL_ChanACL_default_instance_); + } + static constexpr int kIndexInFileMessages = + 15; + + friend void swap(ACL_ChanACL& a, ACL_ChanACL& b) { + a.Swap(&b); + } + inline void Swap(ACL_ChanACL* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ACL_ChanACL* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ACL_ChanACL* New() const final { + return CreateMaybeMessage(nullptr); + } + + ACL_ChanACL* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const ACL_ChanACL& from); + void MergeFrom(const ACL_ChanACL& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ACL_ChanACL* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MumbleProto.ACL.ChanACL"; + } + protected: + explicit ACL_ChanACL(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_Mumble_2eproto); + return ::descriptor_table_Mumble_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kGroupFieldNumber = 5, + kUserIdFieldNumber = 4, + kGrantFieldNumber = 6, + kDenyFieldNumber = 7, + kApplyHereFieldNumber = 1, + kApplySubsFieldNumber = 2, + kInheritedFieldNumber = 3, + }; + // optional string group = 5; + bool has_group() const; + private: + bool _internal_has_group() const; + public: + void clear_group(); + const std::string& group() const; + void set_group(const std::string& value); + void set_group(std::string&& value); + void set_group(const char* value); + void set_group(const char* value, size_t size); + std::string* mutable_group(); + std::string* release_group(); + void set_allocated_group(std::string* group); + private: + const std::string& _internal_group() const; + void _internal_set_group(const std::string& value); + std::string* _internal_mutable_group(); + public: + + // optional uint32 user_id = 4; + bool has_user_id() const; + private: + bool _internal_has_user_id() const; + public: + void clear_user_id(); + ::PROTOBUF_NAMESPACE_ID::uint32 user_id() const; + void set_user_id(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_user_id() const; + void _internal_set_user_id(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional uint32 grant = 6; + bool has_grant() const; + private: + bool _internal_has_grant() const; + public: + void clear_grant(); + ::PROTOBUF_NAMESPACE_ID::uint32 grant() const; + void set_grant(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_grant() const; + void _internal_set_grant(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional uint32 deny = 7; + bool has_deny() const; + private: + bool _internal_has_deny() const; + public: + void clear_deny(); + ::PROTOBUF_NAMESPACE_ID::uint32 deny() const; + void set_deny(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_deny() const; + void _internal_set_deny(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional bool apply_here = 1 [default = true]; + bool has_apply_here() const; + private: + bool _internal_has_apply_here() const; + public: + void clear_apply_here(); + bool apply_here() const; + void set_apply_here(bool value); + private: + bool _internal_apply_here() const; + void _internal_set_apply_here(bool value); + public: + + // optional bool apply_subs = 2 [default = true]; + bool has_apply_subs() const; + private: + bool _internal_has_apply_subs() const; + public: + void clear_apply_subs(); + bool apply_subs() const; + void set_apply_subs(bool value); + private: + bool _internal_apply_subs() const; + void _internal_set_apply_subs(bool value); + public: + + // optional bool inherited = 3 [default = true]; + bool has_inherited() const; + private: + bool _internal_has_inherited() const; + public: + void clear_inherited(); + bool inherited() const; + void set_inherited(bool value); + private: + bool _internal_inherited() const; + void _internal_set_inherited(bool value); + public: + + // @@protoc_insertion_point(class_scope:MumbleProto.ACL.ChanACL) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr group_; + ::PROTOBUF_NAMESPACE_ID::uint32 user_id_; + ::PROTOBUF_NAMESPACE_ID::uint32 grant_; + ::PROTOBUF_NAMESPACE_ID::uint32 deny_; + bool apply_here_; + bool apply_subs_; + bool inherited_; + friend struct ::TableStruct_Mumble_2eproto; +}; +// ------------------------------------------------------------------- + +class ACL PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MumbleProto.ACL) */ { + public: + inline ACL() : ACL(nullptr) {}; + virtual ~ACL(); + + ACL(const ACL& from); + ACL(ACL&& from) noexcept + : ACL() { + *this = ::std::move(from); + } + + inline ACL& operator=(const ACL& from) { + CopyFrom(from); + return *this; + } + inline ACL& operator=(ACL&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const ACL& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const ACL* internal_default_instance() { + return reinterpret_cast( + &_ACL_default_instance_); + } + static constexpr int kIndexInFileMessages = + 16; + + friend void swap(ACL& a, ACL& b) { + a.Swap(&b); + } + inline void Swap(ACL* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ACL* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ACL* New() const final { + return CreateMaybeMessage(nullptr); + } + + ACL* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const ACL& from); + void MergeFrom(const ACL& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ACL* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MumbleProto.ACL"; + } + protected: + explicit ACL(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_Mumble_2eproto); + return ::descriptor_table_Mumble_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + typedef ACL_ChanGroup ChanGroup; + typedef ACL_ChanACL ChanACL; + + // accessors ------------------------------------------------------- + + enum : int { + kGroupsFieldNumber = 3, + kAclsFieldNumber = 4, + kChannelIdFieldNumber = 1, + kQueryFieldNumber = 5, + kInheritAclsFieldNumber = 2, + }; + // repeated .MumbleProto.ACL.ChanGroup groups = 3; + int groups_size() const; + private: + int _internal_groups_size() const; + public: + void clear_groups(); + ::MumbleProto::ACL_ChanGroup* mutable_groups(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MumbleProto::ACL_ChanGroup >* + mutable_groups(); + private: + const ::MumbleProto::ACL_ChanGroup& _internal_groups(int index) const; + ::MumbleProto::ACL_ChanGroup* _internal_add_groups(); + public: + const ::MumbleProto::ACL_ChanGroup& groups(int index) const; + ::MumbleProto::ACL_ChanGroup* add_groups(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MumbleProto::ACL_ChanGroup >& + groups() const; + + // repeated .MumbleProto.ACL.ChanACL acls = 4; + int acls_size() const; + private: + int _internal_acls_size() const; + public: + void clear_acls(); + ::MumbleProto::ACL_ChanACL* mutable_acls(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MumbleProto::ACL_ChanACL >* + mutable_acls(); + private: + const ::MumbleProto::ACL_ChanACL& _internal_acls(int index) const; + ::MumbleProto::ACL_ChanACL* _internal_add_acls(); + public: + const ::MumbleProto::ACL_ChanACL& acls(int index) const; + ::MumbleProto::ACL_ChanACL* add_acls(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MumbleProto::ACL_ChanACL >& + acls() const; + + // required uint32 channel_id = 1; + bool has_channel_id() const; + private: + bool _internal_has_channel_id() const; + public: + void clear_channel_id(); + ::PROTOBUF_NAMESPACE_ID::uint32 channel_id() const; + void set_channel_id(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_channel_id() const; + void _internal_set_channel_id(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional bool query = 5 [default = false]; + bool has_query() const; + private: + bool _internal_has_query() const; + public: + void clear_query(); + bool query() const; + void set_query(bool value); + private: + bool _internal_query() const; + void _internal_set_query(bool value); + public: + + // optional bool inherit_acls = 2 [default = true]; + bool has_inherit_acls() const; + private: + bool _internal_has_inherit_acls() const; + public: + void clear_inherit_acls(); + bool inherit_acls() const; + void set_inherit_acls(bool value); + private: + bool _internal_inherit_acls() const; + void _internal_set_inherit_acls(bool value); + public: + + // @@protoc_insertion_point(class_scope:MumbleProto.ACL) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MumbleProto::ACL_ChanGroup > groups_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MumbleProto::ACL_ChanACL > acls_; + ::PROTOBUF_NAMESPACE_ID::uint32 channel_id_; + bool query_; + bool inherit_acls_; + friend struct ::TableStruct_Mumble_2eproto; +}; +// ------------------------------------------------------------------- + +class QueryUsers PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MumbleProto.QueryUsers) */ { + public: + inline QueryUsers() : QueryUsers(nullptr) {}; + virtual ~QueryUsers(); + + QueryUsers(const QueryUsers& from); + QueryUsers(QueryUsers&& from) noexcept + : QueryUsers() { + *this = ::std::move(from); + } + + inline QueryUsers& operator=(const QueryUsers& from) { + CopyFrom(from); + return *this; + } + inline QueryUsers& operator=(QueryUsers&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const QueryUsers& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const QueryUsers* internal_default_instance() { + return reinterpret_cast( + &_QueryUsers_default_instance_); + } + static constexpr int kIndexInFileMessages = + 17; + + friend void swap(QueryUsers& a, QueryUsers& b) { + a.Swap(&b); + } + inline void Swap(QueryUsers* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(QueryUsers* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline QueryUsers* New() const final { + return CreateMaybeMessage(nullptr); + } + + QueryUsers* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const QueryUsers& from); + void MergeFrom(const QueryUsers& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(QueryUsers* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MumbleProto.QueryUsers"; + } + protected: + explicit QueryUsers(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_Mumble_2eproto); + return ::descriptor_table_Mumble_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kIdsFieldNumber = 1, + kNamesFieldNumber = 2, + }; + // repeated uint32 ids = 1; + int ids_size() const; + private: + int _internal_ids_size() const; + public: + void clear_ids(); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_ids(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& + _internal_ids() const; + void _internal_add_ids(::PROTOBUF_NAMESPACE_ID::uint32 value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* + _internal_mutable_ids(); + public: + ::PROTOBUF_NAMESPACE_ID::uint32 ids(int index) const; + void set_ids(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value); + void add_ids(::PROTOBUF_NAMESPACE_ID::uint32 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& + ids() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* + mutable_ids(); + + // repeated string names = 2; + int names_size() const; + private: + int _internal_names_size() const; + public: + void clear_names(); + const std::string& names(int index) const; + std::string* mutable_names(int index); + void set_names(int index, const std::string& value); + void set_names(int index, std::string&& value); + void set_names(int index, const char* value); + void set_names(int index, const char* value, size_t size); + std::string* add_names(); + void add_names(const std::string& value); + void add_names(std::string&& value); + void add_names(const char* value); + void add_names(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& names() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_names(); + private: + const std::string& _internal_names(int index) const; + std::string* _internal_add_names(); + public: + + // @@protoc_insertion_point(class_scope:MumbleProto.QueryUsers) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 > ids_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField names_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_Mumble_2eproto; +}; +// ------------------------------------------------------------------- + +class CryptSetup PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MumbleProto.CryptSetup) */ { + public: + inline CryptSetup() : CryptSetup(nullptr) {}; + virtual ~CryptSetup(); + + CryptSetup(const CryptSetup& from); + CryptSetup(CryptSetup&& from) noexcept + : CryptSetup() { + *this = ::std::move(from); + } + + inline CryptSetup& operator=(const CryptSetup& from) { + CopyFrom(from); + return *this; + } + inline CryptSetup& operator=(CryptSetup&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const CryptSetup& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const CryptSetup* internal_default_instance() { + return reinterpret_cast( + &_CryptSetup_default_instance_); + } + static constexpr int kIndexInFileMessages = + 18; + + friend void swap(CryptSetup& a, CryptSetup& b) { + a.Swap(&b); + } + inline void Swap(CryptSetup* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(CryptSetup* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline CryptSetup* New() const final { + return CreateMaybeMessage(nullptr); + } + + CryptSetup* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const CryptSetup& from); + void MergeFrom(const CryptSetup& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(CryptSetup* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MumbleProto.CryptSetup"; + } + protected: + explicit CryptSetup(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_Mumble_2eproto); + return ::descriptor_table_Mumble_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kKeyFieldNumber = 1, + kClientNonceFieldNumber = 2, + kServerNonceFieldNumber = 3, + }; + // optional bytes key = 1; + bool has_key() const; + private: + bool _internal_has_key() const; + public: + void clear_key(); + const std::string& key() const; + void set_key(const std::string& value); + void set_key(std::string&& value); + void set_key(const char* value); + void set_key(const void* value, size_t size); + std::string* mutable_key(); + std::string* release_key(); + void set_allocated_key(std::string* key); + private: + const std::string& _internal_key() const; + void _internal_set_key(const std::string& value); + std::string* _internal_mutable_key(); + public: + + // optional bytes client_nonce = 2; + bool has_client_nonce() const; + private: + bool _internal_has_client_nonce() const; + public: + void clear_client_nonce(); + const std::string& client_nonce() const; + void set_client_nonce(const std::string& value); + void set_client_nonce(std::string&& value); + void set_client_nonce(const char* value); + void set_client_nonce(const void* value, size_t size); + std::string* mutable_client_nonce(); + std::string* release_client_nonce(); + void set_allocated_client_nonce(std::string* client_nonce); + private: + const std::string& _internal_client_nonce() const; + void _internal_set_client_nonce(const std::string& value); + std::string* _internal_mutable_client_nonce(); + public: + + // optional bytes server_nonce = 3; + bool has_server_nonce() const; + private: + bool _internal_has_server_nonce() const; + public: + void clear_server_nonce(); + const std::string& server_nonce() const; + void set_server_nonce(const std::string& value); + void set_server_nonce(std::string&& value); + void set_server_nonce(const char* value); + void set_server_nonce(const void* value, size_t size); + std::string* mutable_server_nonce(); + std::string* release_server_nonce(); + void set_allocated_server_nonce(std::string* server_nonce); + private: + const std::string& _internal_server_nonce() const; + void _internal_set_server_nonce(const std::string& value); + std::string* _internal_mutable_server_nonce(); + public: + + // @@protoc_insertion_point(class_scope:MumbleProto.CryptSetup) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr client_nonce_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr server_nonce_; + friend struct ::TableStruct_Mumble_2eproto; +}; +// ------------------------------------------------------------------- + +class ContextActionModify PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MumbleProto.ContextActionModify) */ { + public: + inline ContextActionModify() : ContextActionModify(nullptr) {}; + virtual ~ContextActionModify(); + + ContextActionModify(const ContextActionModify& from); + ContextActionModify(ContextActionModify&& from) noexcept + : ContextActionModify() { + *this = ::std::move(from); + } + + inline ContextActionModify& operator=(const ContextActionModify& from) { + CopyFrom(from); + return *this; + } + inline ContextActionModify& operator=(ContextActionModify&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const ContextActionModify& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const ContextActionModify* internal_default_instance() { + return reinterpret_cast( + &_ContextActionModify_default_instance_); + } + static constexpr int kIndexInFileMessages = + 19; + + friend void swap(ContextActionModify& a, ContextActionModify& b) { + a.Swap(&b); + } + inline void Swap(ContextActionModify* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ContextActionModify* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ContextActionModify* New() const final { + return CreateMaybeMessage(nullptr); + } + + ContextActionModify* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const ContextActionModify& from); + void MergeFrom(const ContextActionModify& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ContextActionModify* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MumbleProto.ContextActionModify"; + } + protected: + explicit ContextActionModify(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_Mumble_2eproto); + return ::descriptor_table_Mumble_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + typedef ContextActionModify_Context Context; + static constexpr Context Server = + ContextActionModify_Context_Server; + static constexpr Context Channel = + ContextActionModify_Context_Channel; + static constexpr Context User = + ContextActionModify_Context_User; + static inline bool Context_IsValid(int value) { + return ContextActionModify_Context_IsValid(value); + } + static constexpr Context Context_MIN = + ContextActionModify_Context_Context_MIN; + static constexpr Context Context_MAX = + ContextActionModify_Context_Context_MAX; + static constexpr int Context_ARRAYSIZE = + ContextActionModify_Context_Context_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + Context_descriptor() { + return ContextActionModify_Context_descriptor(); + } + template + static inline const std::string& Context_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Context_Name."); + return ContextActionModify_Context_Name(enum_t_value); + } + static inline bool Context_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + Context* value) { + return ContextActionModify_Context_Parse(name, value); + } + + typedef ContextActionModify_Operation Operation; + static constexpr Operation Add = + ContextActionModify_Operation_Add; + static constexpr Operation Remove = + ContextActionModify_Operation_Remove; + static inline bool Operation_IsValid(int value) { + return ContextActionModify_Operation_IsValid(value); + } + static constexpr Operation Operation_MIN = + ContextActionModify_Operation_Operation_MIN; + static constexpr Operation Operation_MAX = + ContextActionModify_Operation_Operation_MAX; + static constexpr int Operation_ARRAYSIZE = + ContextActionModify_Operation_Operation_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + Operation_descriptor() { + return ContextActionModify_Operation_descriptor(); + } + template + static inline const std::string& Operation_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Operation_Name."); + return ContextActionModify_Operation_Name(enum_t_value); + } + static inline bool Operation_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + Operation* value) { + return ContextActionModify_Operation_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kActionFieldNumber = 1, + kTextFieldNumber = 2, + kContextFieldNumber = 3, + kOperationFieldNumber = 4, + }; + // required string action = 1; + bool has_action() const; + private: + bool _internal_has_action() const; + public: + void clear_action(); + const std::string& action() const; + void set_action(const std::string& value); + void set_action(std::string&& value); + void set_action(const char* value); + void set_action(const char* value, size_t size); + std::string* mutable_action(); + std::string* release_action(); + void set_allocated_action(std::string* action); + private: + const std::string& _internal_action() const; + void _internal_set_action(const std::string& value); + std::string* _internal_mutable_action(); + public: + + // optional string text = 2; + bool has_text() const; + private: + bool _internal_has_text() const; + public: + void clear_text(); + const std::string& text() const; + void set_text(const std::string& value); + void set_text(std::string&& value); + void set_text(const char* value); + void set_text(const char* value, size_t size); + std::string* mutable_text(); + std::string* release_text(); + void set_allocated_text(std::string* text); + private: + const std::string& _internal_text() const; + void _internal_set_text(const std::string& value); + std::string* _internal_mutable_text(); + public: + + // optional uint32 context = 3; + bool has_context() const; + private: + bool _internal_has_context() const; + public: + void clear_context(); + ::PROTOBUF_NAMESPACE_ID::uint32 context() const; + void set_context(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_context() const; + void _internal_set_context(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional .MumbleProto.ContextActionModify.Operation operation = 4; + bool has_operation() const; + private: + bool _internal_has_operation() const; + public: + void clear_operation(); + ::MumbleProto::ContextActionModify_Operation operation() const; + void set_operation(::MumbleProto::ContextActionModify_Operation value); + private: + ::MumbleProto::ContextActionModify_Operation _internal_operation() const; + void _internal_set_operation(::MumbleProto::ContextActionModify_Operation value); + public: + + // @@protoc_insertion_point(class_scope:MumbleProto.ContextActionModify) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr action_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr text_; + ::PROTOBUF_NAMESPACE_ID::uint32 context_; + int operation_; + friend struct ::TableStruct_Mumble_2eproto; +}; +// ------------------------------------------------------------------- + +class ContextAction PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MumbleProto.ContextAction) */ { + public: + inline ContextAction() : ContextAction(nullptr) {}; + virtual ~ContextAction(); + + ContextAction(const ContextAction& from); + ContextAction(ContextAction&& from) noexcept + : ContextAction() { + *this = ::std::move(from); + } + + inline ContextAction& operator=(const ContextAction& from) { + CopyFrom(from); + return *this; + } + inline ContextAction& operator=(ContextAction&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const ContextAction& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const ContextAction* internal_default_instance() { + return reinterpret_cast( + &_ContextAction_default_instance_); + } + static constexpr int kIndexInFileMessages = + 20; + + friend void swap(ContextAction& a, ContextAction& b) { + a.Swap(&b); + } + inline void Swap(ContextAction* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ContextAction* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ContextAction* New() const final { + return CreateMaybeMessage(nullptr); + } + + ContextAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const ContextAction& from); + void MergeFrom(const ContextAction& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ContextAction* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MumbleProto.ContextAction"; + } + protected: + explicit ContextAction(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_Mumble_2eproto); + return ::descriptor_table_Mumble_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kActionFieldNumber = 3, + kSessionFieldNumber = 1, + kChannelIdFieldNumber = 2, + }; + // required string action = 3; + bool has_action() const; + private: + bool _internal_has_action() const; + public: + void clear_action(); + const std::string& action() const; + void set_action(const std::string& value); + void set_action(std::string&& value); + void set_action(const char* value); + void set_action(const char* value, size_t size); + std::string* mutable_action(); + std::string* release_action(); + void set_allocated_action(std::string* action); + private: + const std::string& _internal_action() const; + void _internal_set_action(const std::string& value); + std::string* _internal_mutable_action(); + public: + + // optional uint32 session = 1; + bool has_session() const; + private: + bool _internal_has_session() const; + public: + void clear_session(); + ::PROTOBUF_NAMESPACE_ID::uint32 session() const; + void set_session(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_session() const; + void _internal_set_session(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional uint32 channel_id = 2; + bool has_channel_id() const; + private: + bool _internal_has_channel_id() const; + public: + void clear_channel_id(); + ::PROTOBUF_NAMESPACE_ID::uint32 channel_id() const; + void set_channel_id(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_channel_id() const; + void _internal_set_channel_id(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // @@protoc_insertion_point(class_scope:MumbleProto.ContextAction) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr action_; + ::PROTOBUF_NAMESPACE_ID::uint32 session_; + ::PROTOBUF_NAMESPACE_ID::uint32 channel_id_; + friend struct ::TableStruct_Mumble_2eproto; +}; +// ------------------------------------------------------------------- + +class UserList_User PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MumbleProto.UserList.User) */ { + public: + inline UserList_User() : UserList_User(nullptr) {}; + virtual ~UserList_User(); + + UserList_User(const UserList_User& from); + UserList_User(UserList_User&& from) noexcept + : UserList_User() { + *this = ::std::move(from); + } + + inline UserList_User& operator=(const UserList_User& from) { + CopyFrom(from); + return *this; + } + inline UserList_User& operator=(UserList_User&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const UserList_User& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const UserList_User* internal_default_instance() { + return reinterpret_cast( + &_UserList_User_default_instance_); + } + static constexpr int kIndexInFileMessages = + 21; + + friend void swap(UserList_User& a, UserList_User& b) { + a.Swap(&b); + } + inline void Swap(UserList_User* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(UserList_User* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline UserList_User* New() const final { + return CreateMaybeMessage(nullptr); + } + + UserList_User* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const UserList_User& from); + void MergeFrom(const UserList_User& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(UserList_User* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MumbleProto.UserList.User"; + } + protected: + explicit UserList_User(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_Mumble_2eproto); + return ::descriptor_table_Mumble_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kNameFieldNumber = 2, + kLastSeenFieldNumber = 3, + kUserIdFieldNumber = 1, + kLastChannelFieldNumber = 4, + }; + // optional string name = 2; + bool has_name() const; + private: + bool _internal_has_name() const; + public: + void clear_name(); + const std::string& name() const; + void set_name(const std::string& value); + void set_name(std::string&& value); + void set_name(const char* value); + void set_name(const char* value, size_t size); + std::string* mutable_name(); + std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); + public: + + // optional string last_seen = 3; + bool has_last_seen() const; + private: + bool _internal_has_last_seen() const; + public: + void clear_last_seen(); + const std::string& last_seen() const; + void set_last_seen(const std::string& value); + void set_last_seen(std::string&& value); + void set_last_seen(const char* value); + void set_last_seen(const char* value, size_t size); + std::string* mutable_last_seen(); + std::string* release_last_seen(); + void set_allocated_last_seen(std::string* last_seen); + private: + const std::string& _internal_last_seen() const; + void _internal_set_last_seen(const std::string& value); + std::string* _internal_mutable_last_seen(); + public: + + // required uint32 user_id = 1; + bool has_user_id() const; + private: + bool _internal_has_user_id() const; + public: + void clear_user_id(); + ::PROTOBUF_NAMESPACE_ID::uint32 user_id() const; + void set_user_id(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_user_id() const; + void _internal_set_user_id(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional uint32 last_channel = 4; + bool has_last_channel() const; + private: + bool _internal_has_last_channel() const; + public: + void clear_last_channel(); + ::PROTOBUF_NAMESPACE_ID::uint32 last_channel() const; + void set_last_channel(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_last_channel() const; + void _internal_set_last_channel(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // @@protoc_insertion_point(class_scope:MumbleProto.UserList.User) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr last_seen_; + ::PROTOBUF_NAMESPACE_ID::uint32 user_id_; + ::PROTOBUF_NAMESPACE_ID::uint32 last_channel_; + friend struct ::TableStruct_Mumble_2eproto; +}; +// ------------------------------------------------------------------- + +class UserList PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MumbleProto.UserList) */ { + public: + inline UserList() : UserList(nullptr) {}; + virtual ~UserList(); + + UserList(const UserList& from); + UserList(UserList&& from) noexcept + : UserList() { + *this = ::std::move(from); + } + + inline UserList& operator=(const UserList& from) { + CopyFrom(from); + return *this; + } + inline UserList& operator=(UserList&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const UserList& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const UserList* internal_default_instance() { + return reinterpret_cast( + &_UserList_default_instance_); + } + static constexpr int kIndexInFileMessages = + 22; + + friend void swap(UserList& a, UserList& b) { + a.Swap(&b); + } + inline void Swap(UserList* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(UserList* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline UserList* New() const final { + return CreateMaybeMessage(nullptr); + } + + UserList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const UserList& from); + void MergeFrom(const UserList& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(UserList* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MumbleProto.UserList"; + } + protected: + explicit UserList(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_Mumble_2eproto); + return ::descriptor_table_Mumble_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + typedef UserList_User User; + + // accessors ------------------------------------------------------- + + enum : int { + kUsersFieldNumber = 1, + }; + // repeated .MumbleProto.UserList.User users = 1; + int users_size() const; + private: + int _internal_users_size() const; + public: + void clear_users(); + ::MumbleProto::UserList_User* mutable_users(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MumbleProto::UserList_User >* + mutable_users(); + private: + const ::MumbleProto::UserList_User& _internal_users(int index) const; + ::MumbleProto::UserList_User* _internal_add_users(); + public: + const ::MumbleProto::UserList_User& users(int index) const; + ::MumbleProto::UserList_User* add_users(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MumbleProto::UserList_User >& + users() const; + + // @@protoc_insertion_point(class_scope:MumbleProto.UserList) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MumbleProto::UserList_User > users_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_Mumble_2eproto; +}; +// ------------------------------------------------------------------- + +class VoiceTarget_Target PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MumbleProto.VoiceTarget.Target) */ { + public: + inline VoiceTarget_Target() : VoiceTarget_Target(nullptr) {}; + virtual ~VoiceTarget_Target(); + + VoiceTarget_Target(const VoiceTarget_Target& from); + VoiceTarget_Target(VoiceTarget_Target&& from) noexcept + : VoiceTarget_Target() { + *this = ::std::move(from); + } + + inline VoiceTarget_Target& operator=(const VoiceTarget_Target& from) { + CopyFrom(from); + return *this; + } + inline VoiceTarget_Target& operator=(VoiceTarget_Target&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const VoiceTarget_Target& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const VoiceTarget_Target* internal_default_instance() { + return reinterpret_cast( + &_VoiceTarget_Target_default_instance_); + } + static constexpr int kIndexInFileMessages = + 23; + + friend void swap(VoiceTarget_Target& a, VoiceTarget_Target& b) { + a.Swap(&b); + } + inline void Swap(VoiceTarget_Target* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(VoiceTarget_Target* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline VoiceTarget_Target* New() const final { + return CreateMaybeMessage(nullptr); + } + + VoiceTarget_Target* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const VoiceTarget_Target& from); + void MergeFrom(const VoiceTarget_Target& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(VoiceTarget_Target* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MumbleProto.VoiceTarget.Target"; + } + protected: + explicit VoiceTarget_Target(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_Mumble_2eproto); + return ::descriptor_table_Mumble_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kSessionFieldNumber = 1, + kGroupFieldNumber = 3, + kChannelIdFieldNumber = 2, + kLinksFieldNumber = 4, + kChildrenFieldNumber = 5, + }; + // repeated uint32 session = 1; + int session_size() const; + private: + int _internal_session_size() const; + public: + void clear_session(); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_session(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& + _internal_session() const; + void _internal_add_session(::PROTOBUF_NAMESPACE_ID::uint32 value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* + _internal_mutable_session(); + public: + ::PROTOBUF_NAMESPACE_ID::uint32 session(int index) const; + void set_session(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value); + void add_session(::PROTOBUF_NAMESPACE_ID::uint32 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& + session() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* + mutable_session(); + + // optional string group = 3; + bool has_group() const; + private: + bool _internal_has_group() const; + public: + void clear_group(); + const std::string& group() const; + void set_group(const std::string& value); + void set_group(std::string&& value); + void set_group(const char* value); + void set_group(const char* value, size_t size); + std::string* mutable_group(); + std::string* release_group(); + void set_allocated_group(std::string* group); + private: + const std::string& _internal_group() const; + void _internal_set_group(const std::string& value); + std::string* _internal_mutable_group(); + public: + + // optional uint32 channel_id = 2; + bool has_channel_id() const; + private: + bool _internal_has_channel_id() const; + public: + void clear_channel_id(); + ::PROTOBUF_NAMESPACE_ID::uint32 channel_id() const; + void set_channel_id(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_channel_id() const; + void _internal_set_channel_id(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional bool links = 4 [default = false]; + bool has_links() const; + private: + bool _internal_has_links() const; + public: + void clear_links(); + bool links() const; + void set_links(bool value); + private: + bool _internal_links() const; + void _internal_set_links(bool value); + public: + + // optional bool children = 5 [default = false]; + bool has_children() const; + private: + bool _internal_has_children() const; + public: + void clear_children(); + bool children() const; + void set_children(bool value); + private: + bool _internal_children() const; + void _internal_set_children(bool value); + public: + + // @@protoc_insertion_point(class_scope:MumbleProto.VoiceTarget.Target) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 > session_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr group_; + ::PROTOBUF_NAMESPACE_ID::uint32 channel_id_; + bool links_; + bool children_; + friend struct ::TableStruct_Mumble_2eproto; +}; +// ------------------------------------------------------------------- + +class VoiceTarget PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MumbleProto.VoiceTarget) */ { + public: + inline VoiceTarget() : VoiceTarget(nullptr) {}; + virtual ~VoiceTarget(); + + VoiceTarget(const VoiceTarget& from); + VoiceTarget(VoiceTarget&& from) noexcept + : VoiceTarget() { + *this = ::std::move(from); + } + + inline VoiceTarget& operator=(const VoiceTarget& from) { + CopyFrom(from); + return *this; + } + inline VoiceTarget& operator=(VoiceTarget&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const VoiceTarget& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const VoiceTarget* internal_default_instance() { + return reinterpret_cast( + &_VoiceTarget_default_instance_); + } + static constexpr int kIndexInFileMessages = + 24; + + friend void swap(VoiceTarget& a, VoiceTarget& b) { + a.Swap(&b); + } + inline void Swap(VoiceTarget* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(VoiceTarget* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline VoiceTarget* New() const final { + return CreateMaybeMessage(nullptr); + } + + VoiceTarget* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const VoiceTarget& from); + void MergeFrom(const VoiceTarget& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(VoiceTarget* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MumbleProto.VoiceTarget"; + } + protected: + explicit VoiceTarget(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_Mumble_2eproto); + return ::descriptor_table_Mumble_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + typedef VoiceTarget_Target Target; + + // accessors ------------------------------------------------------- + + enum : int { + kTargetsFieldNumber = 2, + kIdFieldNumber = 1, + }; + // repeated .MumbleProto.VoiceTarget.Target targets = 2; + int targets_size() const; + private: + int _internal_targets_size() const; + public: + void clear_targets(); + ::MumbleProto::VoiceTarget_Target* mutable_targets(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MumbleProto::VoiceTarget_Target >* + mutable_targets(); + private: + const ::MumbleProto::VoiceTarget_Target& _internal_targets(int index) const; + ::MumbleProto::VoiceTarget_Target* _internal_add_targets(); + public: + const ::MumbleProto::VoiceTarget_Target& targets(int index) const; + ::MumbleProto::VoiceTarget_Target* add_targets(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MumbleProto::VoiceTarget_Target >& + targets() const; + + // optional uint32 id = 1; + bool has_id() const; + private: + bool _internal_has_id() const; + public: + void clear_id(); + ::PROTOBUF_NAMESPACE_ID::uint32 id() const; + void set_id(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_id() const; + void _internal_set_id(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // @@protoc_insertion_point(class_scope:MumbleProto.VoiceTarget) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MumbleProto::VoiceTarget_Target > targets_; + ::PROTOBUF_NAMESPACE_ID::uint32 id_; + friend struct ::TableStruct_Mumble_2eproto; +}; +// ------------------------------------------------------------------- + +class PermissionQuery PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MumbleProto.PermissionQuery) */ { + public: + inline PermissionQuery() : PermissionQuery(nullptr) {}; + virtual ~PermissionQuery(); + + PermissionQuery(const PermissionQuery& from); + PermissionQuery(PermissionQuery&& from) noexcept + : PermissionQuery() { + *this = ::std::move(from); + } + + inline PermissionQuery& operator=(const PermissionQuery& from) { + CopyFrom(from); + return *this; + } + inline PermissionQuery& operator=(PermissionQuery&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const PermissionQuery& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const PermissionQuery* internal_default_instance() { + return reinterpret_cast( + &_PermissionQuery_default_instance_); + } + static constexpr int kIndexInFileMessages = + 25; + + friend void swap(PermissionQuery& a, PermissionQuery& b) { + a.Swap(&b); + } + inline void Swap(PermissionQuery* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(PermissionQuery* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline PermissionQuery* New() const final { + return CreateMaybeMessage(nullptr); + } + + PermissionQuery* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const PermissionQuery& from); + void MergeFrom(const PermissionQuery& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(PermissionQuery* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MumbleProto.PermissionQuery"; + } + protected: + explicit PermissionQuery(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_Mumble_2eproto); + return ::descriptor_table_Mumble_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kChannelIdFieldNumber = 1, + kPermissionsFieldNumber = 2, + kFlushFieldNumber = 3, + }; + // optional uint32 channel_id = 1; + bool has_channel_id() const; + private: + bool _internal_has_channel_id() const; + public: + void clear_channel_id(); + ::PROTOBUF_NAMESPACE_ID::uint32 channel_id() const; + void set_channel_id(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_channel_id() const; + void _internal_set_channel_id(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional uint32 permissions = 2; + bool has_permissions() const; + private: + bool _internal_has_permissions() const; + public: + void clear_permissions(); + ::PROTOBUF_NAMESPACE_ID::uint32 permissions() const; + void set_permissions(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_permissions() const; + void _internal_set_permissions(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional bool flush = 3 [default = false]; + bool has_flush() const; + private: + bool _internal_has_flush() const; + public: + void clear_flush(); + bool flush() const; + void set_flush(bool value); + private: + bool _internal_flush() const; + void _internal_set_flush(bool value); + public: + + // @@protoc_insertion_point(class_scope:MumbleProto.PermissionQuery) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 channel_id_; + ::PROTOBUF_NAMESPACE_ID::uint32 permissions_; + bool flush_; + friend struct ::TableStruct_Mumble_2eproto; +}; +// ------------------------------------------------------------------- + +class CodecVersion PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MumbleProto.CodecVersion) */ { + public: + inline CodecVersion() : CodecVersion(nullptr) {}; + virtual ~CodecVersion(); + + CodecVersion(const CodecVersion& from); + CodecVersion(CodecVersion&& from) noexcept + : CodecVersion() { + *this = ::std::move(from); + } + + inline CodecVersion& operator=(const CodecVersion& from) { + CopyFrom(from); + return *this; + } + inline CodecVersion& operator=(CodecVersion&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const CodecVersion& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const CodecVersion* internal_default_instance() { + return reinterpret_cast( + &_CodecVersion_default_instance_); + } + static constexpr int kIndexInFileMessages = + 26; + + friend void swap(CodecVersion& a, CodecVersion& b) { + a.Swap(&b); + } + inline void Swap(CodecVersion* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(CodecVersion* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline CodecVersion* New() const final { + return CreateMaybeMessage(nullptr); + } + + CodecVersion* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const CodecVersion& from); + void MergeFrom(const CodecVersion& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(CodecVersion* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MumbleProto.CodecVersion"; + } + protected: + explicit CodecVersion(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_Mumble_2eproto); + return ::descriptor_table_Mumble_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kAlphaFieldNumber = 1, + kBetaFieldNumber = 2, + kOpusFieldNumber = 4, + kPreferAlphaFieldNumber = 3, + }; + // required int32 alpha = 1; + bool has_alpha() const; + private: + bool _internal_has_alpha() const; + public: + void clear_alpha(); + ::PROTOBUF_NAMESPACE_ID::int32 alpha() const; + void set_alpha(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_alpha() const; + void _internal_set_alpha(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // required int32 beta = 2; + bool has_beta() const; + private: + bool _internal_has_beta() const; + public: + void clear_beta(); + ::PROTOBUF_NAMESPACE_ID::int32 beta() const; + void set_beta(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_beta() const; + void _internal_set_beta(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // optional bool opus = 4 [default = false]; + bool has_opus() const; + private: + bool _internal_has_opus() const; + public: + void clear_opus(); + bool opus() const; + void set_opus(bool value); + private: + bool _internal_opus() const; + void _internal_set_opus(bool value); + public: + + // required bool prefer_alpha = 3 [default = true]; + bool has_prefer_alpha() const; + private: + bool _internal_has_prefer_alpha() const; + public: + void clear_prefer_alpha(); + bool prefer_alpha() const; + void set_prefer_alpha(bool value); + private: + bool _internal_prefer_alpha() const; + void _internal_set_prefer_alpha(bool value); + public: + + // @@protoc_insertion_point(class_scope:MumbleProto.CodecVersion) + private: + class _Internal; + + // helper for ByteSizeLong() + size_t RequiredFieldsByteSizeFallback() const; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::int32 alpha_; + ::PROTOBUF_NAMESPACE_ID::int32 beta_; + bool opus_; + bool prefer_alpha_; + friend struct ::TableStruct_Mumble_2eproto; +}; +// ------------------------------------------------------------------- + +class UserStats_Stats PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MumbleProto.UserStats.Stats) */ { + public: + inline UserStats_Stats() : UserStats_Stats(nullptr) {}; + virtual ~UserStats_Stats(); + + UserStats_Stats(const UserStats_Stats& from); + UserStats_Stats(UserStats_Stats&& from) noexcept + : UserStats_Stats() { + *this = ::std::move(from); + } + + inline UserStats_Stats& operator=(const UserStats_Stats& from) { + CopyFrom(from); + return *this; + } + inline UserStats_Stats& operator=(UserStats_Stats&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const UserStats_Stats& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const UserStats_Stats* internal_default_instance() { + return reinterpret_cast( + &_UserStats_Stats_default_instance_); + } + static constexpr int kIndexInFileMessages = + 27; + + friend void swap(UserStats_Stats& a, UserStats_Stats& b) { + a.Swap(&b); + } + inline void Swap(UserStats_Stats* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(UserStats_Stats* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline UserStats_Stats* New() const final { + return CreateMaybeMessage(nullptr); + } + + UserStats_Stats* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const UserStats_Stats& from); + void MergeFrom(const UserStats_Stats& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(UserStats_Stats* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MumbleProto.UserStats.Stats"; + } + protected: + explicit UserStats_Stats(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_Mumble_2eproto); + return ::descriptor_table_Mumble_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kGoodFieldNumber = 1, + kLateFieldNumber = 2, + kLostFieldNumber = 3, + kResyncFieldNumber = 4, + }; + // optional uint32 good = 1; + bool has_good() const; + private: + bool _internal_has_good() const; + public: + void clear_good(); + ::PROTOBUF_NAMESPACE_ID::uint32 good() const; + void set_good(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_good() const; + void _internal_set_good(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional uint32 late = 2; + bool has_late() const; + private: + bool _internal_has_late() const; + public: + void clear_late(); + ::PROTOBUF_NAMESPACE_ID::uint32 late() const; + void set_late(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_late() const; + void _internal_set_late(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional uint32 lost = 3; + bool has_lost() const; + private: + bool _internal_has_lost() const; + public: + void clear_lost(); + ::PROTOBUF_NAMESPACE_ID::uint32 lost() const; + void set_lost(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_lost() const; + void _internal_set_lost(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional uint32 resync = 4; + bool has_resync() const; + private: + bool _internal_has_resync() const; + public: + void clear_resync(); + ::PROTOBUF_NAMESPACE_ID::uint32 resync() const; + void set_resync(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_resync() const; + void _internal_set_resync(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // @@protoc_insertion_point(class_scope:MumbleProto.UserStats.Stats) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 good_; + ::PROTOBUF_NAMESPACE_ID::uint32 late_; + ::PROTOBUF_NAMESPACE_ID::uint32 lost_; + ::PROTOBUF_NAMESPACE_ID::uint32 resync_; + friend struct ::TableStruct_Mumble_2eproto; +}; +// ------------------------------------------------------------------- + +class UserStats PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MumbleProto.UserStats) */ { + public: + inline UserStats() : UserStats(nullptr) {}; + virtual ~UserStats(); + + UserStats(const UserStats& from); + UserStats(UserStats&& from) noexcept + : UserStats() { + *this = ::std::move(from); + } + + inline UserStats& operator=(const UserStats& from) { + CopyFrom(from); + return *this; + } + inline UserStats& operator=(UserStats&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const UserStats& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const UserStats* internal_default_instance() { + return reinterpret_cast( + &_UserStats_default_instance_); + } + static constexpr int kIndexInFileMessages = + 28; + + friend void swap(UserStats& a, UserStats& b) { + a.Swap(&b); + } + inline void Swap(UserStats* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(UserStats* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline UserStats* New() const final { + return CreateMaybeMessage(nullptr); + } + + UserStats* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const UserStats& from); + void MergeFrom(const UserStats& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(UserStats* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MumbleProto.UserStats"; + } + protected: + explicit UserStats(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_Mumble_2eproto); + return ::descriptor_table_Mumble_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + typedef UserStats_Stats Stats; + + // accessors ------------------------------------------------------- + + enum : int { + kCertificatesFieldNumber = 3, + kCeltVersionsFieldNumber = 13, + kAddressFieldNumber = 14, + kFromClientFieldNumber = 4, + kFromServerFieldNumber = 5, + kVersionFieldNumber = 12, + kSessionFieldNumber = 1, + kUdpPacketsFieldNumber = 6, + kTcpPacketsFieldNumber = 7, + kUdpPingAvgFieldNumber = 8, + kUdpPingVarFieldNumber = 9, + kTcpPingAvgFieldNumber = 10, + kTcpPingVarFieldNumber = 11, + kStatsOnlyFieldNumber = 2, + kStrongCertificateFieldNumber = 18, + kOpusFieldNumber = 19, + kBandwidthFieldNumber = 15, + kOnlinesecsFieldNumber = 16, + kIdlesecsFieldNumber = 17, + }; + // repeated bytes certificates = 3; + int certificates_size() const; + private: + int _internal_certificates_size() const; + public: + void clear_certificates(); + const std::string& certificates(int index) const; + std::string* mutable_certificates(int index); + void set_certificates(int index, const std::string& value); + void set_certificates(int index, std::string&& value); + void set_certificates(int index, const char* value); + void set_certificates(int index, const void* value, size_t size); + std::string* add_certificates(); + void add_certificates(const std::string& value); + void add_certificates(std::string&& value); + void add_certificates(const char* value); + void add_certificates(const void* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& certificates() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_certificates(); + private: + const std::string& _internal_certificates(int index) const; + std::string* _internal_add_certificates(); + public: + + // repeated int32 celt_versions = 13; + int celt_versions_size() const; + private: + int _internal_celt_versions_size() const; + public: + void clear_celt_versions(); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_celt_versions(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& + _internal_celt_versions() const; + void _internal_add_celt_versions(::PROTOBUF_NAMESPACE_ID::int32 value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* + _internal_mutable_celt_versions(); + public: + ::PROTOBUF_NAMESPACE_ID::int32 celt_versions(int index) const; + void set_celt_versions(int index, ::PROTOBUF_NAMESPACE_ID::int32 value); + void add_celt_versions(::PROTOBUF_NAMESPACE_ID::int32 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& + celt_versions() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* + mutable_celt_versions(); + + // optional bytes address = 14; + bool has_address() const; + private: + bool _internal_has_address() const; + public: + void clear_address(); + const std::string& address() const; + void set_address(const std::string& value); + void set_address(std::string&& value); + void set_address(const char* value); + void set_address(const void* value, size_t size); + std::string* mutable_address(); + std::string* release_address(); + void set_allocated_address(std::string* address); + private: + const std::string& _internal_address() const; + void _internal_set_address(const std::string& value); + std::string* _internal_mutable_address(); + public: + + // optional .MumbleProto.UserStats.Stats from_client = 4; + bool has_from_client() const; + private: + bool _internal_has_from_client() const; + public: + void clear_from_client(); + const ::MumbleProto::UserStats_Stats& from_client() const; + ::MumbleProto::UserStats_Stats* release_from_client(); + ::MumbleProto::UserStats_Stats* mutable_from_client(); + void set_allocated_from_client(::MumbleProto::UserStats_Stats* from_client); + private: + const ::MumbleProto::UserStats_Stats& _internal_from_client() const; + ::MumbleProto::UserStats_Stats* _internal_mutable_from_client(); + public: + void unsafe_arena_set_allocated_from_client( + ::MumbleProto::UserStats_Stats* from_client); + ::MumbleProto::UserStats_Stats* unsafe_arena_release_from_client(); + + // optional .MumbleProto.UserStats.Stats from_server = 5; + bool has_from_server() const; + private: + bool _internal_has_from_server() const; + public: + void clear_from_server(); + const ::MumbleProto::UserStats_Stats& from_server() const; + ::MumbleProto::UserStats_Stats* release_from_server(); + ::MumbleProto::UserStats_Stats* mutable_from_server(); + void set_allocated_from_server(::MumbleProto::UserStats_Stats* from_server); + private: + const ::MumbleProto::UserStats_Stats& _internal_from_server() const; + ::MumbleProto::UserStats_Stats* _internal_mutable_from_server(); + public: + void unsafe_arena_set_allocated_from_server( + ::MumbleProto::UserStats_Stats* from_server); + ::MumbleProto::UserStats_Stats* unsafe_arena_release_from_server(); + + // optional .MumbleProto.Version version = 12; + bool has_version() const; + private: + bool _internal_has_version() const; + public: + void clear_version(); + const ::MumbleProto::Version& version() const; + ::MumbleProto::Version* release_version(); + ::MumbleProto::Version* mutable_version(); + void set_allocated_version(::MumbleProto::Version* version); + private: + const ::MumbleProto::Version& _internal_version() const; + ::MumbleProto::Version* _internal_mutable_version(); + public: + void unsafe_arena_set_allocated_version( + ::MumbleProto::Version* version); + ::MumbleProto::Version* unsafe_arena_release_version(); + + // optional uint32 session = 1; + bool has_session() const; + private: + bool _internal_has_session() const; + public: + void clear_session(); + ::PROTOBUF_NAMESPACE_ID::uint32 session() const; + void set_session(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_session() const; + void _internal_set_session(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional uint32 udp_packets = 6; + bool has_udp_packets() const; + private: + bool _internal_has_udp_packets() const; + public: + void clear_udp_packets(); + ::PROTOBUF_NAMESPACE_ID::uint32 udp_packets() const; + void set_udp_packets(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_udp_packets() const; + void _internal_set_udp_packets(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional uint32 tcp_packets = 7; + bool has_tcp_packets() const; + private: + bool _internal_has_tcp_packets() const; + public: + void clear_tcp_packets(); + ::PROTOBUF_NAMESPACE_ID::uint32 tcp_packets() const; + void set_tcp_packets(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_tcp_packets() const; + void _internal_set_tcp_packets(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional float udp_ping_avg = 8; + bool has_udp_ping_avg() const; + private: + bool _internal_has_udp_ping_avg() const; + public: + void clear_udp_ping_avg(); + float udp_ping_avg() const; + void set_udp_ping_avg(float value); + private: + float _internal_udp_ping_avg() const; + void _internal_set_udp_ping_avg(float value); + public: + + // optional float udp_ping_var = 9; + bool has_udp_ping_var() const; + private: + bool _internal_has_udp_ping_var() const; + public: + void clear_udp_ping_var(); + float udp_ping_var() const; + void set_udp_ping_var(float value); + private: + float _internal_udp_ping_var() const; + void _internal_set_udp_ping_var(float value); + public: + + // optional float tcp_ping_avg = 10; + bool has_tcp_ping_avg() const; + private: + bool _internal_has_tcp_ping_avg() const; + public: + void clear_tcp_ping_avg(); + float tcp_ping_avg() const; + void set_tcp_ping_avg(float value); + private: + float _internal_tcp_ping_avg() const; + void _internal_set_tcp_ping_avg(float value); + public: + + // optional float tcp_ping_var = 11; + bool has_tcp_ping_var() const; + private: + bool _internal_has_tcp_ping_var() const; + public: + void clear_tcp_ping_var(); + float tcp_ping_var() const; + void set_tcp_ping_var(float value); + private: + float _internal_tcp_ping_var() const; + void _internal_set_tcp_ping_var(float value); + public: + + // optional bool stats_only = 2 [default = false]; + bool has_stats_only() const; + private: + bool _internal_has_stats_only() const; + public: + void clear_stats_only(); + bool stats_only() const; + void set_stats_only(bool value); + private: + bool _internal_stats_only() const; + void _internal_set_stats_only(bool value); + public: + + // optional bool strong_certificate = 18 [default = false]; + bool has_strong_certificate() const; + private: + bool _internal_has_strong_certificate() const; + public: + void clear_strong_certificate(); + bool strong_certificate() const; + void set_strong_certificate(bool value); + private: + bool _internal_strong_certificate() const; + void _internal_set_strong_certificate(bool value); + public: + + // optional bool opus = 19 [default = false]; + bool has_opus() const; + private: + bool _internal_has_opus() const; + public: + void clear_opus(); + bool opus() const; + void set_opus(bool value); + private: + bool _internal_opus() const; + void _internal_set_opus(bool value); + public: + + // optional uint32 bandwidth = 15; + bool has_bandwidth() const; + private: + bool _internal_has_bandwidth() const; + public: + void clear_bandwidth(); + ::PROTOBUF_NAMESPACE_ID::uint32 bandwidth() const; + void set_bandwidth(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_bandwidth() const; + void _internal_set_bandwidth(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional uint32 onlinesecs = 16; + bool has_onlinesecs() const; + private: + bool _internal_has_onlinesecs() const; + public: + void clear_onlinesecs(); + ::PROTOBUF_NAMESPACE_ID::uint32 onlinesecs() const; + void set_onlinesecs(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_onlinesecs() const; + void _internal_set_onlinesecs(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional uint32 idlesecs = 17; + bool has_idlesecs() const; + private: + bool _internal_has_idlesecs() const; + public: + void clear_idlesecs(); + ::PROTOBUF_NAMESPACE_ID::uint32 idlesecs() const; + void set_idlesecs(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_idlesecs() const; + void _internal_set_idlesecs(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // @@protoc_insertion_point(class_scope:MumbleProto.UserStats) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField certificates_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > celt_versions_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr address_; + ::MumbleProto::UserStats_Stats* from_client_; + ::MumbleProto::UserStats_Stats* from_server_; + ::MumbleProto::Version* version_; + ::PROTOBUF_NAMESPACE_ID::uint32 session_; + ::PROTOBUF_NAMESPACE_ID::uint32 udp_packets_; + ::PROTOBUF_NAMESPACE_ID::uint32 tcp_packets_; + float udp_ping_avg_; + float udp_ping_var_; + float tcp_ping_avg_; + float tcp_ping_var_; + bool stats_only_; + bool strong_certificate_; + bool opus_; + ::PROTOBUF_NAMESPACE_ID::uint32 bandwidth_; + ::PROTOBUF_NAMESPACE_ID::uint32 onlinesecs_; + ::PROTOBUF_NAMESPACE_ID::uint32 idlesecs_; + friend struct ::TableStruct_Mumble_2eproto; +}; +// ------------------------------------------------------------------- + +class RequestBlob PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MumbleProto.RequestBlob) */ { + public: + inline RequestBlob() : RequestBlob(nullptr) {}; + virtual ~RequestBlob(); + + RequestBlob(const RequestBlob& from); + RequestBlob(RequestBlob&& from) noexcept + : RequestBlob() { + *this = ::std::move(from); + } + + inline RequestBlob& operator=(const RequestBlob& from) { + CopyFrom(from); + return *this; + } + inline RequestBlob& operator=(RequestBlob&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const RequestBlob& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const RequestBlob* internal_default_instance() { + return reinterpret_cast( + &_RequestBlob_default_instance_); + } + static constexpr int kIndexInFileMessages = + 29; + + friend void swap(RequestBlob& a, RequestBlob& b) { + a.Swap(&b); + } + inline void Swap(RequestBlob* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(RequestBlob* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline RequestBlob* New() const final { + return CreateMaybeMessage(nullptr); + } + + RequestBlob* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const RequestBlob& from); + void MergeFrom(const RequestBlob& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(RequestBlob* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MumbleProto.RequestBlob"; + } + protected: + explicit RequestBlob(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_Mumble_2eproto); + return ::descriptor_table_Mumble_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kSessionTextureFieldNumber = 1, + kSessionCommentFieldNumber = 2, + kChannelDescriptionFieldNumber = 3, + }; + // repeated uint32 session_texture = 1; + int session_texture_size() const; + private: + int _internal_session_texture_size() const; + public: + void clear_session_texture(); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_session_texture(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& + _internal_session_texture() const; + void _internal_add_session_texture(::PROTOBUF_NAMESPACE_ID::uint32 value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* + _internal_mutable_session_texture(); + public: + ::PROTOBUF_NAMESPACE_ID::uint32 session_texture(int index) const; + void set_session_texture(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value); + void add_session_texture(::PROTOBUF_NAMESPACE_ID::uint32 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& + session_texture() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* + mutable_session_texture(); + + // repeated uint32 session_comment = 2; + int session_comment_size() const; + private: + int _internal_session_comment_size() const; + public: + void clear_session_comment(); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_session_comment(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& + _internal_session_comment() const; + void _internal_add_session_comment(::PROTOBUF_NAMESPACE_ID::uint32 value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* + _internal_mutable_session_comment(); + public: + ::PROTOBUF_NAMESPACE_ID::uint32 session_comment(int index) const; + void set_session_comment(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value); + void add_session_comment(::PROTOBUF_NAMESPACE_ID::uint32 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& + session_comment() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* + mutable_session_comment(); + + // repeated uint32 channel_description = 3; + int channel_description_size() const; + private: + int _internal_channel_description_size() const; + public: + void clear_channel_description(); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_channel_description(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& + _internal_channel_description() const; + void _internal_add_channel_description(::PROTOBUF_NAMESPACE_ID::uint32 value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* + _internal_mutable_channel_description(); + public: + ::PROTOBUF_NAMESPACE_ID::uint32 channel_description(int index) const; + void set_channel_description(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value); + void add_channel_description(::PROTOBUF_NAMESPACE_ID::uint32 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& + channel_description() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* + mutable_channel_description(); + + // @@protoc_insertion_point(class_scope:MumbleProto.RequestBlob) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 > session_texture_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 > session_comment_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 > channel_description_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_Mumble_2eproto; +}; +// ------------------------------------------------------------------- + +class ServerConfig PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MumbleProto.ServerConfig) */ { + public: + inline ServerConfig() : ServerConfig(nullptr) {}; + virtual ~ServerConfig(); + + ServerConfig(const ServerConfig& from); + ServerConfig(ServerConfig&& from) noexcept + : ServerConfig() { + *this = ::std::move(from); + } + + inline ServerConfig& operator=(const ServerConfig& from) { + CopyFrom(from); + return *this; + } + inline ServerConfig& operator=(ServerConfig&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const ServerConfig& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const ServerConfig* internal_default_instance() { + return reinterpret_cast( + &_ServerConfig_default_instance_); + } + static constexpr int kIndexInFileMessages = + 30; + + friend void swap(ServerConfig& a, ServerConfig& b) { + a.Swap(&b); + } + inline void Swap(ServerConfig* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ServerConfig* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ServerConfig* New() const final { + return CreateMaybeMessage(nullptr); + } + + ServerConfig* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const ServerConfig& from); + void MergeFrom(const ServerConfig& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ServerConfig* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MumbleProto.ServerConfig"; + } + protected: + explicit ServerConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_Mumble_2eproto); + return ::descriptor_table_Mumble_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kWelcomeTextFieldNumber = 2, + kMaxBandwidthFieldNumber = 1, + kAllowHtmlFieldNumber = 3, + kMessageLengthFieldNumber = 4, + kImageMessageLengthFieldNumber = 5, + kMaxUsersFieldNumber = 6, + }; + // optional string welcome_text = 2; + bool has_welcome_text() const; + private: + bool _internal_has_welcome_text() const; + public: + void clear_welcome_text(); + const std::string& welcome_text() const; + void set_welcome_text(const std::string& value); + void set_welcome_text(std::string&& value); + void set_welcome_text(const char* value); + void set_welcome_text(const char* value, size_t size); + std::string* mutable_welcome_text(); + std::string* release_welcome_text(); + void set_allocated_welcome_text(std::string* welcome_text); + private: + const std::string& _internal_welcome_text() const; + void _internal_set_welcome_text(const std::string& value); + std::string* _internal_mutable_welcome_text(); + public: + + // optional uint32 max_bandwidth = 1; + bool has_max_bandwidth() const; + private: + bool _internal_has_max_bandwidth() const; + public: + void clear_max_bandwidth(); + ::PROTOBUF_NAMESPACE_ID::uint32 max_bandwidth() const; + void set_max_bandwidth(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_max_bandwidth() const; + void _internal_set_max_bandwidth(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional bool allow_html = 3; + bool has_allow_html() const; + private: + bool _internal_has_allow_html() const; + public: + void clear_allow_html(); + bool allow_html() const; + void set_allow_html(bool value); + private: + bool _internal_allow_html() const; + void _internal_set_allow_html(bool value); + public: + + // optional uint32 message_length = 4; + bool has_message_length() const; + private: + bool _internal_has_message_length() const; + public: + void clear_message_length(); + ::PROTOBUF_NAMESPACE_ID::uint32 message_length() const; + void set_message_length(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_message_length() const; + void _internal_set_message_length(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional uint32 image_message_length = 5; + bool has_image_message_length() const; + private: + bool _internal_has_image_message_length() const; + public: + void clear_image_message_length(); + ::PROTOBUF_NAMESPACE_ID::uint32 image_message_length() const; + void set_image_message_length(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_image_message_length() const; + void _internal_set_image_message_length(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional uint32 max_users = 6; + bool has_max_users() const; + private: + bool _internal_has_max_users() const; + public: + void clear_max_users(); + ::PROTOBUF_NAMESPACE_ID::uint32 max_users() const; + void set_max_users(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_max_users() const; + void _internal_set_max_users(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // @@protoc_insertion_point(class_scope:MumbleProto.ServerConfig) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr welcome_text_; + ::PROTOBUF_NAMESPACE_ID::uint32 max_bandwidth_; + bool allow_html_; + ::PROTOBUF_NAMESPACE_ID::uint32 message_length_; + ::PROTOBUF_NAMESPACE_ID::uint32 image_message_length_; + ::PROTOBUF_NAMESPACE_ID::uint32 max_users_; + friend struct ::TableStruct_Mumble_2eproto; +}; +// ------------------------------------------------------------------- + +class SuggestConfig PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MumbleProto.SuggestConfig) */ { + public: + inline SuggestConfig() : SuggestConfig(nullptr) {}; + virtual ~SuggestConfig(); + + SuggestConfig(const SuggestConfig& from); + SuggestConfig(SuggestConfig&& from) noexcept + : SuggestConfig() { + *this = ::std::move(from); + } + + inline SuggestConfig& operator=(const SuggestConfig& from) { + CopyFrom(from); + return *this; + } + inline SuggestConfig& operator=(SuggestConfig&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const SuggestConfig& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const SuggestConfig* internal_default_instance() { + return reinterpret_cast( + &_SuggestConfig_default_instance_); + } + static constexpr int kIndexInFileMessages = + 31; + + friend void swap(SuggestConfig& a, SuggestConfig& b) { + a.Swap(&b); + } + inline void Swap(SuggestConfig* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SuggestConfig* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline SuggestConfig* New() const final { + return CreateMaybeMessage(nullptr); + } + + SuggestConfig* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const SuggestConfig& from); + void MergeFrom(const SuggestConfig& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SuggestConfig* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MumbleProto.SuggestConfig"; + } + protected: + explicit SuggestConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_Mumble_2eproto); + return ::descriptor_table_Mumble_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kVersionFieldNumber = 1, + kPositionalFieldNumber = 2, + kPushToTalkFieldNumber = 3, + }; + // optional uint32 version = 1; + bool has_version() const; + private: + bool _internal_has_version() const; + public: + void clear_version(); + ::PROTOBUF_NAMESPACE_ID::uint32 version() const; + void set_version(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_version() const; + void _internal_set_version(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional bool positional = 2; + bool has_positional() const; + private: + bool _internal_has_positional() const; + public: + void clear_positional(); + bool positional() const; + void set_positional(bool value); + private: + bool _internal_positional() const; + void _internal_set_positional(bool value); + public: + + // optional bool push_to_talk = 3; + bool has_push_to_talk() const; + private: + bool _internal_has_push_to_talk() const; + public: + void clear_push_to_talk(); + bool push_to_talk() const; + void set_push_to_talk(bool value); + private: + bool _internal_push_to_talk() const; + void _internal_set_push_to_talk(bool value); + public: + + // @@protoc_insertion_point(class_scope:MumbleProto.SuggestConfig) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 version_; + bool positional_; + bool push_to_talk_; + friend struct ::TableStruct_Mumble_2eproto; +}; +// =================================================================== + + +// =================================================================== + +#ifdef __GNUC__ + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// Version + +// optional uint32 version = 1; +inline bool Version::_internal_has_version() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool Version::has_version() const { + return _internal_has_version(); +} +inline void Version::clear_version() { + version_ = 0u; + _has_bits_[0] &= ~0x00000008u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 Version::_internal_version() const { + return version_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 Version::version() const { + // @@protoc_insertion_point(field_get:MumbleProto.Version.version) + return _internal_version(); +} +inline void Version::_internal_set_version(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000008u; + version_ = value; +} +inline void Version::set_version(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_version(value); + // @@protoc_insertion_point(field_set:MumbleProto.Version.version) +} + +// optional string release = 2; +inline bool Version::_internal_has_release() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Version::has_release() const { + return _internal_has_release(); +} +inline void Version::clear_release() { + release_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Version::release() const { + // @@protoc_insertion_point(field_get:MumbleProto.Version.release) + return _internal_release(); +} +inline void Version::set_release(const std::string& value) { + _internal_set_release(value); + // @@protoc_insertion_point(field_set:MumbleProto.Version.release) +} +inline std::string* Version::mutable_release() { + // @@protoc_insertion_point(field_mutable:MumbleProto.Version.release) + return _internal_mutable_release(); +} +inline const std::string& Version::_internal_release() const { + return release_.Get(); +} +inline void Version::_internal_set_release(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + release_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void Version::set_release(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + release_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:MumbleProto.Version.release) +} +inline void Version::set_release(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + release_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:MumbleProto.Version.release) +} +inline void Version::set_release(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000001u; + release_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.Version.release) +} +inline std::string* Version::_internal_mutable_release() { + _has_bits_[0] |= 0x00000001u; + return release_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* Version::release_release() { + // @@protoc_insertion_point(field_release:MumbleProto.Version.release) + if (!_internal_has_release()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return release_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void Version::set_allocated_release(std::string* release) { + if (release != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + release_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), release, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:MumbleProto.Version.release) +} + +// optional string os = 3; +inline bool Version::_internal_has_os() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Version::has_os() const { + return _internal_has_os(); +} +inline void Version::clear_os() { + os_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Version::os() const { + // @@protoc_insertion_point(field_get:MumbleProto.Version.os) + return _internal_os(); +} +inline void Version::set_os(const std::string& value) { + _internal_set_os(value); + // @@protoc_insertion_point(field_set:MumbleProto.Version.os) +} +inline std::string* Version::mutable_os() { + // @@protoc_insertion_point(field_mutable:MumbleProto.Version.os) + return _internal_mutable_os(); +} +inline const std::string& Version::_internal_os() const { + return os_.Get(); +} +inline void Version::_internal_set_os(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + os_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void Version::set_os(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + os_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:MumbleProto.Version.os) +} +inline void Version::set_os(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + os_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:MumbleProto.Version.os) +} +inline void Version::set_os(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000002u; + os_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.Version.os) +} +inline std::string* Version::_internal_mutable_os() { + _has_bits_[0] |= 0x00000002u; + return os_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* Version::release_os() { + // @@protoc_insertion_point(field_release:MumbleProto.Version.os) + if (!_internal_has_os()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + return os_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void Version::set_allocated_os(std::string* os) { + if (os != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + os_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), os, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:MumbleProto.Version.os) +} + +// optional string os_version = 4; +inline bool Version::_internal_has_os_version() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool Version::has_os_version() const { + return _internal_has_os_version(); +} +inline void Version::clear_os_version() { + os_version_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000004u; +} +inline const std::string& Version::os_version() const { + // @@protoc_insertion_point(field_get:MumbleProto.Version.os_version) + return _internal_os_version(); +} +inline void Version::set_os_version(const std::string& value) { + _internal_set_os_version(value); + // @@protoc_insertion_point(field_set:MumbleProto.Version.os_version) +} +inline std::string* Version::mutable_os_version() { + // @@protoc_insertion_point(field_mutable:MumbleProto.Version.os_version) + return _internal_mutable_os_version(); +} +inline const std::string& Version::_internal_os_version() const { + return os_version_.Get(); +} +inline void Version::_internal_set_os_version(const std::string& value) { + _has_bits_[0] |= 0x00000004u; + os_version_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void Version::set_os_version(std::string&& value) { + _has_bits_[0] |= 0x00000004u; + os_version_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:MumbleProto.Version.os_version) +} +inline void Version::set_os_version(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000004u; + os_version_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:MumbleProto.Version.os_version) +} +inline void Version::set_os_version(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000004u; + os_version_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.Version.os_version) +} +inline std::string* Version::_internal_mutable_os_version() { + _has_bits_[0] |= 0x00000004u; + return os_version_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* Version::release_os_version() { + // @@protoc_insertion_point(field_release:MumbleProto.Version.os_version) + if (!_internal_has_os_version()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000004u; + return os_version_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void Version::set_allocated_os_version(std::string* os_version) { + if (os_version != nullptr) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + os_version_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), os_version, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:MumbleProto.Version.os_version) +} + +// ------------------------------------------------------------------- + +// UDPTunnel + +// required bytes packet = 1; +inline bool UDPTunnel::_internal_has_packet() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool UDPTunnel::has_packet() const { + return _internal_has_packet(); +} +inline void UDPTunnel::clear_packet() { + packet_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& UDPTunnel::packet() const { + // @@protoc_insertion_point(field_get:MumbleProto.UDPTunnel.packet) + return _internal_packet(); +} +inline void UDPTunnel::set_packet(const std::string& value) { + _internal_set_packet(value); + // @@protoc_insertion_point(field_set:MumbleProto.UDPTunnel.packet) +} +inline std::string* UDPTunnel::mutable_packet() { + // @@protoc_insertion_point(field_mutable:MumbleProto.UDPTunnel.packet) + return _internal_mutable_packet(); +} +inline const std::string& UDPTunnel::_internal_packet() const { + return packet_.Get(); +} +inline void UDPTunnel::_internal_set_packet(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + packet_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void UDPTunnel::set_packet(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + packet_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:MumbleProto.UDPTunnel.packet) +} +inline void UDPTunnel::set_packet(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + packet_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:MumbleProto.UDPTunnel.packet) +} +inline void UDPTunnel::set_packet(const void* value, + size_t size) { + _has_bits_[0] |= 0x00000001u; + packet_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.UDPTunnel.packet) +} +inline std::string* UDPTunnel::_internal_mutable_packet() { + _has_bits_[0] |= 0x00000001u; + return packet_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* UDPTunnel::release_packet() { + // @@protoc_insertion_point(field_release:MumbleProto.UDPTunnel.packet) + if (!_internal_has_packet()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return packet_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void UDPTunnel::set_allocated_packet(std::string* packet) { + if (packet != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + packet_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), packet, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:MumbleProto.UDPTunnel.packet) +} + +// ------------------------------------------------------------------- + +// Authenticate + +// optional string username = 1; +inline bool Authenticate::_internal_has_username() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Authenticate::has_username() const { + return _internal_has_username(); +} +inline void Authenticate::clear_username() { + username_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Authenticate::username() const { + // @@protoc_insertion_point(field_get:MumbleProto.Authenticate.username) + return _internal_username(); +} +inline void Authenticate::set_username(const std::string& value) { + _internal_set_username(value); + // @@protoc_insertion_point(field_set:MumbleProto.Authenticate.username) +} +inline std::string* Authenticate::mutable_username() { + // @@protoc_insertion_point(field_mutable:MumbleProto.Authenticate.username) + return _internal_mutable_username(); +} +inline const std::string& Authenticate::_internal_username() const { + return username_.Get(); +} +inline void Authenticate::_internal_set_username(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + username_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void Authenticate::set_username(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + username_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:MumbleProto.Authenticate.username) +} +inline void Authenticate::set_username(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + username_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:MumbleProto.Authenticate.username) +} +inline void Authenticate::set_username(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000001u; + username_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.Authenticate.username) +} +inline std::string* Authenticate::_internal_mutable_username() { + _has_bits_[0] |= 0x00000001u; + return username_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* Authenticate::release_username() { + // @@protoc_insertion_point(field_release:MumbleProto.Authenticate.username) + if (!_internal_has_username()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return username_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void Authenticate::set_allocated_username(std::string* username) { + if (username != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + username_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), username, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:MumbleProto.Authenticate.username) +} + +// optional string password = 2; +inline bool Authenticate::_internal_has_password() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Authenticate::has_password() const { + return _internal_has_password(); +} +inline void Authenticate::clear_password() { + password_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Authenticate::password() const { + // @@protoc_insertion_point(field_get:MumbleProto.Authenticate.password) + return _internal_password(); +} +inline void Authenticate::set_password(const std::string& value) { + _internal_set_password(value); + // @@protoc_insertion_point(field_set:MumbleProto.Authenticate.password) +} +inline std::string* Authenticate::mutable_password() { + // @@protoc_insertion_point(field_mutable:MumbleProto.Authenticate.password) + return _internal_mutable_password(); +} +inline const std::string& Authenticate::_internal_password() const { + return password_.Get(); +} +inline void Authenticate::_internal_set_password(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + password_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void Authenticate::set_password(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + password_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:MumbleProto.Authenticate.password) +} +inline void Authenticate::set_password(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + password_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:MumbleProto.Authenticate.password) +} +inline void Authenticate::set_password(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000002u; + password_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.Authenticate.password) +} +inline std::string* Authenticate::_internal_mutable_password() { + _has_bits_[0] |= 0x00000002u; + return password_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* Authenticate::release_password() { + // @@protoc_insertion_point(field_release:MumbleProto.Authenticate.password) + if (!_internal_has_password()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + return password_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void Authenticate::set_allocated_password(std::string* password) { + if (password != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + password_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), password, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:MumbleProto.Authenticate.password) +} + +// repeated string tokens = 3; +inline int Authenticate::_internal_tokens_size() const { + return tokens_.size(); +} +inline int Authenticate::tokens_size() const { + return _internal_tokens_size(); +} +inline void Authenticate::clear_tokens() { + tokens_.Clear(); +} +inline std::string* Authenticate::add_tokens() { + // @@protoc_insertion_point(field_add_mutable:MumbleProto.Authenticate.tokens) + return _internal_add_tokens(); +} +inline const std::string& Authenticate::_internal_tokens(int index) const { + return tokens_.Get(index); +} +inline const std::string& Authenticate::tokens(int index) const { + // @@protoc_insertion_point(field_get:MumbleProto.Authenticate.tokens) + return _internal_tokens(index); +} +inline std::string* Authenticate::mutable_tokens(int index) { + // @@protoc_insertion_point(field_mutable:MumbleProto.Authenticate.tokens) + return tokens_.Mutable(index); +} +inline void Authenticate::set_tokens(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:MumbleProto.Authenticate.tokens) + tokens_.Mutable(index)->assign(value); +} +inline void Authenticate::set_tokens(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:MumbleProto.Authenticate.tokens) + tokens_.Mutable(index)->assign(std::move(value)); +} +inline void Authenticate::set_tokens(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + tokens_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:MumbleProto.Authenticate.tokens) +} +inline void Authenticate::set_tokens(int index, const char* value, size_t size) { + tokens_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.Authenticate.tokens) +} +inline std::string* Authenticate::_internal_add_tokens() { + return tokens_.Add(); +} +inline void Authenticate::add_tokens(const std::string& value) { + tokens_.Add()->assign(value); + // @@protoc_insertion_point(field_add:MumbleProto.Authenticate.tokens) +} +inline void Authenticate::add_tokens(std::string&& value) { + tokens_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:MumbleProto.Authenticate.tokens) +} +inline void Authenticate::add_tokens(const char* value) { + GOOGLE_DCHECK(value != nullptr); + tokens_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:MumbleProto.Authenticate.tokens) +} +inline void Authenticate::add_tokens(const char* value, size_t size) { + tokens_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:MumbleProto.Authenticate.tokens) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +Authenticate::tokens() const { + // @@protoc_insertion_point(field_list:MumbleProto.Authenticate.tokens) + return tokens_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +Authenticate::mutable_tokens() { + // @@protoc_insertion_point(field_mutable_list:MumbleProto.Authenticate.tokens) + return &tokens_; +} + +// repeated int32 celt_versions = 4; +inline int Authenticate::_internal_celt_versions_size() const { + return celt_versions_.size(); +} +inline int Authenticate::celt_versions_size() const { + return _internal_celt_versions_size(); +} +inline void Authenticate::clear_celt_versions() { + celt_versions_.Clear(); +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Authenticate::_internal_celt_versions(int index) const { + return celt_versions_.Get(index); +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Authenticate::celt_versions(int index) const { + // @@protoc_insertion_point(field_get:MumbleProto.Authenticate.celt_versions) + return _internal_celt_versions(index); +} +inline void Authenticate::set_celt_versions(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) { + celt_versions_.Set(index, value); + // @@protoc_insertion_point(field_set:MumbleProto.Authenticate.celt_versions) +} +inline void Authenticate::_internal_add_celt_versions(::PROTOBUF_NAMESPACE_ID::int32 value) { + celt_versions_.Add(value); +} +inline void Authenticate::add_celt_versions(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_add_celt_versions(value); + // @@protoc_insertion_point(field_add:MumbleProto.Authenticate.celt_versions) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& +Authenticate::_internal_celt_versions() const { + return celt_versions_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& +Authenticate::celt_versions() const { + // @@protoc_insertion_point(field_list:MumbleProto.Authenticate.celt_versions) + return _internal_celt_versions(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* +Authenticate::_internal_mutable_celt_versions() { + return &celt_versions_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* +Authenticate::mutable_celt_versions() { + // @@protoc_insertion_point(field_mutable_list:MumbleProto.Authenticate.celt_versions) + return _internal_mutable_celt_versions(); +} + +// optional bool opus = 5 [default = false]; +inline bool Authenticate::_internal_has_opus() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool Authenticate::has_opus() const { + return _internal_has_opus(); +} +inline void Authenticate::clear_opus() { + opus_ = false; + _has_bits_[0] &= ~0x00000004u; +} +inline bool Authenticate::_internal_opus() const { + return opus_; +} +inline bool Authenticate::opus() const { + // @@protoc_insertion_point(field_get:MumbleProto.Authenticate.opus) + return _internal_opus(); +} +inline void Authenticate::_internal_set_opus(bool value) { + _has_bits_[0] |= 0x00000004u; + opus_ = value; +} +inline void Authenticate::set_opus(bool value) { + _internal_set_opus(value); + // @@protoc_insertion_point(field_set:MumbleProto.Authenticate.opus) +} + +// ------------------------------------------------------------------- + +// Ping + +// optional uint64 timestamp = 1; +inline bool Ping::_internal_has_timestamp() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Ping::has_timestamp() const { + return _internal_has_timestamp(); +} +inline void Ping::clear_timestamp() { + timestamp_ = PROTOBUF_ULONGLONG(0); + _has_bits_[0] &= ~0x00000001u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 Ping::_internal_timestamp() const { + return timestamp_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 Ping::timestamp() const { + // @@protoc_insertion_point(field_get:MumbleProto.Ping.timestamp) + return _internal_timestamp(); +} +inline void Ping::_internal_set_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value) { + _has_bits_[0] |= 0x00000001u; + timestamp_ = value; +} +inline void Ping::set_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value) { + _internal_set_timestamp(value); + // @@protoc_insertion_point(field_set:MumbleProto.Ping.timestamp) +} + +// optional uint32 good = 2; +inline bool Ping::_internal_has_good() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Ping::has_good() const { + return _internal_has_good(); +} +inline void Ping::clear_good() { + good_ = 0u; + _has_bits_[0] &= ~0x00000002u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 Ping::_internal_good() const { + return good_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 Ping::good() const { + // @@protoc_insertion_point(field_get:MumbleProto.Ping.good) + return _internal_good(); +} +inline void Ping::_internal_set_good(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000002u; + good_ = value; +} +inline void Ping::set_good(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_good(value); + // @@protoc_insertion_point(field_set:MumbleProto.Ping.good) +} + +// optional uint32 late = 3; +inline bool Ping::_internal_has_late() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool Ping::has_late() const { + return _internal_has_late(); +} +inline void Ping::clear_late() { + late_ = 0u; + _has_bits_[0] &= ~0x00000004u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 Ping::_internal_late() const { + return late_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 Ping::late() const { + // @@protoc_insertion_point(field_get:MumbleProto.Ping.late) + return _internal_late(); +} +inline void Ping::_internal_set_late(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000004u; + late_ = value; +} +inline void Ping::set_late(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_late(value); + // @@protoc_insertion_point(field_set:MumbleProto.Ping.late) +} + +// optional uint32 lost = 4; +inline bool Ping::_internal_has_lost() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool Ping::has_lost() const { + return _internal_has_lost(); +} +inline void Ping::clear_lost() { + lost_ = 0u; + _has_bits_[0] &= ~0x00000008u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 Ping::_internal_lost() const { + return lost_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 Ping::lost() const { + // @@protoc_insertion_point(field_get:MumbleProto.Ping.lost) + return _internal_lost(); +} +inline void Ping::_internal_set_lost(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000008u; + lost_ = value; +} +inline void Ping::set_lost(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_lost(value); + // @@protoc_insertion_point(field_set:MumbleProto.Ping.lost) +} + +// optional uint32 resync = 5; +inline bool Ping::_internal_has_resync() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool Ping::has_resync() const { + return _internal_has_resync(); +} +inline void Ping::clear_resync() { + resync_ = 0u; + _has_bits_[0] &= ~0x00000010u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 Ping::_internal_resync() const { + return resync_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 Ping::resync() const { + // @@protoc_insertion_point(field_get:MumbleProto.Ping.resync) + return _internal_resync(); +} +inline void Ping::_internal_set_resync(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000010u; + resync_ = value; +} +inline void Ping::set_resync(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_resync(value); + // @@protoc_insertion_point(field_set:MumbleProto.Ping.resync) +} + +// optional uint32 udp_packets = 6; +inline bool Ping::_internal_has_udp_packets() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool Ping::has_udp_packets() const { + return _internal_has_udp_packets(); +} +inline void Ping::clear_udp_packets() { + udp_packets_ = 0u; + _has_bits_[0] &= ~0x00000020u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 Ping::_internal_udp_packets() const { + return udp_packets_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 Ping::udp_packets() const { + // @@protoc_insertion_point(field_get:MumbleProto.Ping.udp_packets) + return _internal_udp_packets(); +} +inline void Ping::_internal_set_udp_packets(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000020u; + udp_packets_ = value; +} +inline void Ping::set_udp_packets(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_udp_packets(value); + // @@protoc_insertion_point(field_set:MumbleProto.Ping.udp_packets) +} + +// optional uint32 tcp_packets = 7; +inline bool Ping::_internal_has_tcp_packets() const { + bool value = (_has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool Ping::has_tcp_packets() const { + return _internal_has_tcp_packets(); +} +inline void Ping::clear_tcp_packets() { + tcp_packets_ = 0u; + _has_bits_[0] &= ~0x00000040u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 Ping::_internal_tcp_packets() const { + return tcp_packets_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 Ping::tcp_packets() const { + // @@protoc_insertion_point(field_get:MumbleProto.Ping.tcp_packets) + return _internal_tcp_packets(); +} +inline void Ping::_internal_set_tcp_packets(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000040u; + tcp_packets_ = value; +} +inline void Ping::set_tcp_packets(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_tcp_packets(value); + // @@protoc_insertion_point(field_set:MumbleProto.Ping.tcp_packets) +} + +// optional float udp_ping_avg = 8; +inline bool Ping::_internal_has_udp_ping_avg() const { + bool value = (_has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool Ping::has_udp_ping_avg() const { + return _internal_has_udp_ping_avg(); +} +inline void Ping::clear_udp_ping_avg() { + udp_ping_avg_ = 0; + _has_bits_[0] &= ~0x00000080u; +} +inline float Ping::_internal_udp_ping_avg() const { + return udp_ping_avg_; +} +inline float Ping::udp_ping_avg() const { + // @@protoc_insertion_point(field_get:MumbleProto.Ping.udp_ping_avg) + return _internal_udp_ping_avg(); +} +inline void Ping::_internal_set_udp_ping_avg(float value) { + _has_bits_[0] |= 0x00000080u; + udp_ping_avg_ = value; +} +inline void Ping::set_udp_ping_avg(float value) { + _internal_set_udp_ping_avg(value); + // @@protoc_insertion_point(field_set:MumbleProto.Ping.udp_ping_avg) +} + +// optional float udp_ping_var = 9; +inline bool Ping::_internal_has_udp_ping_var() const { + bool value = (_has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool Ping::has_udp_ping_var() const { + return _internal_has_udp_ping_var(); +} +inline void Ping::clear_udp_ping_var() { + udp_ping_var_ = 0; + _has_bits_[0] &= ~0x00000100u; +} +inline float Ping::_internal_udp_ping_var() const { + return udp_ping_var_; +} +inline float Ping::udp_ping_var() const { + // @@protoc_insertion_point(field_get:MumbleProto.Ping.udp_ping_var) + return _internal_udp_ping_var(); +} +inline void Ping::_internal_set_udp_ping_var(float value) { + _has_bits_[0] |= 0x00000100u; + udp_ping_var_ = value; +} +inline void Ping::set_udp_ping_var(float value) { + _internal_set_udp_ping_var(value); + // @@protoc_insertion_point(field_set:MumbleProto.Ping.udp_ping_var) +} + +// optional float tcp_ping_avg = 10; +inline bool Ping::_internal_has_tcp_ping_avg() const { + bool value = (_has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool Ping::has_tcp_ping_avg() const { + return _internal_has_tcp_ping_avg(); +} +inline void Ping::clear_tcp_ping_avg() { + tcp_ping_avg_ = 0; + _has_bits_[0] &= ~0x00000200u; +} +inline float Ping::_internal_tcp_ping_avg() const { + return tcp_ping_avg_; +} +inline float Ping::tcp_ping_avg() const { + // @@protoc_insertion_point(field_get:MumbleProto.Ping.tcp_ping_avg) + return _internal_tcp_ping_avg(); +} +inline void Ping::_internal_set_tcp_ping_avg(float value) { + _has_bits_[0] |= 0x00000200u; + tcp_ping_avg_ = value; +} +inline void Ping::set_tcp_ping_avg(float value) { + _internal_set_tcp_ping_avg(value); + // @@protoc_insertion_point(field_set:MumbleProto.Ping.tcp_ping_avg) +} + +// optional float tcp_ping_var = 11; +inline bool Ping::_internal_has_tcp_ping_var() const { + bool value = (_has_bits_[0] & 0x00000400u) != 0; + return value; +} +inline bool Ping::has_tcp_ping_var() const { + return _internal_has_tcp_ping_var(); +} +inline void Ping::clear_tcp_ping_var() { + tcp_ping_var_ = 0; + _has_bits_[0] &= ~0x00000400u; +} +inline float Ping::_internal_tcp_ping_var() const { + return tcp_ping_var_; +} +inline float Ping::tcp_ping_var() const { + // @@protoc_insertion_point(field_get:MumbleProto.Ping.tcp_ping_var) + return _internal_tcp_ping_var(); +} +inline void Ping::_internal_set_tcp_ping_var(float value) { + _has_bits_[0] |= 0x00000400u; + tcp_ping_var_ = value; +} +inline void Ping::set_tcp_ping_var(float value) { + _internal_set_tcp_ping_var(value); + // @@protoc_insertion_point(field_set:MumbleProto.Ping.tcp_ping_var) +} + +// ------------------------------------------------------------------- + +// Reject + +// optional .MumbleProto.Reject.RejectType type = 1; +inline bool Reject::_internal_has_type() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Reject::has_type() const { + return _internal_has_type(); +} +inline void Reject::clear_type() { + type_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline ::MumbleProto::Reject_RejectType Reject::_internal_type() const { + return static_cast< ::MumbleProto::Reject_RejectType >(type_); +} +inline ::MumbleProto::Reject_RejectType Reject::type() const { + // @@protoc_insertion_point(field_get:MumbleProto.Reject.type) + return _internal_type(); +} +inline void Reject::_internal_set_type(::MumbleProto::Reject_RejectType value) { + assert(::MumbleProto::Reject_RejectType_IsValid(value)); + _has_bits_[0] |= 0x00000002u; + type_ = value; +} +inline void Reject::set_type(::MumbleProto::Reject_RejectType value) { + _internal_set_type(value); + // @@protoc_insertion_point(field_set:MumbleProto.Reject.type) +} + +// optional string reason = 2; +inline bool Reject::_internal_has_reason() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Reject::has_reason() const { + return _internal_has_reason(); +} +inline void Reject::clear_reason() { + reason_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Reject::reason() const { + // @@protoc_insertion_point(field_get:MumbleProto.Reject.reason) + return _internal_reason(); +} +inline void Reject::set_reason(const std::string& value) { + _internal_set_reason(value); + // @@protoc_insertion_point(field_set:MumbleProto.Reject.reason) +} +inline std::string* Reject::mutable_reason() { + // @@protoc_insertion_point(field_mutable:MumbleProto.Reject.reason) + return _internal_mutable_reason(); +} +inline const std::string& Reject::_internal_reason() const { + return reason_.Get(); +} +inline void Reject::_internal_set_reason(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + reason_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void Reject::set_reason(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + reason_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:MumbleProto.Reject.reason) +} +inline void Reject::set_reason(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + reason_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:MumbleProto.Reject.reason) +} +inline void Reject::set_reason(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000001u; + reason_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.Reject.reason) +} +inline std::string* Reject::_internal_mutable_reason() { + _has_bits_[0] |= 0x00000001u; + return reason_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* Reject::release_reason() { + // @@protoc_insertion_point(field_release:MumbleProto.Reject.reason) + if (!_internal_has_reason()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return reason_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void Reject::set_allocated_reason(std::string* reason) { + if (reason != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + reason_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), reason, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:MumbleProto.Reject.reason) +} + +// ------------------------------------------------------------------- + +// ServerSync + +// optional uint32 session = 1; +inline bool ServerSync::_internal_has_session() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ServerSync::has_session() const { + return _internal_has_session(); +} +inline void ServerSync::clear_session() { + session_ = 0u; + _has_bits_[0] &= ~0x00000002u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ServerSync::_internal_session() const { + return session_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ServerSync::session() const { + // @@protoc_insertion_point(field_get:MumbleProto.ServerSync.session) + return _internal_session(); +} +inline void ServerSync::_internal_set_session(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000002u; + session_ = value; +} +inline void ServerSync::set_session(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_session(value); + // @@protoc_insertion_point(field_set:MumbleProto.ServerSync.session) +} + +// optional uint32 max_bandwidth = 2; +inline bool ServerSync::_internal_has_max_bandwidth() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ServerSync::has_max_bandwidth() const { + return _internal_has_max_bandwidth(); +} +inline void ServerSync::clear_max_bandwidth() { + max_bandwidth_ = 0u; + _has_bits_[0] &= ~0x00000004u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ServerSync::_internal_max_bandwidth() const { + return max_bandwidth_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ServerSync::max_bandwidth() const { + // @@protoc_insertion_point(field_get:MumbleProto.ServerSync.max_bandwidth) + return _internal_max_bandwidth(); +} +inline void ServerSync::_internal_set_max_bandwidth(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000004u; + max_bandwidth_ = value; +} +inline void ServerSync::set_max_bandwidth(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_max_bandwidth(value); + // @@protoc_insertion_point(field_set:MumbleProto.ServerSync.max_bandwidth) +} + +// optional string welcome_text = 3; +inline bool ServerSync::_internal_has_welcome_text() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ServerSync::has_welcome_text() const { + return _internal_has_welcome_text(); +} +inline void ServerSync::clear_welcome_text() { + welcome_text_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ServerSync::welcome_text() const { + // @@protoc_insertion_point(field_get:MumbleProto.ServerSync.welcome_text) + return _internal_welcome_text(); +} +inline void ServerSync::set_welcome_text(const std::string& value) { + _internal_set_welcome_text(value); + // @@protoc_insertion_point(field_set:MumbleProto.ServerSync.welcome_text) +} +inline std::string* ServerSync::mutable_welcome_text() { + // @@protoc_insertion_point(field_mutable:MumbleProto.ServerSync.welcome_text) + return _internal_mutable_welcome_text(); +} +inline const std::string& ServerSync::_internal_welcome_text() const { + return welcome_text_.Get(); +} +inline void ServerSync::_internal_set_welcome_text(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + welcome_text_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void ServerSync::set_welcome_text(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + welcome_text_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:MumbleProto.ServerSync.welcome_text) +} +inline void ServerSync::set_welcome_text(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + welcome_text_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:MumbleProto.ServerSync.welcome_text) +} +inline void ServerSync::set_welcome_text(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000001u; + welcome_text_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.ServerSync.welcome_text) +} +inline std::string* ServerSync::_internal_mutable_welcome_text() { + _has_bits_[0] |= 0x00000001u; + return welcome_text_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* ServerSync::release_welcome_text() { + // @@protoc_insertion_point(field_release:MumbleProto.ServerSync.welcome_text) + if (!_internal_has_welcome_text()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return welcome_text_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void ServerSync::set_allocated_welcome_text(std::string* welcome_text) { + if (welcome_text != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + welcome_text_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), welcome_text, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:MumbleProto.ServerSync.welcome_text) +} + +// optional uint64 permissions = 4; +inline bool ServerSync::_internal_has_permissions() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool ServerSync::has_permissions() const { + return _internal_has_permissions(); +} +inline void ServerSync::clear_permissions() { + permissions_ = PROTOBUF_ULONGLONG(0); + _has_bits_[0] &= ~0x00000008u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 ServerSync::_internal_permissions() const { + return permissions_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 ServerSync::permissions() const { + // @@protoc_insertion_point(field_get:MumbleProto.ServerSync.permissions) + return _internal_permissions(); +} +inline void ServerSync::_internal_set_permissions(::PROTOBUF_NAMESPACE_ID::uint64 value) { + _has_bits_[0] |= 0x00000008u; + permissions_ = value; +} +inline void ServerSync::set_permissions(::PROTOBUF_NAMESPACE_ID::uint64 value) { + _internal_set_permissions(value); + // @@protoc_insertion_point(field_set:MumbleProto.ServerSync.permissions) +} + +// ------------------------------------------------------------------- + +// ChannelRemove + +// required uint32 channel_id = 1; +inline bool ChannelRemove::_internal_has_channel_id() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ChannelRemove::has_channel_id() const { + return _internal_has_channel_id(); +} +inline void ChannelRemove::clear_channel_id() { + channel_id_ = 0u; + _has_bits_[0] &= ~0x00000001u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ChannelRemove::_internal_channel_id() const { + return channel_id_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ChannelRemove::channel_id() const { + // @@protoc_insertion_point(field_get:MumbleProto.ChannelRemove.channel_id) + return _internal_channel_id(); +} +inline void ChannelRemove::_internal_set_channel_id(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000001u; + channel_id_ = value; +} +inline void ChannelRemove::set_channel_id(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_channel_id(value); + // @@protoc_insertion_point(field_set:MumbleProto.ChannelRemove.channel_id) +} + +// ------------------------------------------------------------------- + +// ChannelState + +// optional uint32 channel_id = 1; +inline bool ChannelState::_internal_has_channel_id() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool ChannelState::has_channel_id() const { + return _internal_has_channel_id(); +} +inline void ChannelState::clear_channel_id() { + channel_id_ = 0u; + _has_bits_[0] &= ~0x00000008u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ChannelState::_internal_channel_id() const { + return channel_id_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ChannelState::channel_id() const { + // @@protoc_insertion_point(field_get:MumbleProto.ChannelState.channel_id) + return _internal_channel_id(); +} +inline void ChannelState::_internal_set_channel_id(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000008u; + channel_id_ = value; +} +inline void ChannelState::set_channel_id(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_channel_id(value); + // @@protoc_insertion_point(field_set:MumbleProto.ChannelState.channel_id) +} + +// optional uint32 parent = 2; +inline bool ChannelState::_internal_has_parent() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool ChannelState::has_parent() const { + return _internal_has_parent(); +} +inline void ChannelState::clear_parent() { + parent_ = 0u; + _has_bits_[0] &= ~0x00000010u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ChannelState::_internal_parent() const { + return parent_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ChannelState::parent() const { + // @@protoc_insertion_point(field_get:MumbleProto.ChannelState.parent) + return _internal_parent(); +} +inline void ChannelState::_internal_set_parent(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000010u; + parent_ = value; +} +inline void ChannelState::set_parent(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_parent(value); + // @@protoc_insertion_point(field_set:MumbleProto.ChannelState.parent) +} + +// optional string name = 3; +inline bool ChannelState::_internal_has_name() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ChannelState::has_name() const { + return _internal_has_name(); +} +inline void ChannelState::clear_name() { + name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ChannelState::name() const { + // @@protoc_insertion_point(field_get:MumbleProto.ChannelState.name) + return _internal_name(); +} +inline void ChannelState::set_name(const std::string& value) { + _internal_set_name(value); + // @@protoc_insertion_point(field_set:MumbleProto.ChannelState.name) +} +inline std::string* ChannelState::mutable_name() { + // @@protoc_insertion_point(field_mutable:MumbleProto.ChannelState.name) + return _internal_mutable_name(); +} +inline const std::string& ChannelState::_internal_name() const { + return name_.Get(); +} +inline void ChannelState::_internal_set_name(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void ChannelState::set_name(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + name_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:MumbleProto.ChannelState.name) +} +inline void ChannelState::set_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:MumbleProto.ChannelState.name) +} +inline void ChannelState::set_name(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000001u; + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.ChannelState.name) +} +inline std::string* ChannelState::_internal_mutable_name() { + _has_bits_[0] |= 0x00000001u; + return name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* ChannelState::release_name() { + // @@protoc_insertion_point(field_release:MumbleProto.ChannelState.name) + if (!_internal_has_name()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void ChannelState::set_allocated_name(std::string* name) { + if (name != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:MumbleProto.ChannelState.name) +} + +// repeated uint32 links = 4; +inline int ChannelState::_internal_links_size() const { + return links_.size(); +} +inline int ChannelState::links_size() const { + return _internal_links_size(); +} +inline void ChannelState::clear_links() { + links_.Clear(); +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ChannelState::_internal_links(int index) const { + return links_.Get(index); +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ChannelState::links(int index) const { + // @@protoc_insertion_point(field_get:MumbleProto.ChannelState.links) + return _internal_links(index); +} +inline void ChannelState::set_links(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value) { + links_.Set(index, value); + // @@protoc_insertion_point(field_set:MumbleProto.ChannelState.links) +} +inline void ChannelState::_internal_add_links(::PROTOBUF_NAMESPACE_ID::uint32 value) { + links_.Add(value); +} +inline void ChannelState::add_links(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_add_links(value); + // @@protoc_insertion_point(field_add:MumbleProto.ChannelState.links) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& +ChannelState::_internal_links() const { + return links_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& +ChannelState::links() const { + // @@protoc_insertion_point(field_list:MumbleProto.ChannelState.links) + return _internal_links(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* +ChannelState::_internal_mutable_links() { + return &links_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* +ChannelState::mutable_links() { + // @@protoc_insertion_point(field_mutable_list:MumbleProto.ChannelState.links) + return _internal_mutable_links(); +} + +// optional string description = 5; +inline bool ChannelState::_internal_has_description() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ChannelState::has_description() const { + return _internal_has_description(); +} +inline void ChannelState::clear_description() { + description_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000002u; +} +inline const std::string& ChannelState::description() const { + // @@protoc_insertion_point(field_get:MumbleProto.ChannelState.description) + return _internal_description(); +} +inline void ChannelState::set_description(const std::string& value) { + _internal_set_description(value); + // @@protoc_insertion_point(field_set:MumbleProto.ChannelState.description) +} +inline std::string* ChannelState::mutable_description() { + // @@protoc_insertion_point(field_mutable:MumbleProto.ChannelState.description) + return _internal_mutable_description(); +} +inline const std::string& ChannelState::_internal_description() const { + return description_.Get(); +} +inline void ChannelState::_internal_set_description(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + description_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void ChannelState::set_description(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + description_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:MumbleProto.ChannelState.description) +} +inline void ChannelState::set_description(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + description_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:MumbleProto.ChannelState.description) +} +inline void ChannelState::set_description(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000002u; + description_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.ChannelState.description) +} +inline std::string* ChannelState::_internal_mutable_description() { + _has_bits_[0] |= 0x00000002u; + return description_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* ChannelState::release_description() { + // @@protoc_insertion_point(field_release:MumbleProto.ChannelState.description) + if (!_internal_has_description()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + return description_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void ChannelState::set_allocated_description(std::string* description) { + if (description != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + description_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), description, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:MumbleProto.ChannelState.description) +} + +// repeated uint32 links_add = 6; +inline int ChannelState::_internal_links_add_size() const { + return links_add_.size(); +} +inline int ChannelState::links_add_size() const { + return _internal_links_add_size(); +} +inline void ChannelState::clear_links_add() { + links_add_.Clear(); +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ChannelState::_internal_links_add(int index) const { + return links_add_.Get(index); +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ChannelState::links_add(int index) const { + // @@protoc_insertion_point(field_get:MumbleProto.ChannelState.links_add) + return _internal_links_add(index); +} +inline void ChannelState::set_links_add(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value) { + links_add_.Set(index, value); + // @@protoc_insertion_point(field_set:MumbleProto.ChannelState.links_add) +} +inline void ChannelState::_internal_add_links_add(::PROTOBUF_NAMESPACE_ID::uint32 value) { + links_add_.Add(value); +} +inline void ChannelState::add_links_add(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_add_links_add(value); + // @@protoc_insertion_point(field_add:MumbleProto.ChannelState.links_add) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& +ChannelState::_internal_links_add() const { + return links_add_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& +ChannelState::links_add() const { + // @@protoc_insertion_point(field_list:MumbleProto.ChannelState.links_add) + return _internal_links_add(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* +ChannelState::_internal_mutable_links_add() { + return &links_add_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* +ChannelState::mutable_links_add() { + // @@protoc_insertion_point(field_mutable_list:MumbleProto.ChannelState.links_add) + return _internal_mutable_links_add(); +} + +// repeated uint32 links_remove = 7; +inline int ChannelState::_internal_links_remove_size() const { + return links_remove_.size(); +} +inline int ChannelState::links_remove_size() const { + return _internal_links_remove_size(); +} +inline void ChannelState::clear_links_remove() { + links_remove_.Clear(); +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ChannelState::_internal_links_remove(int index) const { + return links_remove_.Get(index); +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ChannelState::links_remove(int index) const { + // @@protoc_insertion_point(field_get:MumbleProto.ChannelState.links_remove) + return _internal_links_remove(index); +} +inline void ChannelState::set_links_remove(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value) { + links_remove_.Set(index, value); + // @@protoc_insertion_point(field_set:MumbleProto.ChannelState.links_remove) +} +inline void ChannelState::_internal_add_links_remove(::PROTOBUF_NAMESPACE_ID::uint32 value) { + links_remove_.Add(value); +} +inline void ChannelState::add_links_remove(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_add_links_remove(value); + // @@protoc_insertion_point(field_add:MumbleProto.ChannelState.links_remove) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& +ChannelState::_internal_links_remove() const { + return links_remove_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& +ChannelState::links_remove() const { + // @@protoc_insertion_point(field_list:MumbleProto.ChannelState.links_remove) + return _internal_links_remove(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* +ChannelState::_internal_mutable_links_remove() { + return &links_remove_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* +ChannelState::mutable_links_remove() { + // @@protoc_insertion_point(field_mutable_list:MumbleProto.ChannelState.links_remove) + return _internal_mutable_links_remove(); +} + +// optional bool temporary = 8 [default = false]; +inline bool ChannelState::_internal_has_temporary() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool ChannelState::has_temporary() const { + return _internal_has_temporary(); +} +inline void ChannelState::clear_temporary() { + temporary_ = false; + _has_bits_[0] &= ~0x00000020u; +} +inline bool ChannelState::_internal_temporary() const { + return temporary_; +} +inline bool ChannelState::temporary() const { + // @@protoc_insertion_point(field_get:MumbleProto.ChannelState.temporary) + return _internal_temporary(); +} +inline void ChannelState::_internal_set_temporary(bool value) { + _has_bits_[0] |= 0x00000020u; + temporary_ = value; +} +inline void ChannelState::set_temporary(bool value) { + _internal_set_temporary(value); + // @@protoc_insertion_point(field_set:MumbleProto.ChannelState.temporary) +} + +// optional int32 position = 9 [default = 0]; +inline bool ChannelState::_internal_has_position() const { + bool value = (_has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool ChannelState::has_position() const { + return _internal_has_position(); +} +inline void ChannelState::clear_position() { + position_ = 0; + _has_bits_[0] &= ~0x00000040u; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 ChannelState::_internal_position() const { + return position_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 ChannelState::position() const { + // @@protoc_insertion_point(field_get:MumbleProto.ChannelState.position) + return _internal_position(); +} +inline void ChannelState::_internal_set_position(::PROTOBUF_NAMESPACE_ID::int32 value) { + _has_bits_[0] |= 0x00000040u; + position_ = value; +} +inline void ChannelState::set_position(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_set_position(value); + // @@protoc_insertion_point(field_set:MumbleProto.ChannelState.position) +} + +// optional bytes description_hash = 10; +inline bool ChannelState::_internal_has_description_hash() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ChannelState::has_description_hash() const { + return _internal_has_description_hash(); +} +inline void ChannelState::clear_description_hash() { + description_hash_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000004u; +} +inline const std::string& ChannelState::description_hash() const { + // @@protoc_insertion_point(field_get:MumbleProto.ChannelState.description_hash) + return _internal_description_hash(); +} +inline void ChannelState::set_description_hash(const std::string& value) { + _internal_set_description_hash(value); + // @@protoc_insertion_point(field_set:MumbleProto.ChannelState.description_hash) +} +inline std::string* ChannelState::mutable_description_hash() { + // @@protoc_insertion_point(field_mutable:MumbleProto.ChannelState.description_hash) + return _internal_mutable_description_hash(); +} +inline const std::string& ChannelState::_internal_description_hash() const { + return description_hash_.Get(); +} +inline void ChannelState::_internal_set_description_hash(const std::string& value) { + _has_bits_[0] |= 0x00000004u; + description_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void ChannelState::set_description_hash(std::string&& value) { + _has_bits_[0] |= 0x00000004u; + description_hash_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:MumbleProto.ChannelState.description_hash) +} +inline void ChannelState::set_description_hash(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000004u; + description_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:MumbleProto.ChannelState.description_hash) +} +inline void ChannelState::set_description_hash(const void* value, + size_t size) { + _has_bits_[0] |= 0x00000004u; + description_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.ChannelState.description_hash) +} +inline std::string* ChannelState::_internal_mutable_description_hash() { + _has_bits_[0] |= 0x00000004u; + return description_hash_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* ChannelState::release_description_hash() { + // @@protoc_insertion_point(field_release:MumbleProto.ChannelState.description_hash) + if (!_internal_has_description_hash()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000004u; + return description_hash_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void ChannelState::set_allocated_description_hash(std::string* description_hash) { + if (description_hash != nullptr) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + description_hash_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), description_hash, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:MumbleProto.ChannelState.description_hash) +} + +// optional uint32 max_users = 11; +inline bool ChannelState::_internal_has_max_users() const { + bool value = (_has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool ChannelState::has_max_users() const { + return _internal_has_max_users(); +} +inline void ChannelState::clear_max_users() { + max_users_ = 0u; + _has_bits_[0] &= ~0x00000080u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ChannelState::_internal_max_users() const { + return max_users_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ChannelState::max_users() const { + // @@protoc_insertion_point(field_get:MumbleProto.ChannelState.max_users) + return _internal_max_users(); +} +inline void ChannelState::_internal_set_max_users(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000080u; + max_users_ = value; +} +inline void ChannelState::set_max_users(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_max_users(value); + // @@protoc_insertion_point(field_set:MumbleProto.ChannelState.max_users) +} + +// ------------------------------------------------------------------- + +// UserRemove + +// required uint32 session = 1; +inline bool UserRemove::_internal_has_session() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool UserRemove::has_session() const { + return _internal_has_session(); +} +inline void UserRemove::clear_session() { + session_ = 0u; + _has_bits_[0] &= ~0x00000002u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 UserRemove::_internal_session() const { + return session_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 UserRemove::session() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserRemove.session) + return _internal_session(); +} +inline void UserRemove::_internal_set_session(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000002u; + session_ = value; +} +inline void UserRemove::set_session(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_session(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserRemove.session) +} + +// optional uint32 actor = 2; +inline bool UserRemove::_internal_has_actor() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool UserRemove::has_actor() const { + return _internal_has_actor(); +} +inline void UserRemove::clear_actor() { + actor_ = 0u; + _has_bits_[0] &= ~0x00000004u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 UserRemove::_internal_actor() const { + return actor_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 UserRemove::actor() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserRemove.actor) + return _internal_actor(); +} +inline void UserRemove::_internal_set_actor(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000004u; + actor_ = value; +} +inline void UserRemove::set_actor(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_actor(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserRemove.actor) +} + +// optional string reason = 3; +inline bool UserRemove::_internal_has_reason() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool UserRemove::has_reason() const { + return _internal_has_reason(); +} +inline void UserRemove::clear_reason() { + reason_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& UserRemove::reason() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserRemove.reason) + return _internal_reason(); +} +inline void UserRemove::set_reason(const std::string& value) { + _internal_set_reason(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserRemove.reason) +} +inline std::string* UserRemove::mutable_reason() { + // @@protoc_insertion_point(field_mutable:MumbleProto.UserRemove.reason) + return _internal_mutable_reason(); +} +inline const std::string& UserRemove::_internal_reason() const { + return reason_.Get(); +} +inline void UserRemove::_internal_set_reason(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + reason_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void UserRemove::set_reason(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + reason_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:MumbleProto.UserRemove.reason) +} +inline void UserRemove::set_reason(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + reason_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:MumbleProto.UserRemove.reason) +} +inline void UserRemove::set_reason(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000001u; + reason_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.UserRemove.reason) +} +inline std::string* UserRemove::_internal_mutable_reason() { + _has_bits_[0] |= 0x00000001u; + return reason_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* UserRemove::release_reason() { + // @@protoc_insertion_point(field_release:MumbleProto.UserRemove.reason) + if (!_internal_has_reason()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return reason_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void UserRemove::set_allocated_reason(std::string* reason) { + if (reason != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + reason_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), reason, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:MumbleProto.UserRemove.reason) +} + +// optional bool ban = 4; +inline bool UserRemove::_internal_has_ban() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool UserRemove::has_ban() const { + return _internal_has_ban(); +} +inline void UserRemove::clear_ban() { + ban_ = false; + _has_bits_[0] &= ~0x00000008u; +} +inline bool UserRemove::_internal_ban() const { + return ban_; +} +inline bool UserRemove::ban() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserRemove.ban) + return _internal_ban(); +} +inline void UserRemove::_internal_set_ban(bool value) { + _has_bits_[0] |= 0x00000008u; + ban_ = value; +} +inline void UserRemove::set_ban(bool value) { + _internal_set_ban(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserRemove.ban) +} + +// ------------------------------------------------------------------- + +// UserState + +// optional uint32 session = 1; +inline bool UserState::_internal_has_session() const { + bool value = (_has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool UserState::has_session() const { + return _internal_has_session(); +} +inline void UserState::clear_session() { + session_ = 0u; + _has_bits_[0] &= ~0x00000100u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 UserState::_internal_session() const { + return session_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 UserState::session() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserState.session) + return _internal_session(); +} +inline void UserState::_internal_set_session(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000100u; + session_ = value; +} +inline void UserState::set_session(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_session(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserState.session) +} + +// optional uint32 actor = 2; +inline bool UserState::_internal_has_actor() const { + bool value = (_has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool UserState::has_actor() const { + return _internal_has_actor(); +} +inline void UserState::clear_actor() { + actor_ = 0u; + _has_bits_[0] &= ~0x00000200u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 UserState::_internal_actor() const { + return actor_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 UserState::actor() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserState.actor) + return _internal_actor(); +} +inline void UserState::_internal_set_actor(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000200u; + actor_ = value; +} +inline void UserState::set_actor(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_actor(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserState.actor) +} + +// optional string name = 3; +inline bool UserState::_internal_has_name() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool UserState::has_name() const { + return _internal_has_name(); +} +inline void UserState::clear_name() { + name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& UserState::name() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserState.name) + return _internal_name(); +} +inline void UserState::set_name(const std::string& value) { + _internal_set_name(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserState.name) +} +inline std::string* UserState::mutable_name() { + // @@protoc_insertion_point(field_mutable:MumbleProto.UserState.name) + return _internal_mutable_name(); +} +inline const std::string& UserState::_internal_name() const { + return name_.Get(); +} +inline void UserState::_internal_set_name(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void UserState::set_name(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + name_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:MumbleProto.UserState.name) +} +inline void UserState::set_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:MumbleProto.UserState.name) +} +inline void UserState::set_name(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000001u; + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.UserState.name) +} +inline std::string* UserState::_internal_mutable_name() { + _has_bits_[0] |= 0x00000001u; + return name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* UserState::release_name() { + // @@protoc_insertion_point(field_release:MumbleProto.UserState.name) + if (!_internal_has_name()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void UserState::set_allocated_name(std::string* name) { + if (name != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:MumbleProto.UserState.name) +} + +// optional uint32 user_id = 4; +inline bool UserState::_internal_has_user_id() const { + bool value = (_has_bits_[0] & 0x00000400u) != 0; + return value; +} +inline bool UserState::has_user_id() const { + return _internal_has_user_id(); +} +inline void UserState::clear_user_id() { + user_id_ = 0u; + _has_bits_[0] &= ~0x00000400u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 UserState::_internal_user_id() const { + return user_id_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 UserState::user_id() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserState.user_id) + return _internal_user_id(); +} +inline void UserState::_internal_set_user_id(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000400u; + user_id_ = value; +} +inline void UserState::set_user_id(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_user_id(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserState.user_id) +} + +// optional uint32 channel_id = 5; +inline bool UserState::_internal_has_channel_id() const { + bool value = (_has_bits_[0] & 0x00000800u) != 0; + return value; +} +inline bool UserState::has_channel_id() const { + return _internal_has_channel_id(); +} +inline void UserState::clear_channel_id() { + channel_id_ = 0u; + _has_bits_[0] &= ~0x00000800u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 UserState::_internal_channel_id() const { + return channel_id_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 UserState::channel_id() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserState.channel_id) + return _internal_channel_id(); +} +inline void UserState::_internal_set_channel_id(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000800u; + channel_id_ = value; +} +inline void UserState::set_channel_id(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_channel_id(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserState.channel_id) +} + +// optional bool mute = 6; +inline bool UserState::_internal_has_mute() const { + bool value = (_has_bits_[0] & 0x00001000u) != 0; + return value; +} +inline bool UserState::has_mute() const { + return _internal_has_mute(); +} +inline void UserState::clear_mute() { + mute_ = false; + _has_bits_[0] &= ~0x00001000u; +} +inline bool UserState::_internal_mute() const { + return mute_; +} +inline bool UserState::mute() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserState.mute) + return _internal_mute(); +} +inline void UserState::_internal_set_mute(bool value) { + _has_bits_[0] |= 0x00001000u; + mute_ = value; +} +inline void UserState::set_mute(bool value) { + _internal_set_mute(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserState.mute) +} + +// optional bool deaf = 7; +inline bool UserState::_internal_has_deaf() const { + bool value = (_has_bits_[0] & 0x00002000u) != 0; + return value; +} +inline bool UserState::has_deaf() const { + return _internal_has_deaf(); +} +inline void UserState::clear_deaf() { + deaf_ = false; + _has_bits_[0] &= ~0x00002000u; +} +inline bool UserState::_internal_deaf() const { + return deaf_; +} +inline bool UserState::deaf() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserState.deaf) + return _internal_deaf(); +} +inline void UserState::_internal_set_deaf(bool value) { + _has_bits_[0] |= 0x00002000u; + deaf_ = value; +} +inline void UserState::set_deaf(bool value) { + _internal_set_deaf(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserState.deaf) +} + +// optional bool suppress = 8; +inline bool UserState::_internal_has_suppress() const { + bool value = (_has_bits_[0] & 0x00004000u) != 0; + return value; +} +inline bool UserState::has_suppress() const { + return _internal_has_suppress(); +} +inline void UserState::clear_suppress() { + suppress_ = false; + _has_bits_[0] &= ~0x00004000u; +} +inline bool UserState::_internal_suppress() const { + return suppress_; +} +inline bool UserState::suppress() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserState.suppress) + return _internal_suppress(); +} +inline void UserState::_internal_set_suppress(bool value) { + _has_bits_[0] |= 0x00004000u; + suppress_ = value; +} +inline void UserState::set_suppress(bool value) { + _internal_set_suppress(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserState.suppress) +} + +// optional bool self_mute = 9; +inline bool UserState::_internal_has_self_mute() const { + bool value = (_has_bits_[0] & 0x00008000u) != 0; + return value; +} +inline bool UserState::has_self_mute() const { + return _internal_has_self_mute(); +} +inline void UserState::clear_self_mute() { + self_mute_ = false; + _has_bits_[0] &= ~0x00008000u; +} +inline bool UserState::_internal_self_mute() const { + return self_mute_; +} +inline bool UserState::self_mute() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserState.self_mute) + return _internal_self_mute(); +} +inline void UserState::_internal_set_self_mute(bool value) { + _has_bits_[0] |= 0x00008000u; + self_mute_ = value; +} +inline void UserState::set_self_mute(bool value) { + _internal_set_self_mute(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserState.self_mute) +} + +// optional bool self_deaf = 10; +inline bool UserState::_internal_has_self_deaf() const { + bool value = (_has_bits_[0] & 0x00010000u) != 0; + return value; +} +inline bool UserState::has_self_deaf() const { + return _internal_has_self_deaf(); +} +inline void UserState::clear_self_deaf() { + self_deaf_ = false; + _has_bits_[0] &= ~0x00010000u; +} +inline bool UserState::_internal_self_deaf() const { + return self_deaf_; +} +inline bool UserState::self_deaf() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserState.self_deaf) + return _internal_self_deaf(); +} +inline void UserState::_internal_set_self_deaf(bool value) { + _has_bits_[0] |= 0x00010000u; + self_deaf_ = value; +} +inline void UserState::set_self_deaf(bool value) { + _internal_set_self_deaf(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserState.self_deaf) +} + +// optional bytes texture = 11; +inline bool UserState::_internal_has_texture() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool UserState::has_texture() const { + return _internal_has_texture(); +} +inline void UserState::clear_texture() { + texture_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000002u; +} +inline const std::string& UserState::texture() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserState.texture) + return _internal_texture(); +} +inline void UserState::set_texture(const std::string& value) { + _internal_set_texture(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserState.texture) +} +inline std::string* UserState::mutable_texture() { + // @@protoc_insertion_point(field_mutable:MumbleProto.UserState.texture) + return _internal_mutable_texture(); +} +inline const std::string& UserState::_internal_texture() const { + return texture_.Get(); +} +inline void UserState::_internal_set_texture(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + texture_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void UserState::set_texture(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + texture_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:MumbleProto.UserState.texture) +} +inline void UserState::set_texture(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + texture_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:MumbleProto.UserState.texture) +} +inline void UserState::set_texture(const void* value, + size_t size) { + _has_bits_[0] |= 0x00000002u; + texture_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.UserState.texture) +} +inline std::string* UserState::_internal_mutable_texture() { + _has_bits_[0] |= 0x00000002u; + return texture_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* UserState::release_texture() { + // @@protoc_insertion_point(field_release:MumbleProto.UserState.texture) + if (!_internal_has_texture()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + return texture_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void UserState::set_allocated_texture(std::string* texture) { + if (texture != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + texture_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), texture, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:MumbleProto.UserState.texture) +} + +// optional bytes plugin_context = 12; +inline bool UserState::_internal_has_plugin_context() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool UserState::has_plugin_context() const { + return _internal_has_plugin_context(); +} +inline void UserState::clear_plugin_context() { + plugin_context_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000004u; +} +inline const std::string& UserState::plugin_context() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserState.plugin_context) + return _internal_plugin_context(); +} +inline void UserState::set_plugin_context(const std::string& value) { + _internal_set_plugin_context(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserState.plugin_context) +} +inline std::string* UserState::mutable_plugin_context() { + // @@protoc_insertion_point(field_mutable:MumbleProto.UserState.plugin_context) + return _internal_mutable_plugin_context(); +} +inline const std::string& UserState::_internal_plugin_context() const { + return plugin_context_.Get(); +} +inline void UserState::_internal_set_plugin_context(const std::string& value) { + _has_bits_[0] |= 0x00000004u; + plugin_context_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void UserState::set_plugin_context(std::string&& value) { + _has_bits_[0] |= 0x00000004u; + plugin_context_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:MumbleProto.UserState.plugin_context) +} +inline void UserState::set_plugin_context(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000004u; + plugin_context_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:MumbleProto.UserState.plugin_context) +} +inline void UserState::set_plugin_context(const void* value, + size_t size) { + _has_bits_[0] |= 0x00000004u; + plugin_context_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.UserState.plugin_context) +} +inline std::string* UserState::_internal_mutable_plugin_context() { + _has_bits_[0] |= 0x00000004u; + return plugin_context_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* UserState::release_plugin_context() { + // @@protoc_insertion_point(field_release:MumbleProto.UserState.plugin_context) + if (!_internal_has_plugin_context()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000004u; + return plugin_context_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void UserState::set_allocated_plugin_context(std::string* plugin_context) { + if (plugin_context != nullptr) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + plugin_context_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), plugin_context, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:MumbleProto.UserState.plugin_context) +} + +// optional string plugin_identity = 13; +inline bool UserState::_internal_has_plugin_identity() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool UserState::has_plugin_identity() const { + return _internal_has_plugin_identity(); +} +inline void UserState::clear_plugin_identity() { + plugin_identity_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000008u; +} +inline const std::string& UserState::plugin_identity() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserState.plugin_identity) + return _internal_plugin_identity(); +} +inline void UserState::set_plugin_identity(const std::string& value) { + _internal_set_plugin_identity(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserState.plugin_identity) +} +inline std::string* UserState::mutable_plugin_identity() { + // @@protoc_insertion_point(field_mutable:MumbleProto.UserState.plugin_identity) + return _internal_mutable_plugin_identity(); +} +inline const std::string& UserState::_internal_plugin_identity() const { + return plugin_identity_.Get(); +} +inline void UserState::_internal_set_plugin_identity(const std::string& value) { + _has_bits_[0] |= 0x00000008u; + plugin_identity_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void UserState::set_plugin_identity(std::string&& value) { + _has_bits_[0] |= 0x00000008u; + plugin_identity_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:MumbleProto.UserState.plugin_identity) +} +inline void UserState::set_plugin_identity(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000008u; + plugin_identity_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:MumbleProto.UserState.plugin_identity) +} +inline void UserState::set_plugin_identity(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000008u; + plugin_identity_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.UserState.plugin_identity) +} +inline std::string* UserState::_internal_mutable_plugin_identity() { + _has_bits_[0] |= 0x00000008u; + return plugin_identity_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* UserState::release_plugin_identity() { + // @@protoc_insertion_point(field_release:MumbleProto.UserState.plugin_identity) + if (!_internal_has_plugin_identity()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000008u; + return plugin_identity_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void UserState::set_allocated_plugin_identity(std::string* plugin_identity) { + if (plugin_identity != nullptr) { + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + plugin_identity_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), plugin_identity, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:MumbleProto.UserState.plugin_identity) +} + +// optional string comment = 14; +inline bool UserState::_internal_has_comment() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool UserState::has_comment() const { + return _internal_has_comment(); +} +inline void UserState::clear_comment() { + comment_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000010u; +} +inline const std::string& UserState::comment() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserState.comment) + return _internal_comment(); +} +inline void UserState::set_comment(const std::string& value) { + _internal_set_comment(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserState.comment) +} +inline std::string* UserState::mutable_comment() { + // @@protoc_insertion_point(field_mutable:MumbleProto.UserState.comment) + return _internal_mutable_comment(); +} +inline const std::string& UserState::_internal_comment() const { + return comment_.Get(); +} +inline void UserState::_internal_set_comment(const std::string& value) { + _has_bits_[0] |= 0x00000010u; + comment_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void UserState::set_comment(std::string&& value) { + _has_bits_[0] |= 0x00000010u; + comment_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:MumbleProto.UserState.comment) +} +inline void UserState::set_comment(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000010u; + comment_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:MumbleProto.UserState.comment) +} +inline void UserState::set_comment(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000010u; + comment_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.UserState.comment) +} +inline std::string* UserState::_internal_mutable_comment() { + _has_bits_[0] |= 0x00000010u; + return comment_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* UserState::release_comment() { + // @@protoc_insertion_point(field_release:MumbleProto.UserState.comment) + if (!_internal_has_comment()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000010u; + return comment_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void UserState::set_allocated_comment(std::string* comment) { + if (comment != nullptr) { + _has_bits_[0] |= 0x00000010u; + } else { + _has_bits_[0] &= ~0x00000010u; + } + comment_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), comment, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:MumbleProto.UserState.comment) +} + +// optional string hash = 15; +inline bool UserState::_internal_has_hash() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool UserState::has_hash() const { + return _internal_has_hash(); +} +inline void UserState::clear_hash() { + hash_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000020u; +} +inline const std::string& UserState::hash() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserState.hash) + return _internal_hash(); +} +inline void UserState::set_hash(const std::string& value) { + _internal_set_hash(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserState.hash) +} +inline std::string* UserState::mutable_hash() { + // @@protoc_insertion_point(field_mutable:MumbleProto.UserState.hash) + return _internal_mutable_hash(); +} +inline const std::string& UserState::_internal_hash() const { + return hash_.Get(); +} +inline void UserState::_internal_set_hash(const std::string& value) { + _has_bits_[0] |= 0x00000020u; + hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void UserState::set_hash(std::string&& value) { + _has_bits_[0] |= 0x00000020u; + hash_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:MumbleProto.UserState.hash) +} +inline void UserState::set_hash(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000020u; + hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:MumbleProto.UserState.hash) +} +inline void UserState::set_hash(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000020u; + hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.UserState.hash) +} +inline std::string* UserState::_internal_mutable_hash() { + _has_bits_[0] |= 0x00000020u; + return hash_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* UserState::release_hash() { + // @@protoc_insertion_point(field_release:MumbleProto.UserState.hash) + if (!_internal_has_hash()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000020u; + return hash_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void UserState::set_allocated_hash(std::string* hash) { + if (hash != nullptr) { + _has_bits_[0] |= 0x00000020u; + } else { + _has_bits_[0] &= ~0x00000020u; + } + hash_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), hash, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:MumbleProto.UserState.hash) +} + +// optional bytes comment_hash = 16; +inline bool UserState::_internal_has_comment_hash() const { + bool value = (_has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool UserState::has_comment_hash() const { + return _internal_has_comment_hash(); +} +inline void UserState::clear_comment_hash() { + comment_hash_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000040u; +} +inline const std::string& UserState::comment_hash() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserState.comment_hash) + return _internal_comment_hash(); +} +inline void UserState::set_comment_hash(const std::string& value) { + _internal_set_comment_hash(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserState.comment_hash) +} +inline std::string* UserState::mutable_comment_hash() { + // @@protoc_insertion_point(field_mutable:MumbleProto.UserState.comment_hash) + return _internal_mutable_comment_hash(); +} +inline const std::string& UserState::_internal_comment_hash() const { + return comment_hash_.Get(); +} +inline void UserState::_internal_set_comment_hash(const std::string& value) { + _has_bits_[0] |= 0x00000040u; + comment_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void UserState::set_comment_hash(std::string&& value) { + _has_bits_[0] |= 0x00000040u; + comment_hash_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:MumbleProto.UserState.comment_hash) +} +inline void UserState::set_comment_hash(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000040u; + comment_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:MumbleProto.UserState.comment_hash) +} +inline void UserState::set_comment_hash(const void* value, + size_t size) { + _has_bits_[0] |= 0x00000040u; + comment_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.UserState.comment_hash) +} +inline std::string* UserState::_internal_mutable_comment_hash() { + _has_bits_[0] |= 0x00000040u; + return comment_hash_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* UserState::release_comment_hash() { + // @@protoc_insertion_point(field_release:MumbleProto.UserState.comment_hash) + if (!_internal_has_comment_hash()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000040u; + return comment_hash_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void UserState::set_allocated_comment_hash(std::string* comment_hash) { + if (comment_hash != nullptr) { + _has_bits_[0] |= 0x00000040u; + } else { + _has_bits_[0] &= ~0x00000040u; + } + comment_hash_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), comment_hash, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:MumbleProto.UserState.comment_hash) +} + +// optional bytes texture_hash = 17; +inline bool UserState::_internal_has_texture_hash() const { + bool value = (_has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool UserState::has_texture_hash() const { + return _internal_has_texture_hash(); +} +inline void UserState::clear_texture_hash() { + texture_hash_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000080u; +} +inline const std::string& UserState::texture_hash() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserState.texture_hash) + return _internal_texture_hash(); +} +inline void UserState::set_texture_hash(const std::string& value) { + _internal_set_texture_hash(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserState.texture_hash) +} +inline std::string* UserState::mutable_texture_hash() { + // @@protoc_insertion_point(field_mutable:MumbleProto.UserState.texture_hash) + return _internal_mutable_texture_hash(); +} +inline const std::string& UserState::_internal_texture_hash() const { + return texture_hash_.Get(); +} +inline void UserState::_internal_set_texture_hash(const std::string& value) { + _has_bits_[0] |= 0x00000080u; + texture_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void UserState::set_texture_hash(std::string&& value) { + _has_bits_[0] |= 0x00000080u; + texture_hash_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:MumbleProto.UserState.texture_hash) +} +inline void UserState::set_texture_hash(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000080u; + texture_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:MumbleProto.UserState.texture_hash) +} +inline void UserState::set_texture_hash(const void* value, + size_t size) { + _has_bits_[0] |= 0x00000080u; + texture_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.UserState.texture_hash) +} +inline std::string* UserState::_internal_mutable_texture_hash() { + _has_bits_[0] |= 0x00000080u; + return texture_hash_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* UserState::release_texture_hash() { + // @@protoc_insertion_point(field_release:MumbleProto.UserState.texture_hash) + if (!_internal_has_texture_hash()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000080u; + return texture_hash_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void UserState::set_allocated_texture_hash(std::string* texture_hash) { + if (texture_hash != nullptr) { + _has_bits_[0] |= 0x00000080u; + } else { + _has_bits_[0] &= ~0x00000080u; + } + texture_hash_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), texture_hash, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:MumbleProto.UserState.texture_hash) +} + +// optional bool priority_speaker = 18; +inline bool UserState::_internal_has_priority_speaker() const { + bool value = (_has_bits_[0] & 0x00020000u) != 0; + return value; +} +inline bool UserState::has_priority_speaker() const { + return _internal_has_priority_speaker(); +} +inline void UserState::clear_priority_speaker() { + priority_speaker_ = false; + _has_bits_[0] &= ~0x00020000u; +} +inline bool UserState::_internal_priority_speaker() const { + return priority_speaker_; +} +inline bool UserState::priority_speaker() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserState.priority_speaker) + return _internal_priority_speaker(); +} +inline void UserState::_internal_set_priority_speaker(bool value) { + _has_bits_[0] |= 0x00020000u; + priority_speaker_ = value; +} +inline void UserState::set_priority_speaker(bool value) { + _internal_set_priority_speaker(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserState.priority_speaker) +} + +// optional bool recording = 19; +inline bool UserState::_internal_has_recording() const { + bool value = (_has_bits_[0] & 0x00040000u) != 0; + return value; +} +inline bool UserState::has_recording() const { + return _internal_has_recording(); +} +inline void UserState::clear_recording() { + recording_ = false; + _has_bits_[0] &= ~0x00040000u; +} +inline bool UserState::_internal_recording() const { + return recording_; +} +inline bool UserState::recording() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserState.recording) + return _internal_recording(); +} +inline void UserState::_internal_set_recording(bool value) { + _has_bits_[0] |= 0x00040000u; + recording_ = value; +} +inline void UserState::set_recording(bool value) { + _internal_set_recording(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserState.recording) +} + +// ------------------------------------------------------------------- + +// BanList_BanEntry + +// required bytes address = 1; +inline bool BanList_BanEntry::_internal_has_address() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool BanList_BanEntry::has_address() const { + return _internal_has_address(); +} +inline void BanList_BanEntry::clear_address() { + address_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& BanList_BanEntry::address() const { + // @@protoc_insertion_point(field_get:MumbleProto.BanList.BanEntry.address) + return _internal_address(); +} +inline void BanList_BanEntry::set_address(const std::string& value) { + _internal_set_address(value); + // @@protoc_insertion_point(field_set:MumbleProto.BanList.BanEntry.address) +} +inline std::string* BanList_BanEntry::mutable_address() { + // @@protoc_insertion_point(field_mutable:MumbleProto.BanList.BanEntry.address) + return _internal_mutable_address(); +} +inline const std::string& BanList_BanEntry::_internal_address() const { + return address_.Get(); +} +inline void BanList_BanEntry::_internal_set_address(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void BanList_BanEntry::set_address(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + address_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:MumbleProto.BanList.BanEntry.address) +} +inline void BanList_BanEntry::set_address(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:MumbleProto.BanList.BanEntry.address) +} +inline void BanList_BanEntry::set_address(const void* value, + size_t size) { + _has_bits_[0] |= 0x00000001u; + address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.BanList.BanEntry.address) +} +inline std::string* BanList_BanEntry::_internal_mutable_address() { + _has_bits_[0] |= 0x00000001u; + return address_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* BanList_BanEntry::release_address() { + // @@protoc_insertion_point(field_release:MumbleProto.BanList.BanEntry.address) + if (!_internal_has_address()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return address_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void BanList_BanEntry::set_allocated_address(std::string* address) { + if (address != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + address_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), address, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:MumbleProto.BanList.BanEntry.address) +} + +// required uint32 mask = 2; +inline bool BanList_BanEntry::_internal_has_mask() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool BanList_BanEntry::has_mask() const { + return _internal_has_mask(); +} +inline void BanList_BanEntry::clear_mask() { + mask_ = 0u; + _has_bits_[0] &= ~0x00000020u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 BanList_BanEntry::_internal_mask() const { + return mask_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 BanList_BanEntry::mask() const { + // @@protoc_insertion_point(field_get:MumbleProto.BanList.BanEntry.mask) + return _internal_mask(); +} +inline void BanList_BanEntry::_internal_set_mask(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000020u; + mask_ = value; +} +inline void BanList_BanEntry::set_mask(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_mask(value); + // @@protoc_insertion_point(field_set:MumbleProto.BanList.BanEntry.mask) +} + +// optional string name = 3; +inline bool BanList_BanEntry::_internal_has_name() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool BanList_BanEntry::has_name() const { + return _internal_has_name(); +} +inline void BanList_BanEntry::clear_name() { + name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000002u; +} +inline const std::string& BanList_BanEntry::name() const { + // @@protoc_insertion_point(field_get:MumbleProto.BanList.BanEntry.name) + return _internal_name(); +} +inline void BanList_BanEntry::set_name(const std::string& value) { + _internal_set_name(value); + // @@protoc_insertion_point(field_set:MumbleProto.BanList.BanEntry.name) +} +inline std::string* BanList_BanEntry::mutable_name() { + // @@protoc_insertion_point(field_mutable:MumbleProto.BanList.BanEntry.name) + return _internal_mutable_name(); +} +inline const std::string& BanList_BanEntry::_internal_name() const { + return name_.Get(); +} +inline void BanList_BanEntry::_internal_set_name(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void BanList_BanEntry::set_name(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + name_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:MumbleProto.BanList.BanEntry.name) +} +inline void BanList_BanEntry::set_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:MumbleProto.BanList.BanEntry.name) +} +inline void BanList_BanEntry::set_name(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000002u; + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.BanList.BanEntry.name) +} +inline std::string* BanList_BanEntry::_internal_mutable_name() { + _has_bits_[0] |= 0x00000002u; + return name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* BanList_BanEntry::release_name() { + // @@protoc_insertion_point(field_release:MumbleProto.BanList.BanEntry.name) + if (!_internal_has_name()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + return name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void BanList_BanEntry::set_allocated_name(std::string* name) { + if (name != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:MumbleProto.BanList.BanEntry.name) +} + +// optional string hash = 4; +inline bool BanList_BanEntry::_internal_has_hash() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool BanList_BanEntry::has_hash() const { + return _internal_has_hash(); +} +inline void BanList_BanEntry::clear_hash() { + hash_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000004u; +} +inline const std::string& BanList_BanEntry::hash() const { + // @@protoc_insertion_point(field_get:MumbleProto.BanList.BanEntry.hash) + return _internal_hash(); +} +inline void BanList_BanEntry::set_hash(const std::string& value) { + _internal_set_hash(value); + // @@protoc_insertion_point(field_set:MumbleProto.BanList.BanEntry.hash) +} +inline std::string* BanList_BanEntry::mutable_hash() { + // @@protoc_insertion_point(field_mutable:MumbleProto.BanList.BanEntry.hash) + return _internal_mutable_hash(); +} +inline const std::string& BanList_BanEntry::_internal_hash() const { + return hash_.Get(); +} +inline void BanList_BanEntry::_internal_set_hash(const std::string& value) { + _has_bits_[0] |= 0x00000004u; + hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void BanList_BanEntry::set_hash(std::string&& value) { + _has_bits_[0] |= 0x00000004u; + hash_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:MumbleProto.BanList.BanEntry.hash) +} +inline void BanList_BanEntry::set_hash(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000004u; + hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:MumbleProto.BanList.BanEntry.hash) +} +inline void BanList_BanEntry::set_hash(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000004u; + hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.BanList.BanEntry.hash) +} +inline std::string* BanList_BanEntry::_internal_mutable_hash() { + _has_bits_[0] |= 0x00000004u; + return hash_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* BanList_BanEntry::release_hash() { + // @@protoc_insertion_point(field_release:MumbleProto.BanList.BanEntry.hash) + if (!_internal_has_hash()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000004u; + return hash_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void BanList_BanEntry::set_allocated_hash(std::string* hash) { + if (hash != nullptr) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + hash_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), hash, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:MumbleProto.BanList.BanEntry.hash) +} + +// optional string reason = 5; +inline bool BanList_BanEntry::_internal_has_reason() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool BanList_BanEntry::has_reason() const { + return _internal_has_reason(); +} +inline void BanList_BanEntry::clear_reason() { + reason_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000008u; +} +inline const std::string& BanList_BanEntry::reason() const { + // @@protoc_insertion_point(field_get:MumbleProto.BanList.BanEntry.reason) + return _internal_reason(); +} +inline void BanList_BanEntry::set_reason(const std::string& value) { + _internal_set_reason(value); + // @@protoc_insertion_point(field_set:MumbleProto.BanList.BanEntry.reason) +} +inline std::string* BanList_BanEntry::mutable_reason() { + // @@protoc_insertion_point(field_mutable:MumbleProto.BanList.BanEntry.reason) + return _internal_mutable_reason(); +} +inline const std::string& BanList_BanEntry::_internal_reason() const { + return reason_.Get(); +} +inline void BanList_BanEntry::_internal_set_reason(const std::string& value) { + _has_bits_[0] |= 0x00000008u; + reason_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void BanList_BanEntry::set_reason(std::string&& value) { + _has_bits_[0] |= 0x00000008u; + reason_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:MumbleProto.BanList.BanEntry.reason) +} +inline void BanList_BanEntry::set_reason(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000008u; + reason_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:MumbleProto.BanList.BanEntry.reason) +} +inline void BanList_BanEntry::set_reason(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000008u; + reason_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.BanList.BanEntry.reason) +} +inline std::string* BanList_BanEntry::_internal_mutable_reason() { + _has_bits_[0] |= 0x00000008u; + return reason_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* BanList_BanEntry::release_reason() { + // @@protoc_insertion_point(field_release:MumbleProto.BanList.BanEntry.reason) + if (!_internal_has_reason()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000008u; + return reason_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void BanList_BanEntry::set_allocated_reason(std::string* reason) { + if (reason != nullptr) { + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + reason_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), reason, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:MumbleProto.BanList.BanEntry.reason) +} + +// optional string start = 6; +inline bool BanList_BanEntry::_internal_has_start() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool BanList_BanEntry::has_start() const { + return _internal_has_start(); +} +inline void BanList_BanEntry::clear_start() { + start_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000010u; +} +inline const std::string& BanList_BanEntry::start() const { + // @@protoc_insertion_point(field_get:MumbleProto.BanList.BanEntry.start) + return _internal_start(); +} +inline void BanList_BanEntry::set_start(const std::string& value) { + _internal_set_start(value); + // @@protoc_insertion_point(field_set:MumbleProto.BanList.BanEntry.start) +} +inline std::string* BanList_BanEntry::mutable_start() { + // @@protoc_insertion_point(field_mutable:MumbleProto.BanList.BanEntry.start) + return _internal_mutable_start(); +} +inline const std::string& BanList_BanEntry::_internal_start() const { + return start_.Get(); +} +inline void BanList_BanEntry::_internal_set_start(const std::string& value) { + _has_bits_[0] |= 0x00000010u; + start_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void BanList_BanEntry::set_start(std::string&& value) { + _has_bits_[0] |= 0x00000010u; + start_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:MumbleProto.BanList.BanEntry.start) +} +inline void BanList_BanEntry::set_start(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000010u; + start_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:MumbleProto.BanList.BanEntry.start) +} +inline void BanList_BanEntry::set_start(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000010u; + start_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.BanList.BanEntry.start) +} +inline std::string* BanList_BanEntry::_internal_mutable_start() { + _has_bits_[0] |= 0x00000010u; + return start_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* BanList_BanEntry::release_start() { + // @@protoc_insertion_point(field_release:MumbleProto.BanList.BanEntry.start) + if (!_internal_has_start()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000010u; + return start_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void BanList_BanEntry::set_allocated_start(std::string* start) { + if (start != nullptr) { + _has_bits_[0] |= 0x00000010u; + } else { + _has_bits_[0] &= ~0x00000010u; + } + start_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), start, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:MumbleProto.BanList.BanEntry.start) +} + +// optional uint32 duration = 7; +inline bool BanList_BanEntry::_internal_has_duration() const { + bool value = (_has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool BanList_BanEntry::has_duration() const { + return _internal_has_duration(); +} +inline void BanList_BanEntry::clear_duration() { + duration_ = 0u; + _has_bits_[0] &= ~0x00000040u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 BanList_BanEntry::_internal_duration() const { + return duration_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 BanList_BanEntry::duration() const { + // @@protoc_insertion_point(field_get:MumbleProto.BanList.BanEntry.duration) + return _internal_duration(); +} +inline void BanList_BanEntry::_internal_set_duration(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000040u; + duration_ = value; +} +inline void BanList_BanEntry::set_duration(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_duration(value); + // @@protoc_insertion_point(field_set:MumbleProto.BanList.BanEntry.duration) +} + +// ------------------------------------------------------------------- + +// BanList + +// repeated .MumbleProto.BanList.BanEntry bans = 1; +inline int BanList::_internal_bans_size() const { + return bans_.size(); +} +inline int BanList::bans_size() const { + return _internal_bans_size(); +} +inline void BanList::clear_bans() { + bans_.Clear(); +} +inline ::MumbleProto::BanList_BanEntry* BanList::mutable_bans(int index) { + // @@protoc_insertion_point(field_mutable:MumbleProto.BanList.bans) + return bans_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MumbleProto::BanList_BanEntry >* +BanList::mutable_bans() { + // @@protoc_insertion_point(field_mutable_list:MumbleProto.BanList.bans) + return &bans_; +} +inline const ::MumbleProto::BanList_BanEntry& BanList::_internal_bans(int index) const { + return bans_.Get(index); +} +inline const ::MumbleProto::BanList_BanEntry& BanList::bans(int index) const { + // @@protoc_insertion_point(field_get:MumbleProto.BanList.bans) + return _internal_bans(index); +} +inline ::MumbleProto::BanList_BanEntry* BanList::_internal_add_bans() { + return bans_.Add(); +} +inline ::MumbleProto::BanList_BanEntry* BanList::add_bans() { + // @@protoc_insertion_point(field_add:MumbleProto.BanList.bans) + return _internal_add_bans(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MumbleProto::BanList_BanEntry >& +BanList::bans() const { + // @@protoc_insertion_point(field_list:MumbleProto.BanList.bans) + return bans_; +} + +// optional bool query = 2 [default = false]; +inline bool BanList::_internal_has_query() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool BanList::has_query() const { + return _internal_has_query(); +} +inline void BanList::clear_query() { + query_ = false; + _has_bits_[0] &= ~0x00000001u; +} +inline bool BanList::_internal_query() const { + return query_; +} +inline bool BanList::query() const { + // @@protoc_insertion_point(field_get:MumbleProto.BanList.query) + return _internal_query(); +} +inline void BanList::_internal_set_query(bool value) { + _has_bits_[0] |= 0x00000001u; + query_ = value; +} +inline void BanList::set_query(bool value) { + _internal_set_query(value); + // @@protoc_insertion_point(field_set:MumbleProto.BanList.query) +} + +// ------------------------------------------------------------------- + +// TextMessage + +// optional uint32 actor = 1; +inline bool TextMessage::_internal_has_actor() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool TextMessage::has_actor() const { + return _internal_has_actor(); +} +inline void TextMessage::clear_actor() { + actor_ = 0u; + _has_bits_[0] &= ~0x00000002u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 TextMessage::_internal_actor() const { + return actor_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 TextMessage::actor() const { + // @@protoc_insertion_point(field_get:MumbleProto.TextMessage.actor) + return _internal_actor(); +} +inline void TextMessage::_internal_set_actor(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000002u; + actor_ = value; +} +inline void TextMessage::set_actor(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_actor(value); + // @@protoc_insertion_point(field_set:MumbleProto.TextMessage.actor) +} + +// repeated uint32 session = 2; +inline int TextMessage::_internal_session_size() const { + return session_.size(); +} +inline int TextMessage::session_size() const { + return _internal_session_size(); +} +inline void TextMessage::clear_session() { + session_.Clear(); +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 TextMessage::_internal_session(int index) const { + return session_.Get(index); +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 TextMessage::session(int index) const { + // @@protoc_insertion_point(field_get:MumbleProto.TextMessage.session) + return _internal_session(index); +} +inline void TextMessage::set_session(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value) { + session_.Set(index, value); + // @@protoc_insertion_point(field_set:MumbleProto.TextMessage.session) +} +inline void TextMessage::_internal_add_session(::PROTOBUF_NAMESPACE_ID::uint32 value) { + session_.Add(value); +} +inline void TextMessage::add_session(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_add_session(value); + // @@protoc_insertion_point(field_add:MumbleProto.TextMessage.session) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& +TextMessage::_internal_session() const { + return session_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& +TextMessage::session() const { + // @@protoc_insertion_point(field_list:MumbleProto.TextMessage.session) + return _internal_session(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* +TextMessage::_internal_mutable_session() { + return &session_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* +TextMessage::mutable_session() { + // @@protoc_insertion_point(field_mutable_list:MumbleProto.TextMessage.session) + return _internal_mutable_session(); +} + +// repeated uint32 channel_id = 3; +inline int TextMessage::_internal_channel_id_size() const { + return channel_id_.size(); +} +inline int TextMessage::channel_id_size() const { + return _internal_channel_id_size(); +} +inline void TextMessage::clear_channel_id() { + channel_id_.Clear(); +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 TextMessage::_internal_channel_id(int index) const { + return channel_id_.Get(index); +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 TextMessage::channel_id(int index) const { + // @@protoc_insertion_point(field_get:MumbleProto.TextMessage.channel_id) + return _internal_channel_id(index); +} +inline void TextMessage::set_channel_id(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value) { + channel_id_.Set(index, value); + // @@protoc_insertion_point(field_set:MumbleProto.TextMessage.channel_id) +} +inline void TextMessage::_internal_add_channel_id(::PROTOBUF_NAMESPACE_ID::uint32 value) { + channel_id_.Add(value); +} +inline void TextMessage::add_channel_id(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_add_channel_id(value); + // @@protoc_insertion_point(field_add:MumbleProto.TextMessage.channel_id) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& +TextMessage::_internal_channel_id() const { + return channel_id_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& +TextMessage::channel_id() const { + // @@protoc_insertion_point(field_list:MumbleProto.TextMessage.channel_id) + return _internal_channel_id(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* +TextMessage::_internal_mutable_channel_id() { + return &channel_id_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* +TextMessage::mutable_channel_id() { + // @@protoc_insertion_point(field_mutable_list:MumbleProto.TextMessage.channel_id) + return _internal_mutable_channel_id(); +} + +// repeated uint32 tree_id = 4; +inline int TextMessage::_internal_tree_id_size() const { + return tree_id_.size(); +} +inline int TextMessage::tree_id_size() const { + return _internal_tree_id_size(); +} +inline void TextMessage::clear_tree_id() { + tree_id_.Clear(); +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 TextMessage::_internal_tree_id(int index) const { + return tree_id_.Get(index); +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 TextMessage::tree_id(int index) const { + // @@protoc_insertion_point(field_get:MumbleProto.TextMessage.tree_id) + return _internal_tree_id(index); +} +inline void TextMessage::set_tree_id(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value) { + tree_id_.Set(index, value); + // @@protoc_insertion_point(field_set:MumbleProto.TextMessage.tree_id) +} +inline void TextMessage::_internal_add_tree_id(::PROTOBUF_NAMESPACE_ID::uint32 value) { + tree_id_.Add(value); +} +inline void TextMessage::add_tree_id(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_add_tree_id(value); + // @@protoc_insertion_point(field_add:MumbleProto.TextMessage.tree_id) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& +TextMessage::_internal_tree_id() const { + return tree_id_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& +TextMessage::tree_id() const { + // @@protoc_insertion_point(field_list:MumbleProto.TextMessage.tree_id) + return _internal_tree_id(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* +TextMessage::_internal_mutable_tree_id() { + return &tree_id_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* +TextMessage::mutable_tree_id() { + // @@protoc_insertion_point(field_mutable_list:MumbleProto.TextMessage.tree_id) + return _internal_mutable_tree_id(); +} + +// required string message = 5; +inline bool TextMessage::_internal_has_message() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool TextMessage::has_message() const { + return _internal_has_message(); +} +inline void TextMessage::clear_message() { + message_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& TextMessage::message() const { + // @@protoc_insertion_point(field_get:MumbleProto.TextMessage.message) + return _internal_message(); +} +inline void TextMessage::set_message(const std::string& value) { + _internal_set_message(value); + // @@protoc_insertion_point(field_set:MumbleProto.TextMessage.message) +} +inline std::string* TextMessage::mutable_message() { + // @@protoc_insertion_point(field_mutable:MumbleProto.TextMessage.message) + return _internal_mutable_message(); +} +inline const std::string& TextMessage::_internal_message() const { + return message_.Get(); +} +inline void TextMessage::_internal_set_message(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + message_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void TextMessage::set_message(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + message_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:MumbleProto.TextMessage.message) +} +inline void TextMessage::set_message(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + message_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:MumbleProto.TextMessage.message) +} +inline void TextMessage::set_message(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000001u; + message_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.TextMessage.message) +} +inline std::string* TextMessage::_internal_mutable_message() { + _has_bits_[0] |= 0x00000001u; + return message_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* TextMessage::release_message() { + // @@protoc_insertion_point(field_release:MumbleProto.TextMessage.message) + if (!_internal_has_message()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return message_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void TextMessage::set_allocated_message(std::string* message) { + if (message != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + message_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), message, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:MumbleProto.TextMessage.message) +} + +// ------------------------------------------------------------------- + +// PermissionDenied + +// optional uint32 permission = 1; +inline bool PermissionDenied::_internal_has_permission() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool PermissionDenied::has_permission() const { + return _internal_has_permission(); +} +inline void PermissionDenied::clear_permission() { + permission_ = 0u; + _has_bits_[0] &= ~0x00000004u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 PermissionDenied::_internal_permission() const { + return permission_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 PermissionDenied::permission() const { + // @@protoc_insertion_point(field_get:MumbleProto.PermissionDenied.permission) + return _internal_permission(); +} +inline void PermissionDenied::_internal_set_permission(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000004u; + permission_ = value; +} +inline void PermissionDenied::set_permission(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_permission(value); + // @@protoc_insertion_point(field_set:MumbleProto.PermissionDenied.permission) +} + +// optional uint32 channel_id = 2; +inline bool PermissionDenied::_internal_has_channel_id() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool PermissionDenied::has_channel_id() const { + return _internal_has_channel_id(); +} +inline void PermissionDenied::clear_channel_id() { + channel_id_ = 0u; + _has_bits_[0] &= ~0x00000008u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 PermissionDenied::_internal_channel_id() const { + return channel_id_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 PermissionDenied::channel_id() const { + // @@protoc_insertion_point(field_get:MumbleProto.PermissionDenied.channel_id) + return _internal_channel_id(); +} +inline void PermissionDenied::_internal_set_channel_id(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000008u; + channel_id_ = value; +} +inline void PermissionDenied::set_channel_id(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_channel_id(value); + // @@protoc_insertion_point(field_set:MumbleProto.PermissionDenied.channel_id) +} + +// optional uint32 session = 3; +inline bool PermissionDenied::_internal_has_session() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool PermissionDenied::has_session() const { + return _internal_has_session(); +} +inline void PermissionDenied::clear_session() { + session_ = 0u; + _has_bits_[0] &= ~0x00000010u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 PermissionDenied::_internal_session() const { + return session_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 PermissionDenied::session() const { + // @@protoc_insertion_point(field_get:MumbleProto.PermissionDenied.session) + return _internal_session(); +} +inline void PermissionDenied::_internal_set_session(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000010u; + session_ = value; +} +inline void PermissionDenied::set_session(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_session(value); + // @@protoc_insertion_point(field_set:MumbleProto.PermissionDenied.session) +} + +// optional string reason = 4; +inline bool PermissionDenied::_internal_has_reason() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool PermissionDenied::has_reason() const { + return _internal_has_reason(); +} +inline void PermissionDenied::clear_reason() { + reason_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& PermissionDenied::reason() const { + // @@protoc_insertion_point(field_get:MumbleProto.PermissionDenied.reason) + return _internal_reason(); +} +inline void PermissionDenied::set_reason(const std::string& value) { + _internal_set_reason(value); + // @@protoc_insertion_point(field_set:MumbleProto.PermissionDenied.reason) +} +inline std::string* PermissionDenied::mutable_reason() { + // @@protoc_insertion_point(field_mutable:MumbleProto.PermissionDenied.reason) + return _internal_mutable_reason(); +} +inline const std::string& PermissionDenied::_internal_reason() const { + return reason_.Get(); +} +inline void PermissionDenied::_internal_set_reason(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + reason_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void PermissionDenied::set_reason(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + reason_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:MumbleProto.PermissionDenied.reason) +} +inline void PermissionDenied::set_reason(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + reason_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:MumbleProto.PermissionDenied.reason) +} +inline void PermissionDenied::set_reason(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000001u; + reason_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.PermissionDenied.reason) +} +inline std::string* PermissionDenied::_internal_mutable_reason() { + _has_bits_[0] |= 0x00000001u; + return reason_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* PermissionDenied::release_reason() { + // @@protoc_insertion_point(field_release:MumbleProto.PermissionDenied.reason) + if (!_internal_has_reason()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return reason_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void PermissionDenied::set_allocated_reason(std::string* reason) { + if (reason != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + reason_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), reason, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:MumbleProto.PermissionDenied.reason) +} + +// optional .MumbleProto.PermissionDenied.DenyType type = 5; +inline bool PermissionDenied::_internal_has_type() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool PermissionDenied::has_type() const { + return _internal_has_type(); +} +inline void PermissionDenied::clear_type() { + type_ = 0; + _has_bits_[0] &= ~0x00000020u; +} +inline ::MumbleProto::PermissionDenied_DenyType PermissionDenied::_internal_type() const { + return static_cast< ::MumbleProto::PermissionDenied_DenyType >(type_); +} +inline ::MumbleProto::PermissionDenied_DenyType PermissionDenied::type() const { + // @@protoc_insertion_point(field_get:MumbleProto.PermissionDenied.type) + return _internal_type(); +} +inline void PermissionDenied::_internal_set_type(::MumbleProto::PermissionDenied_DenyType value) { + assert(::MumbleProto::PermissionDenied_DenyType_IsValid(value)); + _has_bits_[0] |= 0x00000020u; + type_ = value; +} +inline void PermissionDenied::set_type(::MumbleProto::PermissionDenied_DenyType value) { + _internal_set_type(value); + // @@protoc_insertion_point(field_set:MumbleProto.PermissionDenied.type) +} + +// optional string name = 6; +inline bool PermissionDenied::_internal_has_name() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool PermissionDenied::has_name() const { + return _internal_has_name(); +} +inline void PermissionDenied::clear_name() { + name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000002u; +} +inline const std::string& PermissionDenied::name() const { + // @@protoc_insertion_point(field_get:MumbleProto.PermissionDenied.name) + return _internal_name(); +} +inline void PermissionDenied::set_name(const std::string& value) { + _internal_set_name(value); + // @@protoc_insertion_point(field_set:MumbleProto.PermissionDenied.name) +} +inline std::string* PermissionDenied::mutable_name() { + // @@protoc_insertion_point(field_mutable:MumbleProto.PermissionDenied.name) + return _internal_mutable_name(); +} +inline const std::string& PermissionDenied::_internal_name() const { + return name_.Get(); +} +inline void PermissionDenied::_internal_set_name(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void PermissionDenied::set_name(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + name_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:MumbleProto.PermissionDenied.name) +} +inline void PermissionDenied::set_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:MumbleProto.PermissionDenied.name) +} +inline void PermissionDenied::set_name(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000002u; + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.PermissionDenied.name) +} +inline std::string* PermissionDenied::_internal_mutable_name() { + _has_bits_[0] |= 0x00000002u; + return name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* PermissionDenied::release_name() { + // @@protoc_insertion_point(field_release:MumbleProto.PermissionDenied.name) + if (!_internal_has_name()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + return name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void PermissionDenied::set_allocated_name(std::string* name) { + if (name != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:MumbleProto.PermissionDenied.name) +} + +// ------------------------------------------------------------------- + +// ACL_ChanGroup + +// required string name = 1; +inline bool ACL_ChanGroup::_internal_has_name() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ACL_ChanGroup::has_name() const { + return _internal_has_name(); +} +inline void ACL_ChanGroup::clear_name() { + name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ACL_ChanGroup::name() const { + // @@protoc_insertion_point(field_get:MumbleProto.ACL.ChanGroup.name) + return _internal_name(); +} +inline void ACL_ChanGroup::set_name(const std::string& value) { + _internal_set_name(value); + // @@protoc_insertion_point(field_set:MumbleProto.ACL.ChanGroup.name) +} +inline std::string* ACL_ChanGroup::mutable_name() { + // @@protoc_insertion_point(field_mutable:MumbleProto.ACL.ChanGroup.name) + return _internal_mutable_name(); +} +inline const std::string& ACL_ChanGroup::_internal_name() const { + return name_.Get(); +} +inline void ACL_ChanGroup::_internal_set_name(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void ACL_ChanGroup::set_name(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + name_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:MumbleProto.ACL.ChanGroup.name) +} +inline void ACL_ChanGroup::set_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:MumbleProto.ACL.ChanGroup.name) +} +inline void ACL_ChanGroup::set_name(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000001u; + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.ACL.ChanGroup.name) +} +inline std::string* ACL_ChanGroup::_internal_mutable_name() { + _has_bits_[0] |= 0x00000001u; + return name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* ACL_ChanGroup::release_name() { + // @@protoc_insertion_point(field_release:MumbleProto.ACL.ChanGroup.name) + if (!_internal_has_name()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void ACL_ChanGroup::set_allocated_name(std::string* name) { + if (name != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:MumbleProto.ACL.ChanGroup.name) +} + +// optional bool inherited = 2 [default = true]; +inline bool ACL_ChanGroup::_internal_has_inherited() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ACL_ChanGroup::has_inherited() const { + return _internal_has_inherited(); +} +inline void ACL_ChanGroup::clear_inherited() { + inherited_ = true; + _has_bits_[0] &= ~0x00000002u; +} +inline bool ACL_ChanGroup::_internal_inherited() const { + return inherited_; +} +inline bool ACL_ChanGroup::inherited() const { + // @@protoc_insertion_point(field_get:MumbleProto.ACL.ChanGroup.inherited) + return _internal_inherited(); +} +inline void ACL_ChanGroup::_internal_set_inherited(bool value) { + _has_bits_[0] |= 0x00000002u; + inherited_ = value; +} +inline void ACL_ChanGroup::set_inherited(bool value) { + _internal_set_inherited(value); + // @@protoc_insertion_point(field_set:MumbleProto.ACL.ChanGroup.inherited) +} + +// optional bool inherit = 3 [default = true]; +inline bool ACL_ChanGroup::_internal_has_inherit() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ACL_ChanGroup::has_inherit() const { + return _internal_has_inherit(); +} +inline void ACL_ChanGroup::clear_inherit() { + inherit_ = true; + _has_bits_[0] &= ~0x00000004u; +} +inline bool ACL_ChanGroup::_internal_inherit() const { + return inherit_; +} +inline bool ACL_ChanGroup::inherit() const { + // @@protoc_insertion_point(field_get:MumbleProto.ACL.ChanGroup.inherit) + return _internal_inherit(); +} +inline void ACL_ChanGroup::_internal_set_inherit(bool value) { + _has_bits_[0] |= 0x00000004u; + inherit_ = value; +} +inline void ACL_ChanGroup::set_inherit(bool value) { + _internal_set_inherit(value); + // @@protoc_insertion_point(field_set:MumbleProto.ACL.ChanGroup.inherit) +} + +// optional bool inheritable = 4 [default = true]; +inline bool ACL_ChanGroup::_internal_has_inheritable() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool ACL_ChanGroup::has_inheritable() const { + return _internal_has_inheritable(); +} +inline void ACL_ChanGroup::clear_inheritable() { + inheritable_ = true; + _has_bits_[0] &= ~0x00000008u; +} +inline bool ACL_ChanGroup::_internal_inheritable() const { + return inheritable_; +} +inline bool ACL_ChanGroup::inheritable() const { + // @@protoc_insertion_point(field_get:MumbleProto.ACL.ChanGroup.inheritable) + return _internal_inheritable(); +} +inline void ACL_ChanGroup::_internal_set_inheritable(bool value) { + _has_bits_[0] |= 0x00000008u; + inheritable_ = value; +} +inline void ACL_ChanGroup::set_inheritable(bool value) { + _internal_set_inheritable(value); + // @@protoc_insertion_point(field_set:MumbleProto.ACL.ChanGroup.inheritable) +} + +// repeated uint32 add = 5; +inline int ACL_ChanGroup::_internal_add_size() const { + return add_.size(); +} +inline int ACL_ChanGroup::add_size() const { + return _internal_add_size(); +} +inline void ACL_ChanGroup::clear_add() { + add_.Clear(); +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ACL_ChanGroup::_internal_add(int index) const { + return add_.Get(index); +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ACL_ChanGroup::add(int index) const { + // @@protoc_insertion_point(field_get:MumbleProto.ACL.ChanGroup.add) + return _internal_add(index); +} +inline void ACL_ChanGroup::set_add(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value) { + add_.Set(index, value); + // @@protoc_insertion_point(field_set:MumbleProto.ACL.ChanGroup.add) +} +inline void ACL_ChanGroup::_internal_add_add(::PROTOBUF_NAMESPACE_ID::uint32 value) { + add_.Add(value); +} +inline void ACL_ChanGroup::add_add(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_add_add(value); + // @@protoc_insertion_point(field_add:MumbleProto.ACL.ChanGroup.add) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& +ACL_ChanGroup::_internal_add() const { + return add_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& +ACL_ChanGroup::add() const { + // @@protoc_insertion_point(field_list:MumbleProto.ACL.ChanGroup.add) + return _internal_add(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* +ACL_ChanGroup::_internal_mutable_add() { + return &add_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* +ACL_ChanGroup::mutable_add() { + // @@protoc_insertion_point(field_mutable_list:MumbleProto.ACL.ChanGroup.add) + return _internal_mutable_add(); +} + +// repeated uint32 remove = 6; +inline int ACL_ChanGroup::_internal_remove_size() const { + return remove_.size(); +} +inline int ACL_ChanGroup::remove_size() const { + return _internal_remove_size(); +} +inline void ACL_ChanGroup::clear_remove() { + remove_.Clear(); +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ACL_ChanGroup::_internal_remove(int index) const { + return remove_.Get(index); +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ACL_ChanGroup::remove(int index) const { + // @@protoc_insertion_point(field_get:MumbleProto.ACL.ChanGroup.remove) + return _internal_remove(index); +} +inline void ACL_ChanGroup::set_remove(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value) { + remove_.Set(index, value); + // @@protoc_insertion_point(field_set:MumbleProto.ACL.ChanGroup.remove) +} +inline void ACL_ChanGroup::_internal_add_remove(::PROTOBUF_NAMESPACE_ID::uint32 value) { + remove_.Add(value); +} +inline void ACL_ChanGroup::add_remove(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_add_remove(value); + // @@protoc_insertion_point(field_add:MumbleProto.ACL.ChanGroup.remove) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& +ACL_ChanGroup::_internal_remove() const { + return remove_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& +ACL_ChanGroup::remove() const { + // @@protoc_insertion_point(field_list:MumbleProto.ACL.ChanGroup.remove) + return _internal_remove(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* +ACL_ChanGroup::_internal_mutable_remove() { + return &remove_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* +ACL_ChanGroup::mutable_remove() { + // @@protoc_insertion_point(field_mutable_list:MumbleProto.ACL.ChanGroup.remove) + return _internal_mutable_remove(); +} + +// repeated uint32 inherited_members = 7; +inline int ACL_ChanGroup::_internal_inherited_members_size() const { + return inherited_members_.size(); +} +inline int ACL_ChanGroup::inherited_members_size() const { + return _internal_inherited_members_size(); +} +inline void ACL_ChanGroup::clear_inherited_members() { + inherited_members_.Clear(); +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ACL_ChanGroup::_internal_inherited_members(int index) const { + return inherited_members_.Get(index); +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ACL_ChanGroup::inherited_members(int index) const { + // @@protoc_insertion_point(field_get:MumbleProto.ACL.ChanGroup.inherited_members) + return _internal_inherited_members(index); +} +inline void ACL_ChanGroup::set_inherited_members(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value) { + inherited_members_.Set(index, value); + // @@protoc_insertion_point(field_set:MumbleProto.ACL.ChanGroup.inherited_members) +} +inline void ACL_ChanGroup::_internal_add_inherited_members(::PROTOBUF_NAMESPACE_ID::uint32 value) { + inherited_members_.Add(value); +} +inline void ACL_ChanGroup::add_inherited_members(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_add_inherited_members(value); + // @@protoc_insertion_point(field_add:MumbleProto.ACL.ChanGroup.inherited_members) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& +ACL_ChanGroup::_internal_inherited_members() const { + return inherited_members_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& +ACL_ChanGroup::inherited_members() const { + // @@protoc_insertion_point(field_list:MumbleProto.ACL.ChanGroup.inherited_members) + return _internal_inherited_members(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* +ACL_ChanGroup::_internal_mutable_inherited_members() { + return &inherited_members_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* +ACL_ChanGroup::mutable_inherited_members() { + // @@protoc_insertion_point(field_mutable_list:MumbleProto.ACL.ChanGroup.inherited_members) + return _internal_mutable_inherited_members(); +} + +// ------------------------------------------------------------------- + +// ACL_ChanACL + +// optional bool apply_here = 1 [default = true]; +inline bool ACL_ChanACL::_internal_has_apply_here() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool ACL_ChanACL::has_apply_here() const { + return _internal_has_apply_here(); +} +inline void ACL_ChanACL::clear_apply_here() { + apply_here_ = true; + _has_bits_[0] &= ~0x00000010u; +} +inline bool ACL_ChanACL::_internal_apply_here() const { + return apply_here_; +} +inline bool ACL_ChanACL::apply_here() const { + // @@protoc_insertion_point(field_get:MumbleProto.ACL.ChanACL.apply_here) + return _internal_apply_here(); +} +inline void ACL_ChanACL::_internal_set_apply_here(bool value) { + _has_bits_[0] |= 0x00000010u; + apply_here_ = value; +} +inline void ACL_ChanACL::set_apply_here(bool value) { + _internal_set_apply_here(value); + // @@protoc_insertion_point(field_set:MumbleProto.ACL.ChanACL.apply_here) +} + +// optional bool apply_subs = 2 [default = true]; +inline bool ACL_ChanACL::_internal_has_apply_subs() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool ACL_ChanACL::has_apply_subs() const { + return _internal_has_apply_subs(); +} +inline void ACL_ChanACL::clear_apply_subs() { + apply_subs_ = true; + _has_bits_[0] &= ~0x00000020u; +} +inline bool ACL_ChanACL::_internal_apply_subs() const { + return apply_subs_; +} +inline bool ACL_ChanACL::apply_subs() const { + // @@protoc_insertion_point(field_get:MumbleProto.ACL.ChanACL.apply_subs) + return _internal_apply_subs(); +} +inline void ACL_ChanACL::_internal_set_apply_subs(bool value) { + _has_bits_[0] |= 0x00000020u; + apply_subs_ = value; +} +inline void ACL_ChanACL::set_apply_subs(bool value) { + _internal_set_apply_subs(value); + // @@protoc_insertion_point(field_set:MumbleProto.ACL.ChanACL.apply_subs) +} + +// optional bool inherited = 3 [default = true]; +inline bool ACL_ChanACL::_internal_has_inherited() const { + bool value = (_has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool ACL_ChanACL::has_inherited() const { + return _internal_has_inherited(); +} +inline void ACL_ChanACL::clear_inherited() { + inherited_ = true; + _has_bits_[0] &= ~0x00000040u; +} +inline bool ACL_ChanACL::_internal_inherited() const { + return inherited_; +} +inline bool ACL_ChanACL::inherited() const { + // @@protoc_insertion_point(field_get:MumbleProto.ACL.ChanACL.inherited) + return _internal_inherited(); +} +inline void ACL_ChanACL::_internal_set_inherited(bool value) { + _has_bits_[0] |= 0x00000040u; + inherited_ = value; +} +inline void ACL_ChanACL::set_inherited(bool value) { + _internal_set_inherited(value); + // @@protoc_insertion_point(field_set:MumbleProto.ACL.ChanACL.inherited) +} + +// optional uint32 user_id = 4; +inline bool ACL_ChanACL::_internal_has_user_id() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ACL_ChanACL::has_user_id() const { + return _internal_has_user_id(); +} +inline void ACL_ChanACL::clear_user_id() { + user_id_ = 0u; + _has_bits_[0] &= ~0x00000002u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ACL_ChanACL::_internal_user_id() const { + return user_id_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ACL_ChanACL::user_id() const { + // @@protoc_insertion_point(field_get:MumbleProto.ACL.ChanACL.user_id) + return _internal_user_id(); +} +inline void ACL_ChanACL::_internal_set_user_id(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000002u; + user_id_ = value; +} +inline void ACL_ChanACL::set_user_id(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_user_id(value); + // @@protoc_insertion_point(field_set:MumbleProto.ACL.ChanACL.user_id) +} + +// optional string group = 5; +inline bool ACL_ChanACL::_internal_has_group() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ACL_ChanACL::has_group() const { + return _internal_has_group(); +} +inline void ACL_ChanACL::clear_group() { + group_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ACL_ChanACL::group() const { + // @@protoc_insertion_point(field_get:MumbleProto.ACL.ChanACL.group) + return _internal_group(); +} +inline void ACL_ChanACL::set_group(const std::string& value) { + _internal_set_group(value); + // @@protoc_insertion_point(field_set:MumbleProto.ACL.ChanACL.group) +} +inline std::string* ACL_ChanACL::mutable_group() { + // @@protoc_insertion_point(field_mutable:MumbleProto.ACL.ChanACL.group) + return _internal_mutable_group(); +} +inline const std::string& ACL_ChanACL::_internal_group() const { + return group_.Get(); +} +inline void ACL_ChanACL::_internal_set_group(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + group_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void ACL_ChanACL::set_group(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + group_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:MumbleProto.ACL.ChanACL.group) +} +inline void ACL_ChanACL::set_group(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + group_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:MumbleProto.ACL.ChanACL.group) +} +inline void ACL_ChanACL::set_group(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000001u; + group_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.ACL.ChanACL.group) +} +inline std::string* ACL_ChanACL::_internal_mutable_group() { + _has_bits_[0] |= 0x00000001u; + return group_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* ACL_ChanACL::release_group() { + // @@protoc_insertion_point(field_release:MumbleProto.ACL.ChanACL.group) + if (!_internal_has_group()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return group_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void ACL_ChanACL::set_allocated_group(std::string* group) { + if (group != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + group_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), group, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:MumbleProto.ACL.ChanACL.group) +} + +// optional uint32 grant = 6; +inline bool ACL_ChanACL::_internal_has_grant() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ACL_ChanACL::has_grant() const { + return _internal_has_grant(); +} +inline void ACL_ChanACL::clear_grant() { + grant_ = 0u; + _has_bits_[0] &= ~0x00000004u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ACL_ChanACL::_internal_grant() const { + return grant_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ACL_ChanACL::grant() const { + // @@protoc_insertion_point(field_get:MumbleProto.ACL.ChanACL.grant) + return _internal_grant(); +} +inline void ACL_ChanACL::_internal_set_grant(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000004u; + grant_ = value; +} +inline void ACL_ChanACL::set_grant(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_grant(value); + // @@protoc_insertion_point(field_set:MumbleProto.ACL.ChanACL.grant) +} + +// optional uint32 deny = 7; +inline bool ACL_ChanACL::_internal_has_deny() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool ACL_ChanACL::has_deny() const { + return _internal_has_deny(); +} +inline void ACL_ChanACL::clear_deny() { + deny_ = 0u; + _has_bits_[0] &= ~0x00000008u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ACL_ChanACL::_internal_deny() const { + return deny_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ACL_ChanACL::deny() const { + // @@protoc_insertion_point(field_get:MumbleProto.ACL.ChanACL.deny) + return _internal_deny(); +} +inline void ACL_ChanACL::_internal_set_deny(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000008u; + deny_ = value; +} +inline void ACL_ChanACL::set_deny(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_deny(value); + // @@protoc_insertion_point(field_set:MumbleProto.ACL.ChanACL.deny) +} + +// ------------------------------------------------------------------- + +// ACL + +// required uint32 channel_id = 1; +inline bool ACL::_internal_has_channel_id() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ACL::has_channel_id() const { + return _internal_has_channel_id(); +} +inline void ACL::clear_channel_id() { + channel_id_ = 0u; + _has_bits_[0] &= ~0x00000001u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ACL::_internal_channel_id() const { + return channel_id_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ACL::channel_id() const { + // @@protoc_insertion_point(field_get:MumbleProto.ACL.channel_id) + return _internal_channel_id(); +} +inline void ACL::_internal_set_channel_id(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000001u; + channel_id_ = value; +} +inline void ACL::set_channel_id(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_channel_id(value); + // @@protoc_insertion_point(field_set:MumbleProto.ACL.channel_id) +} + +// optional bool inherit_acls = 2 [default = true]; +inline bool ACL::_internal_has_inherit_acls() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ACL::has_inherit_acls() const { + return _internal_has_inherit_acls(); +} +inline void ACL::clear_inherit_acls() { + inherit_acls_ = true; + _has_bits_[0] &= ~0x00000004u; +} +inline bool ACL::_internal_inherit_acls() const { + return inherit_acls_; +} +inline bool ACL::inherit_acls() const { + // @@protoc_insertion_point(field_get:MumbleProto.ACL.inherit_acls) + return _internal_inherit_acls(); +} +inline void ACL::_internal_set_inherit_acls(bool value) { + _has_bits_[0] |= 0x00000004u; + inherit_acls_ = value; +} +inline void ACL::set_inherit_acls(bool value) { + _internal_set_inherit_acls(value); + // @@protoc_insertion_point(field_set:MumbleProto.ACL.inherit_acls) +} + +// repeated .MumbleProto.ACL.ChanGroup groups = 3; +inline int ACL::_internal_groups_size() const { + return groups_.size(); +} +inline int ACL::groups_size() const { + return _internal_groups_size(); +} +inline void ACL::clear_groups() { + groups_.Clear(); +} +inline ::MumbleProto::ACL_ChanGroup* ACL::mutable_groups(int index) { + // @@protoc_insertion_point(field_mutable:MumbleProto.ACL.groups) + return groups_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MumbleProto::ACL_ChanGroup >* +ACL::mutable_groups() { + // @@protoc_insertion_point(field_mutable_list:MumbleProto.ACL.groups) + return &groups_; +} +inline const ::MumbleProto::ACL_ChanGroup& ACL::_internal_groups(int index) const { + return groups_.Get(index); +} +inline const ::MumbleProto::ACL_ChanGroup& ACL::groups(int index) const { + // @@protoc_insertion_point(field_get:MumbleProto.ACL.groups) + return _internal_groups(index); +} +inline ::MumbleProto::ACL_ChanGroup* ACL::_internal_add_groups() { + return groups_.Add(); +} +inline ::MumbleProto::ACL_ChanGroup* ACL::add_groups() { + // @@protoc_insertion_point(field_add:MumbleProto.ACL.groups) + return _internal_add_groups(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MumbleProto::ACL_ChanGroup >& +ACL::groups() const { + // @@protoc_insertion_point(field_list:MumbleProto.ACL.groups) + return groups_; +} + +// repeated .MumbleProto.ACL.ChanACL acls = 4; +inline int ACL::_internal_acls_size() const { + return acls_.size(); +} +inline int ACL::acls_size() const { + return _internal_acls_size(); +} +inline void ACL::clear_acls() { + acls_.Clear(); +} +inline ::MumbleProto::ACL_ChanACL* ACL::mutable_acls(int index) { + // @@protoc_insertion_point(field_mutable:MumbleProto.ACL.acls) + return acls_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MumbleProto::ACL_ChanACL >* +ACL::mutable_acls() { + // @@protoc_insertion_point(field_mutable_list:MumbleProto.ACL.acls) + return &acls_; +} +inline const ::MumbleProto::ACL_ChanACL& ACL::_internal_acls(int index) const { + return acls_.Get(index); +} +inline const ::MumbleProto::ACL_ChanACL& ACL::acls(int index) const { + // @@protoc_insertion_point(field_get:MumbleProto.ACL.acls) + return _internal_acls(index); +} +inline ::MumbleProto::ACL_ChanACL* ACL::_internal_add_acls() { + return acls_.Add(); +} +inline ::MumbleProto::ACL_ChanACL* ACL::add_acls() { + // @@protoc_insertion_point(field_add:MumbleProto.ACL.acls) + return _internal_add_acls(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MumbleProto::ACL_ChanACL >& +ACL::acls() const { + // @@protoc_insertion_point(field_list:MumbleProto.ACL.acls) + return acls_; +} + +// optional bool query = 5 [default = false]; +inline bool ACL::_internal_has_query() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ACL::has_query() const { + return _internal_has_query(); +} +inline void ACL::clear_query() { + query_ = false; + _has_bits_[0] &= ~0x00000002u; +} +inline bool ACL::_internal_query() const { + return query_; +} +inline bool ACL::query() const { + // @@protoc_insertion_point(field_get:MumbleProto.ACL.query) + return _internal_query(); +} +inline void ACL::_internal_set_query(bool value) { + _has_bits_[0] |= 0x00000002u; + query_ = value; +} +inline void ACL::set_query(bool value) { + _internal_set_query(value); + // @@protoc_insertion_point(field_set:MumbleProto.ACL.query) +} + +// ------------------------------------------------------------------- + +// QueryUsers + +// repeated uint32 ids = 1; +inline int QueryUsers::_internal_ids_size() const { + return ids_.size(); +} +inline int QueryUsers::ids_size() const { + return _internal_ids_size(); +} +inline void QueryUsers::clear_ids() { + ids_.Clear(); +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 QueryUsers::_internal_ids(int index) const { + return ids_.Get(index); +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 QueryUsers::ids(int index) const { + // @@protoc_insertion_point(field_get:MumbleProto.QueryUsers.ids) + return _internal_ids(index); +} +inline void QueryUsers::set_ids(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value) { + ids_.Set(index, value); + // @@protoc_insertion_point(field_set:MumbleProto.QueryUsers.ids) +} +inline void QueryUsers::_internal_add_ids(::PROTOBUF_NAMESPACE_ID::uint32 value) { + ids_.Add(value); +} +inline void QueryUsers::add_ids(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_add_ids(value); + // @@protoc_insertion_point(field_add:MumbleProto.QueryUsers.ids) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& +QueryUsers::_internal_ids() const { + return ids_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& +QueryUsers::ids() const { + // @@protoc_insertion_point(field_list:MumbleProto.QueryUsers.ids) + return _internal_ids(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* +QueryUsers::_internal_mutable_ids() { + return &ids_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* +QueryUsers::mutable_ids() { + // @@protoc_insertion_point(field_mutable_list:MumbleProto.QueryUsers.ids) + return _internal_mutable_ids(); +} + +// repeated string names = 2; +inline int QueryUsers::_internal_names_size() const { + return names_.size(); +} +inline int QueryUsers::names_size() const { + return _internal_names_size(); +} +inline void QueryUsers::clear_names() { + names_.Clear(); +} +inline std::string* QueryUsers::add_names() { + // @@protoc_insertion_point(field_add_mutable:MumbleProto.QueryUsers.names) + return _internal_add_names(); +} +inline const std::string& QueryUsers::_internal_names(int index) const { + return names_.Get(index); +} +inline const std::string& QueryUsers::names(int index) const { + // @@protoc_insertion_point(field_get:MumbleProto.QueryUsers.names) + return _internal_names(index); +} +inline std::string* QueryUsers::mutable_names(int index) { + // @@protoc_insertion_point(field_mutable:MumbleProto.QueryUsers.names) + return names_.Mutable(index); +} +inline void QueryUsers::set_names(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:MumbleProto.QueryUsers.names) + names_.Mutable(index)->assign(value); +} +inline void QueryUsers::set_names(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:MumbleProto.QueryUsers.names) + names_.Mutable(index)->assign(std::move(value)); +} +inline void QueryUsers::set_names(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + names_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:MumbleProto.QueryUsers.names) +} +inline void QueryUsers::set_names(int index, const char* value, size_t size) { + names_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.QueryUsers.names) +} +inline std::string* QueryUsers::_internal_add_names() { + return names_.Add(); +} +inline void QueryUsers::add_names(const std::string& value) { + names_.Add()->assign(value); + // @@protoc_insertion_point(field_add:MumbleProto.QueryUsers.names) +} +inline void QueryUsers::add_names(std::string&& value) { + names_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:MumbleProto.QueryUsers.names) +} +inline void QueryUsers::add_names(const char* value) { + GOOGLE_DCHECK(value != nullptr); + names_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:MumbleProto.QueryUsers.names) +} +inline void QueryUsers::add_names(const char* value, size_t size) { + names_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:MumbleProto.QueryUsers.names) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +QueryUsers::names() const { + // @@protoc_insertion_point(field_list:MumbleProto.QueryUsers.names) + return names_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +QueryUsers::mutable_names() { + // @@protoc_insertion_point(field_mutable_list:MumbleProto.QueryUsers.names) + return &names_; +} + +// ------------------------------------------------------------------- + +// CryptSetup + +// optional bytes key = 1; +inline bool CryptSetup::_internal_has_key() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool CryptSetup::has_key() const { + return _internal_has_key(); +} +inline void CryptSetup::clear_key() { + key_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& CryptSetup::key() const { + // @@protoc_insertion_point(field_get:MumbleProto.CryptSetup.key) + return _internal_key(); +} +inline void CryptSetup::set_key(const std::string& value) { + _internal_set_key(value); + // @@protoc_insertion_point(field_set:MumbleProto.CryptSetup.key) +} +inline std::string* CryptSetup::mutable_key() { + // @@protoc_insertion_point(field_mutable:MumbleProto.CryptSetup.key) + return _internal_mutable_key(); +} +inline const std::string& CryptSetup::_internal_key() const { + return key_.Get(); +} +inline void CryptSetup::_internal_set_key(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void CryptSetup::set_key(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + key_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:MumbleProto.CryptSetup.key) +} +inline void CryptSetup::set_key(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:MumbleProto.CryptSetup.key) +} +inline void CryptSetup::set_key(const void* value, + size_t size) { + _has_bits_[0] |= 0x00000001u; + key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.CryptSetup.key) +} +inline std::string* CryptSetup::_internal_mutable_key() { + _has_bits_[0] |= 0x00000001u; + return key_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* CryptSetup::release_key() { + // @@protoc_insertion_point(field_release:MumbleProto.CryptSetup.key) + if (!_internal_has_key()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void CryptSetup::set_allocated_key(std::string* key) { + if (key != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:MumbleProto.CryptSetup.key) +} + +// optional bytes client_nonce = 2; +inline bool CryptSetup::_internal_has_client_nonce() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool CryptSetup::has_client_nonce() const { + return _internal_has_client_nonce(); +} +inline void CryptSetup::clear_client_nonce() { + client_nonce_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000002u; +} +inline const std::string& CryptSetup::client_nonce() const { + // @@protoc_insertion_point(field_get:MumbleProto.CryptSetup.client_nonce) + return _internal_client_nonce(); +} +inline void CryptSetup::set_client_nonce(const std::string& value) { + _internal_set_client_nonce(value); + // @@protoc_insertion_point(field_set:MumbleProto.CryptSetup.client_nonce) +} +inline std::string* CryptSetup::mutable_client_nonce() { + // @@protoc_insertion_point(field_mutable:MumbleProto.CryptSetup.client_nonce) + return _internal_mutable_client_nonce(); +} +inline const std::string& CryptSetup::_internal_client_nonce() const { + return client_nonce_.Get(); +} +inline void CryptSetup::_internal_set_client_nonce(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + client_nonce_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void CryptSetup::set_client_nonce(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + client_nonce_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:MumbleProto.CryptSetup.client_nonce) +} +inline void CryptSetup::set_client_nonce(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + client_nonce_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:MumbleProto.CryptSetup.client_nonce) +} +inline void CryptSetup::set_client_nonce(const void* value, + size_t size) { + _has_bits_[0] |= 0x00000002u; + client_nonce_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.CryptSetup.client_nonce) +} +inline std::string* CryptSetup::_internal_mutable_client_nonce() { + _has_bits_[0] |= 0x00000002u; + return client_nonce_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* CryptSetup::release_client_nonce() { + // @@protoc_insertion_point(field_release:MumbleProto.CryptSetup.client_nonce) + if (!_internal_has_client_nonce()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + return client_nonce_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void CryptSetup::set_allocated_client_nonce(std::string* client_nonce) { + if (client_nonce != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + client_nonce_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), client_nonce, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:MumbleProto.CryptSetup.client_nonce) +} + +// optional bytes server_nonce = 3; +inline bool CryptSetup::_internal_has_server_nonce() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool CryptSetup::has_server_nonce() const { + return _internal_has_server_nonce(); +} +inline void CryptSetup::clear_server_nonce() { + server_nonce_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000004u; +} +inline const std::string& CryptSetup::server_nonce() const { + // @@protoc_insertion_point(field_get:MumbleProto.CryptSetup.server_nonce) + return _internal_server_nonce(); +} +inline void CryptSetup::set_server_nonce(const std::string& value) { + _internal_set_server_nonce(value); + // @@protoc_insertion_point(field_set:MumbleProto.CryptSetup.server_nonce) +} +inline std::string* CryptSetup::mutable_server_nonce() { + // @@protoc_insertion_point(field_mutable:MumbleProto.CryptSetup.server_nonce) + return _internal_mutable_server_nonce(); +} +inline const std::string& CryptSetup::_internal_server_nonce() const { + return server_nonce_.Get(); +} +inline void CryptSetup::_internal_set_server_nonce(const std::string& value) { + _has_bits_[0] |= 0x00000004u; + server_nonce_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void CryptSetup::set_server_nonce(std::string&& value) { + _has_bits_[0] |= 0x00000004u; + server_nonce_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:MumbleProto.CryptSetup.server_nonce) +} +inline void CryptSetup::set_server_nonce(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000004u; + server_nonce_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:MumbleProto.CryptSetup.server_nonce) +} +inline void CryptSetup::set_server_nonce(const void* value, + size_t size) { + _has_bits_[0] |= 0x00000004u; + server_nonce_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.CryptSetup.server_nonce) +} +inline std::string* CryptSetup::_internal_mutable_server_nonce() { + _has_bits_[0] |= 0x00000004u; + return server_nonce_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* CryptSetup::release_server_nonce() { + // @@protoc_insertion_point(field_release:MumbleProto.CryptSetup.server_nonce) + if (!_internal_has_server_nonce()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000004u; + return server_nonce_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void CryptSetup::set_allocated_server_nonce(std::string* server_nonce) { + if (server_nonce != nullptr) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + server_nonce_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), server_nonce, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:MumbleProto.CryptSetup.server_nonce) +} + +// ------------------------------------------------------------------- + +// ContextActionModify + +// required string action = 1; +inline bool ContextActionModify::_internal_has_action() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ContextActionModify::has_action() const { + return _internal_has_action(); +} +inline void ContextActionModify::clear_action() { + action_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ContextActionModify::action() const { + // @@protoc_insertion_point(field_get:MumbleProto.ContextActionModify.action) + return _internal_action(); +} +inline void ContextActionModify::set_action(const std::string& value) { + _internal_set_action(value); + // @@protoc_insertion_point(field_set:MumbleProto.ContextActionModify.action) +} +inline std::string* ContextActionModify::mutable_action() { + // @@protoc_insertion_point(field_mutable:MumbleProto.ContextActionModify.action) + return _internal_mutable_action(); +} +inline const std::string& ContextActionModify::_internal_action() const { + return action_.Get(); +} +inline void ContextActionModify::_internal_set_action(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + action_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void ContextActionModify::set_action(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + action_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:MumbleProto.ContextActionModify.action) +} +inline void ContextActionModify::set_action(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + action_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:MumbleProto.ContextActionModify.action) +} +inline void ContextActionModify::set_action(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000001u; + action_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.ContextActionModify.action) +} +inline std::string* ContextActionModify::_internal_mutable_action() { + _has_bits_[0] |= 0x00000001u; + return action_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* ContextActionModify::release_action() { + // @@protoc_insertion_point(field_release:MumbleProto.ContextActionModify.action) + if (!_internal_has_action()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return action_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void ContextActionModify::set_allocated_action(std::string* action) { + if (action != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + action_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), action, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:MumbleProto.ContextActionModify.action) +} + +// optional string text = 2; +inline bool ContextActionModify::_internal_has_text() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ContextActionModify::has_text() const { + return _internal_has_text(); +} +inline void ContextActionModify::clear_text() { + text_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000002u; +} +inline const std::string& ContextActionModify::text() const { + // @@protoc_insertion_point(field_get:MumbleProto.ContextActionModify.text) + return _internal_text(); +} +inline void ContextActionModify::set_text(const std::string& value) { + _internal_set_text(value); + // @@protoc_insertion_point(field_set:MumbleProto.ContextActionModify.text) +} +inline std::string* ContextActionModify::mutable_text() { + // @@protoc_insertion_point(field_mutable:MumbleProto.ContextActionModify.text) + return _internal_mutable_text(); +} +inline const std::string& ContextActionModify::_internal_text() const { + return text_.Get(); +} +inline void ContextActionModify::_internal_set_text(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + text_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void ContextActionModify::set_text(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + text_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:MumbleProto.ContextActionModify.text) +} +inline void ContextActionModify::set_text(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + text_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:MumbleProto.ContextActionModify.text) +} +inline void ContextActionModify::set_text(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000002u; + text_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.ContextActionModify.text) +} +inline std::string* ContextActionModify::_internal_mutable_text() { + _has_bits_[0] |= 0x00000002u; + return text_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* ContextActionModify::release_text() { + // @@protoc_insertion_point(field_release:MumbleProto.ContextActionModify.text) + if (!_internal_has_text()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + return text_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void ContextActionModify::set_allocated_text(std::string* text) { + if (text != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + text_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), text, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:MumbleProto.ContextActionModify.text) +} + +// optional uint32 context = 3; +inline bool ContextActionModify::_internal_has_context() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ContextActionModify::has_context() const { + return _internal_has_context(); +} +inline void ContextActionModify::clear_context() { + context_ = 0u; + _has_bits_[0] &= ~0x00000004u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ContextActionModify::_internal_context() const { + return context_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ContextActionModify::context() const { + // @@protoc_insertion_point(field_get:MumbleProto.ContextActionModify.context) + return _internal_context(); +} +inline void ContextActionModify::_internal_set_context(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000004u; + context_ = value; +} +inline void ContextActionModify::set_context(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_context(value); + // @@protoc_insertion_point(field_set:MumbleProto.ContextActionModify.context) +} + +// optional .MumbleProto.ContextActionModify.Operation operation = 4; +inline bool ContextActionModify::_internal_has_operation() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool ContextActionModify::has_operation() const { + return _internal_has_operation(); +} +inline void ContextActionModify::clear_operation() { + operation_ = 0; + _has_bits_[0] &= ~0x00000008u; +} +inline ::MumbleProto::ContextActionModify_Operation ContextActionModify::_internal_operation() const { + return static_cast< ::MumbleProto::ContextActionModify_Operation >(operation_); +} +inline ::MumbleProto::ContextActionModify_Operation ContextActionModify::operation() const { + // @@protoc_insertion_point(field_get:MumbleProto.ContextActionModify.operation) + return _internal_operation(); +} +inline void ContextActionModify::_internal_set_operation(::MumbleProto::ContextActionModify_Operation value) { + assert(::MumbleProto::ContextActionModify_Operation_IsValid(value)); + _has_bits_[0] |= 0x00000008u; + operation_ = value; +} +inline void ContextActionModify::set_operation(::MumbleProto::ContextActionModify_Operation value) { + _internal_set_operation(value); + // @@protoc_insertion_point(field_set:MumbleProto.ContextActionModify.operation) +} + +// ------------------------------------------------------------------- + +// ContextAction + +// optional uint32 session = 1; +inline bool ContextAction::_internal_has_session() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ContextAction::has_session() const { + return _internal_has_session(); +} +inline void ContextAction::clear_session() { + session_ = 0u; + _has_bits_[0] &= ~0x00000002u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ContextAction::_internal_session() const { + return session_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ContextAction::session() const { + // @@protoc_insertion_point(field_get:MumbleProto.ContextAction.session) + return _internal_session(); +} +inline void ContextAction::_internal_set_session(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000002u; + session_ = value; +} +inline void ContextAction::set_session(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_session(value); + // @@protoc_insertion_point(field_set:MumbleProto.ContextAction.session) +} + +// optional uint32 channel_id = 2; +inline bool ContextAction::_internal_has_channel_id() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ContextAction::has_channel_id() const { + return _internal_has_channel_id(); +} +inline void ContextAction::clear_channel_id() { + channel_id_ = 0u; + _has_bits_[0] &= ~0x00000004u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ContextAction::_internal_channel_id() const { + return channel_id_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ContextAction::channel_id() const { + // @@protoc_insertion_point(field_get:MumbleProto.ContextAction.channel_id) + return _internal_channel_id(); +} +inline void ContextAction::_internal_set_channel_id(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000004u; + channel_id_ = value; +} +inline void ContextAction::set_channel_id(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_channel_id(value); + // @@protoc_insertion_point(field_set:MumbleProto.ContextAction.channel_id) +} + +// required string action = 3; +inline bool ContextAction::_internal_has_action() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ContextAction::has_action() const { + return _internal_has_action(); +} +inline void ContextAction::clear_action() { + action_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ContextAction::action() const { + // @@protoc_insertion_point(field_get:MumbleProto.ContextAction.action) + return _internal_action(); +} +inline void ContextAction::set_action(const std::string& value) { + _internal_set_action(value); + // @@protoc_insertion_point(field_set:MumbleProto.ContextAction.action) +} +inline std::string* ContextAction::mutable_action() { + // @@protoc_insertion_point(field_mutable:MumbleProto.ContextAction.action) + return _internal_mutable_action(); +} +inline const std::string& ContextAction::_internal_action() const { + return action_.Get(); +} +inline void ContextAction::_internal_set_action(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + action_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void ContextAction::set_action(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + action_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:MumbleProto.ContextAction.action) +} +inline void ContextAction::set_action(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + action_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:MumbleProto.ContextAction.action) +} +inline void ContextAction::set_action(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000001u; + action_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.ContextAction.action) +} +inline std::string* ContextAction::_internal_mutable_action() { + _has_bits_[0] |= 0x00000001u; + return action_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* ContextAction::release_action() { + // @@protoc_insertion_point(field_release:MumbleProto.ContextAction.action) + if (!_internal_has_action()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return action_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void ContextAction::set_allocated_action(std::string* action) { + if (action != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + action_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), action, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:MumbleProto.ContextAction.action) +} + +// ------------------------------------------------------------------- + +// UserList_User + +// required uint32 user_id = 1; +inline bool UserList_User::_internal_has_user_id() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool UserList_User::has_user_id() const { + return _internal_has_user_id(); +} +inline void UserList_User::clear_user_id() { + user_id_ = 0u; + _has_bits_[0] &= ~0x00000004u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 UserList_User::_internal_user_id() const { + return user_id_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 UserList_User::user_id() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserList.User.user_id) + return _internal_user_id(); +} +inline void UserList_User::_internal_set_user_id(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000004u; + user_id_ = value; +} +inline void UserList_User::set_user_id(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_user_id(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserList.User.user_id) +} + +// optional string name = 2; +inline bool UserList_User::_internal_has_name() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool UserList_User::has_name() const { + return _internal_has_name(); +} +inline void UserList_User::clear_name() { + name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& UserList_User::name() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserList.User.name) + return _internal_name(); +} +inline void UserList_User::set_name(const std::string& value) { + _internal_set_name(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserList.User.name) +} +inline std::string* UserList_User::mutable_name() { + // @@protoc_insertion_point(field_mutable:MumbleProto.UserList.User.name) + return _internal_mutable_name(); +} +inline const std::string& UserList_User::_internal_name() const { + return name_.Get(); +} +inline void UserList_User::_internal_set_name(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void UserList_User::set_name(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + name_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:MumbleProto.UserList.User.name) +} +inline void UserList_User::set_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:MumbleProto.UserList.User.name) +} +inline void UserList_User::set_name(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000001u; + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.UserList.User.name) +} +inline std::string* UserList_User::_internal_mutable_name() { + _has_bits_[0] |= 0x00000001u; + return name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* UserList_User::release_name() { + // @@protoc_insertion_point(field_release:MumbleProto.UserList.User.name) + if (!_internal_has_name()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void UserList_User::set_allocated_name(std::string* name) { + if (name != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:MumbleProto.UserList.User.name) +} + +// optional string last_seen = 3; +inline bool UserList_User::_internal_has_last_seen() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool UserList_User::has_last_seen() const { + return _internal_has_last_seen(); +} +inline void UserList_User::clear_last_seen() { + last_seen_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000002u; +} +inline const std::string& UserList_User::last_seen() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserList.User.last_seen) + return _internal_last_seen(); +} +inline void UserList_User::set_last_seen(const std::string& value) { + _internal_set_last_seen(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserList.User.last_seen) +} +inline std::string* UserList_User::mutable_last_seen() { + // @@protoc_insertion_point(field_mutable:MumbleProto.UserList.User.last_seen) + return _internal_mutable_last_seen(); +} +inline const std::string& UserList_User::_internal_last_seen() const { + return last_seen_.Get(); +} +inline void UserList_User::_internal_set_last_seen(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + last_seen_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void UserList_User::set_last_seen(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + last_seen_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:MumbleProto.UserList.User.last_seen) +} +inline void UserList_User::set_last_seen(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + last_seen_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:MumbleProto.UserList.User.last_seen) +} +inline void UserList_User::set_last_seen(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000002u; + last_seen_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.UserList.User.last_seen) +} +inline std::string* UserList_User::_internal_mutable_last_seen() { + _has_bits_[0] |= 0x00000002u; + return last_seen_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* UserList_User::release_last_seen() { + // @@protoc_insertion_point(field_release:MumbleProto.UserList.User.last_seen) + if (!_internal_has_last_seen()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + return last_seen_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void UserList_User::set_allocated_last_seen(std::string* last_seen) { + if (last_seen != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + last_seen_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), last_seen, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:MumbleProto.UserList.User.last_seen) +} + +// optional uint32 last_channel = 4; +inline bool UserList_User::_internal_has_last_channel() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool UserList_User::has_last_channel() const { + return _internal_has_last_channel(); +} +inline void UserList_User::clear_last_channel() { + last_channel_ = 0u; + _has_bits_[0] &= ~0x00000008u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 UserList_User::_internal_last_channel() const { + return last_channel_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 UserList_User::last_channel() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserList.User.last_channel) + return _internal_last_channel(); +} +inline void UserList_User::_internal_set_last_channel(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000008u; + last_channel_ = value; +} +inline void UserList_User::set_last_channel(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_last_channel(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserList.User.last_channel) +} + +// ------------------------------------------------------------------- + +// UserList + +// repeated .MumbleProto.UserList.User users = 1; +inline int UserList::_internal_users_size() const { + return users_.size(); +} +inline int UserList::users_size() const { + return _internal_users_size(); +} +inline void UserList::clear_users() { + users_.Clear(); +} +inline ::MumbleProto::UserList_User* UserList::mutable_users(int index) { + // @@protoc_insertion_point(field_mutable:MumbleProto.UserList.users) + return users_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MumbleProto::UserList_User >* +UserList::mutable_users() { + // @@protoc_insertion_point(field_mutable_list:MumbleProto.UserList.users) + return &users_; +} +inline const ::MumbleProto::UserList_User& UserList::_internal_users(int index) const { + return users_.Get(index); +} +inline const ::MumbleProto::UserList_User& UserList::users(int index) const { + // @@protoc_insertion_point(field_get:MumbleProto.UserList.users) + return _internal_users(index); +} +inline ::MumbleProto::UserList_User* UserList::_internal_add_users() { + return users_.Add(); +} +inline ::MumbleProto::UserList_User* UserList::add_users() { + // @@protoc_insertion_point(field_add:MumbleProto.UserList.users) + return _internal_add_users(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MumbleProto::UserList_User >& +UserList::users() const { + // @@protoc_insertion_point(field_list:MumbleProto.UserList.users) + return users_; +} + +// ------------------------------------------------------------------- + +// VoiceTarget_Target + +// repeated uint32 session = 1; +inline int VoiceTarget_Target::_internal_session_size() const { + return session_.size(); +} +inline int VoiceTarget_Target::session_size() const { + return _internal_session_size(); +} +inline void VoiceTarget_Target::clear_session() { + session_.Clear(); +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 VoiceTarget_Target::_internal_session(int index) const { + return session_.Get(index); +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 VoiceTarget_Target::session(int index) const { + // @@protoc_insertion_point(field_get:MumbleProto.VoiceTarget.Target.session) + return _internal_session(index); +} +inline void VoiceTarget_Target::set_session(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value) { + session_.Set(index, value); + // @@protoc_insertion_point(field_set:MumbleProto.VoiceTarget.Target.session) +} +inline void VoiceTarget_Target::_internal_add_session(::PROTOBUF_NAMESPACE_ID::uint32 value) { + session_.Add(value); +} +inline void VoiceTarget_Target::add_session(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_add_session(value); + // @@protoc_insertion_point(field_add:MumbleProto.VoiceTarget.Target.session) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& +VoiceTarget_Target::_internal_session() const { + return session_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& +VoiceTarget_Target::session() const { + // @@protoc_insertion_point(field_list:MumbleProto.VoiceTarget.Target.session) + return _internal_session(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* +VoiceTarget_Target::_internal_mutable_session() { + return &session_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* +VoiceTarget_Target::mutable_session() { + // @@protoc_insertion_point(field_mutable_list:MumbleProto.VoiceTarget.Target.session) + return _internal_mutable_session(); +} + +// optional uint32 channel_id = 2; +inline bool VoiceTarget_Target::_internal_has_channel_id() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool VoiceTarget_Target::has_channel_id() const { + return _internal_has_channel_id(); +} +inline void VoiceTarget_Target::clear_channel_id() { + channel_id_ = 0u; + _has_bits_[0] &= ~0x00000002u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 VoiceTarget_Target::_internal_channel_id() const { + return channel_id_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 VoiceTarget_Target::channel_id() const { + // @@protoc_insertion_point(field_get:MumbleProto.VoiceTarget.Target.channel_id) + return _internal_channel_id(); +} +inline void VoiceTarget_Target::_internal_set_channel_id(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000002u; + channel_id_ = value; +} +inline void VoiceTarget_Target::set_channel_id(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_channel_id(value); + // @@protoc_insertion_point(field_set:MumbleProto.VoiceTarget.Target.channel_id) +} + +// optional string group = 3; +inline bool VoiceTarget_Target::_internal_has_group() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool VoiceTarget_Target::has_group() const { + return _internal_has_group(); +} +inline void VoiceTarget_Target::clear_group() { + group_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& VoiceTarget_Target::group() const { + // @@protoc_insertion_point(field_get:MumbleProto.VoiceTarget.Target.group) + return _internal_group(); +} +inline void VoiceTarget_Target::set_group(const std::string& value) { + _internal_set_group(value); + // @@protoc_insertion_point(field_set:MumbleProto.VoiceTarget.Target.group) +} +inline std::string* VoiceTarget_Target::mutable_group() { + // @@protoc_insertion_point(field_mutable:MumbleProto.VoiceTarget.Target.group) + return _internal_mutable_group(); +} +inline const std::string& VoiceTarget_Target::_internal_group() const { + return group_.Get(); +} +inline void VoiceTarget_Target::_internal_set_group(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + group_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void VoiceTarget_Target::set_group(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + group_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:MumbleProto.VoiceTarget.Target.group) +} +inline void VoiceTarget_Target::set_group(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + group_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:MumbleProto.VoiceTarget.Target.group) +} +inline void VoiceTarget_Target::set_group(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000001u; + group_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.VoiceTarget.Target.group) +} +inline std::string* VoiceTarget_Target::_internal_mutable_group() { + _has_bits_[0] |= 0x00000001u; + return group_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* VoiceTarget_Target::release_group() { + // @@protoc_insertion_point(field_release:MumbleProto.VoiceTarget.Target.group) + if (!_internal_has_group()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return group_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void VoiceTarget_Target::set_allocated_group(std::string* group) { + if (group != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + group_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), group, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:MumbleProto.VoiceTarget.Target.group) +} + +// optional bool links = 4 [default = false]; +inline bool VoiceTarget_Target::_internal_has_links() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool VoiceTarget_Target::has_links() const { + return _internal_has_links(); +} +inline void VoiceTarget_Target::clear_links() { + links_ = false; + _has_bits_[0] &= ~0x00000004u; +} +inline bool VoiceTarget_Target::_internal_links() const { + return links_; +} +inline bool VoiceTarget_Target::links() const { + // @@protoc_insertion_point(field_get:MumbleProto.VoiceTarget.Target.links) + return _internal_links(); +} +inline void VoiceTarget_Target::_internal_set_links(bool value) { + _has_bits_[0] |= 0x00000004u; + links_ = value; +} +inline void VoiceTarget_Target::set_links(bool value) { + _internal_set_links(value); + // @@protoc_insertion_point(field_set:MumbleProto.VoiceTarget.Target.links) +} + +// optional bool children = 5 [default = false]; +inline bool VoiceTarget_Target::_internal_has_children() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool VoiceTarget_Target::has_children() const { + return _internal_has_children(); +} +inline void VoiceTarget_Target::clear_children() { + children_ = false; + _has_bits_[0] &= ~0x00000008u; +} +inline bool VoiceTarget_Target::_internal_children() const { + return children_; +} +inline bool VoiceTarget_Target::children() const { + // @@protoc_insertion_point(field_get:MumbleProto.VoiceTarget.Target.children) + return _internal_children(); +} +inline void VoiceTarget_Target::_internal_set_children(bool value) { + _has_bits_[0] |= 0x00000008u; + children_ = value; +} +inline void VoiceTarget_Target::set_children(bool value) { + _internal_set_children(value); + // @@protoc_insertion_point(field_set:MumbleProto.VoiceTarget.Target.children) +} + +// ------------------------------------------------------------------- + +// VoiceTarget + +// optional uint32 id = 1; +inline bool VoiceTarget::_internal_has_id() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool VoiceTarget::has_id() const { + return _internal_has_id(); +} +inline void VoiceTarget::clear_id() { + id_ = 0u; + _has_bits_[0] &= ~0x00000001u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 VoiceTarget::_internal_id() const { + return id_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 VoiceTarget::id() const { + // @@protoc_insertion_point(field_get:MumbleProto.VoiceTarget.id) + return _internal_id(); +} +inline void VoiceTarget::_internal_set_id(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000001u; + id_ = value; +} +inline void VoiceTarget::set_id(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_id(value); + // @@protoc_insertion_point(field_set:MumbleProto.VoiceTarget.id) +} + +// repeated .MumbleProto.VoiceTarget.Target targets = 2; +inline int VoiceTarget::_internal_targets_size() const { + return targets_.size(); +} +inline int VoiceTarget::targets_size() const { + return _internal_targets_size(); +} +inline void VoiceTarget::clear_targets() { + targets_.Clear(); +} +inline ::MumbleProto::VoiceTarget_Target* VoiceTarget::mutable_targets(int index) { + // @@protoc_insertion_point(field_mutable:MumbleProto.VoiceTarget.targets) + return targets_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MumbleProto::VoiceTarget_Target >* +VoiceTarget::mutable_targets() { + // @@protoc_insertion_point(field_mutable_list:MumbleProto.VoiceTarget.targets) + return &targets_; +} +inline const ::MumbleProto::VoiceTarget_Target& VoiceTarget::_internal_targets(int index) const { + return targets_.Get(index); +} +inline const ::MumbleProto::VoiceTarget_Target& VoiceTarget::targets(int index) const { + // @@protoc_insertion_point(field_get:MumbleProto.VoiceTarget.targets) + return _internal_targets(index); +} +inline ::MumbleProto::VoiceTarget_Target* VoiceTarget::_internal_add_targets() { + return targets_.Add(); +} +inline ::MumbleProto::VoiceTarget_Target* VoiceTarget::add_targets() { + // @@protoc_insertion_point(field_add:MumbleProto.VoiceTarget.targets) + return _internal_add_targets(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MumbleProto::VoiceTarget_Target >& +VoiceTarget::targets() const { + // @@protoc_insertion_point(field_list:MumbleProto.VoiceTarget.targets) + return targets_; +} + +// ------------------------------------------------------------------- + +// PermissionQuery + +// optional uint32 channel_id = 1; +inline bool PermissionQuery::_internal_has_channel_id() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool PermissionQuery::has_channel_id() const { + return _internal_has_channel_id(); +} +inline void PermissionQuery::clear_channel_id() { + channel_id_ = 0u; + _has_bits_[0] &= ~0x00000001u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 PermissionQuery::_internal_channel_id() const { + return channel_id_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 PermissionQuery::channel_id() const { + // @@protoc_insertion_point(field_get:MumbleProto.PermissionQuery.channel_id) + return _internal_channel_id(); +} +inline void PermissionQuery::_internal_set_channel_id(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000001u; + channel_id_ = value; +} +inline void PermissionQuery::set_channel_id(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_channel_id(value); + // @@protoc_insertion_point(field_set:MumbleProto.PermissionQuery.channel_id) +} + +// optional uint32 permissions = 2; +inline bool PermissionQuery::_internal_has_permissions() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool PermissionQuery::has_permissions() const { + return _internal_has_permissions(); +} +inline void PermissionQuery::clear_permissions() { + permissions_ = 0u; + _has_bits_[0] &= ~0x00000002u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 PermissionQuery::_internal_permissions() const { + return permissions_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 PermissionQuery::permissions() const { + // @@protoc_insertion_point(field_get:MumbleProto.PermissionQuery.permissions) + return _internal_permissions(); +} +inline void PermissionQuery::_internal_set_permissions(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000002u; + permissions_ = value; +} +inline void PermissionQuery::set_permissions(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_permissions(value); + // @@protoc_insertion_point(field_set:MumbleProto.PermissionQuery.permissions) +} + +// optional bool flush = 3 [default = false]; +inline bool PermissionQuery::_internal_has_flush() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool PermissionQuery::has_flush() const { + return _internal_has_flush(); +} +inline void PermissionQuery::clear_flush() { + flush_ = false; + _has_bits_[0] &= ~0x00000004u; +} +inline bool PermissionQuery::_internal_flush() const { + return flush_; +} +inline bool PermissionQuery::flush() const { + // @@protoc_insertion_point(field_get:MumbleProto.PermissionQuery.flush) + return _internal_flush(); +} +inline void PermissionQuery::_internal_set_flush(bool value) { + _has_bits_[0] |= 0x00000004u; + flush_ = value; +} +inline void PermissionQuery::set_flush(bool value) { + _internal_set_flush(value); + // @@protoc_insertion_point(field_set:MumbleProto.PermissionQuery.flush) +} + +// ------------------------------------------------------------------- + +// CodecVersion + +// required int32 alpha = 1; +inline bool CodecVersion::_internal_has_alpha() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool CodecVersion::has_alpha() const { + return _internal_has_alpha(); +} +inline void CodecVersion::clear_alpha() { + alpha_ = 0; + _has_bits_[0] &= ~0x00000001u; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 CodecVersion::_internal_alpha() const { + return alpha_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 CodecVersion::alpha() const { + // @@protoc_insertion_point(field_get:MumbleProto.CodecVersion.alpha) + return _internal_alpha(); +} +inline void CodecVersion::_internal_set_alpha(::PROTOBUF_NAMESPACE_ID::int32 value) { + _has_bits_[0] |= 0x00000001u; + alpha_ = value; +} +inline void CodecVersion::set_alpha(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_set_alpha(value); + // @@protoc_insertion_point(field_set:MumbleProto.CodecVersion.alpha) +} + +// required int32 beta = 2; +inline bool CodecVersion::_internal_has_beta() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool CodecVersion::has_beta() const { + return _internal_has_beta(); +} +inline void CodecVersion::clear_beta() { + beta_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 CodecVersion::_internal_beta() const { + return beta_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 CodecVersion::beta() const { + // @@protoc_insertion_point(field_get:MumbleProto.CodecVersion.beta) + return _internal_beta(); +} +inline void CodecVersion::_internal_set_beta(::PROTOBUF_NAMESPACE_ID::int32 value) { + _has_bits_[0] |= 0x00000002u; + beta_ = value; +} +inline void CodecVersion::set_beta(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_set_beta(value); + // @@protoc_insertion_point(field_set:MumbleProto.CodecVersion.beta) +} + +// required bool prefer_alpha = 3 [default = true]; +inline bool CodecVersion::_internal_has_prefer_alpha() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool CodecVersion::has_prefer_alpha() const { + return _internal_has_prefer_alpha(); +} +inline void CodecVersion::clear_prefer_alpha() { + prefer_alpha_ = true; + _has_bits_[0] &= ~0x00000008u; +} +inline bool CodecVersion::_internal_prefer_alpha() const { + return prefer_alpha_; +} +inline bool CodecVersion::prefer_alpha() const { + // @@protoc_insertion_point(field_get:MumbleProto.CodecVersion.prefer_alpha) + return _internal_prefer_alpha(); +} +inline void CodecVersion::_internal_set_prefer_alpha(bool value) { + _has_bits_[0] |= 0x00000008u; + prefer_alpha_ = value; +} +inline void CodecVersion::set_prefer_alpha(bool value) { + _internal_set_prefer_alpha(value); + // @@protoc_insertion_point(field_set:MumbleProto.CodecVersion.prefer_alpha) +} + +// optional bool opus = 4 [default = false]; +inline bool CodecVersion::_internal_has_opus() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool CodecVersion::has_opus() const { + return _internal_has_opus(); +} +inline void CodecVersion::clear_opus() { + opus_ = false; + _has_bits_[0] &= ~0x00000004u; +} +inline bool CodecVersion::_internal_opus() const { + return opus_; +} +inline bool CodecVersion::opus() const { + // @@protoc_insertion_point(field_get:MumbleProto.CodecVersion.opus) + return _internal_opus(); +} +inline void CodecVersion::_internal_set_opus(bool value) { + _has_bits_[0] |= 0x00000004u; + opus_ = value; +} +inline void CodecVersion::set_opus(bool value) { + _internal_set_opus(value); + // @@protoc_insertion_point(field_set:MumbleProto.CodecVersion.opus) +} + +// ------------------------------------------------------------------- + +// UserStats_Stats + +// optional uint32 good = 1; +inline bool UserStats_Stats::_internal_has_good() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool UserStats_Stats::has_good() const { + return _internal_has_good(); +} +inline void UserStats_Stats::clear_good() { + good_ = 0u; + _has_bits_[0] &= ~0x00000001u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 UserStats_Stats::_internal_good() const { + return good_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 UserStats_Stats::good() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserStats.Stats.good) + return _internal_good(); +} +inline void UserStats_Stats::_internal_set_good(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000001u; + good_ = value; +} +inline void UserStats_Stats::set_good(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_good(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserStats.Stats.good) +} + +// optional uint32 late = 2; +inline bool UserStats_Stats::_internal_has_late() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool UserStats_Stats::has_late() const { + return _internal_has_late(); +} +inline void UserStats_Stats::clear_late() { + late_ = 0u; + _has_bits_[0] &= ~0x00000002u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 UserStats_Stats::_internal_late() const { + return late_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 UserStats_Stats::late() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserStats.Stats.late) + return _internal_late(); +} +inline void UserStats_Stats::_internal_set_late(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000002u; + late_ = value; +} +inline void UserStats_Stats::set_late(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_late(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserStats.Stats.late) +} + +// optional uint32 lost = 3; +inline bool UserStats_Stats::_internal_has_lost() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool UserStats_Stats::has_lost() const { + return _internal_has_lost(); +} +inline void UserStats_Stats::clear_lost() { + lost_ = 0u; + _has_bits_[0] &= ~0x00000004u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 UserStats_Stats::_internal_lost() const { + return lost_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 UserStats_Stats::lost() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserStats.Stats.lost) + return _internal_lost(); +} +inline void UserStats_Stats::_internal_set_lost(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000004u; + lost_ = value; +} +inline void UserStats_Stats::set_lost(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_lost(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserStats.Stats.lost) +} + +// optional uint32 resync = 4; +inline bool UserStats_Stats::_internal_has_resync() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool UserStats_Stats::has_resync() const { + return _internal_has_resync(); +} +inline void UserStats_Stats::clear_resync() { + resync_ = 0u; + _has_bits_[0] &= ~0x00000008u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 UserStats_Stats::_internal_resync() const { + return resync_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 UserStats_Stats::resync() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserStats.Stats.resync) + return _internal_resync(); +} +inline void UserStats_Stats::_internal_set_resync(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000008u; + resync_ = value; +} +inline void UserStats_Stats::set_resync(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_resync(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserStats.Stats.resync) +} + +// ------------------------------------------------------------------- + +// UserStats + +// optional uint32 session = 1; +inline bool UserStats::_internal_has_session() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool UserStats::has_session() const { + return _internal_has_session(); +} +inline void UserStats::clear_session() { + session_ = 0u; + _has_bits_[0] &= ~0x00000010u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 UserStats::_internal_session() const { + return session_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 UserStats::session() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserStats.session) + return _internal_session(); +} +inline void UserStats::_internal_set_session(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000010u; + session_ = value; +} +inline void UserStats::set_session(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_session(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserStats.session) +} + +// optional bool stats_only = 2 [default = false]; +inline bool UserStats::_internal_has_stats_only() const { + bool value = (_has_bits_[0] & 0x00000800u) != 0; + return value; +} +inline bool UserStats::has_stats_only() const { + return _internal_has_stats_only(); +} +inline void UserStats::clear_stats_only() { + stats_only_ = false; + _has_bits_[0] &= ~0x00000800u; +} +inline bool UserStats::_internal_stats_only() const { + return stats_only_; +} +inline bool UserStats::stats_only() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserStats.stats_only) + return _internal_stats_only(); +} +inline void UserStats::_internal_set_stats_only(bool value) { + _has_bits_[0] |= 0x00000800u; + stats_only_ = value; +} +inline void UserStats::set_stats_only(bool value) { + _internal_set_stats_only(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserStats.stats_only) +} + +// repeated bytes certificates = 3; +inline int UserStats::_internal_certificates_size() const { + return certificates_.size(); +} +inline int UserStats::certificates_size() const { + return _internal_certificates_size(); +} +inline void UserStats::clear_certificates() { + certificates_.Clear(); +} +inline std::string* UserStats::add_certificates() { + // @@protoc_insertion_point(field_add_mutable:MumbleProto.UserStats.certificates) + return _internal_add_certificates(); +} +inline const std::string& UserStats::_internal_certificates(int index) const { + return certificates_.Get(index); +} +inline const std::string& UserStats::certificates(int index) const { + // @@protoc_insertion_point(field_get:MumbleProto.UserStats.certificates) + return _internal_certificates(index); +} +inline std::string* UserStats::mutable_certificates(int index) { + // @@protoc_insertion_point(field_mutable:MumbleProto.UserStats.certificates) + return certificates_.Mutable(index); +} +inline void UserStats::set_certificates(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:MumbleProto.UserStats.certificates) + certificates_.Mutable(index)->assign(value); +} +inline void UserStats::set_certificates(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:MumbleProto.UserStats.certificates) + certificates_.Mutable(index)->assign(std::move(value)); +} +inline void UserStats::set_certificates(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + certificates_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:MumbleProto.UserStats.certificates) +} +inline void UserStats::set_certificates(int index, const void* value, size_t size) { + certificates_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.UserStats.certificates) +} +inline std::string* UserStats::_internal_add_certificates() { + return certificates_.Add(); +} +inline void UserStats::add_certificates(const std::string& value) { + certificates_.Add()->assign(value); + // @@protoc_insertion_point(field_add:MumbleProto.UserStats.certificates) +} +inline void UserStats::add_certificates(std::string&& value) { + certificates_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:MumbleProto.UserStats.certificates) +} +inline void UserStats::add_certificates(const char* value) { + GOOGLE_DCHECK(value != nullptr); + certificates_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:MumbleProto.UserStats.certificates) +} +inline void UserStats::add_certificates(const void* value, size_t size) { + certificates_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:MumbleProto.UserStats.certificates) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +UserStats::certificates() const { + // @@protoc_insertion_point(field_list:MumbleProto.UserStats.certificates) + return certificates_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +UserStats::mutable_certificates() { + // @@protoc_insertion_point(field_mutable_list:MumbleProto.UserStats.certificates) + return &certificates_; +} + +// optional .MumbleProto.UserStats.Stats from_client = 4; +inline bool UserStats::_internal_has_from_client() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || from_client_ != nullptr); + return value; +} +inline bool UserStats::has_from_client() const { + return _internal_has_from_client(); +} +inline void UserStats::clear_from_client() { + if (from_client_ != nullptr) from_client_->Clear(); + _has_bits_[0] &= ~0x00000002u; +} +inline const ::MumbleProto::UserStats_Stats& UserStats::_internal_from_client() const { + const ::MumbleProto::UserStats_Stats* p = from_client_; + return p != nullptr ? *p : *reinterpret_cast( + &::MumbleProto::_UserStats_Stats_default_instance_); +} +inline const ::MumbleProto::UserStats_Stats& UserStats::from_client() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserStats.from_client) + return _internal_from_client(); +} +inline void UserStats::unsafe_arena_set_allocated_from_client( + ::MumbleProto::UserStats_Stats* from_client) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(from_client_); + } + from_client_ = from_client; + if (from_client) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MumbleProto.UserStats.from_client) +} +inline ::MumbleProto::UserStats_Stats* UserStats::release_from_client() { + _has_bits_[0] &= ~0x00000002u; + ::MumbleProto::UserStats_Stats* temp = from_client_; + from_client_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::MumbleProto::UserStats_Stats* UserStats::unsafe_arena_release_from_client() { + // @@protoc_insertion_point(field_release:MumbleProto.UserStats.from_client) + _has_bits_[0] &= ~0x00000002u; + ::MumbleProto::UserStats_Stats* temp = from_client_; + from_client_ = nullptr; + return temp; +} +inline ::MumbleProto::UserStats_Stats* UserStats::_internal_mutable_from_client() { + _has_bits_[0] |= 0x00000002u; + if (from_client_ == nullptr) { + auto* p = CreateMaybeMessage<::MumbleProto::UserStats_Stats>(GetArena()); + from_client_ = p; + } + return from_client_; +} +inline ::MumbleProto::UserStats_Stats* UserStats::mutable_from_client() { + // @@protoc_insertion_point(field_mutable:MumbleProto.UserStats.from_client) + return _internal_mutable_from_client(); +} +inline void UserStats::set_allocated_from_client(::MumbleProto::UserStats_Stats* from_client) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete from_client_; + } + if (from_client) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(from_client); + if (message_arena != submessage_arena) { + from_client = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, from_client, submessage_arena); + } + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + from_client_ = from_client; + // @@protoc_insertion_point(field_set_allocated:MumbleProto.UserStats.from_client) +} + +// optional .MumbleProto.UserStats.Stats from_server = 5; +inline bool UserStats::_internal_has_from_server() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || from_server_ != nullptr); + return value; +} +inline bool UserStats::has_from_server() const { + return _internal_has_from_server(); +} +inline void UserStats::clear_from_server() { + if (from_server_ != nullptr) from_server_->Clear(); + _has_bits_[0] &= ~0x00000004u; +} +inline const ::MumbleProto::UserStats_Stats& UserStats::_internal_from_server() const { + const ::MumbleProto::UserStats_Stats* p = from_server_; + return p != nullptr ? *p : *reinterpret_cast( + &::MumbleProto::_UserStats_Stats_default_instance_); +} +inline const ::MumbleProto::UserStats_Stats& UserStats::from_server() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserStats.from_server) + return _internal_from_server(); +} +inline void UserStats::unsafe_arena_set_allocated_from_server( + ::MumbleProto::UserStats_Stats* from_server) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(from_server_); + } + from_server_ = from_server; + if (from_server) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MumbleProto.UserStats.from_server) +} +inline ::MumbleProto::UserStats_Stats* UserStats::release_from_server() { + _has_bits_[0] &= ~0x00000004u; + ::MumbleProto::UserStats_Stats* temp = from_server_; + from_server_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::MumbleProto::UserStats_Stats* UserStats::unsafe_arena_release_from_server() { + // @@protoc_insertion_point(field_release:MumbleProto.UserStats.from_server) + _has_bits_[0] &= ~0x00000004u; + ::MumbleProto::UserStats_Stats* temp = from_server_; + from_server_ = nullptr; + return temp; +} +inline ::MumbleProto::UserStats_Stats* UserStats::_internal_mutable_from_server() { + _has_bits_[0] |= 0x00000004u; + if (from_server_ == nullptr) { + auto* p = CreateMaybeMessage<::MumbleProto::UserStats_Stats>(GetArena()); + from_server_ = p; + } + return from_server_; +} +inline ::MumbleProto::UserStats_Stats* UserStats::mutable_from_server() { + // @@protoc_insertion_point(field_mutable:MumbleProto.UserStats.from_server) + return _internal_mutable_from_server(); +} +inline void UserStats::set_allocated_from_server(::MumbleProto::UserStats_Stats* from_server) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete from_server_; + } + if (from_server) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(from_server); + if (message_arena != submessage_arena) { + from_server = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, from_server, submessage_arena); + } + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + from_server_ = from_server; + // @@protoc_insertion_point(field_set_allocated:MumbleProto.UserStats.from_server) +} + +// optional uint32 udp_packets = 6; +inline bool UserStats::_internal_has_udp_packets() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool UserStats::has_udp_packets() const { + return _internal_has_udp_packets(); +} +inline void UserStats::clear_udp_packets() { + udp_packets_ = 0u; + _has_bits_[0] &= ~0x00000020u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 UserStats::_internal_udp_packets() const { + return udp_packets_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 UserStats::udp_packets() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserStats.udp_packets) + return _internal_udp_packets(); +} +inline void UserStats::_internal_set_udp_packets(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000020u; + udp_packets_ = value; +} +inline void UserStats::set_udp_packets(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_udp_packets(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserStats.udp_packets) +} + +// optional uint32 tcp_packets = 7; +inline bool UserStats::_internal_has_tcp_packets() const { + bool value = (_has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool UserStats::has_tcp_packets() const { + return _internal_has_tcp_packets(); +} +inline void UserStats::clear_tcp_packets() { + tcp_packets_ = 0u; + _has_bits_[0] &= ~0x00000040u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 UserStats::_internal_tcp_packets() const { + return tcp_packets_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 UserStats::tcp_packets() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserStats.tcp_packets) + return _internal_tcp_packets(); +} +inline void UserStats::_internal_set_tcp_packets(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000040u; + tcp_packets_ = value; +} +inline void UserStats::set_tcp_packets(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_tcp_packets(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserStats.tcp_packets) +} + +// optional float udp_ping_avg = 8; +inline bool UserStats::_internal_has_udp_ping_avg() const { + bool value = (_has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool UserStats::has_udp_ping_avg() const { + return _internal_has_udp_ping_avg(); +} +inline void UserStats::clear_udp_ping_avg() { + udp_ping_avg_ = 0; + _has_bits_[0] &= ~0x00000080u; +} +inline float UserStats::_internal_udp_ping_avg() const { + return udp_ping_avg_; +} +inline float UserStats::udp_ping_avg() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserStats.udp_ping_avg) + return _internal_udp_ping_avg(); +} +inline void UserStats::_internal_set_udp_ping_avg(float value) { + _has_bits_[0] |= 0x00000080u; + udp_ping_avg_ = value; +} +inline void UserStats::set_udp_ping_avg(float value) { + _internal_set_udp_ping_avg(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserStats.udp_ping_avg) +} + +// optional float udp_ping_var = 9; +inline bool UserStats::_internal_has_udp_ping_var() const { + bool value = (_has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool UserStats::has_udp_ping_var() const { + return _internal_has_udp_ping_var(); +} +inline void UserStats::clear_udp_ping_var() { + udp_ping_var_ = 0; + _has_bits_[0] &= ~0x00000100u; +} +inline float UserStats::_internal_udp_ping_var() const { + return udp_ping_var_; +} +inline float UserStats::udp_ping_var() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserStats.udp_ping_var) + return _internal_udp_ping_var(); +} +inline void UserStats::_internal_set_udp_ping_var(float value) { + _has_bits_[0] |= 0x00000100u; + udp_ping_var_ = value; +} +inline void UserStats::set_udp_ping_var(float value) { + _internal_set_udp_ping_var(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserStats.udp_ping_var) +} + +// optional float tcp_ping_avg = 10; +inline bool UserStats::_internal_has_tcp_ping_avg() const { + bool value = (_has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool UserStats::has_tcp_ping_avg() const { + return _internal_has_tcp_ping_avg(); +} +inline void UserStats::clear_tcp_ping_avg() { + tcp_ping_avg_ = 0; + _has_bits_[0] &= ~0x00000200u; +} +inline float UserStats::_internal_tcp_ping_avg() const { + return tcp_ping_avg_; +} +inline float UserStats::tcp_ping_avg() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserStats.tcp_ping_avg) + return _internal_tcp_ping_avg(); +} +inline void UserStats::_internal_set_tcp_ping_avg(float value) { + _has_bits_[0] |= 0x00000200u; + tcp_ping_avg_ = value; +} +inline void UserStats::set_tcp_ping_avg(float value) { + _internal_set_tcp_ping_avg(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserStats.tcp_ping_avg) +} + +// optional float tcp_ping_var = 11; +inline bool UserStats::_internal_has_tcp_ping_var() const { + bool value = (_has_bits_[0] & 0x00000400u) != 0; + return value; +} +inline bool UserStats::has_tcp_ping_var() const { + return _internal_has_tcp_ping_var(); +} +inline void UserStats::clear_tcp_ping_var() { + tcp_ping_var_ = 0; + _has_bits_[0] &= ~0x00000400u; +} +inline float UserStats::_internal_tcp_ping_var() const { + return tcp_ping_var_; +} +inline float UserStats::tcp_ping_var() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserStats.tcp_ping_var) + return _internal_tcp_ping_var(); +} +inline void UserStats::_internal_set_tcp_ping_var(float value) { + _has_bits_[0] |= 0x00000400u; + tcp_ping_var_ = value; +} +inline void UserStats::set_tcp_ping_var(float value) { + _internal_set_tcp_ping_var(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserStats.tcp_ping_var) +} + +// optional .MumbleProto.Version version = 12; +inline bool UserStats::_internal_has_version() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + PROTOBUF_ASSUME(!value || version_ != nullptr); + return value; +} +inline bool UserStats::has_version() const { + return _internal_has_version(); +} +inline void UserStats::clear_version() { + if (version_ != nullptr) version_->Clear(); + _has_bits_[0] &= ~0x00000008u; +} +inline const ::MumbleProto::Version& UserStats::_internal_version() const { + const ::MumbleProto::Version* p = version_; + return p != nullptr ? *p : *reinterpret_cast( + &::MumbleProto::_Version_default_instance_); +} +inline const ::MumbleProto::Version& UserStats::version() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserStats.version) + return _internal_version(); +} +inline void UserStats::unsafe_arena_set_allocated_version( + ::MumbleProto::Version* version) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(version_); + } + version_ = version; + if (version) { + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MumbleProto.UserStats.version) +} +inline ::MumbleProto::Version* UserStats::release_version() { + _has_bits_[0] &= ~0x00000008u; + ::MumbleProto::Version* temp = version_; + version_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::MumbleProto::Version* UserStats::unsafe_arena_release_version() { + // @@protoc_insertion_point(field_release:MumbleProto.UserStats.version) + _has_bits_[0] &= ~0x00000008u; + ::MumbleProto::Version* temp = version_; + version_ = nullptr; + return temp; +} +inline ::MumbleProto::Version* UserStats::_internal_mutable_version() { + _has_bits_[0] |= 0x00000008u; + if (version_ == nullptr) { + auto* p = CreateMaybeMessage<::MumbleProto::Version>(GetArena()); + version_ = p; + } + return version_; +} +inline ::MumbleProto::Version* UserStats::mutable_version() { + // @@protoc_insertion_point(field_mutable:MumbleProto.UserStats.version) + return _internal_mutable_version(); +} +inline void UserStats::set_allocated_version(::MumbleProto::Version* version) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete version_; + } + if (version) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(version); + if (message_arena != submessage_arena) { + version = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, version, submessage_arena); + } + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + version_ = version; + // @@protoc_insertion_point(field_set_allocated:MumbleProto.UserStats.version) +} + +// repeated int32 celt_versions = 13; +inline int UserStats::_internal_celt_versions_size() const { + return celt_versions_.size(); +} +inline int UserStats::celt_versions_size() const { + return _internal_celt_versions_size(); +} +inline void UserStats::clear_celt_versions() { + celt_versions_.Clear(); +} +inline ::PROTOBUF_NAMESPACE_ID::int32 UserStats::_internal_celt_versions(int index) const { + return celt_versions_.Get(index); +} +inline ::PROTOBUF_NAMESPACE_ID::int32 UserStats::celt_versions(int index) const { + // @@protoc_insertion_point(field_get:MumbleProto.UserStats.celt_versions) + return _internal_celt_versions(index); +} +inline void UserStats::set_celt_versions(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) { + celt_versions_.Set(index, value); + // @@protoc_insertion_point(field_set:MumbleProto.UserStats.celt_versions) +} +inline void UserStats::_internal_add_celt_versions(::PROTOBUF_NAMESPACE_ID::int32 value) { + celt_versions_.Add(value); +} +inline void UserStats::add_celt_versions(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_add_celt_versions(value); + // @@protoc_insertion_point(field_add:MumbleProto.UserStats.celt_versions) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& +UserStats::_internal_celt_versions() const { + return celt_versions_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& +UserStats::celt_versions() const { + // @@protoc_insertion_point(field_list:MumbleProto.UserStats.celt_versions) + return _internal_celt_versions(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* +UserStats::_internal_mutable_celt_versions() { + return &celt_versions_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* +UserStats::mutable_celt_versions() { + // @@protoc_insertion_point(field_mutable_list:MumbleProto.UserStats.celt_versions) + return _internal_mutable_celt_versions(); +} + +// optional bytes address = 14; +inline bool UserStats::_internal_has_address() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool UserStats::has_address() const { + return _internal_has_address(); +} +inline void UserStats::clear_address() { + address_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& UserStats::address() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserStats.address) + return _internal_address(); +} +inline void UserStats::set_address(const std::string& value) { + _internal_set_address(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserStats.address) +} +inline std::string* UserStats::mutable_address() { + // @@protoc_insertion_point(field_mutable:MumbleProto.UserStats.address) + return _internal_mutable_address(); +} +inline const std::string& UserStats::_internal_address() const { + return address_.Get(); +} +inline void UserStats::_internal_set_address(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void UserStats::set_address(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + address_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:MumbleProto.UserStats.address) +} +inline void UserStats::set_address(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:MumbleProto.UserStats.address) +} +inline void UserStats::set_address(const void* value, + size_t size) { + _has_bits_[0] |= 0x00000001u; + address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.UserStats.address) +} +inline std::string* UserStats::_internal_mutable_address() { + _has_bits_[0] |= 0x00000001u; + return address_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* UserStats::release_address() { + // @@protoc_insertion_point(field_release:MumbleProto.UserStats.address) + if (!_internal_has_address()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return address_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void UserStats::set_allocated_address(std::string* address) { + if (address != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + address_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), address, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:MumbleProto.UserStats.address) +} + +// optional uint32 bandwidth = 15; +inline bool UserStats::_internal_has_bandwidth() const { + bool value = (_has_bits_[0] & 0x00004000u) != 0; + return value; +} +inline bool UserStats::has_bandwidth() const { + return _internal_has_bandwidth(); +} +inline void UserStats::clear_bandwidth() { + bandwidth_ = 0u; + _has_bits_[0] &= ~0x00004000u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 UserStats::_internal_bandwidth() const { + return bandwidth_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 UserStats::bandwidth() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserStats.bandwidth) + return _internal_bandwidth(); +} +inline void UserStats::_internal_set_bandwidth(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00004000u; + bandwidth_ = value; +} +inline void UserStats::set_bandwidth(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_bandwidth(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserStats.bandwidth) +} + +// optional uint32 onlinesecs = 16; +inline bool UserStats::_internal_has_onlinesecs() const { + bool value = (_has_bits_[0] & 0x00008000u) != 0; + return value; +} +inline bool UserStats::has_onlinesecs() const { + return _internal_has_onlinesecs(); +} +inline void UserStats::clear_onlinesecs() { + onlinesecs_ = 0u; + _has_bits_[0] &= ~0x00008000u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 UserStats::_internal_onlinesecs() const { + return onlinesecs_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 UserStats::onlinesecs() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserStats.onlinesecs) + return _internal_onlinesecs(); +} +inline void UserStats::_internal_set_onlinesecs(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00008000u; + onlinesecs_ = value; +} +inline void UserStats::set_onlinesecs(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_onlinesecs(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserStats.onlinesecs) +} + +// optional uint32 idlesecs = 17; +inline bool UserStats::_internal_has_idlesecs() const { + bool value = (_has_bits_[0] & 0x00010000u) != 0; + return value; +} +inline bool UserStats::has_idlesecs() const { + return _internal_has_idlesecs(); +} +inline void UserStats::clear_idlesecs() { + idlesecs_ = 0u; + _has_bits_[0] &= ~0x00010000u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 UserStats::_internal_idlesecs() const { + return idlesecs_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 UserStats::idlesecs() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserStats.idlesecs) + return _internal_idlesecs(); +} +inline void UserStats::_internal_set_idlesecs(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00010000u; + idlesecs_ = value; +} +inline void UserStats::set_idlesecs(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_idlesecs(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserStats.idlesecs) +} + +// optional bool strong_certificate = 18 [default = false]; +inline bool UserStats::_internal_has_strong_certificate() const { + bool value = (_has_bits_[0] & 0x00001000u) != 0; + return value; +} +inline bool UserStats::has_strong_certificate() const { + return _internal_has_strong_certificate(); +} +inline void UserStats::clear_strong_certificate() { + strong_certificate_ = false; + _has_bits_[0] &= ~0x00001000u; +} +inline bool UserStats::_internal_strong_certificate() const { + return strong_certificate_; +} +inline bool UserStats::strong_certificate() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserStats.strong_certificate) + return _internal_strong_certificate(); +} +inline void UserStats::_internal_set_strong_certificate(bool value) { + _has_bits_[0] |= 0x00001000u; + strong_certificate_ = value; +} +inline void UserStats::set_strong_certificate(bool value) { + _internal_set_strong_certificate(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserStats.strong_certificate) +} + +// optional bool opus = 19 [default = false]; +inline bool UserStats::_internal_has_opus() const { + bool value = (_has_bits_[0] & 0x00002000u) != 0; + return value; +} +inline bool UserStats::has_opus() const { + return _internal_has_opus(); +} +inline void UserStats::clear_opus() { + opus_ = false; + _has_bits_[0] &= ~0x00002000u; +} +inline bool UserStats::_internal_opus() const { + return opus_; +} +inline bool UserStats::opus() const { + // @@protoc_insertion_point(field_get:MumbleProto.UserStats.opus) + return _internal_opus(); +} +inline void UserStats::_internal_set_opus(bool value) { + _has_bits_[0] |= 0x00002000u; + opus_ = value; +} +inline void UserStats::set_opus(bool value) { + _internal_set_opus(value); + // @@protoc_insertion_point(field_set:MumbleProto.UserStats.opus) +} + +// ------------------------------------------------------------------- + +// RequestBlob + +// repeated uint32 session_texture = 1; +inline int RequestBlob::_internal_session_texture_size() const { + return session_texture_.size(); +} +inline int RequestBlob::session_texture_size() const { + return _internal_session_texture_size(); +} +inline void RequestBlob::clear_session_texture() { + session_texture_.Clear(); +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 RequestBlob::_internal_session_texture(int index) const { + return session_texture_.Get(index); +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 RequestBlob::session_texture(int index) const { + // @@protoc_insertion_point(field_get:MumbleProto.RequestBlob.session_texture) + return _internal_session_texture(index); +} +inline void RequestBlob::set_session_texture(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value) { + session_texture_.Set(index, value); + // @@protoc_insertion_point(field_set:MumbleProto.RequestBlob.session_texture) +} +inline void RequestBlob::_internal_add_session_texture(::PROTOBUF_NAMESPACE_ID::uint32 value) { + session_texture_.Add(value); +} +inline void RequestBlob::add_session_texture(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_add_session_texture(value); + // @@protoc_insertion_point(field_add:MumbleProto.RequestBlob.session_texture) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& +RequestBlob::_internal_session_texture() const { + return session_texture_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& +RequestBlob::session_texture() const { + // @@protoc_insertion_point(field_list:MumbleProto.RequestBlob.session_texture) + return _internal_session_texture(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* +RequestBlob::_internal_mutable_session_texture() { + return &session_texture_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* +RequestBlob::mutable_session_texture() { + // @@protoc_insertion_point(field_mutable_list:MumbleProto.RequestBlob.session_texture) + return _internal_mutable_session_texture(); +} + +// repeated uint32 session_comment = 2; +inline int RequestBlob::_internal_session_comment_size() const { + return session_comment_.size(); +} +inline int RequestBlob::session_comment_size() const { + return _internal_session_comment_size(); +} +inline void RequestBlob::clear_session_comment() { + session_comment_.Clear(); +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 RequestBlob::_internal_session_comment(int index) const { + return session_comment_.Get(index); +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 RequestBlob::session_comment(int index) const { + // @@protoc_insertion_point(field_get:MumbleProto.RequestBlob.session_comment) + return _internal_session_comment(index); +} +inline void RequestBlob::set_session_comment(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value) { + session_comment_.Set(index, value); + // @@protoc_insertion_point(field_set:MumbleProto.RequestBlob.session_comment) +} +inline void RequestBlob::_internal_add_session_comment(::PROTOBUF_NAMESPACE_ID::uint32 value) { + session_comment_.Add(value); +} +inline void RequestBlob::add_session_comment(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_add_session_comment(value); + // @@protoc_insertion_point(field_add:MumbleProto.RequestBlob.session_comment) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& +RequestBlob::_internal_session_comment() const { + return session_comment_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& +RequestBlob::session_comment() const { + // @@protoc_insertion_point(field_list:MumbleProto.RequestBlob.session_comment) + return _internal_session_comment(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* +RequestBlob::_internal_mutable_session_comment() { + return &session_comment_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* +RequestBlob::mutable_session_comment() { + // @@protoc_insertion_point(field_mutable_list:MumbleProto.RequestBlob.session_comment) + return _internal_mutable_session_comment(); +} + +// repeated uint32 channel_description = 3; +inline int RequestBlob::_internal_channel_description_size() const { + return channel_description_.size(); +} +inline int RequestBlob::channel_description_size() const { + return _internal_channel_description_size(); +} +inline void RequestBlob::clear_channel_description() { + channel_description_.Clear(); +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 RequestBlob::_internal_channel_description(int index) const { + return channel_description_.Get(index); +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 RequestBlob::channel_description(int index) const { + // @@protoc_insertion_point(field_get:MumbleProto.RequestBlob.channel_description) + return _internal_channel_description(index); +} +inline void RequestBlob::set_channel_description(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value) { + channel_description_.Set(index, value); + // @@protoc_insertion_point(field_set:MumbleProto.RequestBlob.channel_description) +} +inline void RequestBlob::_internal_add_channel_description(::PROTOBUF_NAMESPACE_ID::uint32 value) { + channel_description_.Add(value); +} +inline void RequestBlob::add_channel_description(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_add_channel_description(value); + // @@protoc_insertion_point(field_add:MumbleProto.RequestBlob.channel_description) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& +RequestBlob::_internal_channel_description() const { + return channel_description_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& +RequestBlob::channel_description() const { + // @@protoc_insertion_point(field_list:MumbleProto.RequestBlob.channel_description) + return _internal_channel_description(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* +RequestBlob::_internal_mutable_channel_description() { + return &channel_description_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* +RequestBlob::mutable_channel_description() { + // @@protoc_insertion_point(field_mutable_list:MumbleProto.RequestBlob.channel_description) + return _internal_mutable_channel_description(); +} + +// ------------------------------------------------------------------- + +// ServerConfig + +// optional uint32 max_bandwidth = 1; +inline bool ServerConfig::_internal_has_max_bandwidth() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ServerConfig::has_max_bandwidth() const { + return _internal_has_max_bandwidth(); +} +inline void ServerConfig::clear_max_bandwidth() { + max_bandwidth_ = 0u; + _has_bits_[0] &= ~0x00000002u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ServerConfig::_internal_max_bandwidth() const { + return max_bandwidth_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ServerConfig::max_bandwidth() const { + // @@protoc_insertion_point(field_get:MumbleProto.ServerConfig.max_bandwidth) + return _internal_max_bandwidth(); +} +inline void ServerConfig::_internal_set_max_bandwidth(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000002u; + max_bandwidth_ = value; +} +inline void ServerConfig::set_max_bandwidth(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_max_bandwidth(value); + // @@protoc_insertion_point(field_set:MumbleProto.ServerConfig.max_bandwidth) +} + +// optional string welcome_text = 2; +inline bool ServerConfig::_internal_has_welcome_text() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ServerConfig::has_welcome_text() const { + return _internal_has_welcome_text(); +} +inline void ServerConfig::clear_welcome_text() { + welcome_text_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ServerConfig::welcome_text() const { + // @@protoc_insertion_point(field_get:MumbleProto.ServerConfig.welcome_text) + return _internal_welcome_text(); +} +inline void ServerConfig::set_welcome_text(const std::string& value) { + _internal_set_welcome_text(value); + // @@protoc_insertion_point(field_set:MumbleProto.ServerConfig.welcome_text) +} +inline std::string* ServerConfig::mutable_welcome_text() { + // @@protoc_insertion_point(field_mutable:MumbleProto.ServerConfig.welcome_text) + return _internal_mutable_welcome_text(); +} +inline const std::string& ServerConfig::_internal_welcome_text() const { + return welcome_text_.Get(); +} +inline void ServerConfig::_internal_set_welcome_text(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + welcome_text_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void ServerConfig::set_welcome_text(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + welcome_text_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:MumbleProto.ServerConfig.welcome_text) +} +inline void ServerConfig::set_welcome_text(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + welcome_text_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:MumbleProto.ServerConfig.welcome_text) +} +inline void ServerConfig::set_welcome_text(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000001u; + welcome_text_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:MumbleProto.ServerConfig.welcome_text) +} +inline std::string* ServerConfig::_internal_mutable_welcome_text() { + _has_bits_[0] |= 0x00000001u; + return welcome_text_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* ServerConfig::release_welcome_text() { + // @@protoc_insertion_point(field_release:MumbleProto.ServerConfig.welcome_text) + if (!_internal_has_welcome_text()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return welcome_text_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void ServerConfig::set_allocated_welcome_text(std::string* welcome_text) { + if (welcome_text != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + welcome_text_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), welcome_text, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:MumbleProto.ServerConfig.welcome_text) +} + +// optional bool allow_html = 3; +inline bool ServerConfig::_internal_has_allow_html() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ServerConfig::has_allow_html() const { + return _internal_has_allow_html(); +} +inline void ServerConfig::clear_allow_html() { + allow_html_ = false; + _has_bits_[0] &= ~0x00000004u; +} +inline bool ServerConfig::_internal_allow_html() const { + return allow_html_; +} +inline bool ServerConfig::allow_html() const { + // @@protoc_insertion_point(field_get:MumbleProto.ServerConfig.allow_html) + return _internal_allow_html(); +} +inline void ServerConfig::_internal_set_allow_html(bool value) { + _has_bits_[0] |= 0x00000004u; + allow_html_ = value; +} +inline void ServerConfig::set_allow_html(bool value) { + _internal_set_allow_html(value); + // @@protoc_insertion_point(field_set:MumbleProto.ServerConfig.allow_html) +} + +// optional uint32 message_length = 4; +inline bool ServerConfig::_internal_has_message_length() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool ServerConfig::has_message_length() const { + return _internal_has_message_length(); +} +inline void ServerConfig::clear_message_length() { + message_length_ = 0u; + _has_bits_[0] &= ~0x00000008u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ServerConfig::_internal_message_length() const { + return message_length_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ServerConfig::message_length() const { + // @@protoc_insertion_point(field_get:MumbleProto.ServerConfig.message_length) + return _internal_message_length(); +} +inline void ServerConfig::_internal_set_message_length(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000008u; + message_length_ = value; +} +inline void ServerConfig::set_message_length(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_message_length(value); + // @@protoc_insertion_point(field_set:MumbleProto.ServerConfig.message_length) +} + +// optional uint32 image_message_length = 5; +inline bool ServerConfig::_internal_has_image_message_length() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool ServerConfig::has_image_message_length() const { + return _internal_has_image_message_length(); +} +inline void ServerConfig::clear_image_message_length() { + image_message_length_ = 0u; + _has_bits_[0] &= ~0x00000010u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ServerConfig::_internal_image_message_length() const { + return image_message_length_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ServerConfig::image_message_length() const { + // @@protoc_insertion_point(field_get:MumbleProto.ServerConfig.image_message_length) + return _internal_image_message_length(); +} +inline void ServerConfig::_internal_set_image_message_length(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000010u; + image_message_length_ = value; +} +inline void ServerConfig::set_image_message_length(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_image_message_length(value); + // @@protoc_insertion_point(field_set:MumbleProto.ServerConfig.image_message_length) +} + +// optional uint32 max_users = 6; +inline bool ServerConfig::_internal_has_max_users() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool ServerConfig::has_max_users() const { + return _internal_has_max_users(); +} +inline void ServerConfig::clear_max_users() { + max_users_ = 0u; + _has_bits_[0] &= ~0x00000020u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ServerConfig::_internal_max_users() const { + return max_users_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ServerConfig::max_users() const { + // @@protoc_insertion_point(field_get:MumbleProto.ServerConfig.max_users) + return _internal_max_users(); +} +inline void ServerConfig::_internal_set_max_users(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000020u; + max_users_ = value; +} +inline void ServerConfig::set_max_users(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_max_users(value); + // @@protoc_insertion_point(field_set:MumbleProto.ServerConfig.max_users) +} + +// ------------------------------------------------------------------- + +// SuggestConfig + +// optional uint32 version = 1; +inline bool SuggestConfig::_internal_has_version() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SuggestConfig::has_version() const { + return _internal_has_version(); +} +inline void SuggestConfig::clear_version() { + version_ = 0u; + _has_bits_[0] &= ~0x00000001u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 SuggestConfig::_internal_version() const { + return version_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 SuggestConfig::version() const { + // @@protoc_insertion_point(field_get:MumbleProto.SuggestConfig.version) + return _internal_version(); +} +inline void SuggestConfig::_internal_set_version(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000001u; + version_ = value; +} +inline void SuggestConfig::set_version(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_version(value); + // @@protoc_insertion_point(field_set:MumbleProto.SuggestConfig.version) +} + +// optional bool positional = 2; +inline bool SuggestConfig::_internal_has_positional() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool SuggestConfig::has_positional() const { + return _internal_has_positional(); +} +inline void SuggestConfig::clear_positional() { + positional_ = false; + _has_bits_[0] &= ~0x00000002u; +} +inline bool SuggestConfig::_internal_positional() const { + return positional_; +} +inline bool SuggestConfig::positional() const { + // @@protoc_insertion_point(field_get:MumbleProto.SuggestConfig.positional) + return _internal_positional(); +} +inline void SuggestConfig::_internal_set_positional(bool value) { + _has_bits_[0] |= 0x00000002u; + positional_ = value; +} +inline void SuggestConfig::set_positional(bool value) { + _internal_set_positional(value); + // @@protoc_insertion_point(field_set:MumbleProto.SuggestConfig.positional) +} + +// optional bool push_to_talk = 3; +inline bool SuggestConfig::_internal_has_push_to_talk() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool SuggestConfig::has_push_to_talk() const { + return _internal_has_push_to_talk(); +} +inline void SuggestConfig::clear_push_to_talk() { + push_to_talk_ = false; + _has_bits_[0] &= ~0x00000004u; +} +inline bool SuggestConfig::_internal_push_to_talk() const { + return push_to_talk_; +} +inline bool SuggestConfig::push_to_talk() const { + // @@protoc_insertion_point(field_get:MumbleProto.SuggestConfig.push_to_talk) + return _internal_push_to_talk(); +} +inline void SuggestConfig::_internal_set_push_to_talk(bool value) { + _has_bits_[0] |= 0x00000004u; + push_to_talk_ = value; +} +inline void SuggestConfig::set_push_to_talk(bool value) { + _internal_set_push_to_talk(value); + // @@protoc_insertion_point(field_set:MumbleProto.SuggestConfig.push_to_talk) +} + +#ifdef __GNUC__ + #pragma GCC diagnostic pop +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace MumbleProto + +PROTOBUF_NAMESPACE_OPEN + +template <> struct is_proto_enum< ::MumbleProto::Reject_RejectType> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::MumbleProto::Reject_RejectType>() { + return ::MumbleProto::Reject_RejectType_descriptor(); +} +template <> struct is_proto_enum< ::MumbleProto::PermissionDenied_DenyType> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::MumbleProto::PermissionDenied_DenyType>() { + return ::MumbleProto::PermissionDenied_DenyType_descriptor(); +} +template <> struct is_proto_enum< ::MumbleProto::ContextActionModify_Context> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::MumbleProto::ContextActionModify_Context>() { + return ::MumbleProto::ContextActionModify_Context_descriptor(); +} +template <> struct is_proto_enum< ::MumbleProto::ContextActionModify_Operation> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::MumbleProto::ContextActionModify_Operation>() { + return ::MumbleProto::ContextActionModify_Operation_descriptor(); +} + +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) + +#include +#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_Mumble_2eproto From d1c503268f6c3126b272a5ed13171c23d591c6e0 Mon Sep 17 00:00:00 2001 From: "Hiroshi Takey F. (hiro2233)" Date: Wed, 10 Jun 2020 05:15:53 -0400 Subject: [PATCH 42/78] build: added missing cxxflags for unix targets. --- CMakeLists.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/CMakeLists.txt b/CMakeLists.txt index c9fea75..242a3d7 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -5,6 +5,7 @@ if (MSYS) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -DLOG4CPP_FIX_ERROR_COLLISION=1 -D__USE_W32_SOCKETS") add_definitions(-DOPT_TLS_OPENSSL) elseif (NOT APPLE) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11") add_definitions(-DOPT_TLS_OPENSSL -D_POSIX_C_SOURCE=200112L) elseif() LINK_DIRECTORIES(/opt/local/lib) # Include the default MacPorts library directory From 79b9dbbe4c0393fbfc24dc607e9c75aeb8eea61b Mon Sep 17 00:00:00 2001 From: "Hiroshi Takey F. (hiro2233)" Date: Wed, 10 Jun 2020 05:36:31 -0400 Subject: [PATCH 43/78] buld: added urusstudio project. --- mumlib.usp | 99 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 99 insertions(+) create mode 100644 mumlib.usp diff --git a/mumlib.usp b/mumlib.usp new file mode 100644 index 0000000..4113c6a --- /dev/null +++ b/mumlib.usp @@ -0,0 +1,99 @@ + + + + + + From c4374ce0cef57dcb61e0710d3db712459184ee17 Mon Sep 17 00:00:00 2001 From: Benedikt Wildenhain Date: Wed, 10 Jun 2020 12:49:10 +0200 Subject: [PATCH 44/78] Added dependency to Speex DSP library --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index b0ee43e..ecf049d 100644 --- a/README.md +++ b/README.md @@ -21,6 +21,7 @@ Todo: * Opus library * Google Protobuf: libraries and compiler * CMake +* Speex DSP Library ## Build From 926d477479635623a5b0177c56dd1eb231fa482b Mon Sep 17 00:00:00 2001 From: Benedikt Wildenhain Date: Wed, 10 Jun 2020 12:52:27 +0200 Subject: [PATCH 45/78] Added instructions to install deps on Debian --- README.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/README.md b/README.md index ecf049d..c522c14 100644 --- a/README.md +++ b/README.md @@ -23,6 +23,11 @@ Todo: * CMake * Speex DSP Library +Install those dependencies on Debian GNU/Linux using: +``` +sudo apt install libboost-dev libssl-dev liblog4cpp5-dev libopus-dev protobuf-compiler libspeexdsp-dev +``` + ## Build The library uses CMake build system: From 89c76ba10968ae966558e9f3f9baf8568c7f4dc7 Mon Sep 17 00:00:00 2001 From: Benedikt Wildenhain Date: Wed, 10 Jun 2020 13:12:19 +0200 Subject: [PATCH 46/78] Typos --- README.md | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/README.md b/README.md index c522c14..443ee0c 100644 --- a/README.md +++ b/README.md @@ -2,16 +2,16 @@ # mumlib - simple Mumble client library -Fairy simple Mumble library written in C++, using *boost::asio* asynchronous networking framework. Library supports: +Fairly simple Mumble library written in C++, using *boost::asio* asynchronous networking framework. Library supports: -* audio streaming through TCP and UDP channel -* text messaging +* Audio streaming through TCP and UDP channel +* Text messaging Todo: -* channel support -* user information -* remaining server messages (ACL, user stats etc) +* Channel support +* User information +* Remaining server messages (ACL, user stats etc) ## Dependencies @@ -21,7 +21,7 @@ Todo: * Opus library * Google Protobuf: libraries and compiler * CMake -* Speex DSP Library +* Speex DSP library Install those dependencies on Debian GNU/Linux using: ``` From 386935919ac43b99abf17557c357b623df9ea72a Mon Sep 17 00:00:00 2001 From: Benedikt Wildenhain Date: Wed, 10 Jun 2020 13:19:52 +0200 Subject: [PATCH 47/78] Added missing Debian dependencies --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 443ee0c..8f82d69 100644 --- a/README.md +++ b/README.md @@ -25,7 +25,7 @@ Todo: Install those dependencies on Debian GNU/Linux using: ``` -sudo apt install libboost-dev libssl-dev liblog4cpp5-dev libopus-dev protobuf-compiler libspeexdsp-dev +apt install libboost{,-system}-dev libssl-dev liblog4cpp5-dev libopus-dev protobuf-compiler libspeexdsp-dev cmake build-essential ``` ## Build From aeaa5738e9aef4d738681e31b142870b67cebec0 Mon Sep 17 00:00:00 2001 From: "Hiroshi Takey F. (hiro2233)" Date: Fri, 12 Jun 2020 17:44:20 -0400 Subject: [PATCH 48/78] root: changed Mumble proto c and headers filename for msys. --- Mumble.pb.cc => Mumble.pb-msys.cc | 0 Mumble.pb.h => Mumble.pb-msys.h | 0 2 files changed, 0 insertions(+), 0 deletions(-) rename Mumble.pb.cc => Mumble.pb-msys.cc (100%) rename Mumble.pb.h => Mumble.pb-msys.h (100%) diff --git a/Mumble.pb.cc b/Mumble.pb-msys.cc similarity index 100% rename from Mumble.pb.cc rename to Mumble.pb-msys.cc diff --git a/Mumble.pb.h b/Mumble.pb-msys.h similarity index 100% rename from Mumble.pb.h rename to Mumble.pb-msys.h From ab8d4526df707f0cdecb78dfda3b28bfe62d31c5 Mon Sep 17 00:00:00 2001 From: "Hiroshi Takey F. (hiro2233)" Date: Fri, 12 Jun 2020 19:45:46 -0400 Subject: [PATCH 49/78] build: fixed linking boost library. --- CMakeLists.txt | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 242a3d7..6750a6f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -13,19 +13,26 @@ endif() INCLUDE(FindPkgConfig) find_package(PkgConfig REQUIRED) -#find_package(Boost COMPONENTS system REQUIRED) + +if (NOT APPLE) +find_package(Boost COMPONENTS system REQUIRED) +endif() + find_package(OpenSSL REQUIRED) find_package(Protobuf REQUIRED) pkg_check_modules(LOG4CPP "log4cpp") pkg_check_modules(OPUS "opus") -#INCLUDE_DIRECTORIES(${Boost_INCLUDE_DIR}) +if (MSYS) +include_directories(~/boost_1_72_0) +elseif (NOT APPLE) +INCLUDE_DIRECTORIES(${Boost_INCLUDE_DIR}) +endif() include_directories(${OPENSSL_INCLUDE_DIR}) include_directories(${PROTOBUF_INCLUDE_DIRS}) include_directories(${OPUS_INCLUDE_DIRS}) -include_directories(~/boost_1_72_0) include_directories(${CMAKE_CURRENT_BINARY_DIR}) include_directories(${LOG4CPP_INCLUDE_DIRS}) include_directories(include) @@ -70,7 +77,8 @@ target_link_libraries(mumlib ${PROTOBUF_LIBRARIES} ${OPENSSL_LIBRARIES} ${LOG4CPP_LIBRARIES} - ${OPUS_LIBRARIES}) + ${OPUS_LIBRARIES} + ${Boost_LIBRARIES}) endif () set_target_properties(mumlib PROPERTIES PUBLIC_HEADER "${MUMLIB_PUBLIC_HEADERS}") From 4d6362431f3a68b27799d6e19230f1ea62d4f25f Mon Sep 17 00:00:00 2001 From: "Hiroshi Takey F. (hiro2233)" Date: Sat, 13 Jun 2020 02:46:40 -0400 Subject: [PATCH 50/78] build: added optimization level 3 on cmake. --- CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 6750a6f..6f3490c 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -5,7 +5,7 @@ if (MSYS) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -DLOG4CPP_FIX_ERROR_COLLISION=1 -D__USE_W32_SOCKETS") add_definitions(-DOPT_TLS_OPENSSL) elseif (NOT APPLE) - set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -O3") add_definitions(-DOPT_TLS_OPENSSL -D_POSIX_C_SOURCE=200112L) elseif() LINK_DIRECTORIES(/opt/local/lib) # Include the default MacPorts library directory From 1774ad8feb6412b13809faa60ac9cfdde64da0d6 Mon Sep 17 00:00:00 2001 From: "Hiroshi Takey F. (hiro2233)" Date: Sat, 13 Jun 2020 02:48:03 -0400 Subject: [PATCH 51/78] src: improve throw expceptions for optimizations builds. --- src/Transport.cpp | 27 ++++++++++++++------------- 1 file changed, 14 insertions(+), 13 deletions(-) diff --git a/src/Transport.cpp b/src/Transport.cpp index 66368af..7b55764 100644 --- a/src/Transport.cpp +++ b/src/Transport.cpp @@ -71,6 +71,7 @@ void mumlib::Transport::connect( noUdp = true; #endif udpActive = false; + state = ConnectionState::IN_PROGRESS; logger.warn("Verify_mode"); sslSocket.set_verify_mode(boost::asio::ssl::verify_peer); @@ -112,6 +113,8 @@ void mumlib::Transport::connect( void mumlib::Transport::disconnect() { + ioService.stop(); + if (state != ConnectionState::NOT_CONNECTED) { boost::system::error_code errorCode; @@ -130,6 +133,7 @@ void mumlib::Transport::disconnect() } printf("Disconnected\n"); + std::this_thread::sleep_for(std::chrono::seconds(5)); } void mumlib::Transport::sendVersion() { @@ -195,7 +199,7 @@ void mumlib::Transport::doReceiveUdp() //logger.warn("Received UDP packet of %d B.", bytesTransferred); if (not cryptState.isValid()) { - throwTransportException("received UDP packet before CRYPT SETUP message"); + throwTransportException("received UDP packet before: CRYPT SETUP message"); } else { lastReceivedUdpPacketTimestamp = std::chrono::system_clock::now(); @@ -211,7 +215,7 @@ void mumlib::Transport::doReceiveUdp() udpIncomingBuffer, plainBuffer, static_cast(bytesTransferred)); if (not success) { - throwTransportException("UDP packet decryption failed"); + throwTransportException("UDP packet: decryption failed"); } processAudioPacket(plainBuffer, plainBufferLength); @@ -237,7 +241,7 @@ void mumlib::Transport::sslConnectHandler(const boost::system::error_code &error boost::asio::placeholders::error)); } else { - throwTransportException((boost::format("sslConnectHandler: Connect failed: %s.") % error.message()).str()); + disconnect(); } } @@ -272,17 +276,14 @@ void mumlib::Transport::pingTimerTick(const boost::system::error_code &e) { if (lastUdpReceivedMilliseconds > PING_INTERVAL.total_milliseconds() + 1000) { logger.warn("Didn't receive UDP ping in %d ms, falling back to TCP.", lastUdpReceivedMilliseconds); - throwTransportException("pingTimerTick: Didn't receive UDP ping"); - return; } } } } if ((state == ConnectionState::NOT_CONNECTED) && (ping_state == PingState::PING)) { - logger.warn("ioService RESET!."); - throwTransportException("pingTimerTick: NOT CONNECTED PING"); - return; + logger.warn("pingTimerTick disconnect!."); + disconnect(); } logger.warn("TimerTick!."); @@ -292,7 +293,7 @@ void mumlib::Transport::pingTimerTick(const boost::system::error_code &e) { void mumlib::Transport::sendUdpAsync(uint8_t *buff, int length) { if (length > MAX_UDP_LENGTH - 4) { - throwTransportException("maximum allowed data length is %d" + to_string(MAX_UDP_LENGTH - 4)); + throwTransportException("maximum allowed: data length is %d" + to_string(MAX_UDP_LENGTH - 4)); } auto *encryptedMsgBuff = asyncBufferPool.malloc(); @@ -432,7 +433,7 @@ void mumlib::Transport::processMessageInternal(MessageType messageType, uint8_t if (cryptsetup.client_nonce().length() != AES_BLOCK_SIZE or cryptsetup.server_nonce().length() != AES_BLOCK_SIZE or cryptsetup.key().length() != AES_BLOCK_SIZE) { - throwTransportException("one of cryptographic parameters has invalid length"); + throwTransportException("one of cryptographic: parameters has invalid length"); } cryptState.setKey( @@ -441,7 +442,7 @@ void mumlib::Transport::processMessageInternal(MessageType messageType, uint8_t reinterpret_cast(cryptsetup.server_nonce().c_str())); if (not cryptState.isValid()) { - throwTransportException("crypt setup data not valid"); + throwTransportException("crypt setup: data not valid"); } logger.warn("Set up cryptography for UDP transport. Sending UDP ping."); @@ -572,10 +573,10 @@ void mumlib::Transport::sendEncodedAudioPacket(uint8_t *buffer, int length) { } if (udpActive) { - //logger.warn("Sending %d B of audio data via UDP.", length); + logger.warn("Sending %d B of audio data via UDP.", length); sendUdpAsync(buffer, length); } else { - //logger.warn("Sending %d B of audio data via TCP.", length); + logger.warn("Sending %d B of audio data via TCP.", length); const uint16_t netUdptunnelType = htons(static_cast(MessageType::UDPTUNNEL)); From 75c66103bafffd29a1f5f154ac822ad088a5caec Mon Sep 17 00:00:00 2001 From: "Hiroshi Takey F. (hiro2233)" Date: Sat, 13 Jun 2020 02:48:53 -0400 Subject: [PATCH 52/78] src: commented throwing exceptions. --- src/VarInt.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/VarInt.cpp b/src/VarInt.cpp index bd489da..d76d8c3 100644 --- a/src/VarInt.cpp +++ b/src/VarInt.cpp @@ -23,10 +23,10 @@ int64_t mumlib::VarInt::parseVariant(const uint8_t *buffer) { case 0xF0: return buffer[1] << 24 | buffer[2] << 16 | buffer[3] << 8 | buffer[4]; case 0xF4: - throw VarIntException("currently unsupported 8-byte varint size"); + //throw VarIntException("currently unsupported 8-byte varint size"); case 0xF8: case 0xFC: - throw VarIntException("currently negative varints aren't supported"); + //throw VarIntException("currently negative varints aren't supported"); default: break; } @@ -37,7 +37,7 @@ int64_t mumlib::VarInt::parseVariant(const uint8_t *buffer) { } - throw VarIntException("invalid varint"); + //throw VarIntException("invalid varint"); } std::vector mumlib::VarInt::getEncoded() const { From fec8d3d99bfa78cf5569cf7fe18aab24a947a5ac Mon Sep 17 00:00:00 2001 From: "Hiroshi Takey F. (hiro2233)" Date: Sat, 13 Jun 2020 03:38:20 -0400 Subject: [PATCH 53/78] src: commented log on sendEncodedAudioPacket. --- src/Transport.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/Transport.cpp b/src/Transport.cpp index 7b55764..d2a0217 100644 --- a/src/Transport.cpp +++ b/src/Transport.cpp @@ -573,10 +573,10 @@ void mumlib::Transport::sendEncodedAudioPacket(uint8_t *buffer, int length) { } if (udpActive) { - logger.warn("Sending %d B of audio data via UDP.", length); + //logger.warn("Sending %d B of audio data via UDP.", length); sendUdpAsync(buffer, length); } else { - logger.warn("Sending %d B of audio data via TCP.", length); + //logger.warn("Sending %d B of audio data via TCP.", length); const uint16_t netUdptunnelType = htons(static_cast(MessageType::UDPTUNNEL)); From 98eb01b3a7904c93fe2b4cda52286abf103410e8 Mon Sep 17 00:00:00 2001 From: "Hiroshi Takey F. (hiro2233)" Date: Sat, 13 Jun 2020 03:39:58 -0400 Subject: [PATCH 54/78] build: fixed finding boost on msys. --- CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 6f3490c..374f604 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -14,7 +14,7 @@ endif() INCLUDE(FindPkgConfig) find_package(PkgConfig REQUIRED) -if (NOT APPLE) +if (NOT MSYS) find_package(Boost COMPONENTS system REQUIRED) endif() From 274d25d6b898bc4440cc1b2af566af129c845fad Mon Sep 17 00:00:00 2001 From: "Hiroshi Takey F. (hiro2233)" Date: Sun, 14 Jun 2020 04:55:43 -0400 Subject: [PATCH 55/78] src: fixed udp connection on MSYS. --- src/Transport.cpp | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/Transport.cpp b/src/Transport.cpp index d2a0217..f4b6bd6 100644 --- a/src/Transport.cpp +++ b/src/Transport.cpp @@ -2,6 +2,7 @@ #include "Mumble.pb.h" +#include #include using namespace std; @@ -67,9 +68,6 @@ void mumlib::Transport::connect( connectionParams = make_pair(host, port); credentials = make_pair(user, password); -#ifdef __MSYS__ - noUdp = true; -#endif udpActive = false; state = ConnectionState::IN_PROGRESS; @@ -92,6 +90,9 @@ void mumlib::Transport::connect( udpReceiverEndpoint = *resolverUdp.resolve(queryUdp); udpSocket.open(ip::udp::v4()); + boost::array send_buf = { 0 }; + udpSocket.send_to(boost::asio::buffer(send_buf), udpReceiverEndpoint); + doReceiveUdp(); logger.warn("noUdp try"); } From f086dbb78ee3248be8a30ca21ab3f64524fd17b9 Mon Sep 17 00:00:00 2001 From: "Hiroshi Takey F. (hiro2233)" Date: Wed, 17 Jun 2020 02:01:24 -0400 Subject: [PATCH 56/78] build: added missing static libraries to cmakelist. --- CMakeLists.txt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 374f604..5ba27fa 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 2.8.0) project(mumlib) if (MSYS) - set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -DLOG4CPP_FIX_ERROR_COLLISION=1 -D__USE_W32_SOCKETS") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -O3 -DLOG4CPP_FIX_ERROR_COLLISION=1 -D__USE_W32_SOCKETS -static-libstdc++ -static-libgcc -static") add_definitions(-DOPT_TLS_OPENSSL) elseif (NOT APPLE) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -O3") @@ -70,7 +70,7 @@ target_link_libraries(mumlib ${PROTOBUF_LIBRARIES} ${OPENSSL_LIBRARIES} ${LOG4CPP_LIBRARIES} - ${OPUS_LIBRARIES} ws2_32) + ${OPUS_LIBRARIES} ws2_32 winmm z crypto ssl) else () target_link_libraries(mumlib ${SPEEX_LIBRARIES} From 8cea28e3c23d58c8fca68870ea5e78f354cd63c4 Mon Sep 17 00:00:00 2001 From: "Hiroshi Takey F. (hiro2233)" Date: Wed, 17 Jun 2020 05:16:41 -0400 Subject: [PATCH 57/78] build: added missing params to mumlib usp. --- mumlib.usp | 21 ++++++++++++++------- 1 file changed, 14 insertions(+), 7 deletions(-) diff --git a/mumlib.usp b/mumlib.usp index 4113c6a..b2407e2 100644 --- a/mumlib.usp +++ b/mumlib.usp @@ -27,14 +27,11 @@