diff --git a/pokerth.proto b/pokerth.proto index d39b446e..41f45a0e 100644 --- a/pokerth.proto +++ b/pokerth.proto @@ -696,10 +696,30 @@ message AdminRemoveGameMessage { required uint32 removeGameId = 1; } +message AdminRemoveGameAckMessage { + required uint32 removeGameId = 1; + enum AdminRemoveGameResult { + gameRemoveAccepted = 0; + gameRemoveInvalid = 1; + } + required AdminRemoveGameResult removeGameResult = 2; +} + message AdminBanPlayerMessage { required uint32 banPlayerId = 1; } +message AdminBanPlayerAckMessage { + required uint32 banPlayerId = 1; + enum AdminBanPlayerResult { + banPlayerAccepted = 0; + banPlayerInvalid = 1; + banPlayerNoDB = 2; + banPlayerDBError = 3; + } + required AdminBanPlayerResult banPlayerResult = 2; +} + // The main message type (it is prefixed by 4 bytes length of the message). message PokerTHMessage { @@ -778,7 +798,9 @@ message PokerTHMessage { Type_ReportGameAckMessage = 72; Type_ErrorMessage = 73; Type_AdminRemoveGameMessage = 74; - Type_AdminBanPlayerMessage = 75; + Type_AdminRemoveGameAckMessage = 75; + Type_AdminBanPlayerMessage = 76; + Type_AdminBanPlayerAckMessage = 77; } required PokerTHMessageType messageType = 1; @@ -856,5 +878,7 @@ message PokerTHMessage { optional ReportGameAckMessage reportGameAckMessage = 73; optional ErrorMessage errorMessage = 74; optional AdminRemoveGameMessage adminRemoveGameMessage = 75; - optional AdminBanPlayerMessage adminBanPlayerMessage = 76; + optional AdminRemoveGameAckMessage adminRemoveGameAckMessage = 76; + optional AdminBanPlayerMessage adminBanPlayerMessage = 77; + optional AdminBanPlayerAckMessage adminBanPlayerAckMessage = 78; } diff --git a/src/net/common/netpacketvalidator.cpp b/src/net/common/netpacketvalidator.cpp index 8c26140b..978d0631 100644 --- a/src/net/common/netpacketvalidator.cpp +++ b/src/net/common/netpacketvalidator.cpp @@ -129,7 +129,9 @@ NetPacketValidator::NetPacketValidator() m_validationMap.insert(make_pair(PokerTHMessage_PokerTHMessageType_Type_ReportGameAckMessage, ValidateReportGameAckMessage)); m_validationMap.insert(make_pair(PokerTHMessage_PokerTHMessageType_Type_ErrorMessage, ValidateErrorMessage)); m_validationMap.insert(make_pair(PokerTHMessage_PokerTHMessageType_Type_AdminRemoveGameMessage, ValidateAdminRemoveGameMessage)); + m_validationMap.insert(make_pair(PokerTHMessage_PokerTHMessageType_Type_AdminRemoveGameAckMessage, ValidateAdminRemoveGameAckMessage)); m_validationMap.insert(make_pair(PokerTHMessage_PokerTHMessageType_Type_AdminBanPlayerMessage, ValidateAdminBanPlayerMessage)); + m_validationMap.insert(make_pair(PokerTHMessage_PokerTHMessageType_Type_AdminBanPlayerAckMessage, ValidateAdminBanPlayerAckMessage)); } bool @@ -1160,6 +1162,19 @@ NetPacketValidator::ValidateAdminRemoveGameMessage(const NetPacket &packet) return retVal; } +bool +NetPacketValidator::ValidateAdminRemoveGameAckMessage(const NetPacket &packet) +{ + bool retVal = false; + if (packet.GetMsg()->has_adminremovegameackmessage()) { + const AdminRemoveGameAckMessage &msg = packet.GetMsg()->adminremovegameackmessage(); + if (msg.removegameid() != 0) { + retVal = true; + } + } + return retVal; +} + bool NetPacketValidator::ValidateAdminBanPlayerMessage(const NetPacket &packet) { @@ -1173,6 +1188,19 @@ NetPacketValidator::ValidateAdminBanPlayerMessage(const NetPacket &packet) return retVal; } +bool +NetPacketValidator::ValidateAdminBanPlayerAckMessage(const NetPacket &packet) +{ + bool retVal = false; + if (packet.GetMsg()->has_adminbanplayerackmessage()) { + const AdminBanPlayerAckMessage &msg = packet.GetMsg()->adminbanplayerackmessage(); + if (msg.banplayerid() != 0) { + retVal = true; + } + } + return retVal; +} + bool NetPacketValidator::ValidateGameInfo(const NetGameInfo &gameInfo) { diff --git a/src/net/common/servergamestate.cpp b/src/net/common/servergamestate.cpp index 4579778f..2d7bd063 100644 --- a/src/net/common/servergamestate.cpp +++ b/src/net/common/servergamestate.cpp @@ -657,6 +657,10 @@ ServerGameStateInit::InternalProcessPacket(boost::shared_ptr server, if (session->GetPlayerData()->IsGameAdmin()) { RegisterAdminTimer(server); } + } else if (packet->GetMsg()->messagetype() == PokerTHMessage::Type_AdminRemoveGameMessage) { + server->GetLobbyThread().HandleAdminRemoveGame(session, packet->GetMsg()->adminremovegamemessage()); + } else if (packet->GetMsg()->messagetype() == PokerTHMessage::Type_AdminBanPlayerMessage) { + server->GetLobbyThread().HandleAdminBanPlayer(session, packet->GetMsg()->adminbanplayermessage()); } else { server->SessionError(session, ERR_SOCK_INVALID_PACKET); } diff --git a/src/net/common/serverlobbythread.cpp b/src/net/common/serverlobbythread.cpp index a13ef8c1..310d62bf 100644 --- a/src/net/common/serverlobbythread.cpp +++ b/src/net/common/serverlobbythread.cpp @@ -516,6 +516,20 @@ ServerLobbyThread::HandleChatRequest(boost::shared_ptr session, con HandleNetPacketChatRequest(session, chatRequest); } +void +ServerLobbyThread::HandleAdminRemoveGame(boost::shared_ptr session, const AdminRemoveGameMessage &removeGame) +{ + // An admin within a game sent a remove game message. + HandleNetPacketAdminRemoveGame(session, removeGame); +} + +void +ServerLobbyThread::HandleAdminBanPlayer(boost::shared_ptr session, const AdminBanPlayerMessage &banPlayer) +{ + // An admin within a game sent a ban player message. + HandleNetPacketAdminBanPlayer(session, banPlayer); +} + bool ServerLobbyThread::KickPlayerByName(const std::string &playerName) { @@ -1478,9 +1492,20 @@ ServerLobbyThread::HandleNetPacketAdminRemoveGame(boost::shared_ptr { GameMap::iterator pos = m_gameMap.find(removeGame.removegameid()); + // Create Ack-Packet. + boost::shared_ptr packet(new NetPacket); + packet->GetMsg()->set_messagetype(PokerTHMessage::Type_AdminRemoveGameAckMessage); + AdminRemoveGameAckMessage *netRemoveAck = packet->GetMsg()->mutable_adminremovegameackmessage(); + netRemoveAck->set_removegameid(removeGame.removegameid()); + + // Check whether game id is valid and whether the player is an admin. if (pos != m_gameMap.end() && session->GetPlayerData() && GetBanManager().IsAdminPlayer(session->GetPlayerData()->GetDBId())) { InternalRemoveGame(pos->second); + netRemoveAck->set_removegameresult(AdminRemoveGameAckMessage::gameRemoveAccepted); + } else { + netRemoveAck->set_removegameresult(AdminRemoveGameAckMessage::gameRemoveInvalid); } + GetSender().Send(session, packet); } void diff --git a/src/net/netpacketvalidator.h b/src/net/netpacketvalidator.h index ed159b3a..f290075d 100644 --- a/src/net/netpacketvalidator.h +++ b/src/net/netpacketvalidator.h @@ -120,7 +120,9 @@ protected: static bool ValidateReportGameAckMessage(const NetPacket &packet); static bool ValidateErrorMessage(const NetPacket &packet); static bool ValidateAdminRemoveGameMessage(const NetPacket &packet); + static bool ValidateAdminRemoveGameAckMessage(const NetPacket &packet); static bool ValidateAdminBanPlayerMessage(const NetPacket &packet); + static bool ValidateAdminBanPlayerAckMessage(const NetPacket &packet); static bool ValidateGameInfo(const NetGameInfo &gameInfo); diff --git a/src/net/serverlobbythread.h b/src/net/serverlobbythread.h index 0e60f3d9..df7706c9 100644 --- a/src/net/serverlobbythread.h +++ b/src/net/serverlobbythread.h @@ -88,6 +88,8 @@ public: void HandleGameRetrieveAvatar(boost::shared_ptr session, const AvatarRequestMessage &retrieveAvatar); void HandleGameReportGame(boost::shared_ptr session, const ReportGameMessage &reportGame); void HandleChatRequest(boost::shared_ptr session, const ChatRequestMessage &chatRequest); + void HandleAdminRemoveGame(boost::shared_ptr session, const AdminRemoveGameMessage &removeGame); + void HandleAdminBanPlayer(boost::shared_ptr session, const AdminBanPlayerMessage &banPlayer); bool KickPlayerByName(const std::string &playerName); bool RemoveGameByPlayerName(const std::string &playerName); diff --git a/src/third_party/protobuf/pokerth.pb.cc b/src/third_party/protobuf/pokerth.pb.cc index bdfd5d7b..9db897a3 100644 --- a/src/third_party/protobuf/pokerth.pb.cc +++ b/src/third_party/protobuf/pokerth.pb.cc @@ -94,7 +94,9 @@ void protobuf_ShutdownFile_pokerth_2eproto() { delete ReportGameAckMessage::default_instance_; delete ErrorMessage::default_instance_; delete AdminRemoveGameMessage::default_instance_; + delete AdminRemoveGameAckMessage::default_instance_; delete AdminBanPlayerMessage::default_instance_; + delete AdminBanPlayerAckMessage::default_instance_; delete PokerTHMessage::default_instance_; } @@ -187,7 +189,9 @@ void protobuf_AddDesc_pokerth_2eproto() { ReportGameAckMessage::default_instance_ = new ReportGameAckMessage(); ErrorMessage::default_instance_ = new ErrorMessage(); AdminRemoveGameMessage::default_instance_ = new AdminRemoveGameMessage(); + AdminRemoveGameAckMessage::default_instance_ = new AdminRemoveGameAckMessage(); AdminBanPlayerMessage::default_instance_ = new AdminBanPlayerMessage(); + AdminBanPlayerAckMessage::default_instance_ = new AdminBanPlayerAckMessage(); PokerTHMessage::default_instance_ = new PokerTHMessage(); NetGameInfo::default_instance_->InitAsDefaultInstance(); PlayerResult::default_instance_->InitAsDefaultInstance(); @@ -272,7 +276,9 @@ void protobuf_AddDesc_pokerth_2eproto() { ReportGameAckMessage::default_instance_->InitAsDefaultInstance(); ErrorMessage::default_instance_->InitAsDefaultInstance(); AdminRemoveGameMessage::default_instance_->InitAsDefaultInstance(); + AdminRemoveGameAckMessage::default_instance_->InitAsDefaultInstance(); AdminBanPlayerMessage::default_instance_->InitAsDefaultInstance(); + AdminBanPlayerAckMessage::default_instance_->InitAsDefaultInstance(); PokerTHMessage::default_instance_->InitAsDefaultInstance(); ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_pokerth_2eproto); } @@ -19546,6 +19552,220 @@ void AdminRemoveGameMessage::Swap(AdminRemoveGameMessage* other) { } +// =================================================================== + +bool AdminRemoveGameAckMessage_AdminRemoveGameResult_IsValid(int value) { + switch(value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +#ifndef _MSC_VER +const AdminRemoveGameAckMessage_AdminRemoveGameResult AdminRemoveGameAckMessage::gameRemoveAccepted; +const AdminRemoveGameAckMessage_AdminRemoveGameResult AdminRemoveGameAckMessage::gameRemoveInvalid; +const AdminRemoveGameAckMessage_AdminRemoveGameResult AdminRemoveGameAckMessage::AdminRemoveGameResult_MIN; +const AdminRemoveGameAckMessage_AdminRemoveGameResult AdminRemoveGameAckMessage::AdminRemoveGameResult_MAX; +const int AdminRemoveGameAckMessage::AdminRemoveGameResult_ARRAYSIZE; +#endif // _MSC_VER +#ifndef _MSC_VER +const int AdminRemoveGameAckMessage::kRemoveGameIdFieldNumber; +const int AdminRemoveGameAckMessage::kRemoveGameResultFieldNumber; +#endif // !_MSC_VER + +AdminRemoveGameAckMessage::AdminRemoveGameAckMessage() + : ::google::protobuf::MessageLite() { + SharedCtor(); +} + +void AdminRemoveGameAckMessage::InitAsDefaultInstance() { +} + +AdminRemoveGameAckMessage::AdminRemoveGameAckMessage(const AdminRemoveGameAckMessage& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); +} + +void AdminRemoveGameAckMessage::SharedCtor() { + _cached_size_ = 0; + removegameid_ = 0u; + removegameresult_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +AdminRemoveGameAckMessage::~AdminRemoveGameAckMessage() { + SharedDtor(); +} + +void AdminRemoveGameAckMessage::SharedDtor() { + if (this != default_instance_) { + } +} + +void AdminRemoveGameAckMessage::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const AdminRemoveGameAckMessage& AdminRemoveGameAckMessage::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto(); return *default_instance_; +} + +AdminRemoveGameAckMessage* AdminRemoveGameAckMessage::default_instance_ = NULL; + +AdminRemoveGameAckMessage* AdminRemoveGameAckMessage::New() const { + return new AdminRemoveGameAckMessage; +} + +void AdminRemoveGameAckMessage::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + removegameid_ = 0u; + removegameresult_ = 0; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +bool AdminRemoveGameAckMessage::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required uint32 removeGameId = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &removegameid_))); + set_has_removegameid(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(16)) goto parse_removeGameResult; + break; + } + + // required .AdminRemoveGameAckMessage.AdminRemoveGameResult removeGameResult = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_removeGameResult: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::AdminRemoveGameAckMessage_AdminRemoveGameResult_IsValid(value)) { + set_removegameresult(static_cast< ::AdminRemoveGameAckMessage_AdminRemoveGameResult >(value)); + } + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } + return true; +#undef DO_ +} + +void AdminRemoveGameAckMessage::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required uint32 removeGameId = 1; + if (has_removegameid()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->removegameid(), output); + } + + // required .AdminRemoveGameAckMessage.AdminRemoveGameResult removeGameResult = 2; + if (has_removegameresult()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 2, this->removegameresult(), output); + } + +} + +int AdminRemoveGameAckMessage::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required uint32 removeGameId = 1; + if (has_removegameid()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->removegameid()); + } + + // required .AdminRemoveGameAckMessage.AdminRemoveGameResult removeGameResult = 2; + if (has_removegameresult()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->removegameresult()); + } + + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void AdminRemoveGameAckMessage::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void AdminRemoveGameAckMessage::MergeFrom(const AdminRemoveGameAckMessage& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_removegameid()) { + set_removegameid(from.removegameid()); + } + if (from.has_removegameresult()) { + set_removegameresult(from.removegameresult()); + } + } +} + +void AdminRemoveGameAckMessage::CopyFrom(const AdminRemoveGameAckMessage& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AdminRemoveGameAckMessage::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + return true; +} + +void AdminRemoveGameAckMessage::Swap(AdminRemoveGameAckMessage* other) { + if (other != this) { + std::swap(removegameid_, other->removegameid_); + std::swap(removegameresult_, other->removegameresult_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string AdminRemoveGameAckMessage::GetTypeName() const { + return "AdminRemoveGameAckMessage"; +} + + // =================================================================== #ifndef _MSC_VER @@ -19705,6 +19925,224 @@ void AdminBanPlayerMessage::Swap(AdminBanPlayerMessage* other) { } +// =================================================================== + +bool AdminBanPlayerAckMessage_AdminBanPlayerResult_IsValid(int value) { + switch(value) { + case 0: + case 1: + case 2: + case 3: + return true; + default: + return false; + } +} + +#ifndef _MSC_VER +const AdminBanPlayerAckMessage_AdminBanPlayerResult AdminBanPlayerAckMessage::banPlayerAccepted; +const AdminBanPlayerAckMessage_AdminBanPlayerResult AdminBanPlayerAckMessage::banPlayerInvalid; +const AdminBanPlayerAckMessage_AdminBanPlayerResult AdminBanPlayerAckMessage::banPlayerNoDB; +const AdminBanPlayerAckMessage_AdminBanPlayerResult AdminBanPlayerAckMessage::banPlayerDBError; +const AdminBanPlayerAckMessage_AdminBanPlayerResult AdminBanPlayerAckMessage::AdminBanPlayerResult_MIN; +const AdminBanPlayerAckMessage_AdminBanPlayerResult AdminBanPlayerAckMessage::AdminBanPlayerResult_MAX; +const int AdminBanPlayerAckMessage::AdminBanPlayerResult_ARRAYSIZE; +#endif // _MSC_VER +#ifndef _MSC_VER +const int AdminBanPlayerAckMessage::kBanPlayerIdFieldNumber; +const int AdminBanPlayerAckMessage::kBanPlayerResultFieldNumber; +#endif // !_MSC_VER + +AdminBanPlayerAckMessage::AdminBanPlayerAckMessage() + : ::google::protobuf::MessageLite() { + SharedCtor(); +} + +void AdminBanPlayerAckMessage::InitAsDefaultInstance() { +} + +AdminBanPlayerAckMessage::AdminBanPlayerAckMessage(const AdminBanPlayerAckMessage& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); +} + +void AdminBanPlayerAckMessage::SharedCtor() { + _cached_size_ = 0; + banplayerid_ = 0u; + banplayerresult_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +AdminBanPlayerAckMessage::~AdminBanPlayerAckMessage() { + SharedDtor(); +} + +void AdminBanPlayerAckMessage::SharedDtor() { + if (this != default_instance_) { + } +} + +void AdminBanPlayerAckMessage::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const AdminBanPlayerAckMessage& AdminBanPlayerAckMessage::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto(); return *default_instance_; +} + +AdminBanPlayerAckMessage* AdminBanPlayerAckMessage::default_instance_ = NULL; + +AdminBanPlayerAckMessage* AdminBanPlayerAckMessage::New() const { + return new AdminBanPlayerAckMessage; +} + +void AdminBanPlayerAckMessage::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + banplayerid_ = 0u; + banplayerresult_ = 0; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +bool AdminBanPlayerAckMessage::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required uint32 banPlayerId = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &banplayerid_))); + set_has_banplayerid(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(16)) goto parse_banPlayerResult; + break; + } + + // required .AdminBanPlayerAckMessage.AdminBanPlayerResult banPlayerResult = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_banPlayerResult: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::AdminBanPlayerAckMessage_AdminBanPlayerResult_IsValid(value)) { + set_banplayerresult(static_cast< ::AdminBanPlayerAckMessage_AdminBanPlayerResult >(value)); + } + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } + return true; +#undef DO_ +} + +void AdminBanPlayerAckMessage::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required uint32 banPlayerId = 1; + if (has_banplayerid()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->banplayerid(), output); + } + + // required .AdminBanPlayerAckMessage.AdminBanPlayerResult banPlayerResult = 2; + if (has_banplayerresult()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 2, this->banplayerresult(), output); + } + +} + +int AdminBanPlayerAckMessage::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required uint32 banPlayerId = 1; + if (has_banplayerid()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->banplayerid()); + } + + // required .AdminBanPlayerAckMessage.AdminBanPlayerResult banPlayerResult = 2; + if (has_banplayerresult()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->banplayerresult()); + } + + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void AdminBanPlayerAckMessage::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void AdminBanPlayerAckMessage::MergeFrom(const AdminBanPlayerAckMessage& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_banplayerid()) { + set_banplayerid(from.banplayerid()); + } + if (from.has_banplayerresult()) { + set_banplayerresult(from.banplayerresult()); + } + } +} + +void AdminBanPlayerAckMessage::CopyFrom(const AdminBanPlayerAckMessage& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AdminBanPlayerAckMessage::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + return true; +} + +void AdminBanPlayerAckMessage::Swap(AdminBanPlayerAckMessage* other) { + if (other != this) { + std::swap(banplayerid_, other->banplayerid_); + std::swap(banplayerresult_, other->banplayerresult_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string AdminBanPlayerAckMessage::GetTypeName() const { + return "AdminBanPlayerAckMessage"; +} + + // =================================================================== bool PokerTHMessage_PokerTHMessageType_IsValid(int value) { @@ -19784,6 +20222,8 @@ bool PokerTHMessage_PokerTHMessageType_IsValid(int value) { case 73: case 74: case 75: + case 76: + case 77: return true; default: return false; @@ -19865,7 +20305,9 @@ const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_ReportGameMessage; const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_ReportGameAckMessage; const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_ErrorMessage; const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_AdminRemoveGameMessage; +const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_AdminRemoveGameAckMessage; const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_AdminBanPlayerMessage; +const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_AdminBanPlayerAckMessage; const PokerTHMessage_PokerTHMessageType PokerTHMessage::PokerTHMessageType_MIN; const PokerTHMessage_PokerTHMessageType PokerTHMessage::PokerTHMessageType_MAX; const int PokerTHMessage::PokerTHMessageType_ARRAYSIZE; @@ -19946,7 +20388,9 @@ const int PokerTHMessage::kReportGameMessageFieldNumber; const int PokerTHMessage::kReportGameAckMessageFieldNumber; const int PokerTHMessage::kErrorMessageFieldNumber; const int PokerTHMessage::kAdminRemoveGameMessageFieldNumber; +const int PokerTHMessage::kAdminRemoveGameAckMessageFieldNumber; const int PokerTHMessage::kAdminBanPlayerMessageFieldNumber; +const int PokerTHMessage::kAdminBanPlayerAckMessageFieldNumber; #endif // !_MSC_VER PokerTHMessage::PokerTHMessage() @@ -20029,7 +20473,9 @@ void PokerTHMessage::InitAsDefaultInstance() { reportgameackmessage_ = const_cast< ::ReportGameAckMessage*>(&::ReportGameAckMessage::default_instance()); errormessage_ = const_cast< ::ErrorMessage*>(&::ErrorMessage::default_instance()); adminremovegamemessage_ = const_cast< ::AdminRemoveGameMessage*>(&::AdminRemoveGameMessage::default_instance()); + adminremovegameackmessage_ = const_cast< ::AdminRemoveGameAckMessage*>(&::AdminRemoveGameAckMessage::default_instance()); adminbanplayermessage_ = const_cast< ::AdminBanPlayerMessage*>(&::AdminBanPlayerMessage::default_instance()); + adminbanplayerackmessage_ = const_cast< ::AdminBanPlayerAckMessage*>(&::AdminBanPlayerAckMessage::default_instance()); } PokerTHMessage::PokerTHMessage(const PokerTHMessage& from) @@ -20115,7 +20561,9 @@ void PokerTHMessage::SharedCtor() { reportgameackmessage_ = NULL; errormessage_ = NULL; adminremovegamemessage_ = NULL; + adminremovegameackmessage_ = NULL; adminbanplayermessage_ = NULL; + adminbanplayerackmessage_ = NULL; ::memset(_has_bits_, 0, sizeof(_has_bits_)); } @@ -20199,7 +20647,9 @@ void PokerTHMessage::SharedDtor() { delete reportgameackmessage_; delete errormessage_; delete adminremovegamemessage_; + delete adminremovegameackmessage_; delete adminbanplayermessage_; + delete adminbanplayerackmessage_; } } @@ -20461,9 +20911,15 @@ void PokerTHMessage::Clear() { if (has_adminremovegamemessage()) { if (adminremovegamemessage_ != NULL) adminremovegamemessage_->::AdminRemoveGameMessage::Clear(); } + if (has_adminremovegameackmessage()) { + if (adminremovegameackmessage_ != NULL) adminremovegameackmessage_->::AdminRemoveGameAckMessage::Clear(); + } if (has_adminbanplayermessage()) { if (adminbanplayermessage_ != NULL) adminbanplayermessage_->::AdminBanPlayerMessage::Clear(); } + if (has_adminbanplayerackmessage()) { + if (adminbanplayerackmessage_ != NULL) adminbanplayerackmessage_->::AdminBanPlayerAckMessage::Clear(); + } } ::memset(_has_bits_, 0, sizeof(_has_bits_)); } @@ -21524,12 +21980,26 @@ bool PokerTHMessage::MergePartialFromCodedStream( } else { goto handle_uninterpreted; } - if (input->ExpectTag(610)) goto parse_adminBanPlayerMessage; + if (input->ExpectTag(610)) goto parse_adminRemoveGameAckMessage; break; } - // optional .AdminBanPlayerMessage adminBanPlayerMessage = 76; + // optional .AdminRemoveGameAckMessage adminRemoveGameAckMessage = 76; case 76: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_adminRemoveGameAckMessage: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_adminremovegameackmessage())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(618)) goto parse_adminBanPlayerMessage; + break; + } + + // optional .AdminBanPlayerMessage adminBanPlayerMessage = 77; + case 77: { if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { parse_adminBanPlayerMessage: @@ -21538,6 +22008,20 @@ bool PokerTHMessage::MergePartialFromCodedStream( } else { goto handle_uninterpreted; } + if (input->ExpectTag(626)) goto parse_adminBanPlayerAckMessage; + break; + } + + // optional .AdminBanPlayerAckMessage adminBanPlayerAckMessage = 78; + case 78: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_adminBanPlayerAckMessage: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_adminbanplayerackmessage())); + } else { + goto handle_uninterpreted; + } if (input->ExpectAtEnd()) return true; break; } @@ -22009,10 +22493,22 @@ void PokerTHMessage::SerializeWithCachedSizes( 75, this->adminremovegamemessage(), output); } - // optional .AdminBanPlayerMessage adminBanPlayerMessage = 76; + // optional .AdminRemoveGameAckMessage adminRemoveGameAckMessage = 76; + if (has_adminremovegameackmessage()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 76, this->adminremovegameackmessage(), output); + } + + // optional .AdminBanPlayerMessage adminBanPlayerMessage = 77; if (has_adminbanplayermessage()) { ::google::protobuf::internal::WireFormatLite::WriteMessage( - 76, this->adminbanplayermessage(), output); + 77, this->adminbanplayermessage(), output); + } + + // optional .AdminBanPlayerAckMessage adminBanPlayerAckMessage = 78; + if (has_adminbanplayerackmessage()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 78, this->adminbanplayerackmessage(), output); } } @@ -22563,13 +23059,27 @@ int PokerTHMessage::ByteSize() const { this->adminremovegamemessage()); } - // optional .AdminBanPlayerMessage adminBanPlayerMessage = 76; + // optional .AdminRemoveGameAckMessage adminRemoveGameAckMessage = 76; + if (has_adminremovegameackmessage()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->adminremovegameackmessage()); + } + + // optional .AdminBanPlayerMessage adminBanPlayerMessage = 77; if (has_adminbanplayermessage()) { total_size += 2 + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( this->adminbanplayermessage()); } + // optional .AdminBanPlayerAckMessage adminBanPlayerAckMessage = 78; + if (has_adminbanplayerackmessage()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->adminbanplayerackmessage()); + } + } GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; @@ -22828,9 +23338,15 @@ void PokerTHMessage::MergeFrom(const PokerTHMessage& from) { if (from.has_adminremovegamemessage()) { mutable_adminremovegamemessage()->::AdminRemoveGameMessage::MergeFrom(from.adminremovegamemessage()); } + if (from.has_adminremovegameackmessage()) { + mutable_adminremovegameackmessage()->::AdminRemoveGameAckMessage::MergeFrom(from.adminremovegameackmessage()); + } if (from.has_adminbanplayermessage()) { mutable_adminbanplayermessage()->::AdminBanPlayerMessage::MergeFrom(from.adminbanplayermessage()); } + if (from.has_adminbanplayerackmessage()) { + mutable_adminbanplayerackmessage()->::AdminBanPlayerAckMessage::MergeFrom(from.adminbanplayerackmessage()); + } } } @@ -23056,9 +23572,15 @@ bool PokerTHMessage::IsInitialized() const { if (has_adminremovegamemessage()) { if (!this->adminremovegamemessage().IsInitialized()) return false; } + if (has_adminremovegameackmessage()) { + if (!this->adminremovegameackmessage().IsInitialized()) return false; + } if (has_adminbanplayermessage()) { if (!this->adminbanplayermessage().IsInitialized()) return false; } + if (has_adminbanplayerackmessage()) { + if (!this->adminbanplayerackmessage().IsInitialized()) return false; + } return true; } @@ -23139,7 +23661,9 @@ void PokerTHMessage::Swap(PokerTHMessage* other) { std::swap(reportgameackmessage_, other->reportgameackmessage_); std::swap(errormessage_, other->errormessage_); std::swap(adminremovegamemessage_, other->adminremovegamemessage_); + std::swap(adminremovegameackmessage_, other->adminremovegameackmessage_); std::swap(adminbanplayermessage_, other->adminbanplayermessage_); + std::swap(adminbanplayerackmessage_, other->adminbanplayerackmessage_); std::swap(_has_bits_[0], other->_has_bits_[0]); std::swap(_has_bits_[1], other->_has_bits_[1]); std::swap(_has_bits_[2], other->_has_bits_[2]); diff --git a/src/third_party/protobuf/pokerth.pb.h b/src/third_party/protobuf/pokerth.pb.h index f6112a64..f74de861 100644 --- a/src/third_party/protobuf/pokerth.pb.h +++ b/src/third_party/protobuf/pokerth.pb.h @@ -112,7 +112,9 @@ class ReportGameMessage; class ReportGameAckMessage; class ErrorMessage; class AdminRemoveGameMessage; +class AdminRemoveGameAckMessage; class AdminBanPlayerMessage; +class AdminBanPlayerAckMessage; class PokerTHMessage; enum NetGameInfo_NetGameType { @@ -357,6 +359,26 @@ const ErrorMessage_ErrorReason ErrorMessage_ErrorReason_ErrorReason_MIN = ErrorM const ErrorMessage_ErrorReason ErrorMessage_ErrorReason_ErrorReason_MAX = ErrorMessage_ErrorReason_sessionTimeout; const int ErrorMessage_ErrorReason_ErrorReason_ARRAYSIZE = ErrorMessage_ErrorReason_ErrorReason_MAX + 1; +enum AdminRemoveGameAckMessage_AdminRemoveGameResult { + AdminRemoveGameAckMessage_AdminRemoveGameResult_gameRemoveAccepted = 0, + AdminRemoveGameAckMessage_AdminRemoveGameResult_gameRemoveInvalid = 1 +}; +bool AdminRemoveGameAckMessage_AdminRemoveGameResult_IsValid(int value); +const AdminRemoveGameAckMessage_AdminRemoveGameResult AdminRemoveGameAckMessage_AdminRemoveGameResult_AdminRemoveGameResult_MIN = AdminRemoveGameAckMessage_AdminRemoveGameResult_gameRemoveAccepted; +const AdminRemoveGameAckMessage_AdminRemoveGameResult AdminRemoveGameAckMessage_AdminRemoveGameResult_AdminRemoveGameResult_MAX = AdminRemoveGameAckMessage_AdminRemoveGameResult_gameRemoveInvalid; +const int AdminRemoveGameAckMessage_AdminRemoveGameResult_AdminRemoveGameResult_ARRAYSIZE = AdminRemoveGameAckMessage_AdminRemoveGameResult_AdminRemoveGameResult_MAX + 1; + +enum AdminBanPlayerAckMessage_AdminBanPlayerResult { + AdminBanPlayerAckMessage_AdminBanPlayerResult_banPlayerAccepted = 0, + AdminBanPlayerAckMessage_AdminBanPlayerResult_banPlayerInvalid = 1, + AdminBanPlayerAckMessage_AdminBanPlayerResult_banPlayerNoDB = 2, + AdminBanPlayerAckMessage_AdminBanPlayerResult_banPlayerDBError = 3 +}; +bool AdminBanPlayerAckMessage_AdminBanPlayerResult_IsValid(int value); +const AdminBanPlayerAckMessage_AdminBanPlayerResult AdminBanPlayerAckMessage_AdminBanPlayerResult_AdminBanPlayerResult_MIN = AdminBanPlayerAckMessage_AdminBanPlayerResult_banPlayerAccepted; +const AdminBanPlayerAckMessage_AdminBanPlayerResult AdminBanPlayerAckMessage_AdminBanPlayerResult_AdminBanPlayerResult_MAX = AdminBanPlayerAckMessage_AdminBanPlayerResult_banPlayerDBError; +const int AdminBanPlayerAckMessage_AdminBanPlayerResult_AdminBanPlayerResult_ARRAYSIZE = AdminBanPlayerAckMessage_AdminBanPlayerResult_AdminBanPlayerResult_MAX + 1; + enum PokerTHMessage_PokerTHMessageType { PokerTHMessage_PokerTHMessageType_Type_AnnounceMessage = 1, PokerTHMessage_PokerTHMessageType_Type_InitMessage = 2, @@ -432,11 +454,13 @@ enum PokerTHMessage_PokerTHMessageType { PokerTHMessage_PokerTHMessageType_Type_ReportGameAckMessage = 72, PokerTHMessage_PokerTHMessageType_Type_ErrorMessage = 73, PokerTHMessage_PokerTHMessageType_Type_AdminRemoveGameMessage = 74, - PokerTHMessage_PokerTHMessageType_Type_AdminBanPlayerMessage = 75 + PokerTHMessage_PokerTHMessageType_Type_AdminRemoveGameAckMessage = 75, + PokerTHMessage_PokerTHMessageType_Type_AdminBanPlayerMessage = 76, + PokerTHMessage_PokerTHMessageType_Type_AdminBanPlayerAckMessage = 77 }; bool PokerTHMessage_PokerTHMessageType_IsValid(int value); const PokerTHMessage_PokerTHMessageType PokerTHMessage_PokerTHMessageType_PokerTHMessageType_MIN = PokerTHMessage_PokerTHMessageType_Type_AnnounceMessage; -const PokerTHMessage_PokerTHMessageType PokerTHMessage_PokerTHMessageType_PokerTHMessageType_MAX = PokerTHMessage_PokerTHMessageType_Type_AdminBanPlayerMessage; +const PokerTHMessage_PokerTHMessageType PokerTHMessage_PokerTHMessageType_PokerTHMessageType_MAX = PokerTHMessage_PokerTHMessageType_Type_AdminBanPlayerAckMessage; const int PokerTHMessage_PokerTHMessageType_PokerTHMessageType_ARRAYSIZE = PokerTHMessage_PokerTHMessageType_PokerTHMessageType_MAX + 1; enum NetGameMode { @@ -8198,6 +8222,98 @@ class AdminRemoveGameMessage : public ::google::protobuf::MessageLite { }; // ------------------------------------------------------------------- +class AdminRemoveGameAckMessage : public ::google::protobuf::MessageLite { + public: + AdminRemoveGameAckMessage(); + virtual ~AdminRemoveGameAckMessage(); + + AdminRemoveGameAckMessage(const AdminRemoveGameAckMessage& from); + + inline AdminRemoveGameAckMessage& operator=(const AdminRemoveGameAckMessage& from) { + CopyFrom(from); + return *this; + } + + static const AdminRemoveGameAckMessage& default_instance(); + + void Swap(AdminRemoveGameAckMessage* other); + + // implements Message ---------------------------------------------- + + AdminRemoveGameAckMessage* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const AdminRemoveGameAckMessage& from); + void MergeFrom(const AdminRemoveGameAckMessage& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + typedef AdminRemoveGameAckMessage_AdminRemoveGameResult AdminRemoveGameResult; + static const AdminRemoveGameResult gameRemoveAccepted = AdminRemoveGameAckMessage_AdminRemoveGameResult_gameRemoveAccepted; + static const AdminRemoveGameResult gameRemoveInvalid = AdminRemoveGameAckMessage_AdminRemoveGameResult_gameRemoveInvalid; + static inline bool AdminRemoveGameResult_IsValid(int value) { + return AdminRemoveGameAckMessage_AdminRemoveGameResult_IsValid(value); + } + static const AdminRemoveGameResult AdminRemoveGameResult_MIN = + AdminRemoveGameAckMessage_AdminRemoveGameResult_AdminRemoveGameResult_MIN; + static const AdminRemoveGameResult AdminRemoveGameResult_MAX = + AdminRemoveGameAckMessage_AdminRemoveGameResult_AdminRemoveGameResult_MAX; + static const int AdminRemoveGameResult_ARRAYSIZE = + AdminRemoveGameAckMessage_AdminRemoveGameResult_AdminRemoveGameResult_ARRAYSIZE; + + // accessors ------------------------------------------------------- + + // required uint32 removeGameId = 1; + inline bool has_removegameid() const; + inline void clear_removegameid(); + static const int kRemoveGameIdFieldNumber = 1; + inline ::google::protobuf::uint32 removegameid() const; + inline void set_removegameid(::google::protobuf::uint32 value); + + // required .AdminRemoveGameAckMessage.AdminRemoveGameResult removeGameResult = 2; + inline bool has_removegameresult() const; + inline void clear_removegameresult(); + static const int kRemoveGameResultFieldNumber = 2; + inline ::AdminRemoveGameAckMessage_AdminRemoveGameResult removegameresult() const; + inline void set_removegameresult(::AdminRemoveGameAckMessage_AdminRemoveGameResult value); + + // @@protoc_insertion_point(class_scope:AdminRemoveGameAckMessage) + private: + inline void set_has_removegameid(); + inline void clear_has_removegameid(); + inline void set_has_removegameresult(); + inline void clear_has_removegameresult(); + + ::google::protobuf::uint32 removegameid_; + int removegameresult_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; + + friend void protobuf_AddDesc_pokerth_2eproto(); + friend void protobuf_AssignDesc_pokerth_2eproto(); + friend void protobuf_ShutdownFile_pokerth_2eproto(); + + void InitAsDefaultInstance(); + static AdminRemoveGameAckMessage* default_instance_; +}; +// ------------------------------------------------------------------- + class AdminBanPlayerMessage : public ::google::protobuf::MessageLite { public: AdminBanPlayerMessage(); @@ -8267,6 +8383,100 @@ class AdminBanPlayerMessage : public ::google::protobuf::MessageLite { }; // ------------------------------------------------------------------- +class AdminBanPlayerAckMessage : public ::google::protobuf::MessageLite { + public: + AdminBanPlayerAckMessage(); + virtual ~AdminBanPlayerAckMessage(); + + AdminBanPlayerAckMessage(const AdminBanPlayerAckMessage& from); + + inline AdminBanPlayerAckMessage& operator=(const AdminBanPlayerAckMessage& from) { + CopyFrom(from); + return *this; + } + + static const AdminBanPlayerAckMessage& default_instance(); + + void Swap(AdminBanPlayerAckMessage* other); + + // implements Message ---------------------------------------------- + + AdminBanPlayerAckMessage* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const AdminBanPlayerAckMessage& from); + void MergeFrom(const AdminBanPlayerAckMessage& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + typedef AdminBanPlayerAckMessage_AdminBanPlayerResult AdminBanPlayerResult; + static const AdminBanPlayerResult banPlayerAccepted = AdminBanPlayerAckMessage_AdminBanPlayerResult_banPlayerAccepted; + static const AdminBanPlayerResult banPlayerInvalid = AdminBanPlayerAckMessage_AdminBanPlayerResult_banPlayerInvalid; + static const AdminBanPlayerResult banPlayerNoDB = AdminBanPlayerAckMessage_AdminBanPlayerResult_banPlayerNoDB; + static const AdminBanPlayerResult banPlayerDBError = AdminBanPlayerAckMessage_AdminBanPlayerResult_banPlayerDBError; + static inline bool AdminBanPlayerResult_IsValid(int value) { + return AdminBanPlayerAckMessage_AdminBanPlayerResult_IsValid(value); + } + static const AdminBanPlayerResult AdminBanPlayerResult_MIN = + AdminBanPlayerAckMessage_AdminBanPlayerResult_AdminBanPlayerResult_MIN; + static const AdminBanPlayerResult AdminBanPlayerResult_MAX = + AdminBanPlayerAckMessage_AdminBanPlayerResult_AdminBanPlayerResult_MAX; + static const int AdminBanPlayerResult_ARRAYSIZE = + AdminBanPlayerAckMessage_AdminBanPlayerResult_AdminBanPlayerResult_ARRAYSIZE; + + // accessors ------------------------------------------------------- + + // required uint32 banPlayerId = 1; + inline bool has_banplayerid() const; + inline void clear_banplayerid(); + static const int kBanPlayerIdFieldNumber = 1; + inline ::google::protobuf::uint32 banplayerid() const; + inline void set_banplayerid(::google::protobuf::uint32 value); + + // required .AdminBanPlayerAckMessage.AdminBanPlayerResult banPlayerResult = 2; + inline bool has_banplayerresult() const; + inline void clear_banplayerresult(); + static const int kBanPlayerResultFieldNumber = 2; + inline ::AdminBanPlayerAckMessage_AdminBanPlayerResult banplayerresult() const; + inline void set_banplayerresult(::AdminBanPlayerAckMessage_AdminBanPlayerResult value); + + // @@protoc_insertion_point(class_scope:AdminBanPlayerAckMessage) + private: + inline void set_has_banplayerid(); + inline void clear_has_banplayerid(); + inline void set_has_banplayerresult(); + inline void clear_has_banplayerresult(); + + ::google::protobuf::uint32 banplayerid_; + int banplayerresult_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; + + friend void protobuf_AddDesc_pokerth_2eproto(); + friend void protobuf_AssignDesc_pokerth_2eproto(); + friend void protobuf_ShutdownFile_pokerth_2eproto(); + + void InitAsDefaultInstance(); + static AdminBanPlayerAckMessage* default_instance_; +}; +// ------------------------------------------------------------------- + class PokerTHMessage : public ::google::protobuf::MessageLite { public: PokerTHMessage(); @@ -8383,7 +8593,9 @@ class PokerTHMessage : public ::google::protobuf::MessageLite { static const PokerTHMessageType Type_ReportGameAckMessage = PokerTHMessage_PokerTHMessageType_Type_ReportGameAckMessage; static const PokerTHMessageType Type_ErrorMessage = PokerTHMessage_PokerTHMessageType_Type_ErrorMessage; static const PokerTHMessageType Type_AdminRemoveGameMessage = PokerTHMessage_PokerTHMessageType_Type_AdminRemoveGameMessage; + static const PokerTHMessageType Type_AdminRemoveGameAckMessage = PokerTHMessage_PokerTHMessageType_Type_AdminRemoveGameAckMessage; static const PokerTHMessageType Type_AdminBanPlayerMessage = PokerTHMessage_PokerTHMessageType_Type_AdminBanPlayerMessage; + static const PokerTHMessageType Type_AdminBanPlayerAckMessage = PokerTHMessage_PokerTHMessageType_Type_AdminBanPlayerAckMessage; static inline bool PokerTHMessageType_IsValid(int value) { return PokerTHMessage_PokerTHMessageType_IsValid(value); } @@ -8995,14 +9207,30 @@ class PokerTHMessage : public ::google::protobuf::MessageLite { inline ::AdminRemoveGameMessage* mutable_adminremovegamemessage(); inline ::AdminRemoveGameMessage* release_adminremovegamemessage(); - // optional .AdminBanPlayerMessage adminBanPlayerMessage = 76; + // optional .AdminRemoveGameAckMessage adminRemoveGameAckMessage = 76; + inline bool has_adminremovegameackmessage() const; + inline void clear_adminremovegameackmessage(); + static const int kAdminRemoveGameAckMessageFieldNumber = 76; + inline const ::AdminRemoveGameAckMessage& adminremovegameackmessage() const; + inline ::AdminRemoveGameAckMessage* mutable_adminremovegameackmessage(); + inline ::AdminRemoveGameAckMessage* release_adminremovegameackmessage(); + + // optional .AdminBanPlayerMessage adminBanPlayerMessage = 77; inline bool has_adminbanplayermessage() const; inline void clear_adminbanplayermessage(); - static const int kAdminBanPlayerMessageFieldNumber = 76; + static const int kAdminBanPlayerMessageFieldNumber = 77; inline const ::AdminBanPlayerMessage& adminbanplayermessage() const; inline ::AdminBanPlayerMessage* mutable_adminbanplayermessage(); inline ::AdminBanPlayerMessage* release_adminbanplayermessage(); + // optional .AdminBanPlayerAckMessage adminBanPlayerAckMessage = 78; + inline bool has_adminbanplayerackmessage() const; + inline void clear_adminbanplayerackmessage(); + static const int kAdminBanPlayerAckMessageFieldNumber = 78; + inline const ::AdminBanPlayerAckMessage& adminbanplayerackmessage() const; + inline ::AdminBanPlayerAckMessage* mutable_adminbanplayerackmessage(); + inline ::AdminBanPlayerAckMessage* release_adminbanplayerackmessage(); + // @@protoc_insertion_point(class_scope:PokerTHMessage) private: inline void set_has_messagetype(); @@ -9155,8 +9383,12 @@ class PokerTHMessage : public ::google::protobuf::MessageLite { inline void clear_has_errormessage(); inline void set_has_adminremovegamemessage(); inline void clear_has_adminremovegamemessage(); + inline void set_has_adminremovegameackmessage(); + inline void clear_has_adminremovegameackmessage(); inline void set_has_adminbanplayermessage(); inline void clear_has_adminbanplayermessage(); + inline void set_has_adminbanplayerackmessage(); + inline void clear_has_adminbanplayerackmessage(); ::AnnounceMessage* announcemessage_; ::InitMessage* initmessage_; @@ -9232,11 +9464,13 @@ class PokerTHMessage : public ::google::protobuf::MessageLite { ::ReportGameAckMessage* reportgameackmessage_; ::ErrorMessage* errormessage_; ::AdminRemoveGameMessage* adminremovegamemessage_; + ::AdminRemoveGameAckMessage* adminremovegameackmessage_; ::AdminBanPlayerMessage* adminbanplayermessage_; + ::AdminBanPlayerAckMessage* adminbanplayerackmessage_; int messagetype_; mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(76 + 31) / 32]; + ::google::protobuf::uint32 _has_bits_[(78 + 31) / 32]; friend void protobuf_AddDesc_pokerth_2eproto(); friend void protobuf_AssignDesc_pokerth_2eproto(); @@ -15665,6 +15899,55 @@ inline void AdminRemoveGameMessage::set_removegameid(::google::protobuf::uint32 // ------------------------------------------------------------------- +// AdminRemoveGameAckMessage + +// required uint32 removeGameId = 1; +inline bool AdminRemoveGameAckMessage::has_removegameid() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void AdminRemoveGameAckMessage::set_has_removegameid() { + _has_bits_[0] |= 0x00000001u; +} +inline void AdminRemoveGameAckMessage::clear_has_removegameid() { + _has_bits_[0] &= ~0x00000001u; +} +inline void AdminRemoveGameAckMessage::clear_removegameid() { + removegameid_ = 0u; + clear_has_removegameid(); +} +inline ::google::protobuf::uint32 AdminRemoveGameAckMessage::removegameid() const { + return removegameid_; +} +inline void AdminRemoveGameAckMessage::set_removegameid(::google::protobuf::uint32 value) { + set_has_removegameid(); + removegameid_ = value; +} + +// required .AdminRemoveGameAckMessage.AdminRemoveGameResult removeGameResult = 2; +inline bool AdminRemoveGameAckMessage::has_removegameresult() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void AdminRemoveGameAckMessage::set_has_removegameresult() { + _has_bits_[0] |= 0x00000002u; +} +inline void AdminRemoveGameAckMessage::clear_has_removegameresult() { + _has_bits_[0] &= ~0x00000002u; +} +inline void AdminRemoveGameAckMessage::clear_removegameresult() { + removegameresult_ = 0; + clear_has_removegameresult(); +} +inline ::AdminRemoveGameAckMessage_AdminRemoveGameResult AdminRemoveGameAckMessage::removegameresult() const { + return static_cast< ::AdminRemoveGameAckMessage_AdminRemoveGameResult >(removegameresult_); +} +inline void AdminRemoveGameAckMessage::set_removegameresult(::AdminRemoveGameAckMessage_AdminRemoveGameResult value) { + GOOGLE_DCHECK(::AdminRemoveGameAckMessage_AdminRemoveGameResult_IsValid(value)); + set_has_removegameresult(); + removegameresult_ = value; +} + +// ------------------------------------------------------------------- + // AdminBanPlayerMessage // required uint32 banPlayerId = 1; @@ -15691,6 +15974,55 @@ inline void AdminBanPlayerMessage::set_banplayerid(::google::protobuf::uint32 va // ------------------------------------------------------------------- +// AdminBanPlayerAckMessage + +// required uint32 banPlayerId = 1; +inline bool AdminBanPlayerAckMessage::has_banplayerid() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void AdminBanPlayerAckMessage::set_has_banplayerid() { + _has_bits_[0] |= 0x00000001u; +} +inline void AdminBanPlayerAckMessage::clear_has_banplayerid() { + _has_bits_[0] &= ~0x00000001u; +} +inline void AdminBanPlayerAckMessage::clear_banplayerid() { + banplayerid_ = 0u; + clear_has_banplayerid(); +} +inline ::google::protobuf::uint32 AdminBanPlayerAckMessage::banplayerid() const { + return banplayerid_; +} +inline void AdminBanPlayerAckMessage::set_banplayerid(::google::protobuf::uint32 value) { + set_has_banplayerid(); + banplayerid_ = value; +} + +// required .AdminBanPlayerAckMessage.AdminBanPlayerResult banPlayerResult = 2; +inline bool AdminBanPlayerAckMessage::has_banplayerresult() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void AdminBanPlayerAckMessage::set_has_banplayerresult() { + _has_bits_[0] |= 0x00000002u; +} +inline void AdminBanPlayerAckMessage::clear_has_banplayerresult() { + _has_bits_[0] &= ~0x00000002u; +} +inline void AdminBanPlayerAckMessage::clear_banplayerresult() { + banplayerresult_ = 0; + clear_has_banplayerresult(); +} +inline ::AdminBanPlayerAckMessage_AdminBanPlayerResult AdminBanPlayerAckMessage::banplayerresult() const { + return static_cast< ::AdminBanPlayerAckMessage_AdminBanPlayerResult >(banplayerresult_); +} +inline void AdminBanPlayerAckMessage::set_banplayerresult(::AdminBanPlayerAckMessage_AdminBanPlayerResult value) { + GOOGLE_DCHECK(::AdminBanPlayerAckMessage_AdminBanPlayerResult_IsValid(value)); + set_has_banplayerresult(); + banplayerresult_ = value; +} + +// ------------------------------------------------------------------- + // PokerTHMessage // required .PokerTHMessage.PokerTHMessageType messageType = 1; @@ -17862,16 +18194,45 @@ inline ::AdminRemoveGameMessage* PokerTHMessage::release_adminremovegamemessage( return temp; } -// optional .AdminBanPlayerMessage adminBanPlayerMessage = 76; -inline bool PokerTHMessage::has_adminbanplayermessage() const { +// optional .AdminRemoveGameAckMessage adminRemoveGameAckMessage = 76; +inline bool PokerTHMessage::has_adminremovegameackmessage() const { return (_has_bits_[2] & 0x00000800u) != 0; } -inline void PokerTHMessage::set_has_adminbanplayermessage() { +inline void PokerTHMessage::set_has_adminremovegameackmessage() { _has_bits_[2] |= 0x00000800u; } -inline void PokerTHMessage::clear_has_adminbanplayermessage() { +inline void PokerTHMessage::clear_has_adminremovegameackmessage() { _has_bits_[2] &= ~0x00000800u; } +inline void PokerTHMessage::clear_adminremovegameackmessage() { + if (adminremovegameackmessage_ != NULL) adminremovegameackmessage_->::AdminRemoveGameAckMessage::Clear(); + clear_has_adminremovegameackmessage(); +} +inline const ::AdminRemoveGameAckMessage& PokerTHMessage::adminremovegameackmessage() const { + return adminremovegameackmessage_ != NULL ? *adminremovegameackmessage_ : *default_instance_->adminremovegameackmessage_; +} +inline ::AdminRemoveGameAckMessage* PokerTHMessage::mutable_adminremovegameackmessage() { + set_has_adminremovegameackmessage(); + if (adminremovegameackmessage_ == NULL) adminremovegameackmessage_ = new ::AdminRemoveGameAckMessage; + return adminremovegameackmessage_; +} +inline ::AdminRemoveGameAckMessage* PokerTHMessage::release_adminremovegameackmessage() { + clear_has_adminremovegameackmessage(); + ::AdminRemoveGameAckMessage* temp = adminremovegameackmessage_; + adminremovegameackmessage_ = NULL; + return temp; +} + +// optional .AdminBanPlayerMessage adminBanPlayerMessage = 77; +inline bool PokerTHMessage::has_adminbanplayermessage() const { + return (_has_bits_[2] & 0x00001000u) != 0; +} +inline void PokerTHMessage::set_has_adminbanplayermessage() { + _has_bits_[2] |= 0x00001000u; +} +inline void PokerTHMessage::clear_has_adminbanplayermessage() { + _has_bits_[2] &= ~0x00001000u; +} inline void PokerTHMessage::clear_adminbanplayermessage() { if (adminbanplayermessage_ != NULL) adminbanplayermessage_->::AdminBanPlayerMessage::Clear(); clear_has_adminbanplayermessage(); @@ -17891,6 +18252,35 @@ inline ::AdminBanPlayerMessage* PokerTHMessage::release_adminbanplayermessage() return temp; } +// optional .AdminBanPlayerAckMessage adminBanPlayerAckMessage = 78; +inline bool PokerTHMessage::has_adminbanplayerackmessage() const { + return (_has_bits_[2] & 0x00002000u) != 0; +} +inline void PokerTHMessage::set_has_adminbanplayerackmessage() { + _has_bits_[2] |= 0x00002000u; +} +inline void PokerTHMessage::clear_has_adminbanplayerackmessage() { + _has_bits_[2] &= ~0x00002000u; +} +inline void PokerTHMessage::clear_adminbanplayerackmessage() { + if (adminbanplayerackmessage_ != NULL) adminbanplayerackmessage_->::AdminBanPlayerAckMessage::Clear(); + clear_has_adminbanplayerackmessage(); +} +inline const ::AdminBanPlayerAckMessage& PokerTHMessage::adminbanplayerackmessage() const { + return adminbanplayerackmessage_ != NULL ? *adminbanplayerackmessage_ : *default_instance_->adminbanplayerackmessage_; +} +inline ::AdminBanPlayerAckMessage* PokerTHMessage::mutable_adminbanplayerackmessage() { + set_has_adminbanplayerackmessage(); + if (adminbanplayerackmessage_ == NULL) adminbanplayerackmessage_ = new ::AdminBanPlayerAckMessage; + return adminbanplayerackmessage_; +} +inline ::AdminBanPlayerAckMessage* PokerTHMessage::release_adminbanplayerackmessage() { + clear_has_adminbanplayerackmessage(); + ::AdminBanPlayerAckMessage* temp = adminbanplayerackmessage_; + adminbanplayerackmessage_ = NULL; + return temp; +} + // @@protoc_insertion_point(namespace_scope) diff --git a/tests/src/de/pokerth/protocol/ProtoBuf.java b/tests/src/de/pokerth/protocol/ProtoBuf.java index ba1f3915..1f43c828 100644 --- a/tests/src/de/pokerth/protocol/ProtoBuf.java +++ b/tests/src/de/pokerth/protocol/ProtoBuf.java @@ -36615,6 +36615,410 @@ public final class ProtoBuf { // @@protoc_insertion_point(class_scope:AdminRemoveGameMessage) } + public interface AdminRemoveGameAckMessageOrBuilder + extends com.google.protobuf.MessageLiteOrBuilder { + + // required uint32 removeGameId = 1; + boolean hasRemoveGameId(); + int getRemoveGameId(); + + // required .AdminRemoveGameAckMessage.AdminRemoveGameResult removeGameResult = 2; + boolean hasRemoveGameResult(); + de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage.AdminRemoveGameResult getRemoveGameResult(); + } + public static final class AdminRemoveGameAckMessage extends + com.google.protobuf.GeneratedMessageLite + implements AdminRemoveGameAckMessageOrBuilder { + // Use AdminRemoveGameAckMessage.newBuilder() to construct. + private AdminRemoveGameAckMessage(Builder builder) { + super(builder); + } + private AdminRemoveGameAckMessage(boolean noInit) {} + + private static final AdminRemoveGameAckMessage defaultInstance; + public static AdminRemoveGameAckMessage getDefaultInstance() { + return defaultInstance; + } + + public AdminRemoveGameAckMessage getDefaultInstanceForType() { + return defaultInstance; + } + + public enum AdminRemoveGameResult + implements com.google.protobuf.Internal.EnumLite { + gameRemoveAccepted(0, 0), + gameRemoveInvalid(1, 1), + ; + + public static final int gameRemoveAccepted_VALUE = 0; + public static final int gameRemoveInvalid_VALUE = 1; + + + public final int getNumber() { return value; } + + public static AdminRemoveGameResult valueOf(int value) { + switch (value) { + case 0: return gameRemoveAccepted; + case 1: return gameRemoveInvalid; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static com.google.protobuf.Internal.EnumLiteMap + internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public AdminRemoveGameResult findValueByNumber(int number) { + return AdminRemoveGameResult.valueOf(number); + } + }; + + private final int value; + + private AdminRemoveGameResult(int index, int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:AdminRemoveGameAckMessage.AdminRemoveGameResult) + } + + private int bitField0_; + // required uint32 removeGameId = 1; + public static final int REMOVEGAMEID_FIELD_NUMBER = 1; + private int removeGameId_; + public boolean hasRemoveGameId() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + public int getRemoveGameId() { + return removeGameId_; + } + + // required .AdminRemoveGameAckMessage.AdminRemoveGameResult removeGameResult = 2; + public static final int REMOVEGAMERESULT_FIELD_NUMBER = 2; + private de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage.AdminRemoveGameResult removeGameResult_; + public boolean hasRemoveGameResult() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + public de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage.AdminRemoveGameResult getRemoveGameResult() { + return removeGameResult_; + } + + private void initFields() { + removeGameId_ = 0; + removeGameResult_ = de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage.AdminRemoveGameResult.gameRemoveAccepted; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + if (!hasRemoveGameId()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasRemoveGameResult()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeUInt32(1, removeGameId_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeEnum(2, removeGameResult_.getNumber()); + } + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += com.google.protobuf.CodedOutputStream + .computeUInt32Size(1, removeGameId_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(2, removeGameResult_.getNumber()); + } + memoizedSerializedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + protected java.lang.Object writeReplace() + throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + public static de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage parseFrom(java.io.InputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + public static de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input, extensionRegistry)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + public static final class Builder extends + com.google.protobuf.GeneratedMessageLite.Builder< + de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage, Builder> + implements de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessageOrBuilder { + // Construct using de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + removeGameId_ = 0; + bitField0_ = (bitField0_ & ~0x00000001); + removeGameResult_ = de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage.AdminRemoveGameResult.gameRemoveAccepted; + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage getDefaultInstanceForType() { + return de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage.getDefaultInstance(); + } + + public de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage build() { + de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + private de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage buildParsed() + throws com.google.protobuf.InvalidProtocolBufferException { + de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException( + result).asInvalidProtocolBufferException(); + } + return result; + } + + public de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage buildPartial() { + de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage result = new de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.removeGameId_ = removeGameId_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.removeGameResult_ = removeGameResult_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage other) { + if (other == de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage.getDefaultInstance()) return this; + if (other.hasRemoveGameId()) { + setRemoveGameId(other.getRemoveGameId()); + } + if (other.hasRemoveGameResult()) { + setRemoveGameResult(other.getRemoveGameResult()); + } + return this; + } + + public final boolean isInitialized() { + if (!hasRemoveGameId()) { + + return false; + } + if (!hasRemoveGameResult()) { + + return false; + } + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + while (true) { + int tag = input.readTag(); + switch (tag) { + case 0: + + return this; + default: { + if (!parseUnknownField(input, extensionRegistry, tag)) { + + return this; + } + break; + } + case 8: { + bitField0_ |= 0x00000001; + removeGameId_ = input.readUInt32(); + break; + } + case 16: { + int rawValue = input.readEnum(); + de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage.AdminRemoveGameResult value = de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage.AdminRemoveGameResult.valueOf(rawValue); + if (value != null) { + bitField0_ |= 0x00000002; + removeGameResult_ = value; + } + break; + } + } + } + } + + private int bitField0_; + + // required uint32 removeGameId = 1; + private int removeGameId_ ; + public boolean hasRemoveGameId() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + public int getRemoveGameId() { + return removeGameId_; + } + public Builder setRemoveGameId(int value) { + bitField0_ |= 0x00000001; + removeGameId_ = value; + + return this; + } + public Builder clearRemoveGameId() { + bitField0_ = (bitField0_ & ~0x00000001); + removeGameId_ = 0; + + return this; + } + + // required .AdminRemoveGameAckMessage.AdminRemoveGameResult removeGameResult = 2; + private de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage.AdminRemoveGameResult removeGameResult_ = de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage.AdminRemoveGameResult.gameRemoveAccepted; + public boolean hasRemoveGameResult() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + public de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage.AdminRemoveGameResult getRemoveGameResult() { + return removeGameResult_; + } + public Builder setRemoveGameResult(de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage.AdminRemoveGameResult value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + removeGameResult_ = value; + + return this; + } + public Builder clearRemoveGameResult() { + bitField0_ = (bitField0_ & ~0x00000002); + removeGameResult_ = de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage.AdminRemoveGameResult.gameRemoveAccepted; + + return this; + } + + // @@protoc_insertion_point(builder_scope:AdminRemoveGameAckMessage) + } + + static { + defaultInstance = new AdminRemoveGameAckMessage(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:AdminRemoveGameAckMessage) + } + public interface AdminBanPlayerMessageOrBuilder extends com.google.protobuf.MessageLiteOrBuilder { @@ -36906,6 +37310,416 @@ public final class ProtoBuf { // @@protoc_insertion_point(class_scope:AdminBanPlayerMessage) } + public interface AdminBanPlayerAckMessageOrBuilder + extends com.google.protobuf.MessageLiteOrBuilder { + + // required uint32 banPlayerId = 1; + boolean hasBanPlayerId(); + int getBanPlayerId(); + + // required .AdminBanPlayerAckMessage.AdminBanPlayerResult banPlayerResult = 2; + boolean hasBanPlayerResult(); + de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage.AdminBanPlayerResult getBanPlayerResult(); + } + public static final class AdminBanPlayerAckMessage extends + com.google.protobuf.GeneratedMessageLite + implements AdminBanPlayerAckMessageOrBuilder { + // Use AdminBanPlayerAckMessage.newBuilder() to construct. + private AdminBanPlayerAckMessage(Builder builder) { + super(builder); + } + private AdminBanPlayerAckMessage(boolean noInit) {} + + private static final AdminBanPlayerAckMessage defaultInstance; + public static AdminBanPlayerAckMessage getDefaultInstance() { + return defaultInstance; + } + + public AdminBanPlayerAckMessage getDefaultInstanceForType() { + return defaultInstance; + } + + public enum AdminBanPlayerResult + implements com.google.protobuf.Internal.EnumLite { + banPlayerAccepted(0, 0), + banPlayerInvalid(1, 1), + banPlayerNoDB(2, 2), + banPlayerDBError(3, 3), + ; + + public static final int banPlayerAccepted_VALUE = 0; + public static final int banPlayerInvalid_VALUE = 1; + public static final int banPlayerNoDB_VALUE = 2; + public static final int banPlayerDBError_VALUE = 3; + + + public final int getNumber() { return value; } + + public static AdminBanPlayerResult valueOf(int value) { + switch (value) { + case 0: return banPlayerAccepted; + case 1: return banPlayerInvalid; + case 2: return banPlayerNoDB; + case 3: return banPlayerDBError; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static com.google.protobuf.Internal.EnumLiteMap + internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public AdminBanPlayerResult findValueByNumber(int number) { + return AdminBanPlayerResult.valueOf(number); + } + }; + + private final int value; + + private AdminBanPlayerResult(int index, int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:AdminBanPlayerAckMessage.AdminBanPlayerResult) + } + + private int bitField0_; + // required uint32 banPlayerId = 1; + public static final int BANPLAYERID_FIELD_NUMBER = 1; + private int banPlayerId_; + public boolean hasBanPlayerId() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + public int getBanPlayerId() { + return banPlayerId_; + } + + // required .AdminBanPlayerAckMessage.AdminBanPlayerResult banPlayerResult = 2; + public static final int BANPLAYERRESULT_FIELD_NUMBER = 2; + private de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage.AdminBanPlayerResult banPlayerResult_; + public boolean hasBanPlayerResult() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + public de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage.AdminBanPlayerResult getBanPlayerResult() { + return banPlayerResult_; + } + + private void initFields() { + banPlayerId_ = 0; + banPlayerResult_ = de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage.AdminBanPlayerResult.banPlayerAccepted; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + if (!hasBanPlayerId()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasBanPlayerResult()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeUInt32(1, banPlayerId_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeEnum(2, banPlayerResult_.getNumber()); + } + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += com.google.protobuf.CodedOutputStream + .computeUInt32Size(1, banPlayerId_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(2, banPlayerResult_.getNumber()); + } + memoizedSerializedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + protected java.lang.Object writeReplace() + throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + public static de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage parseFrom(java.io.InputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + public static de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input, extensionRegistry)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + public static final class Builder extends + com.google.protobuf.GeneratedMessageLite.Builder< + de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage, Builder> + implements de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessageOrBuilder { + // Construct using de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + banPlayerId_ = 0; + bitField0_ = (bitField0_ & ~0x00000001); + banPlayerResult_ = de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage.AdminBanPlayerResult.banPlayerAccepted; + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage getDefaultInstanceForType() { + return de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage.getDefaultInstance(); + } + + public de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage build() { + de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + private de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage buildParsed() + throws com.google.protobuf.InvalidProtocolBufferException { + de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException( + result).asInvalidProtocolBufferException(); + } + return result; + } + + public de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage buildPartial() { + de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage result = new de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.banPlayerId_ = banPlayerId_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.banPlayerResult_ = banPlayerResult_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage other) { + if (other == de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage.getDefaultInstance()) return this; + if (other.hasBanPlayerId()) { + setBanPlayerId(other.getBanPlayerId()); + } + if (other.hasBanPlayerResult()) { + setBanPlayerResult(other.getBanPlayerResult()); + } + return this; + } + + public final boolean isInitialized() { + if (!hasBanPlayerId()) { + + return false; + } + if (!hasBanPlayerResult()) { + + return false; + } + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + while (true) { + int tag = input.readTag(); + switch (tag) { + case 0: + + return this; + default: { + if (!parseUnknownField(input, extensionRegistry, tag)) { + + return this; + } + break; + } + case 8: { + bitField0_ |= 0x00000001; + banPlayerId_ = input.readUInt32(); + break; + } + case 16: { + int rawValue = input.readEnum(); + de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage.AdminBanPlayerResult value = de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage.AdminBanPlayerResult.valueOf(rawValue); + if (value != null) { + bitField0_ |= 0x00000002; + banPlayerResult_ = value; + } + break; + } + } + } + } + + private int bitField0_; + + // required uint32 banPlayerId = 1; + private int banPlayerId_ ; + public boolean hasBanPlayerId() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + public int getBanPlayerId() { + return banPlayerId_; + } + public Builder setBanPlayerId(int value) { + bitField0_ |= 0x00000001; + banPlayerId_ = value; + + return this; + } + public Builder clearBanPlayerId() { + bitField0_ = (bitField0_ & ~0x00000001); + banPlayerId_ = 0; + + return this; + } + + // required .AdminBanPlayerAckMessage.AdminBanPlayerResult banPlayerResult = 2; + private de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage.AdminBanPlayerResult banPlayerResult_ = de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage.AdminBanPlayerResult.banPlayerAccepted; + public boolean hasBanPlayerResult() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + public de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage.AdminBanPlayerResult getBanPlayerResult() { + return banPlayerResult_; + } + public Builder setBanPlayerResult(de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage.AdminBanPlayerResult value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + banPlayerResult_ = value; + + return this; + } + public Builder clearBanPlayerResult() { + bitField0_ = (bitField0_ & ~0x00000002); + banPlayerResult_ = de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage.AdminBanPlayerResult.banPlayerAccepted; + + return this; + } + + // @@protoc_insertion_point(builder_scope:AdminBanPlayerAckMessage) + } + + static { + defaultInstance = new AdminBanPlayerAckMessage(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:AdminBanPlayerAckMessage) + } + public interface PokerTHMessageOrBuilder extends com.google.protobuf.MessageLiteOrBuilder { @@ -37209,9 +38023,17 @@ public final class ProtoBuf { boolean hasAdminRemoveGameMessage(); de.pokerth.protocol.ProtoBuf.AdminRemoveGameMessage getAdminRemoveGameMessage(); - // optional .AdminBanPlayerMessage adminBanPlayerMessage = 76; + // optional .AdminRemoveGameAckMessage adminRemoveGameAckMessage = 76; + boolean hasAdminRemoveGameAckMessage(); + de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage getAdminRemoveGameAckMessage(); + + // optional .AdminBanPlayerMessage adminBanPlayerMessage = 77; boolean hasAdminBanPlayerMessage(); de.pokerth.protocol.ProtoBuf.AdminBanPlayerMessage getAdminBanPlayerMessage(); + + // optional .AdminBanPlayerAckMessage adminBanPlayerAckMessage = 78; + boolean hasAdminBanPlayerAckMessage(); + de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage getAdminBanPlayerAckMessage(); } public static final class PokerTHMessage extends com.google.protobuf.GeneratedMessageLite @@ -37307,7 +38129,9 @@ public final class ProtoBuf { Type_ReportGameAckMessage(71, 72), Type_ErrorMessage(72, 73), Type_AdminRemoveGameMessage(73, 74), - Type_AdminBanPlayerMessage(74, 75), + Type_AdminRemoveGameAckMessage(74, 75), + Type_AdminBanPlayerMessage(75, 76), + Type_AdminBanPlayerAckMessage(76, 77), ; public static final int Type_AnnounceMessage_VALUE = 1; @@ -37384,7 +38208,9 @@ public final class ProtoBuf { public static final int Type_ReportGameAckMessage_VALUE = 72; public static final int Type_ErrorMessage_VALUE = 73; public static final int Type_AdminRemoveGameMessage_VALUE = 74; - public static final int Type_AdminBanPlayerMessage_VALUE = 75; + public static final int Type_AdminRemoveGameAckMessage_VALUE = 75; + public static final int Type_AdminBanPlayerMessage_VALUE = 76; + public static final int Type_AdminBanPlayerAckMessage_VALUE = 77; public final int getNumber() { return value; } @@ -37465,7 +38291,9 @@ public final class ProtoBuf { case 72: return Type_ReportGameAckMessage; case 73: return Type_ErrorMessage; case 74: return Type_AdminRemoveGameMessage; - case 75: return Type_AdminBanPlayerMessage; + case 75: return Type_AdminRemoveGameAckMessage; + case 76: return Type_AdminBanPlayerMessage; + case 77: return Type_AdminBanPlayerAckMessage; default: return null; } } @@ -38244,16 +39072,36 @@ public final class ProtoBuf { return adminRemoveGameMessage_; } - // optional .AdminBanPlayerMessage adminBanPlayerMessage = 76; - public static final int ADMINBANPLAYERMESSAGE_FIELD_NUMBER = 76; + // optional .AdminRemoveGameAckMessage adminRemoveGameAckMessage = 76; + public static final int ADMINREMOVEGAMEACKMESSAGE_FIELD_NUMBER = 76; + private de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage adminRemoveGameAckMessage_; + public boolean hasAdminRemoveGameAckMessage() { + return ((bitField2_ & 0x00000800) == 0x00000800); + } + public de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage getAdminRemoveGameAckMessage() { + return adminRemoveGameAckMessage_; + } + + // optional .AdminBanPlayerMessage adminBanPlayerMessage = 77; + public static final int ADMINBANPLAYERMESSAGE_FIELD_NUMBER = 77; private de.pokerth.protocol.ProtoBuf.AdminBanPlayerMessage adminBanPlayerMessage_; public boolean hasAdminBanPlayerMessage() { - return ((bitField2_ & 0x00000800) == 0x00000800); + return ((bitField2_ & 0x00001000) == 0x00001000); } public de.pokerth.protocol.ProtoBuf.AdminBanPlayerMessage getAdminBanPlayerMessage() { return adminBanPlayerMessage_; } + // optional .AdminBanPlayerAckMessage adminBanPlayerAckMessage = 78; + public static final int ADMINBANPLAYERACKMESSAGE_FIELD_NUMBER = 78; + private de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage adminBanPlayerAckMessage_; + public boolean hasAdminBanPlayerAckMessage() { + return ((bitField2_ & 0x00002000) == 0x00002000); + } + public de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage getAdminBanPlayerAckMessage() { + return adminBanPlayerAckMessage_; + } + private void initFields() { messageType_ = de.pokerth.protocol.ProtoBuf.PokerTHMessage.PokerTHMessageType.Type_AnnounceMessage; announceMessage_ = de.pokerth.protocol.ProtoBuf.AnnounceMessage.getDefaultInstance(); @@ -38330,7 +39178,9 @@ public final class ProtoBuf { reportGameAckMessage_ = de.pokerth.protocol.ProtoBuf.ReportGameAckMessage.getDefaultInstance(); errorMessage_ = de.pokerth.protocol.ProtoBuf.ErrorMessage.getDefaultInstance(); adminRemoveGameMessage_ = de.pokerth.protocol.ProtoBuf.AdminRemoveGameMessage.getDefaultInstance(); + adminRemoveGameAckMessage_ = de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage.getDefaultInstance(); adminBanPlayerMessage_ = de.pokerth.protocol.ProtoBuf.AdminBanPlayerMessage.getDefaultInstance(); + adminBanPlayerAckMessage_ = de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage.getDefaultInstance(); } private byte memoizedIsInitialized = -1; public final boolean isInitialized() { @@ -38767,12 +39617,24 @@ public final class ProtoBuf { return false; } } + if (hasAdminRemoveGameAckMessage()) { + if (!getAdminRemoveGameAckMessage().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } if (hasAdminBanPlayerMessage()) { if (!getAdminBanPlayerMessage().isInitialized()) { memoizedIsInitialized = 0; return false; } } + if (hasAdminBanPlayerAckMessage()) { + if (!getAdminBanPlayerAckMessage().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } memoizedIsInitialized = 1; return true; } @@ -39006,7 +39868,13 @@ public final class ProtoBuf { output.writeMessage(75, adminRemoveGameMessage_); } if (((bitField2_ & 0x00000800) == 0x00000800)) { - output.writeMessage(76, adminBanPlayerMessage_); + output.writeMessage(76, adminRemoveGameAckMessage_); + } + if (((bitField2_ & 0x00001000) == 0x00001000)) { + output.writeMessage(77, adminBanPlayerMessage_); + } + if (((bitField2_ & 0x00002000) == 0x00002000)) { + output.writeMessage(78, adminBanPlayerAckMessage_); } } @@ -39318,7 +40186,15 @@ public final class ProtoBuf { } if (((bitField2_ & 0x00000800) == 0x00000800)) { size += com.google.protobuf.CodedOutputStream - .computeMessageSize(76, adminBanPlayerMessage_); + .computeMessageSize(76, adminRemoveGameAckMessage_); + } + if (((bitField2_ & 0x00001000) == 0x00001000)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(77, adminBanPlayerMessage_); + } + if (((bitField2_ & 0x00002000) == 0x00002000)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(78, adminBanPlayerAckMessage_); } memoizedSerializedSize = size; return size; @@ -39572,8 +40448,12 @@ public final class ProtoBuf { bitField2_ = (bitField2_ & ~0x00000200); adminRemoveGameMessage_ = de.pokerth.protocol.ProtoBuf.AdminRemoveGameMessage.getDefaultInstance(); bitField2_ = (bitField2_ & ~0x00000400); - adminBanPlayerMessage_ = de.pokerth.protocol.ProtoBuf.AdminBanPlayerMessage.getDefaultInstance(); + adminRemoveGameAckMessage_ = de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage.getDefaultInstance(); bitField2_ = (bitField2_ & ~0x00000800); + adminBanPlayerMessage_ = de.pokerth.protocol.ProtoBuf.AdminBanPlayerMessage.getDefaultInstance(); + bitField2_ = (bitField2_ & ~0x00001000); + adminBanPlayerAckMessage_ = de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage.getDefaultInstance(); + bitField2_ = (bitField2_ & ~0x00002000); return this; } @@ -39914,7 +40794,15 @@ public final class ProtoBuf { if (((from_bitField2_ & 0x00000800) == 0x00000800)) { to_bitField2_ |= 0x00000800; } + result.adminRemoveGameAckMessage_ = adminRemoveGameAckMessage_; + if (((from_bitField2_ & 0x00001000) == 0x00001000)) { + to_bitField2_ |= 0x00001000; + } result.adminBanPlayerMessage_ = adminBanPlayerMessage_; + if (((from_bitField2_ & 0x00002000) == 0x00002000)) { + to_bitField2_ |= 0x00002000; + } + result.adminBanPlayerAckMessage_ = adminBanPlayerAckMessage_; result.bitField0_ = to_bitField0_; result.bitField1_ = to_bitField1_; result.bitField2_ = to_bitField2_; @@ -40148,9 +41036,15 @@ public final class ProtoBuf { if (other.hasAdminRemoveGameMessage()) { mergeAdminRemoveGameMessage(other.getAdminRemoveGameMessage()); } + if (other.hasAdminRemoveGameAckMessage()) { + mergeAdminRemoveGameAckMessage(other.getAdminRemoveGameAckMessage()); + } if (other.hasAdminBanPlayerMessage()) { mergeAdminBanPlayerMessage(other.getAdminBanPlayerMessage()); } + if (other.hasAdminBanPlayerAckMessage()) { + mergeAdminBanPlayerAckMessage(other.getAdminBanPlayerAckMessage()); + } return this; } @@ -40585,12 +41479,24 @@ public final class ProtoBuf { return false; } } + if (hasAdminRemoveGameAckMessage()) { + if (!getAdminRemoveGameAckMessage().isInitialized()) { + + return false; + } + } if (hasAdminBanPlayerMessage()) { if (!getAdminBanPlayerMessage().isInitialized()) { return false; } } + if (hasAdminBanPlayerAckMessage()) { + if (!getAdminBanPlayerAckMessage().isInitialized()) { + + return false; + } + } return true; } @@ -41287,6 +42193,15 @@ public final class ProtoBuf { break; } case 610: { + de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage.Builder subBuilder = de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage.newBuilder(); + if (hasAdminRemoveGameAckMessage()) { + subBuilder.mergeFrom(getAdminRemoveGameAckMessage()); + } + input.readMessage(subBuilder, extensionRegistry); + setAdminRemoveGameAckMessage(subBuilder.buildPartial()); + break; + } + case 618: { de.pokerth.protocol.ProtoBuf.AdminBanPlayerMessage.Builder subBuilder = de.pokerth.protocol.ProtoBuf.AdminBanPlayerMessage.newBuilder(); if (hasAdminBanPlayerMessage()) { subBuilder.mergeFrom(getAdminBanPlayerMessage()); @@ -41295,6 +42210,15 @@ public final class ProtoBuf { setAdminBanPlayerMessage(subBuilder.buildPartial()); break; } + case 626: { + de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage.Builder subBuilder = de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage.newBuilder(); + if (hasAdminBanPlayerAckMessage()) { + subBuilder.mergeFrom(getAdminBanPlayerAckMessage()); + } + input.readMessage(subBuilder, extensionRegistry); + setAdminBanPlayerAckMessage(subBuilder.buildPartial()); + break; + } } } } @@ -44509,10 +45433,53 @@ public final class ProtoBuf { return this; } - // optional .AdminBanPlayerMessage adminBanPlayerMessage = 76; + // optional .AdminRemoveGameAckMessage adminRemoveGameAckMessage = 76; + private de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage adminRemoveGameAckMessage_ = de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage.getDefaultInstance(); + public boolean hasAdminRemoveGameAckMessage() { + return ((bitField2_ & 0x00000800) == 0x00000800); + } + public de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage getAdminRemoveGameAckMessage() { + return adminRemoveGameAckMessage_; + } + public Builder setAdminRemoveGameAckMessage(de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage value) { + if (value == null) { + throw new NullPointerException(); + } + adminRemoveGameAckMessage_ = value; + + bitField2_ |= 0x00000800; + return this; + } + public Builder setAdminRemoveGameAckMessage( + de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage.Builder builderForValue) { + adminRemoveGameAckMessage_ = builderForValue.build(); + + bitField2_ |= 0x00000800; + return this; + } + public Builder mergeAdminRemoveGameAckMessage(de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage value) { + if (((bitField2_ & 0x00000800) == 0x00000800) && + adminRemoveGameAckMessage_ != de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage.getDefaultInstance()) { + adminRemoveGameAckMessage_ = + de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage.newBuilder(adminRemoveGameAckMessage_).mergeFrom(value).buildPartial(); + } else { + adminRemoveGameAckMessage_ = value; + } + + bitField2_ |= 0x00000800; + return this; + } + public Builder clearAdminRemoveGameAckMessage() { + adminRemoveGameAckMessage_ = de.pokerth.protocol.ProtoBuf.AdminRemoveGameAckMessage.getDefaultInstance(); + + bitField2_ = (bitField2_ & ~0x00000800); + return this; + } + + // optional .AdminBanPlayerMessage adminBanPlayerMessage = 77; private de.pokerth.protocol.ProtoBuf.AdminBanPlayerMessage adminBanPlayerMessage_ = de.pokerth.protocol.ProtoBuf.AdminBanPlayerMessage.getDefaultInstance(); public boolean hasAdminBanPlayerMessage() { - return ((bitField2_ & 0x00000800) == 0x00000800); + return ((bitField2_ & 0x00001000) == 0x00001000); } public de.pokerth.protocol.ProtoBuf.AdminBanPlayerMessage getAdminBanPlayerMessage() { return adminBanPlayerMessage_; @@ -44523,18 +45490,18 @@ public final class ProtoBuf { } adminBanPlayerMessage_ = value; - bitField2_ |= 0x00000800; + bitField2_ |= 0x00001000; return this; } public Builder setAdminBanPlayerMessage( de.pokerth.protocol.ProtoBuf.AdminBanPlayerMessage.Builder builderForValue) { adminBanPlayerMessage_ = builderForValue.build(); - bitField2_ |= 0x00000800; + bitField2_ |= 0x00001000; return this; } public Builder mergeAdminBanPlayerMessage(de.pokerth.protocol.ProtoBuf.AdminBanPlayerMessage value) { - if (((bitField2_ & 0x00000800) == 0x00000800) && + if (((bitField2_ & 0x00001000) == 0x00001000) && adminBanPlayerMessage_ != de.pokerth.protocol.ProtoBuf.AdminBanPlayerMessage.getDefaultInstance()) { adminBanPlayerMessage_ = de.pokerth.protocol.ProtoBuf.AdminBanPlayerMessage.newBuilder(adminBanPlayerMessage_).mergeFrom(value).buildPartial(); @@ -44542,13 +45509,56 @@ public final class ProtoBuf { adminBanPlayerMessage_ = value; } - bitField2_ |= 0x00000800; + bitField2_ |= 0x00001000; return this; } public Builder clearAdminBanPlayerMessage() { adminBanPlayerMessage_ = de.pokerth.protocol.ProtoBuf.AdminBanPlayerMessage.getDefaultInstance(); - bitField2_ = (bitField2_ & ~0x00000800); + bitField2_ = (bitField2_ & ~0x00001000); + return this; + } + + // optional .AdminBanPlayerAckMessage adminBanPlayerAckMessage = 78; + private de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage adminBanPlayerAckMessage_ = de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage.getDefaultInstance(); + public boolean hasAdminBanPlayerAckMessage() { + return ((bitField2_ & 0x00002000) == 0x00002000); + } + public de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage getAdminBanPlayerAckMessage() { + return adminBanPlayerAckMessage_; + } + public Builder setAdminBanPlayerAckMessage(de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage value) { + if (value == null) { + throw new NullPointerException(); + } + adminBanPlayerAckMessage_ = value; + + bitField2_ |= 0x00002000; + return this; + } + public Builder setAdminBanPlayerAckMessage( + de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage.Builder builderForValue) { + adminBanPlayerAckMessage_ = builderForValue.build(); + + bitField2_ |= 0x00002000; + return this; + } + public Builder mergeAdminBanPlayerAckMessage(de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage value) { + if (((bitField2_ & 0x00002000) == 0x00002000) && + adminBanPlayerAckMessage_ != de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage.getDefaultInstance()) { + adminBanPlayerAckMessage_ = + de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage.newBuilder(adminBanPlayerAckMessage_).mergeFrom(value).buildPartial(); + } else { + adminBanPlayerAckMessage_ = value; + } + + bitField2_ |= 0x00002000; + return this; + } + public Builder clearAdminBanPlayerAckMessage() { + adminBanPlayerAckMessage_ = de.pokerth.protocol.ProtoBuf.AdminBanPlayerAckMessage.getDefaultInstance(); + + bitField2_ = (bitField2_ & ~0x00002000); return this; }