diff --git a/.gitignore b/.gitignore index 4286771..6a15b59 100644 --- a/.gitignore +++ b/.gitignore @@ -32,3 +32,18 @@ build/ # IntelliJ *.iml .idea/ + + +# QtCreator +*.user + +debug +release +*.gch +*.layout +*.depend +*cscope_file_list +bin +Mumble.pb.cc +Mumble.pb.h + diff --git a/CMakeLists.txt b/CMakeLists.txt index 9fbbab3..5ba27fa 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,24 +1,38 @@ 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 (MSYS) + 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") + 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) + +if (NOT MSYS) 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") - +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(${CMAKE_CURRENT_BINARY_DIR}) include_directories(${LOG4CPP_INCLUDE_DIRS}) include_directories(include) @@ -42,15 +56,39 @@ set(MUMLIB_SRC src/Audio.cpp ) +set(SPEEX_LIBRARIES + 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}) +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 winmm z crypto ssl) +else () +target_link_libraries(mumlib + ${SPEEX_LIBRARIES} + ${PROTOBUF_LIBRARIES} + ${OPENSSL_LIBRARIES} + ${LOG4CPP_LIBRARIES} + ${OPUS_LIBRARIES} + ${Boost_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 DESTINATION mumlib LIBRARY DESTINATION lib PUBLIC_HEADER DESTINATION include/mumlib) diff --git a/Mumble.pb-msys.cc b/Mumble.pb-msys.cc new file mode 100644 index 0000000..6c7528d --- /dev/null +++ b/Mumble.pb-msys.cc @@ -0,0 +1,13279 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: Mumble.proto + +#include "Mumble.pb-msys.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-msys.h b/Mumble.pb-msys.h new file mode 100644 index 0000000..a23152b --- /dev/null +++ b/Mumble.pb-msys.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 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/README.md b/README.md index efae754..8f82d69 100644 --- a/README.md +++ b/README.md @@ -1,15 +1,17 @@ +**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: +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 @@ -19,6 +21,12 @@ Todo: * Opus library * Google Protobuf: libraries and compiler * CMake +* Speex DSP library + +Install those dependencies on Debian GNU/Linux using: +``` +apt install libboost{,-system}-dev libssl-dev liblog4cpp5-dev libopus-dev protobuf-compiler libspeexdsp-dev cmake build-essential +``` ## Build @@ -35,6 +43,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 +52,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 95afe02..e2b9e79 100644 --- a/include/mumlib.hpp +++ b/include/mumlib.hpp @@ -1,16 +1,22 @@ #pragma once #include "mumlib/Callback.hpp" +#include "mumlib/enums.hpp" + +#ifdef __MSYS__ +#define __MSABI_LONG(x) x +#endif #include #include #include -#include namespace mumlib { - constexpr int DEFAULT_OPUS_ENCODER_BITRATE = 16000; + constexpr int DEFAULT_OPUS_ENCODER_BITRATE = 8000; + constexpr int DEFAULT_OPUS_SAMPLE_RATE = 16000; + constexpr int DEFAULT_OPUS_NUM_CHANNELS = 1; using namespace std; using namespace boost::asio; @@ -22,15 +28,30 @@ namespace mumlib { struct MumlibConfiguration { 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 }; + struct MumbleUser { + int32_t sessionId; + string name; + }; + + struct MumbleChannel { + int32_t channelId; + string name; + string description; + }; + struct _Mumlib_Private; class Mumlib : boost::noncopyable { public: - Mumlib(Callback &callback); + explicit Mumlib(Callback &callback); Mumlib(Callback &callback, io_service &ioService); @@ -48,13 +69,38 @@ namespace mumlib { ConnectionState getConnectionState(); + int getChannelId(); + + vector getListAllUser(); + + vector getListAllChannel(); + 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 joinChannel(std::string channelName); + + void sendVoiceTarget(int targetId, mumlib::VoiceTargetType type, int sessionId); + + void sendVoiceTarget(int targetId, mumlib::VoiceTargetType type, std::string name, int &error); + + void sendUserState(mumlib::UserState state, bool val); + + void sendUserState(mumlib::UserState state, std::string value); + + bool isSessionIdValid(int sessionId); private: _Mumlib_Private *impl; + + int getChannelIdBy(std::string channelName); + + int getUserIdBy(std::string userName); + + bool isChannelIdValid(int channelId); }; } diff --git a/include/mumlib/Audio.hpp b/include/mumlib/Audio.hpp index d98f41a..cfea013 100644 --- a/include/mumlib/Audio.hpp +++ b/include/mumlib/Audio.hpp @@ -2,19 +2,20 @@ #include "Transport.hpp" -#include +#include + +#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 { @@ -28,17 +29,32 @@ namespace mumlib { class Audio : boost::noncopyable { public: - Audio(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(int sessionId, + int16_t *pcmBuffer, + int pcmBufferSize); + std::pair decodeOpusPayload(uint8_t *inputBuffer, int inputLength, + int sessionId, int16_t *pcmBuffer, int pcmBufferSize); + int encodeAudioPacket( int target, int16_t *inputPcmBuffer, @@ -52,14 +68,25 @@ namespace mumlib { void resetEncoder(); + void resetJitterBuffer(); + private: log4cpp::Category &logger; - OpusDecoder *opusDecoder; + std::map opusDecoders; OpusEncoder *opusEncoder; + JitterBuffer *jbBuffer; int64_t outgoingSequenceNumber; + unsigned int iSampleRate; + unsigned int iChannels; + unsigned int iFrameSize; + unsigned int iAudioBufferSize; + + float *fFadeIn; + float *fFadeOut; + std::chrono::time_point lastEncodedAudioPacketTimestamp; }; -} \ No newline at end of file +} 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/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/include/mumlib/Transport.hpp b/include/mumlib/Transport.hpp index ccf94a7..2850c5b 100644 --- a/include/mumlib/Transport.hpp +++ b/include/mumlib/Transport.hpp @@ -14,6 +14,7 @@ #include #include +#include namespace mumlib { @@ -30,7 +31,19 @@ namespace mumlib { class TransportException : public MumlibException { public: - TransportException(string message) : MumlibException(message) { } + 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 { @@ -38,7 +51,9 @@ namespace mumlib { Transport(io_service &ioService, ProcessControlMessageFunction processControlMessageFunc, ProcessEncodedAudioPacketFunction processEncodedAudioPacketFunction, - bool noUdp = false); + bool noUdp = false, + std::string cert_file = "", + std::string privkey_file = ""); ~Transport(); @@ -47,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() { @@ -72,11 +94,16 @@ namespace mumlib { ProcessEncodedAudioPacketFunction processEncodedAudioPacketFunction; +#ifdef __MSYS__ + bool noUdp; +#else const bool noUdp; +#endif volatile bool udpActive; ConnectionState state; + PingState ping_state; udp::socket udpSocket; ip::udp::endpoint udpReceiverEndpoint; @@ -84,6 +111,7 @@ namespace mumlib { CryptState cryptState; ssl::context sslContext; + SslContextHelper sslContextHelper; ssl::stream sslSocket; uint8_t *sslIncomingBuffer; diff --git a/include/mumlib/VarInt.hpp b/include/mumlib/VarInt.hpp index 451c61e..7e301c7 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); + int64_t parseVariant(const uint8_t *buffer); }; } \ No newline at end of file diff --git a/include/mumlib/enums.hpp b/include/mumlib/enums.hpp index b4a9b43..afdeb46 100644 --- a/include/mumlib/enums.hpp +++ b/include/mumlib/enums.hpp @@ -45,4 +45,26 @@ namespace mumlib { OPUS }; + enum class UserState { + MUTE, + DEAF, + SUPPRESS, + SELF_MUTE, + SELF_DEAF, + COMMENT, + PRIORITY_SPEAKER, + RECORDING + }; + + enum class VoiceTargetType { + CHANNEL, + USER + }; + + enum class PingState { + PING, + PONG, + NONE + }; + } \ No newline at end of file diff --git a/mumlib.usp b/mumlib.usp new file mode 100644 index 0000000..7d8054e --- /dev/null +++ b/mumlib.usp @@ -0,0 +1,189 @@ + + + + + + diff --git a/mumlib_example.cpp b/mumlib_example.cpp index 2e874d6..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); } }; @@ -39,8 +43,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; } @@ -49,10 +53,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()); @@ -61,4 +69,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/Audio.cpp b/src/Audio.cpp index 3ce7594..32f6413 100644 --- a/src/Audio.cpp +++ b/src/Audio.cpp @@ -2,41 +2,99 @@ #include -static boost::posix_time::seconds RESET_SEQUENCE_NUMBER_INTERVAL(5); +static boost::posix_time::seconds RESET_SEQUENCE_NUMBER_INTERVAL(2); -mumlib::Audio::Audio(int opusEncoderBitrate) - : logger(log4cpp::Category::getInstance("mumlib.Audio")), - opusDecoder(nullptr), - opusEncoder(nullptr), - outgoingSequenceNumber(0) { +namespace { +OpusDecoder* CreateOpusDecoder(int sampleRate, int channels) +{ int error; + OpusDecoder* decoder = nullptr; - opusDecoder = opus_decoder_create(SAMPLE_RATE, 1, &error); + decoder = opus_decoder_create(sampleRate, channels, &error); if (error != OPUS_OK) { - throw AudioException((boost::format("failed to initialize OPUS decoder: %s") % opus_strerror(error)).str()); + throw mumlib::AudioException((boost::format("failed to initialize OPUS decoder: %s") % opus_strerror(error)).str()); } - opusEncoder = opus_encoder_create(SAMPLE_RATE, 1, OPUS_APPLICATION_VOIP, &error); + return decoder; +} + +} // anonymous namespace + +mumlib::Audio::Audio(int sampleRate, int bitrate, int channels) + : logger(log4cpp::Category::getInstance("mumlib.Audio")), + opusEncoder(nullptr), + outgoingSequenceNumber(0), + iSampleRate(sampleRate), + iChannels(channels) { + + int error, ret; + iFrameSize = sampleRate / 1000 * 10; + iAudioBufferSize = iFrameSize; + iAudioBufferSize *= 12; + + 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)); + 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()); + } - setOpusEncoderBitrate(opusEncoderBitrate); + opus_encoder_ctl(opusEncoder, OPUS_SET_SIGNAL(OPUS_SIGNAL_VOICE)); 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() { - if (opusDecoder) { - opus_decoder_destroy(opusDecoder); + for (const auto decoder : opusDecoders) { + opus_decoder_destroy(decoder.second); } if (opusEncoder) { opus_encoder_destroy(opusEncoder); } + + jitter_buffer_destroy(jbBuffer); + + delete[] fFadeIn; + delete[] fFadeOut; } void mumlib::Audio::setOpusEncoderBitrate(int bitrate) { @@ -56,8 +114,117 @@ 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(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); + jitter_buffer_remaining_span(jbBuffer, remaining); + int timestamp = jitter_buffer_get_pointer_timestamp(jbBuffer); + + char data[4096]; + JitterBufferPacket jbPacket; + jbPacket.data = data; + jbPacket.len = 4096; + + spx_int32_t startofs = 0; + int opusDataLength; + int outputSize; + spx_uint32_t lastPacket; + + typedef std::numeric_limits rlimit; + float pcmbuf[pcmBufferSize]; + + 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); + } + OpusDecoder* &opusDecoder = opusDecoders[sessionId]; + if (!opusDecoder) { + opusDecoder = CreateOpusDecoder(iSampleRate, iChannels); + } + + if(opusDataLength) { + outputSize = opus_decode_float(opusDecoder, + reinterpret_cast(jbPacket.data), + jbPacket.len, + pcmbuf, + pcmBufferSize, 0); + } else { + outputSize = opus_decode_float(opusDecoder, + NULL, 0, pcmbuf, pcmBufferSize, 0); + } + + if(outputSize < 0) { + outputSize = iFrameSize; + memset(pcmbuf, 0, iFrameSize * sizeof(float)); + } + + if(lastPacket) { + for(unsigned int i = 0; i < iFrameSize; i++) + pcmbuf[i] *= fFadeOut[i]; + } + + for (int i = 0; i < pcmBufferSize; i++) { + pcmBuffer[i] = pcmbuf[i] * rlimit::max(); + } + + 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, + int sessionId, int16_t *pcmBuffer, int pcmBufferSize) { int64_t opusDataLength; @@ -75,8 +242,22 @@ 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. + 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, - reinterpret_cast(&inputBuffer[dataPointer]), + packet, opusDataLength, pcmBuffer, pcmBufferSize, @@ -102,13 +283,13 @@ 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(); } 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 +311,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 / iSampleRate; outgoingSequenceNumber += incrementNumber; lastEncodedAudioPacketTimestamp = std::chrono::system_clock::now(); - return outputSize + header.size(); + return static_cast(outputSize + header.size()); } void mumlib::Audio::resetEncoder() { @@ -151,8 +332,13 @@ 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; + mumlib::IncomingAudioPacket incomingAudioPacket{}; incomingAudioPacket.type = static_cast((inputBuffer[0] & 0xE0) >> 5); incomingAudioPacket.target = inputBuffer[0] & 0x1F; @@ -174,15 +360,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; } diff --git a/src/Callback.cpp b/src/Callback.cpp index ea8fb80..b50c7a8 100644 --- a/src/Callback.cpp +++ b/src/Callback.cpp @@ -31,17 +31,17 @@ 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()); } -void mumlib::BasicCallback::audio( +void BasicCallback::audio( int target, int sessionId, 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."); } diff --git a/src/CryptState.cpp b/src/CryptState.cpp index 9c5937a..e1763c3 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]; diff --git a/src/Transport.cpp b/src/Transport.cpp index f134512..addbd66 100644 --- a/src/Transport.cpp +++ b/src/Transport.cpp @@ -1,12 +1,19 @@ #include "mumlib/Transport.hpp" +#if defined(__MSYS__) && defined(__URUSSTUDIO__) +#include "Mumble.pb-msys.h" +#else #include "Mumble.pb.h" +#endif +#include #include +#include + 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"); @@ -29,18 +36,22 @@ 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(processMessageFunc), - processEncodedAudioPacketFunction(processEncodedAudioPacketFunction), + processMessageFunction(std::move(processMessageFunc)), + 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), 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]; @@ -48,7 +59,7 @@ mumlib::Transport::Transport( } mumlib::Transport::~Transport() { - disconnect(); + //disconnect(); delete[] sslIncomingBuffer; } @@ -58,20 +69,26 @@ void mumlib::Transport::connect( std::string user, std::string password) { - state = ConnectionState::IN_PROGRESS; + boost::system::error_code errorCode; connectionParams = make_pair(host, port); credentials = make_pair(user, password); udpActive = false; + state = ConnectionState::IN_PROGRESS; + logger.warn("Verify_mode"); sslSocket.set_verify_mode(boost::asio::ssl::verify_peer); + 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; }); + logger.warn("Trying connection..."); + try { if (not noUdp) { ip::udp::resolver resolverUdp(ioService); @@ -79,45 +96,52 @@ 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"); } + logger.warn("after noUdp try"); + ip::tcp::resolver resolverTcp(ioService); + logger.warn("resolverTcp"); ip::tcp::resolver::query queryTcp(host, to_string(port)); + logger.warn("queryTcp"); async_connect(sslSocket.lowest_layer(), resolverTcp.resolve(queryTcp), bind(&Transport::sslConnectHandler, this, boost::asio::placeholders::error)); + logger.warn("async_connect try"); } catch (runtime_error &exp) { throwTransportException(string("failed to establish connection: ") + exp.what()); } } -void mumlib::Transport::disconnect() { +void mumlib::Transport::disconnect() +{ + ioService.stop(); if (state != ConnectionState::NOT_CONNECTED) { 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); - if (errorCode) { - logger.warn("SSL socket lowest layer shutdown returned an error: %s.", errorCode.message().c_str()); - } + sslSocket.lowest_layer().close(errorCode); + udpSocket.shutdown(boost::asio::ip::udp::socket::shutdown_both, errorCode); udpSocket.close(errorCode); if (errorCode) { - logger.warn("UDP socket close returned error: %s.", errorCode.message().c_str()); + logger.warn("Not ping: UDP socket close returned error: %s.", errorCode.message().c_str()); } state = ConnectionState::NOT_CONNECTED; + printf("Not Connected\n"); } -} + printf("Disconnected\n"); + std::this_thread::sleep_for(std::chrono::seconds(3)); +} void mumlib::Transport::sendVersion() { MumbleProto::Version version; @@ -127,7 +151,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); } @@ -143,16 +167,26 @@ void mumlib::Transport::sendAuthentication() { authenticate.clear_tokens(); authenticate.set_opus(true); - logger.info("Sending authententication."); + logger.warn("Sending authententication."); sendControlMessagePrivate(MessageType::AUTHENTICATE, authenticate); } void mumlib::Transport::sendSslPing() { + + if (ping_state == PingState::PING) { + logger.warn("Continue sending SSL ping."); + disconnect(); + 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); } @@ -162,36 +196,33 @@ 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, [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"); + throwTransportException("received UDP packet before: CRYPT SETUP message"); } else { lastReceivedUdpPacketTimestamp = std::chrono::system_clock::now(); if (udpActive == false) { udpActive = true; - logger.notice("UDP is up."); + logger.warn("UDP is up."); } 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"); + throwTransportException("UDP packet: decryption failed"); } processAudioPacket(plainBuffer, plainBufferLength); @@ -199,7 +230,11 @@ 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) { + logger.warn("UDP receive function cancelled PONG."); + } } else { throwTransportException("UDP receive failed: " + ec.message()); } @@ -213,11 +248,13 @@ void mumlib::Transport::sslConnectHandler(const boost::system::error_code &error boost::asio::placeholders::error)); } else { - throwTransportException((boost::format("Connect failed: %s.") % error.message()).str()); + disconnect(); } } -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(); @@ -237,6 +274,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) { @@ -244,36 +282,41 @@ 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); } } } } + if ((state == ConnectionState::NOT_CONNECTED) && (ping_state == PingState::PING)) { + logger.warn("pingTimerTick disconnect!."); + disconnect(); + } + + logger.warn("TimerTick!."); pingTimer.expires_at(pingTimer.expires_at() + PING_INTERVAL); pingTimer.async_wait(boost::bind(&Transport::pingTimerTick, this, _1)); } 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(); 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); + //logger.warn("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); 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()); } @@ -281,10 +324,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), @@ -312,13 +351,13 @@ 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), &sslIncomingBuffer[6], - bytesTransferred - 6); + static_cast(bytesTransferred - 6)); doReceiveSsl(); } else { @@ -334,7 +373,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; @@ -362,7 +401,9 @@ 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()); + ping_state = PingState::PONG; } break; case MessageType::REJECT: { @@ -386,7 +427,8 @@ 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; @@ -398,7 +440,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( @@ -407,53 +449,54 @@ 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.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; } } -void mumlib::Transport::sendUdpPing() { - if (state == ConnectionState::NOT_CONNECTED) { - logger.debug("State changed to NOT_CONNECTED, skipping UDP ping."); - return; - } - - logger.debug("Sending UDP ping."); +void mumlib::Transport::sendUdpPing() +{ + //logger.warn("Sending UDP ping."); 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) { + 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, 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,16 +510,16 @@ 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); + //logger.warn("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); + //logger.warn("Sent %d B.", bytesTransferred); if (!ec and bytesTransferred > 0) { } else { @@ -487,7 +530,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); @@ -499,11 +542,11 @@ 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; - uint8_t buff[MAX_TCP_LENGTH]; + uint8_t buff[MAX_UDP_LENGTH]; memcpy(buff, &type_network, sizeof(type_network)); @@ -517,45 +560,56 @@ 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)); } +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."); + logger.warn("sendEncodedAudioPacket: Connection not established."); return; } 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)); - const uint32_t netLength = htonl(length); + const uint32_t netLength = htonl(static_cast(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)); - 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)); + sendSsl(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: 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; diff --git a/src/VarInt.cpp b/src/VarInt.cpp index 2eeebf8..fdf179b 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); @@ -23,10 +23,10 @@ int64_t mumlib::VarInt::parseVariant(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; } @@ -36,7 +36,8 @@ int64_t mumlib::VarInt::parseVariant(uint8_t *buffer) { return (v & 0x1F) << 16 | buffer[1] << 8 | buffer[2]; } - throw VarIntException("invalid varint"); + return 0; + //throw VarIntException("invalid varint"); } std::vector mumlib::VarInt::getEncoded() const { @@ -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 08197d1..08fdf3b 100644 --- a/src/mumlib.cpp +++ b/src/mumlib.cpp @@ -8,9 +8,14 @@ #include #include +#include #include -#include +#if defined(__MSYS__) && defined(__URUSSTUDIO__) +#include "Mumble.pb-msys.h" +#else +#include "Mumble.pb.h" +#endif using namespace std; using namespace boost::asio; @@ -32,18 +37,31 @@ namespace mumlib { int sessionId = 0; int channelId = 0; + int64_t seq = 0; + + std::vector listMumbleUser; + std::vector listMumbleChannel; _Mumlib_Private(Callback &callback, MumlibConfiguration &configuration) : _Mumlib_Private(callback, *(new io_service()), configuration) { 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); } @@ -60,19 +78,31 @@ namespace mumlib { auto incomingAudioPacket = audio.decodeIncomingAudioPacket(buffer, length); if (type == AudioPacketType::OPUS) { - int16_t pcmData[5000]; - auto status = audio.decodeOpusPayload(incomingAudioPacket.audioPayload, - incomingAudioPacket.audioPayloadLength, - pcmData, - 5000); + int16_t frame_size = DEFAULT_OPUS_SAMPLE_RATE / 1000 * 20 * 8; + int16_t pcmData[frame_size]; + + audio.addFrameToBuffer(incomingAudioPacket.audioPayload, + incomingAudioPacket.audioPayloadLength, + seq); + + auto status = audio.decodeOpusPayload(incomingAudioPacket.sessionId, pcmData, frame_size); + + // auto status = audio.decodeOpusPayload(incomingAudioPacket.audioPayload, + // incomingAudioPacket.audioPayloadLength, + // incomingAudioPacket.sessionId, + // 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."); + logger.warn("Incoming audio packet doesn't contain Opus data, calling unsupportedAudio callback. Type: %d", type); callback.unsupportedAudio(incomingAudioPacket.target, incomingAudioPacket.sessionId, incomingAudioPacket.sequenceNumber, @@ -122,6 +152,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; @@ -152,7 +187,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(), @@ -175,6 +217,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, @@ -200,6 +246,18 @@ 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; + } + + MumbleUser mumbleUser; + mumbleUser.name = userState.name(); + mumbleUser.sessionId = session; + + if(not isListUserContains(session)) { + listMumbleUser.push_back(mumbleUser); + } + callback.userState(session, actor, userState.name(), @@ -334,7 +392,37 @@ 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); + return; + } + } + } + + bool isListChannelContains(int channelId) { + for(int i = 0; i < listMumbleChannel.size(); i++) + if(listMumbleChannel[i].channelId == channelId) + 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); + return; + } + } + } }; Mumlib::Mumlib(Callback &callback) { @@ -363,13 +451,25 @@ namespace mumlib { return impl->transport.getConnectionState(); } + int Mumlib::getChannelId() { + return impl->channelId; + } + + vector Mumlib::getListAllUser() { + return impl->listMumbleUser; + } + + vector Mumlib::getListAllChannel() { + return impl->listMumbleChannel; + } + void Mumlib::connect(string host, int port, string user, string password) { impl->transport.connect(host, port, user, password); } void Mumlib::disconnect() { if (not impl->externalIoService) { - impl->ioService.reset(); + impl->ioService.stop(); } if (impl->transport.getConnectionState() != ConnectionState::NOT_CONNECTED) { impl->transport.disconnect(); @@ -385,8 +485,12 @@ namespace mumlib { } void Mumlib::sendAudioData(int16_t *pcmData, int pcmLength) { + Mumlib::sendAudioDataTarget(0, pcmData, pcmLength); + } + + void Mumlib::sendAudioDataTarget(int targetId, int16_t *pcmData, int pcmLength) { uint8_t encodedData[5000]; - int length = impl->audio.encodeAudioPacket(0, pcmData, pcmLength, encodedData, 5000); + int length = impl->audio.encodeAudioPacket(targetId, pcmData, pcmLength, encodedData, 5000); impl->transport.sendEncodedAudioPacket(encodedData, length); } @@ -394,14 +498,152 @@ 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); } 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); impl->channelId = channelId; } + + void Mumlib::joinChannel(string name) { + int channelId = Mumlib::getChannelIdBy(name); + Mumlib::joinChannel(channelId); + } + + void Mumlib::sendVoiceTarget(int targetId, VoiceTargetType type, int id) { + static MumbleProto::VoiceTarget voiceTarget; + MumbleProto::VoiceTarget_Target voiceTargetTarget; + 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, VoiceTargetType type, string name, int &error) { + int id; + switch(type) { + case VoiceTargetType::CHANNEL: + id = getChannelIdBy(name); + break; + case VoiceTargetType::USER: + id = getUserIdBy(name); + break; + default: + break; + } + error = id < 0 ? 1: 0; + if(error) return; + sendVoiceTarget(targetId, type, id); + } + + 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; + + // 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) + userState.set_comment(val); + else + userState.set_comment_hash(mdString); + break; + default: + // in any other case, just ignore the command + return; + } + + impl->transport.sendControlMessage(MessageType::USERSTATE, userState); + } + + int Mumlib::getChannelIdBy(string name) { + vector listMumbleChannel = impl->listMumbleChannel; + for(int i = 0; i < listMumbleChannel.size(); i++) + if(listMumbleChannel[i].name == name) + return listMumbleChannel[i].channelId; + return -1; + } + + int Mumlib::getUserIdBy(string name) { + vector listMumbleUser = impl->listMumbleUser; + for(int i = 0; i < listMumbleUser.size(); i++) + if(listMumbleUser[i].name == name) + 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; + } }