From 12a2c648b6a0a31a44a5cef1454345e1c1927904 Mon Sep 17 00:00:00 2001 From: Nicholas Hastings Date: Wed, 13 Mar 2013 23:54:54 -0400 Subject: [PATCH] Added IServerGameClients::DispatchClientMessage + client message protos, generated code, and helpers. --- public/eiface.h | 4 + .../protobuf/dota_clientmessage_helpers.cpp | 68 + .../protobuf/dota_clientmessage_helpers.h | 27 + .../dota/protobuf/dota_clientmessages.pb.cc | 3862 +++++++++++++++++ .../dota/protobuf/dota_clientmessages.pb.h | 1948 +++++++++ .../dota/protobuf/dota_clientmessages.proto | 172 + 6 files changed, 6081 insertions(+) create mode 100644 public/game/shared/dota/protobuf/dota_clientmessage_helpers.cpp create mode 100644 public/game/shared/dota/protobuf/dota_clientmessage_helpers.h create mode 100644 public/game/shared/dota/protobuf/dota_clientmessages.pb.cc create mode 100644 public/game/shared/dota/protobuf/dota_clientmessages.pb.h create mode 100644 public/game/shared/dota/protobuf/dota_clientmessages.proto diff --git a/public/eiface.h b/public/eiface.h index 7904c08f..4df3d831 100644 --- a/public/eiface.h +++ b/public/eiface.h @@ -691,6 +691,10 @@ public: // The client has submitted a keyvalues command virtual void ClientCommandKeyValues( edict_t *pEntity, KeyValues *pKeyValues ) = 0; + + virtual void UnknownFunc1() = 0; + + virtual bool DispatchClientMessage( edict_t *pEntity, int msg_type, int size, uint8_t *pData ) = 0; }; #define INTERFACEVERSION_UPLOADGAMESTATS "ServerUploadGameStats001" diff --git a/public/game/shared/dota/protobuf/dota_clientmessage_helpers.cpp b/public/game/shared/dota/protobuf/dota_clientmessage_helpers.cpp new file mode 100644 index 00000000..b368c298 --- /dev/null +++ b/public/game/shared/dota/protobuf/dota_clientmessage_helpers.cpp @@ -0,0 +1,68 @@ + +#include "dota_clientmessage_helpers.h" + +CDotaClientMessageHelpers g_DotaClientMessageHelpers; + +#define SETUP_DOTA_MESSAGE( msgname ) \ + m_NameIndexMap.Insert( #msgname, DOTA_CM_##msgname ); \ + m_IndexNameMap[DOTA_CM_##msgname] = #msgname; \ + m_Prototypes[DOTA_CM_##msgname] = &CDOTAClientMsg_##msgname::default_instance(); + +CDotaClientMessageHelpers::CDotaClientMessageHelpers() +{ + // Clear all so that any unused are inited. + memset( m_Prototypes, 0, sizeof(m_Prototypes) ); + memset( m_IndexNameMap, 0, sizeof(m_IndexNameMap) ); + + SETUP_DOTA_MESSAGE( MapLine ); + SETUP_DOTA_MESSAGE( AspectRatio ); + SETUP_DOTA_MESSAGE( MapPing ); + SETUP_DOTA_MESSAGE( UnitsAutoAttack ); + SETUP_DOTA_MESSAGE( AutoPurchaseItems ); + SETUP_DOTA_MESSAGE( TestItems ); + SETUP_DOTA_MESSAGE( SearchString ); + SETUP_DOTA_MESSAGE( Pause ); + SETUP_DOTA_MESSAGE( ShopViewMode ); + SETUP_DOTA_MESSAGE( SetUnitShareFlag ); + SETUP_DOTA_MESSAGE( SwapRequest ); + SETUP_DOTA_MESSAGE( SwapAccept ); + SETUP_DOTA_MESSAGE( WorldLine ); + SETUP_DOTA_MESSAGE( RequestGraphUpdate ); + SETUP_DOTA_MESSAGE( ItemAlert ); + SETUP_DOTA_MESSAGE( ChatWheel ); +} + +const google::protobuf::Message *CDotaClientMessageHelpers::GetPrototype( int index ) const +{ + if( index >= 0 && index < EDotaClientMessages_ARRAYSIZE ) + return m_Prototypes[index]; + + return NULL; +} + +const google::protobuf::Message *CDotaClientMessageHelpers::GetPrototype( const char *name ) const +{ + int index = GetIndex( name ); + if( index > -1 ) + return m_Prototypes[ index ]; + + return NULL; +} + +int CDotaClientMessageHelpers::GetIndex( const char *name ) const +{ + int idx = m_NameIndexMap.Find( name ); + if( idx != m_NameIndexMap.InvalidHandle() ) + return m_NameIndexMap[idx]; + + return -1; +} + +const char *CDotaClientMessageHelpers::GetName( int index ) const +{ + if( index >= 0 && index < EDotaClientMessages_ARRAYSIZE ) + return m_IndexNameMap[index]; + + return NULL; +} + diff --git a/public/game/shared/dota/protobuf/dota_clientmessage_helpers.h b/public/game/shared/dota/protobuf/dota_clientmessage_helpers.h new file mode 100644 index 00000000..3234d4cb --- /dev/null +++ b/public/game/shared/dota/protobuf/dota_clientmessage_helpers.h @@ -0,0 +1,27 @@ +#ifndef DOTA_CM_HELPERS +#define DOTA_CM_HELPERS + +#include +#include + +class CDotaClientMessageHelpers +{ +public: + CDotaClientMessageHelpers(); + + const google::protobuf::Message *GetPrototype( int index ) const; + const google::protobuf::Message *GetPrototype( const char *name ) const; + + int GetIndex( const char *name ) const; + + const char *GetName( int index ) const; + +private: + CUtlHashDict m_NameIndexMap; + const char *m_IndexNameMap[EDotaClientMessages_ARRAYSIZE]; + const google::protobuf::Message *m_Prototypes[EDotaClientMessages_ARRAYSIZE]; +}; + +extern CDotaClientMessageHelpers g_DotaClientMessageHelpers; + +#endif // DOTA_CM_HELPERS diff --git a/public/game/shared/dota/protobuf/dota_clientmessages.pb.cc b/public/game/shared/dota/protobuf/dota_clientmessages.pb.cc new file mode 100644 index 00000000..d3065646 --- /dev/null +++ b/public/game/shared/dota/protobuf/dota_clientmessages.pb.cc @@ -0,0 +1,3862 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "dota_clientmessages.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) + +namespace { + +const ::google::protobuf::Descriptor* CDOTAClientMsg_MapPing_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + CDOTAClientMsg_MapPing_reflection_ = NULL; +const ::google::protobuf::Descriptor* CDOTAClientMsg_ItemAlert_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + CDOTAClientMsg_ItemAlert_reflection_ = NULL; +const ::google::protobuf::Descriptor* CDOTAClientMsg_MapLine_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + CDOTAClientMsg_MapLine_reflection_ = NULL; +const ::google::protobuf::Descriptor* CDOTAClientMsg_AspectRatio_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + CDOTAClientMsg_AspectRatio_reflection_ = NULL; +const ::google::protobuf::Descriptor* CDOTAClientMsg_UnitsAutoAttack_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + CDOTAClientMsg_UnitsAutoAttack_reflection_ = NULL; +const ::google::protobuf::Descriptor* CDOTAClientMsg_AutoPurchaseItems_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + CDOTAClientMsg_AutoPurchaseItems_reflection_ = NULL; +const ::google::protobuf::Descriptor* CDOTAClientMsg_TestItems_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + CDOTAClientMsg_TestItems_reflection_ = NULL; +const ::google::protobuf::Descriptor* CDOTAClientMsg_SearchString_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + CDOTAClientMsg_SearchString_reflection_ = NULL; +const ::google::protobuf::Descriptor* CDOTAClientMsg_Pause_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + CDOTAClientMsg_Pause_reflection_ = NULL; +const ::google::protobuf::Descriptor* CDOTAClientMsg_ShopViewMode_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + CDOTAClientMsg_ShopViewMode_reflection_ = NULL; +const ::google::protobuf::Descriptor* CDOTAClientMsg_SetUnitShareFlag_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + CDOTAClientMsg_SetUnitShareFlag_reflection_ = NULL; +const ::google::protobuf::Descriptor* CDOTAClientMsg_SwapRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + CDOTAClientMsg_SwapRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* CDOTAClientMsg_SwapAccept_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + CDOTAClientMsg_SwapAccept_reflection_ = NULL; +const ::google::protobuf::Descriptor* CDOTAClientMsg_WorldLine_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + CDOTAClientMsg_WorldLine_reflection_ = NULL; +const ::google::protobuf::Descriptor* CDOTAClientMsg_RequestGraphUpdate_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + CDOTAClientMsg_RequestGraphUpdate_reflection_ = NULL; +const ::google::protobuf::Descriptor* CDOTAClientMsg_ChatWheel_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + CDOTAClientMsg_ChatWheel_reflection_ = NULL; +const ::google::protobuf::EnumDescriptor* EDotaClientMessages_descriptor_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_dota_5fclientmessages_2eproto() { + protobuf_AddDesc_dota_5fclientmessages_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "dota_clientmessages.proto"); + GOOGLE_CHECK(file != NULL); + CDOTAClientMsg_MapPing_descriptor_ = file->message_type(0); + static const int CDOTAClientMsg_MapPing_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_MapPing, location_ping_), + }; + CDOTAClientMsg_MapPing_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + CDOTAClientMsg_MapPing_descriptor_, + CDOTAClientMsg_MapPing::default_instance_, + CDOTAClientMsg_MapPing_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_MapPing, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_MapPing, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(CDOTAClientMsg_MapPing)); + CDOTAClientMsg_ItemAlert_descriptor_ = file->message_type(1); + static const int CDOTAClientMsg_ItemAlert_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_ItemAlert, item_alert_), + }; + CDOTAClientMsg_ItemAlert_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + CDOTAClientMsg_ItemAlert_descriptor_, + CDOTAClientMsg_ItemAlert::default_instance_, + CDOTAClientMsg_ItemAlert_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_ItemAlert, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_ItemAlert, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(CDOTAClientMsg_ItemAlert)); + CDOTAClientMsg_MapLine_descriptor_ = file->message_type(2); + static const int CDOTAClientMsg_MapLine_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_MapLine, mapline_), + }; + CDOTAClientMsg_MapLine_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + CDOTAClientMsg_MapLine_descriptor_, + CDOTAClientMsg_MapLine::default_instance_, + CDOTAClientMsg_MapLine_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_MapLine, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_MapLine, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(CDOTAClientMsg_MapLine)); + CDOTAClientMsg_AspectRatio_descriptor_ = file->message_type(3); + static const int CDOTAClientMsg_AspectRatio_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_AspectRatio, ratio_), + }; + CDOTAClientMsg_AspectRatio_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + CDOTAClientMsg_AspectRatio_descriptor_, + CDOTAClientMsg_AspectRatio::default_instance_, + CDOTAClientMsg_AspectRatio_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_AspectRatio, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_AspectRatio, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(CDOTAClientMsg_AspectRatio)); + CDOTAClientMsg_UnitsAutoAttack_descriptor_ = file->message_type(4); + static const int CDOTAClientMsg_UnitsAutoAttack_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_UnitsAutoAttack, enabled_), + }; + CDOTAClientMsg_UnitsAutoAttack_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + CDOTAClientMsg_UnitsAutoAttack_descriptor_, + CDOTAClientMsg_UnitsAutoAttack::default_instance_, + CDOTAClientMsg_UnitsAutoAttack_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_UnitsAutoAttack, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_UnitsAutoAttack, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(CDOTAClientMsg_UnitsAutoAttack)); + CDOTAClientMsg_AutoPurchaseItems_descriptor_ = file->message_type(5); + static const int CDOTAClientMsg_AutoPurchaseItems_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_AutoPurchaseItems, enabled_), + }; + CDOTAClientMsg_AutoPurchaseItems_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + CDOTAClientMsg_AutoPurchaseItems_descriptor_, + CDOTAClientMsg_AutoPurchaseItems::default_instance_, + CDOTAClientMsg_AutoPurchaseItems_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_AutoPurchaseItems, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_AutoPurchaseItems, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(CDOTAClientMsg_AutoPurchaseItems)); + CDOTAClientMsg_TestItems_descriptor_ = file->message_type(6); + static const int CDOTAClientMsg_TestItems_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_TestItems, key_values_), + }; + CDOTAClientMsg_TestItems_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + CDOTAClientMsg_TestItems_descriptor_, + CDOTAClientMsg_TestItems::default_instance_, + CDOTAClientMsg_TestItems_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_TestItems, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_TestItems, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(CDOTAClientMsg_TestItems)); + CDOTAClientMsg_SearchString_descriptor_ = file->message_type(7); + static const int CDOTAClientMsg_SearchString_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_SearchString, search_), + }; + CDOTAClientMsg_SearchString_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + CDOTAClientMsg_SearchString_descriptor_, + CDOTAClientMsg_SearchString::default_instance_, + CDOTAClientMsg_SearchString_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_SearchString, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_SearchString, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(CDOTAClientMsg_SearchString)); + CDOTAClientMsg_Pause_descriptor_ = file->message_type(8); + static const int CDOTAClientMsg_Pause_offsets_[1] = { + }; + CDOTAClientMsg_Pause_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + CDOTAClientMsg_Pause_descriptor_, + CDOTAClientMsg_Pause::default_instance_, + CDOTAClientMsg_Pause_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_Pause, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_Pause, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(CDOTAClientMsg_Pause)); + CDOTAClientMsg_ShopViewMode_descriptor_ = file->message_type(9); + static const int CDOTAClientMsg_ShopViewMode_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_ShopViewMode, mode_), + }; + CDOTAClientMsg_ShopViewMode_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + CDOTAClientMsg_ShopViewMode_descriptor_, + CDOTAClientMsg_ShopViewMode::default_instance_, + CDOTAClientMsg_ShopViewMode_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_ShopViewMode, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_ShopViewMode, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(CDOTAClientMsg_ShopViewMode)); + CDOTAClientMsg_SetUnitShareFlag_descriptor_ = file->message_type(10); + static const int CDOTAClientMsg_SetUnitShareFlag_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_SetUnitShareFlag, playerid_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_SetUnitShareFlag, flag_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_SetUnitShareFlag, state_), + }; + CDOTAClientMsg_SetUnitShareFlag_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + CDOTAClientMsg_SetUnitShareFlag_descriptor_, + CDOTAClientMsg_SetUnitShareFlag::default_instance_, + CDOTAClientMsg_SetUnitShareFlag_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_SetUnitShareFlag, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_SetUnitShareFlag, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(CDOTAClientMsg_SetUnitShareFlag)); + CDOTAClientMsg_SwapRequest_descriptor_ = file->message_type(11); + static const int CDOTAClientMsg_SwapRequest_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_SwapRequest, player_id_), + }; + CDOTAClientMsg_SwapRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + CDOTAClientMsg_SwapRequest_descriptor_, + CDOTAClientMsg_SwapRequest::default_instance_, + CDOTAClientMsg_SwapRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_SwapRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_SwapRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(CDOTAClientMsg_SwapRequest)); + CDOTAClientMsg_SwapAccept_descriptor_ = file->message_type(12); + static const int CDOTAClientMsg_SwapAccept_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_SwapAccept, player_id_), + }; + CDOTAClientMsg_SwapAccept_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + CDOTAClientMsg_SwapAccept_descriptor_, + CDOTAClientMsg_SwapAccept::default_instance_, + CDOTAClientMsg_SwapAccept_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_SwapAccept, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_SwapAccept, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(CDOTAClientMsg_SwapAccept)); + CDOTAClientMsg_WorldLine_descriptor_ = file->message_type(13); + static const int CDOTAClientMsg_WorldLine_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_WorldLine, worldline_), + }; + CDOTAClientMsg_WorldLine_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + CDOTAClientMsg_WorldLine_descriptor_, + CDOTAClientMsg_WorldLine::default_instance_, + CDOTAClientMsg_WorldLine_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_WorldLine, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_WorldLine, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(CDOTAClientMsg_WorldLine)); + CDOTAClientMsg_RequestGraphUpdate_descriptor_ = file->message_type(14); + static const int CDOTAClientMsg_RequestGraphUpdate_offsets_[1] = { + }; + CDOTAClientMsg_RequestGraphUpdate_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + CDOTAClientMsg_RequestGraphUpdate_descriptor_, + CDOTAClientMsg_RequestGraphUpdate::default_instance_, + CDOTAClientMsg_RequestGraphUpdate_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_RequestGraphUpdate, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_RequestGraphUpdate, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(CDOTAClientMsg_RequestGraphUpdate)); + CDOTAClientMsg_ChatWheel_descriptor_ = file->message_type(15); + static const int CDOTAClientMsg_ChatWheel_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_ChatWheel, chat_message_), + }; + CDOTAClientMsg_ChatWheel_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + CDOTAClientMsg_ChatWheel_descriptor_, + CDOTAClientMsg_ChatWheel::default_instance_, + CDOTAClientMsg_ChatWheel_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_ChatWheel, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CDOTAClientMsg_ChatWheel, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(CDOTAClientMsg_ChatWheel)); + EDotaClientMessages_descriptor_ = file->enum_type(0); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +inline void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_dota_5fclientmessages_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + CDOTAClientMsg_MapPing_descriptor_, &CDOTAClientMsg_MapPing::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + CDOTAClientMsg_ItemAlert_descriptor_, &CDOTAClientMsg_ItemAlert::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + CDOTAClientMsg_MapLine_descriptor_, &CDOTAClientMsg_MapLine::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + CDOTAClientMsg_AspectRatio_descriptor_, &CDOTAClientMsg_AspectRatio::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + CDOTAClientMsg_UnitsAutoAttack_descriptor_, &CDOTAClientMsg_UnitsAutoAttack::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + CDOTAClientMsg_AutoPurchaseItems_descriptor_, &CDOTAClientMsg_AutoPurchaseItems::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + CDOTAClientMsg_TestItems_descriptor_, &CDOTAClientMsg_TestItems::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + CDOTAClientMsg_SearchString_descriptor_, &CDOTAClientMsg_SearchString::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + CDOTAClientMsg_Pause_descriptor_, &CDOTAClientMsg_Pause::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + CDOTAClientMsg_ShopViewMode_descriptor_, &CDOTAClientMsg_ShopViewMode::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + CDOTAClientMsg_SetUnitShareFlag_descriptor_, &CDOTAClientMsg_SetUnitShareFlag::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + CDOTAClientMsg_SwapRequest_descriptor_, &CDOTAClientMsg_SwapRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + CDOTAClientMsg_SwapAccept_descriptor_, &CDOTAClientMsg_SwapAccept::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + CDOTAClientMsg_WorldLine_descriptor_, &CDOTAClientMsg_WorldLine::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + CDOTAClientMsg_RequestGraphUpdate_descriptor_, &CDOTAClientMsg_RequestGraphUpdate::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + CDOTAClientMsg_ChatWheel_descriptor_, &CDOTAClientMsg_ChatWheel::default_instance()); +} + +} // namespace + +void protobuf_ShutdownFile_dota_5fclientmessages_2eproto() { + delete CDOTAClientMsg_MapPing::default_instance_; + delete CDOTAClientMsg_MapPing_reflection_; + delete CDOTAClientMsg_ItemAlert::default_instance_; + delete CDOTAClientMsg_ItemAlert_reflection_; + delete CDOTAClientMsg_MapLine::default_instance_; + delete CDOTAClientMsg_MapLine_reflection_; + delete CDOTAClientMsg_AspectRatio::default_instance_; + delete CDOTAClientMsg_AspectRatio_reflection_; + delete CDOTAClientMsg_UnitsAutoAttack::default_instance_; + delete CDOTAClientMsg_UnitsAutoAttack_reflection_; + delete CDOTAClientMsg_AutoPurchaseItems::default_instance_; + delete CDOTAClientMsg_AutoPurchaseItems_reflection_; + delete CDOTAClientMsg_TestItems::default_instance_; + delete CDOTAClientMsg_TestItems_reflection_; + delete CDOTAClientMsg_SearchString::default_instance_; + delete CDOTAClientMsg_SearchString_reflection_; + delete CDOTAClientMsg_Pause::default_instance_; + delete CDOTAClientMsg_Pause_reflection_; + delete CDOTAClientMsg_ShopViewMode::default_instance_; + delete CDOTAClientMsg_ShopViewMode_reflection_; + delete CDOTAClientMsg_SetUnitShareFlag::default_instance_; + delete CDOTAClientMsg_SetUnitShareFlag_reflection_; + delete CDOTAClientMsg_SwapRequest::default_instance_; + delete CDOTAClientMsg_SwapRequest_reflection_; + delete CDOTAClientMsg_SwapAccept::default_instance_; + delete CDOTAClientMsg_SwapAccept_reflection_; + delete CDOTAClientMsg_WorldLine::default_instance_; + delete CDOTAClientMsg_WorldLine_reflection_; + delete CDOTAClientMsg_RequestGraphUpdate::default_instance_; + delete CDOTAClientMsg_RequestGraphUpdate_reflection_; + delete CDOTAClientMsg_ChatWheel::default_instance_; + delete CDOTAClientMsg_ChatWheel_reflection_; +} + +void protobuf_AddDesc_dota_5fclientmessages_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::google::protobuf::protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); + ::protobuf_AddDesc_netmessages_2eproto(); + ::protobuf_AddDesc_dota_5fcommonmessages_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\031dota_clientmessages.proto\032 google/prot" + "obuf/descriptor.proto\032\021netmessages.proto" + "\032\031dota_commonmessages.proto\"G\n\026CDOTAClie" + "ntMsg_MapPing\022-\n\rlocation_ping\030\001 \001(\0132\026.C" + "DOTAMsg_LocationPing\"C\n\030CDOTAClientMsg_I" + "temAlert\022\'\n\nitem_alert\030\001 \001(\0132\023.CDOTAMsg_" + "ItemAlert\"<\n\026CDOTAClientMsg_MapLine\022\"\n\007m" + "apline\030\001 \001(\0132\021.CDOTAMsg_MapLine\"+\n\032CDOTA" + "ClientMsg_AspectRatio\022\r\n\005ratio\030\001 \001(\002\"1\n\036" + "CDOTAClientMsg_UnitsAutoAttack\022\017\n\007enable" + "d\030\001 \001(\010\"3\n CDOTAClientMsg_AutoPurchaseIt" + "ems\022\017\n\007enabled\030\001 \001(\010\".\n\030CDOTAClientMsg_T" + "estItems\022\022\n\nkey_values\030\001 \001(\t\"-\n\033CDOTACli" + "entMsg_SearchString\022\016\n\006search\030\001 \001(\t\"\026\n\024C" + "DOTAClientMsg_Pause\"+\n\033CDOTAClientMsg_Sh" + "opViewMode\022\014\n\004mode\030\001 \001(\r\"P\n\037CDOTAClientM" + "sg_SetUnitShareFlag\022\020\n\010playerID\030\001 \001(\r\022\014\n" + "\004flag\030\002 \001(\r\022\r\n\005state\030\003 \001(\010\"/\n\032CDOTAClien" + "tMsg_SwapRequest\022\021\n\tplayer_id\030\001 \001(\r\".\n\031C" + "DOTAClientMsg_SwapAccept\022\021\n\tplayer_id\030\001 " + "\001(\r\"B\n\030CDOTAClientMsg_WorldLine\022&\n\tworld" + "line\030\001 \001(\0132\023.CDOTAMsg_WorldLine\"#\n!CDOTA" + "ClientMsg_RequestGraphUpdate\"W\n\030CDOTACli" + "entMsg_ChatWheel\022;\n\014chat_message\030\001 \001(\0162\026" + ".EDOTAChatWheelMessage:\rk_EDOTA_CW_Ok*\246\003" + "\n\023EDotaClientMessages\022\023\n\017DOTA_CM_MapLine" + "\020\001\022\027\n\023DOTA_CM_AspectRatio\020\002\022\023\n\017DOTA_CM_M" + "apPing\020\003\022\033\n\027DOTA_CM_UnitsAutoAttack\020\004\022\035\n" + "\031DOTA_CM_AutoPurchaseItems\020\005\022\025\n\021DOTA_CM_" + "TestItems\020\006\022\030\n\024DOTA_CM_SearchString\020\007\022\021\n" + "\rDOTA_CM_Pause\020\010\022\030\n\024DOTA_CM_ShopViewMode" + "\020\t\022\034\n\030DOTA_CM_SetUnitShareFlag\020\n\022\027\n\023DOTA" + "_CM_SwapRequest\020\013\022\026\n\022DOTA_CM_SwapAccept\020" + "\014\022\025\n\021DOTA_CM_WorldLine\020\r\022\036\n\032DOTA_CM_Requ" + "estGraphUpdate\020\016\022\025\n\021DOTA_CM_ItemAlert\020\017\022" + "\025\n\021DOTA_CM_ChatWheel\020\020B\005H\001\200\001\000", 1429); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "dota_clientmessages.proto", &protobuf_RegisterTypes); + CDOTAClientMsg_MapPing::default_instance_ = new CDOTAClientMsg_MapPing(); + CDOTAClientMsg_ItemAlert::default_instance_ = new CDOTAClientMsg_ItemAlert(); + CDOTAClientMsg_MapLine::default_instance_ = new CDOTAClientMsg_MapLine(); + CDOTAClientMsg_AspectRatio::default_instance_ = new CDOTAClientMsg_AspectRatio(); + CDOTAClientMsg_UnitsAutoAttack::default_instance_ = new CDOTAClientMsg_UnitsAutoAttack(); + CDOTAClientMsg_AutoPurchaseItems::default_instance_ = new CDOTAClientMsg_AutoPurchaseItems(); + CDOTAClientMsg_TestItems::default_instance_ = new CDOTAClientMsg_TestItems(); + CDOTAClientMsg_SearchString::default_instance_ = new CDOTAClientMsg_SearchString(); + CDOTAClientMsg_Pause::default_instance_ = new CDOTAClientMsg_Pause(); + CDOTAClientMsg_ShopViewMode::default_instance_ = new CDOTAClientMsg_ShopViewMode(); + CDOTAClientMsg_SetUnitShareFlag::default_instance_ = new CDOTAClientMsg_SetUnitShareFlag(); + CDOTAClientMsg_SwapRequest::default_instance_ = new CDOTAClientMsg_SwapRequest(); + CDOTAClientMsg_SwapAccept::default_instance_ = new CDOTAClientMsg_SwapAccept(); + CDOTAClientMsg_WorldLine::default_instance_ = new CDOTAClientMsg_WorldLine(); + CDOTAClientMsg_RequestGraphUpdate::default_instance_ = new CDOTAClientMsg_RequestGraphUpdate(); + CDOTAClientMsg_ChatWheel::default_instance_ = new CDOTAClientMsg_ChatWheel(); + CDOTAClientMsg_MapPing::default_instance_->InitAsDefaultInstance(); + CDOTAClientMsg_ItemAlert::default_instance_->InitAsDefaultInstance(); + CDOTAClientMsg_MapLine::default_instance_->InitAsDefaultInstance(); + CDOTAClientMsg_AspectRatio::default_instance_->InitAsDefaultInstance(); + CDOTAClientMsg_UnitsAutoAttack::default_instance_->InitAsDefaultInstance(); + CDOTAClientMsg_AutoPurchaseItems::default_instance_->InitAsDefaultInstance(); + CDOTAClientMsg_TestItems::default_instance_->InitAsDefaultInstance(); + CDOTAClientMsg_SearchString::default_instance_->InitAsDefaultInstance(); + CDOTAClientMsg_Pause::default_instance_->InitAsDefaultInstance(); + CDOTAClientMsg_ShopViewMode::default_instance_->InitAsDefaultInstance(); + CDOTAClientMsg_SetUnitShareFlag::default_instance_->InitAsDefaultInstance(); + CDOTAClientMsg_SwapRequest::default_instance_->InitAsDefaultInstance(); + CDOTAClientMsg_SwapAccept::default_instance_->InitAsDefaultInstance(); + CDOTAClientMsg_WorldLine::default_instance_->InitAsDefaultInstance(); + CDOTAClientMsg_RequestGraphUpdate::default_instance_->InitAsDefaultInstance(); + CDOTAClientMsg_ChatWheel::default_instance_->InitAsDefaultInstance(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_dota_5fclientmessages_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_dota_5fclientmessages_2eproto { + StaticDescriptorInitializer_dota_5fclientmessages_2eproto() { + protobuf_AddDesc_dota_5fclientmessages_2eproto(); + } +} static_descriptor_initializer_dota_5fclientmessages_2eproto_; + +const ::google::protobuf::EnumDescriptor* EDotaClientMessages_descriptor() { + protobuf_AssignDescriptorsOnce(); + return EDotaClientMessages_descriptor_; +} +bool EDotaClientMessages_IsValid(int value) { + switch(value) { + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + case 10: + case 11: + case 12: + case 13: + case 14: + case 15: + case 16: + return true; + default: + return false; + } +} + + +// =================================================================== + +#ifndef _MSC_VER +const int CDOTAClientMsg_MapPing::kLocationPingFieldNumber; +#endif // !_MSC_VER + +CDOTAClientMsg_MapPing::CDOTAClientMsg_MapPing() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void CDOTAClientMsg_MapPing::InitAsDefaultInstance() { + location_ping_ = const_cast< ::CDOTAMsg_LocationPing*>(&::CDOTAMsg_LocationPing::default_instance()); +} + +CDOTAClientMsg_MapPing::CDOTAClientMsg_MapPing(const CDOTAClientMsg_MapPing& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void CDOTAClientMsg_MapPing::SharedCtor() { + _cached_size_ = 0; + location_ping_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +CDOTAClientMsg_MapPing::~CDOTAClientMsg_MapPing() { + SharedDtor(); +} + +void CDOTAClientMsg_MapPing::SharedDtor() { + if (this != default_instance_) { + delete location_ping_; + } +} + +void CDOTAClientMsg_MapPing::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* CDOTAClientMsg_MapPing::descriptor() { + protobuf_AssignDescriptorsOnce(); + return CDOTAClientMsg_MapPing_descriptor_; +} + +const CDOTAClientMsg_MapPing& CDOTAClientMsg_MapPing::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_dota_5fclientmessages_2eproto(); return *default_instance_; +} + +CDOTAClientMsg_MapPing* CDOTAClientMsg_MapPing::default_instance_ = NULL; + +CDOTAClientMsg_MapPing* CDOTAClientMsg_MapPing::New() const { + return new CDOTAClientMsg_MapPing; +} + +void CDOTAClientMsg_MapPing::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_location_ping()) { + if (location_ping_ != NULL) location_ping_->::CDOTAMsg_LocationPing::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool CDOTAClientMsg_MapPing::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)) { + // optional .CDOTAMsg_LocationPing location_ping = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_location_ping())); + } 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::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void CDOTAClientMsg_MapPing::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // optional .CDOTAMsg_LocationPing location_ping = 1; + if (has_location_ping()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->location_ping(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* CDOTAClientMsg_MapPing::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // optional .CDOTAMsg_LocationPing location_ping = 1; + if (has_location_ping()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->location_ping(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int CDOTAClientMsg_MapPing::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .CDOTAMsg_LocationPing location_ping = 1; + if (has_location_ping()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->location_ping()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void CDOTAClientMsg_MapPing::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const CDOTAClientMsg_MapPing* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void CDOTAClientMsg_MapPing::MergeFrom(const CDOTAClientMsg_MapPing& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_location_ping()) { + mutable_location_ping()->::CDOTAMsg_LocationPing::MergeFrom(from.location_ping()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void CDOTAClientMsg_MapPing::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void CDOTAClientMsg_MapPing::CopyFrom(const CDOTAClientMsg_MapPing& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CDOTAClientMsg_MapPing::IsInitialized() const { + + return true; +} + +void CDOTAClientMsg_MapPing::Swap(CDOTAClientMsg_MapPing* other) { + if (other != this) { + std::swap(location_ping_, other->location_ping_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata CDOTAClientMsg_MapPing::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = CDOTAClientMsg_MapPing_descriptor_; + metadata.reflection = CDOTAClientMsg_MapPing_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int CDOTAClientMsg_ItemAlert::kItemAlertFieldNumber; +#endif // !_MSC_VER + +CDOTAClientMsg_ItemAlert::CDOTAClientMsg_ItemAlert() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void CDOTAClientMsg_ItemAlert::InitAsDefaultInstance() { + item_alert_ = const_cast< ::CDOTAMsg_ItemAlert*>(&::CDOTAMsg_ItemAlert::default_instance()); +} + +CDOTAClientMsg_ItemAlert::CDOTAClientMsg_ItemAlert(const CDOTAClientMsg_ItemAlert& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void CDOTAClientMsg_ItemAlert::SharedCtor() { + _cached_size_ = 0; + item_alert_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +CDOTAClientMsg_ItemAlert::~CDOTAClientMsg_ItemAlert() { + SharedDtor(); +} + +void CDOTAClientMsg_ItemAlert::SharedDtor() { + if (this != default_instance_) { + delete item_alert_; + } +} + +void CDOTAClientMsg_ItemAlert::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* CDOTAClientMsg_ItemAlert::descriptor() { + protobuf_AssignDescriptorsOnce(); + return CDOTAClientMsg_ItemAlert_descriptor_; +} + +const CDOTAClientMsg_ItemAlert& CDOTAClientMsg_ItemAlert::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_dota_5fclientmessages_2eproto(); return *default_instance_; +} + +CDOTAClientMsg_ItemAlert* CDOTAClientMsg_ItemAlert::default_instance_ = NULL; + +CDOTAClientMsg_ItemAlert* CDOTAClientMsg_ItemAlert::New() const { + return new CDOTAClientMsg_ItemAlert; +} + +void CDOTAClientMsg_ItemAlert::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_item_alert()) { + if (item_alert_ != NULL) item_alert_->::CDOTAMsg_ItemAlert::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool CDOTAClientMsg_ItemAlert::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)) { + // optional .CDOTAMsg_ItemAlert item_alert = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_item_alert())); + } 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::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void CDOTAClientMsg_ItemAlert::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // optional .CDOTAMsg_ItemAlert item_alert = 1; + if (has_item_alert()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->item_alert(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* CDOTAClientMsg_ItemAlert::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // optional .CDOTAMsg_ItemAlert item_alert = 1; + if (has_item_alert()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->item_alert(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int CDOTAClientMsg_ItemAlert::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .CDOTAMsg_ItemAlert item_alert = 1; + if (has_item_alert()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->item_alert()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void CDOTAClientMsg_ItemAlert::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const CDOTAClientMsg_ItemAlert* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void CDOTAClientMsg_ItemAlert::MergeFrom(const CDOTAClientMsg_ItemAlert& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_item_alert()) { + mutable_item_alert()->::CDOTAMsg_ItemAlert::MergeFrom(from.item_alert()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void CDOTAClientMsg_ItemAlert::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void CDOTAClientMsg_ItemAlert::CopyFrom(const CDOTAClientMsg_ItemAlert& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CDOTAClientMsg_ItemAlert::IsInitialized() const { + + return true; +} + +void CDOTAClientMsg_ItemAlert::Swap(CDOTAClientMsg_ItemAlert* other) { + if (other != this) { + std::swap(item_alert_, other->item_alert_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata CDOTAClientMsg_ItemAlert::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = CDOTAClientMsg_ItemAlert_descriptor_; + metadata.reflection = CDOTAClientMsg_ItemAlert_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int CDOTAClientMsg_MapLine::kMaplineFieldNumber; +#endif // !_MSC_VER + +CDOTAClientMsg_MapLine::CDOTAClientMsg_MapLine() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void CDOTAClientMsg_MapLine::InitAsDefaultInstance() { + mapline_ = const_cast< ::CDOTAMsg_MapLine*>(&::CDOTAMsg_MapLine::default_instance()); +} + +CDOTAClientMsg_MapLine::CDOTAClientMsg_MapLine(const CDOTAClientMsg_MapLine& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void CDOTAClientMsg_MapLine::SharedCtor() { + _cached_size_ = 0; + mapline_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +CDOTAClientMsg_MapLine::~CDOTAClientMsg_MapLine() { + SharedDtor(); +} + +void CDOTAClientMsg_MapLine::SharedDtor() { + if (this != default_instance_) { + delete mapline_; + } +} + +void CDOTAClientMsg_MapLine::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* CDOTAClientMsg_MapLine::descriptor() { + protobuf_AssignDescriptorsOnce(); + return CDOTAClientMsg_MapLine_descriptor_; +} + +const CDOTAClientMsg_MapLine& CDOTAClientMsg_MapLine::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_dota_5fclientmessages_2eproto(); return *default_instance_; +} + +CDOTAClientMsg_MapLine* CDOTAClientMsg_MapLine::default_instance_ = NULL; + +CDOTAClientMsg_MapLine* CDOTAClientMsg_MapLine::New() const { + return new CDOTAClientMsg_MapLine; +} + +void CDOTAClientMsg_MapLine::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_mapline()) { + if (mapline_ != NULL) mapline_->::CDOTAMsg_MapLine::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool CDOTAClientMsg_MapLine::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)) { + // optional .CDOTAMsg_MapLine mapline = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_mapline())); + } 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::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void CDOTAClientMsg_MapLine::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // optional .CDOTAMsg_MapLine mapline = 1; + if (has_mapline()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->mapline(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* CDOTAClientMsg_MapLine::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // optional .CDOTAMsg_MapLine mapline = 1; + if (has_mapline()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->mapline(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int CDOTAClientMsg_MapLine::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .CDOTAMsg_MapLine mapline = 1; + if (has_mapline()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->mapline()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void CDOTAClientMsg_MapLine::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const CDOTAClientMsg_MapLine* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void CDOTAClientMsg_MapLine::MergeFrom(const CDOTAClientMsg_MapLine& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_mapline()) { + mutable_mapline()->::CDOTAMsg_MapLine::MergeFrom(from.mapline()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void CDOTAClientMsg_MapLine::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void CDOTAClientMsg_MapLine::CopyFrom(const CDOTAClientMsg_MapLine& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CDOTAClientMsg_MapLine::IsInitialized() const { + + return true; +} + +void CDOTAClientMsg_MapLine::Swap(CDOTAClientMsg_MapLine* other) { + if (other != this) { + std::swap(mapline_, other->mapline_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata CDOTAClientMsg_MapLine::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = CDOTAClientMsg_MapLine_descriptor_; + metadata.reflection = CDOTAClientMsg_MapLine_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int CDOTAClientMsg_AspectRatio::kRatioFieldNumber; +#endif // !_MSC_VER + +CDOTAClientMsg_AspectRatio::CDOTAClientMsg_AspectRatio() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void CDOTAClientMsg_AspectRatio::InitAsDefaultInstance() { +} + +CDOTAClientMsg_AspectRatio::CDOTAClientMsg_AspectRatio(const CDOTAClientMsg_AspectRatio& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void CDOTAClientMsg_AspectRatio::SharedCtor() { + _cached_size_ = 0; + ratio_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +CDOTAClientMsg_AspectRatio::~CDOTAClientMsg_AspectRatio() { + SharedDtor(); +} + +void CDOTAClientMsg_AspectRatio::SharedDtor() { + if (this != default_instance_) { + } +} + +void CDOTAClientMsg_AspectRatio::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* CDOTAClientMsg_AspectRatio::descriptor() { + protobuf_AssignDescriptorsOnce(); + return CDOTAClientMsg_AspectRatio_descriptor_; +} + +const CDOTAClientMsg_AspectRatio& CDOTAClientMsg_AspectRatio::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_dota_5fclientmessages_2eproto(); return *default_instance_; +} + +CDOTAClientMsg_AspectRatio* CDOTAClientMsg_AspectRatio::default_instance_ = NULL; + +CDOTAClientMsg_AspectRatio* CDOTAClientMsg_AspectRatio::New() const { + return new CDOTAClientMsg_AspectRatio; +} + +void CDOTAClientMsg_AspectRatio::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + ratio_ = 0; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool CDOTAClientMsg_AspectRatio::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)) { + // optional float ratio = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &ratio_))); + set_has_ratio(); + } 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::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void CDOTAClientMsg_AspectRatio::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // optional float ratio = 1; + if (has_ratio()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->ratio(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* CDOTAClientMsg_AspectRatio::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // optional float ratio = 1; + if (has_ratio()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(1, this->ratio(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int CDOTAClientMsg_AspectRatio::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional float ratio = 1; + if (has_ratio()) { + total_size += 1 + 4; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void CDOTAClientMsg_AspectRatio::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const CDOTAClientMsg_AspectRatio* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void CDOTAClientMsg_AspectRatio::MergeFrom(const CDOTAClientMsg_AspectRatio& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_ratio()) { + set_ratio(from.ratio()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void CDOTAClientMsg_AspectRatio::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void CDOTAClientMsg_AspectRatio::CopyFrom(const CDOTAClientMsg_AspectRatio& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CDOTAClientMsg_AspectRatio::IsInitialized() const { + + return true; +} + +void CDOTAClientMsg_AspectRatio::Swap(CDOTAClientMsg_AspectRatio* other) { + if (other != this) { + std::swap(ratio_, other->ratio_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata CDOTAClientMsg_AspectRatio::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = CDOTAClientMsg_AspectRatio_descriptor_; + metadata.reflection = CDOTAClientMsg_AspectRatio_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int CDOTAClientMsg_UnitsAutoAttack::kEnabledFieldNumber; +#endif // !_MSC_VER + +CDOTAClientMsg_UnitsAutoAttack::CDOTAClientMsg_UnitsAutoAttack() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void CDOTAClientMsg_UnitsAutoAttack::InitAsDefaultInstance() { +} + +CDOTAClientMsg_UnitsAutoAttack::CDOTAClientMsg_UnitsAutoAttack(const CDOTAClientMsg_UnitsAutoAttack& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void CDOTAClientMsg_UnitsAutoAttack::SharedCtor() { + _cached_size_ = 0; + enabled_ = false; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +CDOTAClientMsg_UnitsAutoAttack::~CDOTAClientMsg_UnitsAutoAttack() { + SharedDtor(); +} + +void CDOTAClientMsg_UnitsAutoAttack::SharedDtor() { + if (this != default_instance_) { + } +} + +void CDOTAClientMsg_UnitsAutoAttack::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* CDOTAClientMsg_UnitsAutoAttack::descriptor() { + protobuf_AssignDescriptorsOnce(); + return CDOTAClientMsg_UnitsAutoAttack_descriptor_; +} + +const CDOTAClientMsg_UnitsAutoAttack& CDOTAClientMsg_UnitsAutoAttack::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_dota_5fclientmessages_2eproto(); return *default_instance_; +} + +CDOTAClientMsg_UnitsAutoAttack* CDOTAClientMsg_UnitsAutoAttack::default_instance_ = NULL; + +CDOTAClientMsg_UnitsAutoAttack* CDOTAClientMsg_UnitsAutoAttack::New() const { + return new CDOTAClientMsg_UnitsAutoAttack; +} + +void CDOTAClientMsg_UnitsAutoAttack::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + enabled_ = false; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool CDOTAClientMsg_UnitsAutoAttack::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)) { + // optional bool enabled = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &enabled_))); + set_has_enabled(); + } 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::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void CDOTAClientMsg_UnitsAutoAttack::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // optional bool enabled = 1; + if (has_enabled()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->enabled(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* CDOTAClientMsg_UnitsAutoAttack::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // optional bool enabled = 1; + if (has_enabled()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->enabled(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int CDOTAClientMsg_UnitsAutoAttack::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional bool enabled = 1; + if (has_enabled()) { + total_size += 1 + 1; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void CDOTAClientMsg_UnitsAutoAttack::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const CDOTAClientMsg_UnitsAutoAttack* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void CDOTAClientMsg_UnitsAutoAttack::MergeFrom(const CDOTAClientMsg_UnitsAutoAttack& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_enabled()) { + set_enabled(from.enabled()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void CDOTAClientMsg_UnitsAutoAttack::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void CDOTAClientMsg_UnitsAutoAttack::CopyFrom(const CDOTAClientMsg_UnitsAutoAttack& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CDOTAClientMsg_UnitsAutoAttack::IsInitialized() const { + + return true; +} + +void CDOTAClientMsg_UnitsAutoAttack::Swap(CDOTAClientMsg_UnitsAutoAttack* other) { + if (other != this) { + std::swap(enabled_, other->enabled_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata CDOTAClientMsg_UnitsAutoAttack::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = CDOTAClientMsg_UnitsAutoAttack_descriptor_; + metadata.reflection = CDOTAClientMsg_UnitsAutoAttack_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int CDOTAClientMsg_AutoPurchaseItems::kEnabledFieldNumber; +#endif // !_MSC_VER + +CDOTAClientMsg_AutoPurchaseItems::CDOTAClientMsg_AutoPurchaseItems() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void CDOTAClientMsg_AutoPurchaseItems::InitAsDefaultInstance() { +} + +CDOTAClientMsg_AutoPurchaseItems::CDOTAClientMsg_AutoPurchaseItems(const CDOTAClientMsg_AutoPurchaseItems& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void CDOTAClientMsg_AutoPurchaseItems::SharedCtor() { + _cached_size_ = 0; + enabled_ = false; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +CDOTAClientMsg_AutoPurchaseItems::~CDOTAClientMsg_AutoPurchaseItems() { + SharedDtor(); +} + +void CDOTAClientMsg_AutoPurchaseItems::SharedDtor() { + if (this != default_instance_) { + } +} + +void CDOTAClientMsg_AutoPurchaseItems::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* CDOTAClientMsg_AutoPurchaseItems::descriptor() { + protobuf_AssignDescriptorsOnce(); + return CDOTAClientMsg_AutoPurchaseItems_descriptor_; +} + +const CDOTAClientMsg_AutoPurchaseItems& CDOTAClientMsg_AutoPurchaseItems::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_dota_5fclientmessages_2eproto(); return *default_instance_; +} + +CDOTAClientMsg_AutoPurchaseItems* CDOTAClientMsg_AutoPurchaseItems::default_instance_ = NULL; + +CDOTAClientMsg_AutoPurchaseItems* CDOTAClientMsg_AutoPurchaseItems::New() const { + return new CDOTAClientMsg_AutoPurchaseItems; +} + +void CDOTAClientMsg_AutoPurchaseItems::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + enabled_ = false; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool CDOTAClientMsg_AutoPurchaseItems::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)) { + // optional bool enabled = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &enabled_))); + set_has_enabled(); + } 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::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void CDOTAClientMsg_AutoPurchaseItems::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // optional bool enabled = 1; + if (has_enabled()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->enabled(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* CDOTAClientMsg_AutoPurchaseItems::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // optional bool enabled = 1; + if (has_enabled()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->enabled(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int CDOTAClientMsg_AutoPurchaseItems::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional bool enabled = 1; + if (has_enabled()) { + total_size += 1 + 1; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void CDOTAClientMsg_AutoPurchaseItems::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const CDOTAClientMsg_AutoPurchaseItems* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void CDOTAClientMsg_AutoPurchaseItems::MergeFrom(const CDOTAClientMsg_AutoPurchaseItems& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_enabled()) { + set_enabled(from.enabled()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void CDOTAClientMsg_AutoPurchaseItems::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void CDOTAClientMsg_AutoPurchaseItems::CopyFrom(const CDOTAClientMsg_AutoPurchaseItems& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CDOTAClientMsg_AutoPurchaseItems::IsInitialized() const { + + return true; +} + +void CDOTAClientMsg_AutoPurchaseItems::Swap(CDOTAClientMsg_AutoPurchaseItems* other) { + if (other != this) { + std::swap(enabled_, other->enabled_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata CDOTAClientMsg_AutoPurchaseItems::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = CDOTAClientMsg_AutoPurchaseItems_descriptor_; + metadata.reflection = CDOTAClientMsg_AutoPurchaseItems_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int CDOTAClientMsg_TestItems::kKeyValuesFieldNumber; +#endif // !_MSC_VER + +CDOTAClientMsg_TestItems::CDOTAClientMsg_TestItems() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void CDOTAClientMsg_TestItems::InitAsDefaultInstance() { +} + +CDOTAClientMsg_TestItems::CDOTAClientMsg_TestItems(const CDOTAClientMsg_TestItems& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void CDOTAClientMsg_TestItems::SharedCtor() { + _cached_size_ = 0; + key_values_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +CDOTAClientMsg_TestItems::~CDOTAClientMsg_TestItems() { + SharedDtor(); +} + +void CDOTAClientMsg_TestItems::SharedDtor() { + if (key_values_ != &::google::protobuf::internal::kEmptyString) { + delete key_values_; + } + if (this != default_instance_) { + } +} + +void CDOTAClientMsg_TestItems::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* CDOTAClientMsg_TestItems::descriptor() { + protobuf_AssignDescriptorsOnce(); + return CDOTAClientMsg_TestItems_descriptor_; +} + +const CDOTAClientMsg_TestItems& CDOTAClientMsg_TestItems::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_dota_5fclientmessages_2eproto(); return *default_instance_; +} + +CDOTAClientMsg_TestItems* CDOTAClientMsg_TestItems::default_instance_ = NULL; + +CDOTAClientMsg_TestItems* CDOTAClientMsg_TestItems::New() const { + return new CDOTAClientMsg_TestItems; +} + +void CDOTAClientMsg_TestItems::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_key_values()) { + if (key_values_ != &::google::protobuf::internal::kEmptyString) { + key_values_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool CDOTAClientMsg_TestItems::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)) { + // optional string key_values = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_key_values())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->key_values().data(), this->key_values().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } 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::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void CDOTAClientMsg_TestItems::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // optional string key_values = 1; + if (has_key_values()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->key_values().data(), this->key_values().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->key_values(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* CDOTAClientMsg_TestItems::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // optional string key_values = 1; + if (has_key_values()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->key_values().data(), this->key_values().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->key_values(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int CDOTAClientMsg_TestItems::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional string key_values = 1; + if (has_key_values()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->key_values()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void CDOTAClientMsg_TestItems::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const CDOTAClientMsg_TestItems* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void CDOTAClientMsg_TestItems::MergeFrom(const CDOTAClientMsg_TestItems& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_key_values()) { + set_key_values(from.key_values()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void CDOTAClientMsg_TestItems::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void CDOTAClientMsg_TestItems::CopyFrom(const CDOTAClientMsg_TestItems& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CDOTAClientMsg_TestItems::IsInitialized() const { + + return true; +} + +void CDOTAClientMsg_TestItems::Swap(CDOTAClientMsg_TestItems* other) { + if (other != this) { + std::swap(key_values_, other->key_values_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata CDOTAClientMsg_TestItems::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = CDOTAClientMsg_TestItems_descriptor_; + metadata.reflection = CDOTAClientMsg_TestItems_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int CDOTAClientMsg_SearchString::kSearchFieldNumber; +#endif // !_MSC_VER + +CDOTAClientMsg_SearchString::CDOTAClientMsg_SearchString() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void CDOTAClientMsg_SearchString::InitAsDefaultInstance() { +} + +CDOTAClientMsg_SearchString::CDOTAClientMsg_SearchString(const CDOTAClientMsg_SearchString& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void CDOTAClientMsg_SearchString::SharedCtor() { + _cached_size_ = 0; + search_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +CDOTAClientMsg_SearchString::~CDOTAClientMsg_SearchString() { + SharedDtor(); +} + +void CDOTAClientMsg_SearchString::SharedDtor() { + if (search_ != &::google::protobuf::internal::kEmptyString) { + delete search_; + } + if (this != default_instance_) { + } +} + +void CDOTAClientMsg_SearchString::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* CDOTAClientMsg_SearchString::descriptor() { + protobuf_AssignDescriptorsOnce(); + return CDOTAClientMsg_SearchString_descriptor_; +} + +const CDOTAClientMsg_SearchString& CDOTAClientMsg_SearchString::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_dota_5fclientmessages_2eproto(); return *default_instance_; +} + +CDOTAClientMsg_SearchString* CDOTAClientMsg_SearchString::default_instance_ = NULL; + +CDOTAClientMsg_SearchString* CDOTAClientMsg_SearchString::New() const { + return new CDOTAClientMsg_SearchString; +} + +void CDOTAClientMsg_SearchString::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_search()) { + if (search_ != &::google::protobuf::internal::kEmptyString) { + search_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool CDOTAClientMsg_SearchString::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)) { + // optional string search = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_search())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->search().data(), this->search().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } 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::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void CDOTAClientMsg_SearchString::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // optional string search = 1; + if (has_search()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->search().data(), this->search().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->search(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* CDOTAClientMsg_SearchString::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // optional string search = 1; + if (has_search()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->search().data(), this->search().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->search(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int CDOTAClientMsg_SearchString::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional string search = 1; + if (has_search()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->search()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void CDOTAClientMsg_SearchString::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const CDOTAClientMsg_SearchString* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void CDOTAClientMsg_SearchString::MergeFrom(const CDOTAClientMsg_SearchString& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_search()) { + set_search(from.search()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void CDOTAClientMsg_SearchString::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void CDOTAClientMsg_SearchString::CopyFrom(const CDOTAClientMsg_SearchString& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CDOTAClientMsg_SearchString::IsInitialized() const { + + return true; +} + +void CDOTAClientMsg_SearchString::Swap(CDOTAClientMsg_SearchString* other) { + if (other != this) { + std::swap(search_, other->search_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata CDOTAClientMsg_SearchString::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = CDOTAClientMsg_SearchString_descriptor_; + metadata.reflection = CDOTAClientMsg_SearchString_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +#endif // !_MSC_VER + +CDOTAClientMsg_Pause::CDOTAClientMsg_Pause() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void CDOTAClientMsg_Pause::InitAsDefaultInstance() { +} + +CDOTAClientMsg_Pause::CDOTAClientMsg_Pause(const CDOTAClientMsg_Pause& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void CDOTAClientMsg_Pause::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +CDOTAClientMsg_Pause::~CDOTAClientMsg_Pause() { + SharedDtor(); +} + +void CDOTAClientMsg_Pause::SharedDtor() { + if (this != default_instance_) { + } +} + +void CDOTAClientMsg_Pause::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* CDOTAClientMsg_Pause::descriptor() { + protobuf_AssignDescriptorsOnce(); + return CDOTAClientMsg_Pause_descriptor_; +} + +const CDOTAClientMsg_Pause& CDOTAClientMsg_Pause::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_dota_5fclientmessages_2eproto(); return *default_instance_; +} + +CDOTAClientMsg_Pause* CDOTAClientMsg_Pause::default_instance_ = NULL; + +CDOTAClientMsg_Pause* CDOTAClientMsg_Pause::New() const { + return new CDOTAClientMsg_Pause; +} + +void CDOTAClientMsg_Pause::Clear() { + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool CDOTAClientMsg_Pause::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + } + return true; +#undef DO_ +} + +void CDOTAClientMsg_Pause::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* CDOTAClientMsg_Pause::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int CDOTAClientMsg_Pause::ByteSize() const { + int total_size = 0; + + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void CDOTAClientMsg_Pause::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const CDOTAClientMsg_Pause* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void CDOTAClientMsg_Pause::MergeFrom(const CDOTAClientMsg_Pause& from) { + GOOGLE_CHECK_NE(&from, this); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void CDOTAClientMsg_Pause::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void CDOTAClientMsg_Pause::CopyFrom(const CDOTAClientMsg_Pause& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CDOTAClientMsg_Pause::IsInitialized() const { + + return true; +} + +void CDOTAClientMsg_Pause::Swap(CDOTAClientMsg_Pause* other) { + if (other != this) { + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata CDOTAClientMsg_Pause::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = CDOTAClientMsg_Pause_descriptor_; + metadata.reflection = CDOTAClientMsg_Pause_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int CDOTAClientMsg_ShopViewMode::kModeFieldNumber; +#endif // !_MSC_VER + +CDOTAClientMsg_ShopViewMode::CDOTAClientMsg_ShopViewMode() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void CDOTAClientMsg_ShopViewMode::InitAsDefaultInstance() { +} + +CDOTAClientMsg_ShopViewMode::CDOTAClientMsg_ShopViewMode(const CDOTAClientMsg_ShopViewMode& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void CDOTAClientMsg_ShopViewMode::SharedCtor() { + _cached_size_ = 0; + mode_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +CDOTAClientMsg_ShopViewMode::~CDOTAClientMsg_ShopViewMode() { + SharedDtor(); +} + +void CDOTAClientMsg_ShopViewMode::SharedDtor() { + if (this != default_instance_) { + } +} + +void CDOTAClientMsg_ShopViewMode::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* CDOTAClientMsg_ShopViewMode::descriptor() { + protobuf_AssignDescriptorsOnce(); + return CDOTAClientMsg_ShopViewMode_descriptor_; +} + +const CDOTAClientMsg_ShopViewMode& CDOTAClientMsg_ShopViewMode::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_dota_5fclientmessages_2eproto(); return *default_instance_; +} + +CDOTAClientMsg_ShopViewMode* CDOTAClientMsg_ShopViewMode::default_instance_ = NULL; + +CDOTAClientMsg_ShopViewMode* CDOTAClientMsg_ShopViewMode::New() const { + return new CDOTAClientMsg_ShopViewMode; +} + +void CDOTAClientMsg_ShopViewMode::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + mode_ = 0u; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool CDOTAClientMsg_ShopViewMode::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)) { + // optional uint32 mode = 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, &mode_))); + set_has_mode(); + } 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::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void CDOTAClientMsg_ShopViewMode::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // optional uint32 mode = 1; + if (has_mode()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->mode(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* CDOTAClientMsg_ShopViewMode::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // optional uint32 mode = 1; + if (has_mode()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->mode(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int CDOTAClientMsg_ShopViewMode::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional uint32 mode = 1; + if (has_mode()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->mode()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void CDOTAClientMsg_ShopViewMode::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const CDOTAClientMsg_ShopViewMode* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void CDOTAClientMsg_ShopViewMode::MergeFrom(const CDOTAClientMsg_ShopViewMode& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_mode()) { + set_mode(from.mode()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void CDOTAClientMsg_ShopViewMode::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void CDOTAClientMsg_ShopViewMode::CopyFrom(const CDOTAClientMsg_ShopViewMode& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CDOTAClientMsg_ShopViewMode::IsInitialized() const { + + return true; +} + +void CDOTAClientMsg_ShopViewMode::Swap(CDOTAClientMsg_ShopViewMode* other) { + if (other != this) { + std::swap(mode_, other->mode_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata CDOTAClientMsg_ShopViewMode::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = CDOTAClientMsg_ShopViewMode_descriptor_; + metadata.reflection = CDOTAClientMsg_ShopViewMode_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int CDOTAClientMsg_SetUnitShareFlag::kPlayerIDFieldNumber; +const int CDOTAClientMsg_SetUnitShareFlag::kFlagFieldNumber; +const int CDOTAClientMsg_SetUnitShareFlag::kStateFieldNumber; +#endif // !_MSC_VER + +CDOTAClientMsg_SetUnitShareFlag::CDOTAClientMsg_SetUnitShareFlag() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void CDOTAClientMsg_SetUnitShareFlag::InitAsDefaultInstance() { +} + +CDOTAClientMsg_SetUnitShareFlag::CDOTAClientMsg_SetUnitShareFlag(const CDOTAClientMsg_SetUnitShareFlag& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void CDOTAClientMsg_SetUnitShareFlag::SharedCtor() { + _cached_size_ = 0; + playerid_ = 0u; + flag_ = 0u; + state_ = false; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +CDOTAClientMsg_SetUnitShareFlag::~CDOTAClientMsg_SetUnitShareFlag() { + SharedDtor(); +} + +void CDOTAClientMsg_SetUnitShareFlag::SharedDtor() { + if (this != default_instance_) { + } +} + +void CDOTAClientMsg_SetUnitShareFlag::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* CDOTAClientMsg_SetUnitShareFlag::descriptor() { + protobuf_AssignDescriptorsOnce(); + return CDOTAClientMsg_SetUnitShareFlag_descriptor_; +} + +const CDOTAClientMsg_SetUnitShareFlag& CDOTAClientMsg_SetUnitShareFlag::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_dota_5fclientmessages_2eproto(); return *default_instance_; +} + +CDOTAClientMsg_SetUnitShareFlag* CDOTAClientMsg_SetUnitShareFlag::default_instance_ = NULL; + +CDOTAClientMsg_SetUnitShareFlag* CDOTAClientMsg_SetUnitShareFlag::New() const { + return new CDOTAClientMsg_SetUnitShareFlag; +} + +void CDOTAClientMsg_SetUnitShareFlag::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + playerid_ = 0u; + flag_ = 0u; + state_ = false; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool CDOTAClientMsg_SetUnitShareFlag::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)) { + // optional uint32 playerID = 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, &playerid_))); + set_has_playerid(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(16)) goto parse_flag; + break; + } + + // optional uint32 flag = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_flag: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &flag_))); + set_has_flag(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(24)) goto parse_state; + break; + } + + // optional bool state = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_state: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &state_))); + set_has_state(); + } 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::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void CDOTAClientMsg_SetUnitShareFlag::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // optional uint32 playerID = 1; + if (has_playerid()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->playerid(), output); + } + + // optional uint32 flag = 2; + if (has_flag()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->flag(), output); + } + + // optional bool state = 3; + if (has_state()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->state(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* CDOTAClientMsg_SetUnitShareFlag::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // optional uint32 playerID = 1; + if (has_playerid()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->playerid(), target); + } + + // optional uint32 flag = 2; + if (has_flag()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->flag(), target); + } + + // optional bool state = 3; + if (has_state()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->state(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int CDOTAClientMsg_SetUnitShareFlag::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional uint32 playerID = 1; + if (has_playerid()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->playerid()); + } + + // optional uint32 flag = 2; + if (has_flag()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->flag()); + } + + // optional bool state = 3; + if (has_state()) { + total_size += 1 + 1; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void CDOTAClientMsg_SetUnitShareFlag::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const CDOTAClientMsg_SetUnitShareFlag* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void CDOTAClientMsg_SetUnitShareFlag::MergeFrom(const CDOTAClientMsg_SetUnitShareFlag& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_playerid()) { + set_playerid(from.playerid()); + } + if (from.has_flag()) { + set_flag(from.flag()); + } + if (from.has_state()) { + set_state(from.state()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void CDOTAClientMsg_SetUnitShareFlag::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void CDOTAClientMsg_SetUnitShareFlag::CopyFrom(const CDOTAClientMsg_SetUnitShareFlag& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CDOTAClientMsg_SetUnitShareFlag::IsInitialized() const { + + return true; +} + +void CDOTAClientMsg_SetUnitShareFlag::Swap(CDOTAClientMsg_SetUnitShareFlag* other) { + if (other != this) { + std::swap(playerid_, other->playerid_); + std::swap(flag_, other->flag_); + std::swap(state_, other->state_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata CDOTAClientMsg_SetUnitShareFlag::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = CDOTAClientMsg_SetUnitShareFlag_descriptor_; + metadata.reflection = CDOTAClientMsg_SetUnitShareFlag_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int CDOTAClientMsg_SwapRequest::kPlayerIdFieldNumber; +#endif // !_MSC_VER + +CDOTAClientMsg_SwapRequest::CDOTAClientMsg_SwapRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void CDOTAClientMsg_SwapRequest::InitAsDefaultInstance() { +} + +CDOTAClientMsg_SwapRequest::CDOTAClientMsg_SwapRequest(const CDOTAClientMsg_SwapRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void CDOTAClientMsg_SwapRequest::SharedCtor() { + _cached_size_ = 0; + player_id_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +CDOTAClientMsg_SwapRequest::~CDOTAClientMsg_SwapRequest() { + SharedDtor(); +} + +void CDOTAClientMsg_SwapRequest::SharedDtor() { + if (this != default_instance_) { + } +} + +void CDOTAClientMsg_SwapRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* CDOTAClientMsg_SwapRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return CDOTAClientMsg_SwapRequest_descriptor_; +} + +const CDOTAClientMsg_SwapRequest& CDOTAClientMsg_SwapRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_dota_5fclientmessages_2eproto(); return *default_instance_; +} + +CDOTAClientMsg_SwapRequest* CDOTAClientMsg_SwapRequest::default_instance_ = NULL; + +CDOTAClientMsg_SwapRequest* CDOTAClientMsg_SwapRequest::New() const { + return new CDOTAClientMsg_SwapRequest; +} + +void CDOTAClientMsg_SwapRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + player_id_ = 0u; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool CDOTAClientMsg_SwapRequest::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)) { + // optional uint32 player_id = 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, &player_id_))); + set_has_player_id(); + } 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::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void CDOTAClientMsg_SwapRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // optional uint32 player_id = 1; + if (has_player_id()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->player_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* CDOTAClientMsg_SwapRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // optional uint32 player_id = 1; + if (has_player_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->player_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int CDOTAClientMsg_SwapRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional uint32 player_id = 1; + if (has_player_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->player_id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void CDOTAClientMsg_SwapRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const CDOTAClientMsg_SwapRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void CDOTAClientMsg_SwapRequest::MergeFrom(const CDOTAClientMsg_SwapRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_player_id()) { + set_player_id(from.player_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void CDOTAClientMsg_SwapRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void CDOTAClientMsg_SwapRequest::CopyFrom(const CDOTAClientMsg_SwapRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CDOTAClientMsg_SwapRequest::IsInitialized() const { + + return true; +} + +void CDOTAClientMsg_SwapRequest::Swap(CDOTAClientMsg_SwapRequest* other) { + if (other != this) { + std::swap(player_id_, other->player_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata CDOTAClientMsg_SwapRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = CDOTAClientMsg_SwapRequest_descriptor_; + metadata.reflection = CDOTAClientMsg_SwapRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int CDOTAClientMsg_SwapAccept::kPlayerIdFieldNumber; +#endif // !_MSC_VER + +CDOTAClientMsg_SwapAccept::CDOTAClientMsg_SwapAccept() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void CDOTAClientMsg_SwapAccept::InitAsDefaultInstance() { +} + +CDOTAClientMsg_SwapAccept::CDOTAClientMsg_SwapAccept(const CDOTAClientMsg_SwapAccept& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void CDOTAClientMsg_SwapAccept::SharedCtor() { + _cached_size_ = 0; + player_id_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +CDOTAClientMsg_SwapAccept::~CDOTAClientMsg_SwapAccept() { + SharedDtor(); +} + +void CDOTAClientMsg_SwapAccept::SharedDtor() { + if (this != default_instance_) { + } +} + +void CDOTAClientMsg_SwapAccept::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* CDOTAClientMsg_SwapAccept::descriptor() { + protobuf_AssignDescriptorsOnce(); + return CDOTAClientMsg_SwapAccept_descriptor_; +} + +const CDOTAClientMsg_SwapAccept& CDOTAClientMsg_SwapAccept::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_dota_5fclientmessages_2eproto(); return *default_instance_; +} + +CDOTAClientMsg_SwapAccept* CDOTAClientMsg_SwapAccept::default_instance_ = NULL; + +CDOTAClientMsg_SwapAccept* CDOTAClientMsg_SwapAccept::New() const { + return new CDOTAClientMsg_SwapAccept; +} + +void CDOTAClientMsg_SwapAccept::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + player_id_ = 0u; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool CDOTAClientMsg_SwapAccept::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)) { + // optional uint32 player_id = 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, &player_id_))); + set_has_player_id(); + } 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::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void CDOTAClientMsg_SwapAccept::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // optional uint32 player_id = 1; + if (has_player_id()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->player_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* CDOTAClientMsg_SwapAccept::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // optional uint32 player_id = 1; + if (has_player_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->player_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int CDOTAClientMsg_SwapAccept::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional uint32 player_id = 1; + if (has_player_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->player_id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void CDOTAClientMsg_SwapAccept::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const CDOTAClientMsg_SwapAccept* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void CDOTAClientMsg_SwapAccept::MergeFrom(const CDOTAClientMsg_SwapAccept& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_player_id()) { + set_player_id(from.player_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void CDOTAClientMsg_SwapAccept::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void CDOTAClientMsg_SwapAccept::CopyFrom(const CDOTAClientMsg_SwapAccept& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CDOTAClientMsg_SwapAccept::IsInitialized() const { + + return true; +} + +void CDOTAClientMsg_SwapAccept::Swap(CDOTAClientMsg_SwapAccept* other) { + if (other != this) { + std::swap(player_id_, other->player_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata CDOTAClientMsg_SwapAccept::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = CDOTAClientMsg_SwapAccept_descriptor_; + metadata.reflection = CDOTAClientMsg_SwapAccept_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int CDOTAClientMsg_WorldLine::kWorldlineFieldNumber; +#endif // !_MSC_VER + +CDOTAClientMsg_WorldLine::CDOTAClientMsg_WorldLine() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void CDOTAClientMsg_WorldLine::InitAsDefaultInstance() { + worldline_ = const_cast< ::CDOTAMsg_WorldLine*>(&::CDOTAMsg_WorldLine::default_instance()); +} + +CDOTAClientMsg_WorldLine::CDOTAClientMsg_WorldLine(const CDOTAClientMsg_WorldLine& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void CDOTAClientMsg_WorldLine::SharedCtor() { + _cached_size_ = 0; + worldline_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +CDOTAClientMsg_WorldLine::~CDOTAClientMsg_WorldLine() { + SharedDtor(); +} + +void CDOTAClientMsg_WorldLine::SharedDtor() { + if (this != default_instance_) { + delete worldline_; + } +} + +void CDOTAClientMsg_WorldLine::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* CDOTAClientMsg_WorldLine::descriptor() { + protobuf_AssignDescriptorsOnce(); + return CDOTAClientMsg_WorldLine_descriptor_; +} + +const CDOTAClientMsg_WorldLine& CDOTAClientMsg_WorldLine::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_dota_5fclientmessages_2eproto(); return *default_instance_; +} + +CDOTAClientMsg_WorldLine* CDOTAClientMsg_WorldLine::default_instance_ = NULL; + +CDOTAClientMsg_WorldLine* CDOTAClientMsg_WorldLine::New() const { + return new CDOTAClientMsg_WorldLine; +} + +void CDOTAClientMsg_WorldLine::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_worldline()) { + if (worldline_ != NULL) worldline_->::CDOTAMsg_WorldLine::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool CDOTAClientMsg_WorldLine::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)) { + // optional .CDOTAMsg_WorldLine worldline = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_worldline())); + } 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::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void CDOTAClientMsg_WorldLine::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // optional .CDOTAMsg_WorldLine worldline = 1; + if (has_worldline()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->worldline(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* CDOTAClientMsg_WorldLine::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // optional .CDOTAMsg_WorldLine worldline = 1; + if (has_worldline()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->worldline(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int CDOTAClientMsg_WorldLine::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .CDOTAMsg_WorldLine worldline = 1; + if (has_worldline()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->worldline()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void CDOTAClientMsg_WorldLine::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const CDOTAClientMsg_WorldLine* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void CDOTAClientMsg_WorldLine::MergeFrom(const CDOTAClientMsg_WorldLine& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_worldline()) { + mutable_worldline()->::CDOTAMsg_WorldLine::MergeFrom(from.worldline()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void CDOTAClientMsg_WorldLine::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void CDOTAClientMsg_WorldLine::CopyFrom(const CDOTAClientMsg_WorldLine& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CDOTAClientMsg_WorldLine::IsInitialized() const { + + return true; +} + +void CDOTAClientMsg_WorldLine::Swap(CDOTAClientMsg_WorldLine* other) { + if (other != this) { + std::swap(worldline_, other->worldline_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata CDOTAClientMsg_WorldLine::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = CDOTAClientMsg_WorldLine_descriptor_; + metadata.reflection = CDOTAClientMsg_WorldLine_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +#endif // !_MSC_VER + +CDOTAClientMsg_RequestGraphUpdate::CDOTAClientMsg_RequestGraphUpdate() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void CDOTAClientMsg_RequestGraphUpdate::InitAsDefaultInstance() { +} + +CDOTAClientMsg_RequestGraphUpdate::CDOTAClientMsg_RequestGraphUpdate(const CDOTAClientMsg_RequestGraphUpdate& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void CDOTAClientMsg_RequestGraphUpdate::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +CDOTAClientMsg_RequestGraphUpdate::~CDOTAClientMsg_RequestGraphUpdate() { + SharedDtor(); +} + +void CDOTAClientMsg_RequestGraphUpdate::SharedDtor() { + if (this != default_instance_) { + } +} + +void CDOTAClientMsg_RequestGraphUpdate::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* CDOTAClientMsg_RequestGraphUpdate::descriptor() { + protobuf_AssignDescriptorsOnce(); + return CDOTAClientMsg_RequestGraphUpdate_descriptor_; +} + +const CDOTAClientMsg_RequestGraphUpdate& CDOTAClientMsg_RequestGraphUpdate::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_dota_5fclientmessages_2eproto(); return *default_instance_; +} + +CDOTAClientMsg_RequestGraphUpdate* CDOTAClientMsg_RequestGraphUpdate::default_instance_ = NULL; + +CDOTAClientMsg_RequestGraphUpdate* CDOTAClientMsg_RequestGraphUpdate::New() const { + return new CDOTAClientMsg_RequestGraphUpdate; +} + +void CDOTAClientMsg_RequestGraphUpdate::Clear() { + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool CDOTAClientMsg_RequestGraphUpdate::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + } + return true; +#undef DO_ +} + +void CDOTAClientMsg_RequestGraphUpdate::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* CDOTAClientMsg_RequestGraphUpdate::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int CDOTAClientMsg_RequestGraphUpdate::ByteSize() const { + int total_size = 0; + + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void CDOTAClientMsg_RequestGraphUpdate::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const CDOTAClientMsg_RequestGraphUpdate* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void CDOTAClientMsg_RequestGraphUpdate::MergeFrom(const CDOTAClientMsg_RequestGraphUpdate& from) { + GOOGLE_CHECK_NE(&from, this); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void CDOTAClientMsg_RequestGraphUpdate::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void CDOTAClientMsg_RequestGraphUpdate::CopyFrom(const CDOTAClientMsg_RequestGraphUpdate& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CDOTAClientMsg_RequestGraphUpdate::IsInitialized() const { + + return true; +} + +void CDOTAClientMsg_RequestGraphUpdate::Swap(CDOTAClientMsg_RequestGraphUpdate* other) { + if (other != this) { + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata CDOTAClientMsg_RequestGraphUpdate::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = CDOTAClientMsg_RequestGraphUpdate_descriptor_; + metadata.reflection = CDOTAClientMsg_RequestGraphUpdate_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int CDOTAClientMsg_ChatWheel::kChatMessageFieldNumber; +#endif // !_MSC_VER + +CDOTAClientMsg_ChatWheel::CDOTAClientMsg_ChatWheel() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void CDOTAClientMsg_ChatWheel::InitAsDefaultInstance() { +} + +CDOTAClientMsg_ChatWheel::CDOTAClientMsg_ChatWheel(const CDOTAClientMsg_ChatWheel& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void CDOTAClientMsg_ChatWheel::SharedCtor() { + _cached_size_ = 0; + chat_message_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +CDOTAClientMsg_ChatWheel::~CDOTAClientMsg_ChatWheel() { + SharedDtor(); +} + +void CDOTAClientMsg_ChatWheel::SharedDtor() { + if (this != default_instance_) { + } +} + +void CDOTAClientMsg_ChatWheel::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* CDOTAClientMsg_ChatWheel::descriptor() { + protobuf_AssignDescriptorsOnce(); + return CDOTAClientMsg_ChatWheel_descriptor_; +} + +const CDOTAClientMsg_ChatWheel& CDOTAClientMsg_ChatWheel::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_dota_5fclientmessages_2eproto(); return *default_instance_; +} + +CDOTAClientMsg_ChatWheel* CDOTAClientMsg_ChatWheel::default_instance_ = NULL; + +CDOTAClientMsg_ChatWheel* CDOTAClientMsg_ChatWheel::New() const { + return new CDOTAClientMsg_ChatWheel; +} + +void CDOTAClientMsg_ChatWheel::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + chat_message_ = 0; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool CDOTAClientMsg_ChatWheel::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)) { + // optional .EDOTAChatWheelMessage chat_message = 1 [default = k_EDOTA_CW_Ok]; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (EDOTAChatWheelMessage_IsValid(value)) { + set_chat_message(static_cast< EDOTAChatWheelMessage >(value)); + } else { + mutable_unknown_fields()->AddVarint(1, 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::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void CDOTAClientMsg_ChatWheel::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // optional .EDOTAChatWheelMessage chat_message = 1 [default = k_EDOTA_CW_Ok]; + if (has_chat_message()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 1, this->chat_message(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* CDOTAClientMsg_ChatWheel::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // optional .EDOTAChatWheelMessage chat_message = 1 [default = k_EDOTA_CW_Ok]; + if (has_chat_message()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 1, this->chat_message(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int CDOTAClientMsg_ChatWheel::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .EDOTAChatWheelMessage chat_message = 1 [default = k_EDOTA_CW_Ok]; + if (has_chat_message()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->chat_message()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void CDOTAClientMsg_ChatWheel::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const CDOTAClientMsg_ChatWheel* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void CDOTAClientMsg_ChatWheel::MergeFrom(const CDOTAClientMsg_ChatWheel& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_chat_message()) { + set_chat_message(from.chat_message()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void CDOTAClientMsg_ChatWheel::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void CDOTAClientMsg_ChatWheel::CopyFrom(const CDOTAClientMsg_ChatWheel& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CDOTAClientMsg_ChatWheel::IsInitialized() const { + + return true; +} + +void CDOTAClientMsg_ChatWheel::Swap(CDOTAClientMsg_ChatWheel* other) { + if (other != this) { + std::swap(chat_message_, other->chat_message_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata CDOTAClientMsg_ChatWheel::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = CDOTAClientMsg_ChatWheel_descriptor_; + metadata.reflection = CDOTAClientMsg_ChatWheel_reflection_; + return metadata; +} + + +// @@protoc_insertion_point(namespace_scope) + +// @@protoc_insertion_point(global_scope) diff --git a/public/game/shared/dota/protobuf/dota_clientmessages.pb.h b/public/game/shared/dota/protobuf/dota_clientmessages.pb.h new file mode 100644 index 00000000..baf2cdb6 --- /dev/null +++ b/public/game/shared/dota/protobuf/dota_clientmessages.pb.h @@ -0,0 +1,1948 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: dota_clientmessages.proto + +#ifndef PROTOBUF_dota_5fclientmessages_2eproto__INCLUDED +#define PROTOBUF_dota_5fclientmessages_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2004000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2004001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include "google/protobuf/descriptor.pb.h" +#include "netmessages.pb.h" +#include "dota_commonmessages.pb.h" +// @@protoc_insertion_point(includes) + +// Internal implementation detail -- do not call these. +void protobuf_AddDesc_dota_5fclientmessages_2eproto(); +void protobuf_AssignDesc_dota_5fclientmessages_2eproto(); +void protobuf_ShutdownFile_dota_5fclientmessages_2eproto(); + +class CDOTAClientMsg_MapPing; +class CDOTAClientMsg_ItemAlert; +class CDOTAClientMsg_MapLine; +class CDOTAClientMsg_AspectRatio; +class CDOTAClientMsg_UnitsAutoAttack; +class CDOTAClientMsg_AutoPurchaseItems; +class CDOTAClientMsg_TestItems; +class CDOTAClientMsg_SearchString; +class CDOTAClientMsg_Pause; +class CDOTAClientMsg_ShopViewMode; +class CDOTAClientMsg_SetUnitShareFlag; +class CDOTAClientMsg_SwapRequest; +class CDOTAClientMsg_SwapAccept; +class CDOTAClientMsg_WorldLine; +class CDOTAClientMsg_RequestGraphUpdate; +class CDOTAClientMsg_ChatWheel; + +enum EDotaClientMessages { + DOTA_CM_MapLine = 1, + DOTA_CM_AspectRatio = 2, + DOTA_CM_MapPing = 3, + DOTA_CM_UnitsAutoAttack = 4, + DOTA_CM_AutoPurchaseItems = 5, + DOTA_CM_TestItems = 6, + DOTA_CM_SearchString = 7, + DOTA_CM_Pause = 8, + DOTA_CM_ShopViewMode = 9, + DOTA_CM_SetUnitShareFlag = 10, + DOTA_CM_SwapRequest = 11, + DOTA_CM_SwapAccept = 12, + DOTA_CM_WorldLine = 13, + DOTA_CM_RequestGraphUpdate = 14, + DOTA_CM_ItemAlert = 15, + DOTA_CM_ChatWheel = 16 +}; +bool EDotaClientMessages_IsValid(int value); +const EDotaClientMessages EDotaClientMessages_MIN = DOTA_CM_MapLine; +const EDotaClientMessages EDotaClientMessages_MAX = DOTA_CM_ChatWheel; +const int EDotaClientMessages_ARRAYSIZE = EDotaClientMessages_MAX + 1; + +const ::google::protobuf::EnumDescriptor* EDotaClientMessages_descriptor(); +inline const ::std::string& EDotaClientMessages_Name(EDotaClientMessages value) { + return ::google::protobuf::internal::NameOfEnum( + EDotaClientMessages_descriptor(), value); +} +inline bool EDotaClientMessages_Parse( + const ::std::string& name, EDotaClientMessages* value) { + return ::google::protobuf::internal::ParseNamedEnum( + EDotaClientMessages_descriptor(), name, value); +} +// =================================================================== + +class CDOTAClientMsg_MapPing : public ::google::protobuf::Message { + public: + CDOTAClientMsg_MapPing(); + virtual ~CDOTAClientMsg_MapPing(); + + CDOTAClientMsg_MapPing(const CDOTAClientMsg_MapPing& from); + + inline CDOTAClientMsg_MapPing& operator=(const CDOTAClientMsg_MapPing& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const CDOTAClientMsg_MapPing& default_instance(); + + void Swap(CDOTAClientMsg_MapPing* other); + + // implements Message ---------------------------------------------- + + CDOTAClientMsg_MapPing* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const CDOTAClientMsg_MapPing& from); + void MergeFrom(const CDOTAClientMsg_MapPing& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .CDOTAMsg_LocationPing location_ping = 1; + inline bool has_location_ping() const; + inline void clear_location_ping(); + static const int kLocationPingFieldNumber = 1; + inline const ::CDOTAMsg_LocationPing& location_ping() const; + inline ::CDOTAMsg_LocationPing* mutable_location_ping(); + inline ::CDOTAMsg_LocationPing* release_location_ping(); + + // @@protoc_insertion_point(class_scope:CDOTAClientMsg_MapPing) + private: + inline void set_has_location_ping(); + inline void clear_has_location_ping(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::CDOTAMsg_LocationPing* location_ping_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_dota_5fclientmessages_2eproto(); + friend void protobuf_AssignDesc_dota_5fclientmessages_2eproto(); + friend void protobuf_ShutdownFile_dota_5fclientmessages_2eproto(); + + void InitAsDefaultInstance(); + static CDOTAClientMsg_MapPing* default_instance_; +}; +// ------------------------------------------------------------------- + +class CDOTAClientMsg_ItemAlert : public ::google::protobuf::Message { + public: + CDOTAClientMsg_ItemAlert(); + virtual ~CDOTAClientMsg_ItemAlert(); + + CDOTAClientMsg_ItemAlert(const CDOTAClientMsg_ItemAlert& from); + + inline CDOTAClientMsg_ItemAlert& operator=(const CDOTAClientMsg_ItemAlert& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const CDOTAClientMsg_ItemAlert& default_instance(); + + void Swap(CDOTAClientMsg_ItemAlert* other); + + // implements Message ---------------------------------------------- + + CDOTAClientMsg_ItemAlert* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const CDOTAClientMsg_ItemAlert& from); + void MergeFrom(const CDOTAClientMsg_ItemAlert& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .CDOTAMsg_ItemAlert item_alert = 1; + inline bool has_item_alert() const; + inline void clear_item_alert(); + static const int kItemAlertFieldNumber = 1; + inline const ::CDOTAMsg_ItemAlert& item_alert() const; + inline ::CDOTAMsg_ItemAlert* mutable_item_alert(); + inline ::CDOTAMsg_ItemAlert* release_item_alert(); + + // @@protoc_insertion_point(class_scope:CDOTAClientMsg_ItemAlert) + private: + inline void set_has_item_alert(); + inline void clear_has_item_alert(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::CDOTAMsg_ItemAlert* item_alert_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_dota_5fclientmessages_2eproto(); + friend void protobuf_AssignDesc_dota_5fclientmessages_2eproto(); + friend void protobuf_ShutdownFile_dota_5fclientmessages_2eproto(); + + void InitAsDefaultInstance(); + static CDOTAClientMsg_ItemAlert* default_instance_; +}; +// ------------------------------------------------------------------- + +class CDOTAClientMsg_MapLine : public ::google::protobuf::Message { + public: + CDOTAClientMsg_MapLine(); + virtual ~CDOTAClientMsg_MapLine(); + + CDOTAClientMsg_MapLine(const CDOTAClientMsg_MapLine& from); + + inline CDOTAClientMsg_MapLine& operator=(const CDOTAClientMsg_MapLine& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const CDOTAClientMsg_MapLine& default_instance(); + + void Swap(CDOTAClientMsg_MapLine* other); + + // implements Message ---------------------------------------------- + + CDOTAClientMsg_MapLine* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const CDOTAClientMsg_MapLine& from); + void MergeFrom(const CDOTAClientMsg_MapLine& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .CDOTAMsg_MapLine mapline = 1; + inline bool has_mapline() const; + inline void clear_mapline(); + static const int kMaplineFieldNumber = 1; + inline const ::CDOTAMsg_MapLine& mapline() const; + inline ::CDOTAMsg_MapLine* mutable_mapline(); + inline ::CDOTAMsg_MapLine* release_mapline(); + + // @@protoc_insertion_point(class_scope:CDOTAClientMsg_MapLine) + private: + inline void set_has_mapline(); + inline void clear_has_mapline(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::CDOTAMsg_MapLine* mapline_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_dota_5fclientmessages_2eproto(); + friend void protobuf_AssignDesc_dota_5fclientmessages_2eproto(); + friend void protobuf_ShutdownFile_dota_5fclientmessages_2eproto(); + + void InitAsDefaultInstance(); + static CDOTAClientMsg_MapLine* default_instance_; +}; +// ------------------------------------------------------------------- + +class CDOTAClientMsg_AspectRatio : public ::google::protobuf::Message { + public: + CDOTAClientMsg_AspectRatio(); + virtual ~CDOTAClientMsg_AspectRatio(); + + CDOTAClientMsg_AspectRatio(const CDOTAClientMsg_AspectRatio& from); + + inline CDOTAClientMsg_AspectRatio& operator=(const CDOTAClientMsg_AspectRatio& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const CDOTAClientMsg_AspectRatio& default_instance(); + + void Swap(CDOTAClientMsg_AspectRatio* other); + + // implements Message ---------------------------------------------- + + CDOTAClientMsg_AspectRatio* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const CDOTAClientMsg_AspectRatio& from); + void MergeFrom(const CDOTAClientMsg_AspectRatio& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional float ratio = 1; + inline bool has_ratio() const; + inline void clear_ratio(); + static const int kRatioFieldNumber = 1; + inline float ratio() const; + inline void set_ratio(float value); + + // @@protoc_insertion_point(class_scope:CDOTAClientMsg_AspectRatio) + private: + inline void set_has_ratio(); + inline void clear_has_ratio(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + float ratio_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_dota_5fclientmessages_2eproto(); + friend void protobuf_AssignDesc_dota_5fclientmessages_2eproto(); + friend void protobuf_ShutdownFile_dota_5fclientmessages_2eproto(); + + void InitAsDefaultInstance(); + static CDOTAClientMsg_AspectRatio* default_instance_; +}; +// ------------------------------------------------------------------- + +class CDOTAClientMsg_UnitsAutoAttack : public ::google::protobuf::Message { + public: + CDOTAClientMsg_UnitsAutoAttack(); + virtual ~CDOTAClientMsg_UnitsAutoAttack(); + + CDOTAClientMsg_UnitsAutoAttack(const CDOTAClientMsg_UnitsAutoAttack& from); + + inline CDOTAClientMsg_UnitsAutoAttack& operator=(const CDOTAClientMsg_UnitsAutoAttack& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const CDOTAClientMsg_UnitsAutoAttack& default_instance(); + + void Swap(CDOTAClientMsg_UnitsAutoAttack* other); + + // implements Message ---------------------------------------------- + + CDOTAClientMsg_UnitsAutoAttack* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const CDOTAClientMsg_UnitsAutoAttack& from); + void MergeFrom(const CDOTAClientMsg_UnitsAutoAttack& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional bool enabled = 1; + inline bool has_enabled() const; + inline void clear_enabled(); + static const int kEnabledFieldNumber = 1; + inline bool enabled() const; + inline void set_enabled(bool value); + + // @@protoc_insertion_point(class_scope:CDOTAClientMsg_UnitsAutoAttack) + private: + inline void set_has_enabled(); + inline void clear_has_enabled(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + bool enabled_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_dota_5fclientmessages_2eproto(); + friend void protobuf_AssignDesc_dota_5fclientmessages_2eproto(); + friend void protobuf_ShutdownFile_dota_5fclientmessages_2eproto(); + + void InitAsDefaultInstance(); + static CDOTAClientMsg_UnitsAutoAttack* default_instance_; +}; +// ------------------------------------------------------------------- + +class CDOTAClientMsg_AutoPurchaseItems : public ::google::protobuf::Message { + public: + CDOTAClientMsg_AutoPurchaseItems(); + virtual ~CDOTAClientMsg_AutoPurchaseItems(); + + CDOTAClientMsg_AutoPurchaseItems(const CDOTAClientMsg_AutoPurchaseItems& from); + + inline CDOTAClientMsg_AutoPurchaseItems& operator=(const CDOTAClientMsg_AutoPurchaseItems& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const CDOTAClientMsg_AutoPurchaseItems& default_instance(); + + void Swap(CDOTAClientMsg_AutoPurchaseItems* other); + + // implements Message ---------------------------------------------- + + CDOTAClientMsg_AutoPurchaseItems* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const CDOTAClientMsg_AutoPurchaseItems& from); + void MergeFrom(const CDOTAClientMsg_AutoPurchaseItems& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional bool enabled = 1; + inline bool has_enabled() const; + inline void clear_enabled(); + static const int kEnabledFieldNumber = 1; + inline bool enabled() const; + inline void set_enabled(bool value); + + // @@protoc_insertion_point(class_scope:CDOTAClientMsg_AutoPurchaseItems) + private: + inline void set_has_enabled(); + inline void clear_has_enabled(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + bool enabled_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_dota_5fclientmessages_2eproto(); + friend void protobuf_AssignDesc_dota_5fclientmessages_2eproto(); + friend void protobuf_ShutdownFile_dota_5fclientmessages_2eproto(); + + void InitAsDefaultInstance(); + static CDOTAClientMsg_AutoPurchaseItems* default_instance_; +}; +// ------------------------------------------------------------------- + +class CDOTAClientMsg_TestItems : public ::google::protobuf::Message { + public: + CDOTAClientMsg_TestItems(); + virtual ~CDOTAClientMsg_TestItems(); + + CDOTAClientMsg_TestItems(const CDOTAClientMsg_TestItems& from); + + inline CDOTAClientMsg_TestItems& operator=(const CDOTAClientMsg_TestItems& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const CDOTAClientMsg_TestItems& default_instance(); + + void Swap(CDOTAClientMsg_TestItems* other); + + // implements Message ---------------------------------------------- + + CDOTAClientMsg_TestItems* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const CDOTAClientMsg_TestItems& from); + void MergeFrom(const CDOTAClientMsg_TestItems& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional string key_values = 1; + inline bool has_key_values() const; + inline void clear_key_values(); + static const int kKeyValuesFieldNumber = 1; + inline const ::std::string& key_values() const; + inline void set_key_values(const ::std::string& value); + inline void set_key_values(const char* value); + inline void set_key_values(const char* value, size_t size); + inline ::std::string* mutable_key_values(); + inline ::std::string* release_key_values(); + + // @@protoc_insertion_point(class_scope:CDOTAClientMsg_TestItems) + private: + inline void set_has_key_values(); + inline void clear_has_key_values(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* key_values_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_dota_5fclientmessages_2eproto(); + friend void protobuf_AssignDesc_dota_5fclientmessages_2eproto(); + friend void protobuf_ShutdownFile_dota_5fclientmessages_2eproto(); + + void InitAsDefaultInstance(); + static CDOTAClientMsg_TestItems* default_instance_; +}; +// ------------------------------------------------------------------- + +class CDOTAClientMsg_SearchString : public ::google::protobuf::Message { + public: + CDOTAClientMsg_SearchString(); + virtual ~CDOTAClientMsg_SearchString(); + + CDOTAClientMsg_SearchString(const CDOTAClientMsg_SearchString& from); + + inline CDOTAClientMsg_SearchString& operator=(const CDOTAClientMsg_SearchString& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const CDOTAClientMsg_SearchString& default_instance(); + + void Swap(CDOTAClientMsg_SearchString* other); + + // implements Message ---------------------------------------------- + + CDOTAClientMsg_SearchString* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const CDOTAClientMsg_SearchString& from); + void MergeFrom(const CDOTAClientMsg_SearchString& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional string search = 1; + inline bool has_search() const; + inline void clear_search(); + static const int kSearchFieldNumber = 1; + inline const ::std::string& search() const; + inline void set_search(const ::std::string& value); + inline void set_search(const char* value); + inline void set_search(const char* value, size_t size); + inline ::std::string* mutable_search(); + inline ::std::string* release_search(); + + // @@protoc_insertion_point(class_scope:CDOTAClientMsg_SearchString) + private: + inline void set_has_search(); + inline void clear_has_search(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* search_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_dota_5fclientmessages_2eproto(); + friend void protobuf_AssignDesc_dota_5fclientmessages_2eproto(); + friend void protobuf_ShutdownFile_dota_5fclientmessages_2eproto(); + + void InitAsDefaultInstance(); + static CDOTAClientMsg_SearchString* default_instance_; +}; +// ------------------------------------------------------------------- + +class CDOTAClientMsg_Pause : public ::google::protobuf::Message { + public: + CDOTAClientMsg_Pause(); + virtual ~CDOTAClientMsg_Pause(); + + CDOTAClientMsg_Pause(const CDOTAClientMsg_Pause& from); + + inline CDOTAClientMsg_Pause& operator=(const CDOTAClientMsg_Pause& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const CDOTAClientMsg_Pause& default_instance(); + + void Swap(CDOTAClientMsg_Pause* other); + + // implements Message ---------------------------------------------- + + CDOTAClientMsg_Pause* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const CDOTAClientMsg_Pause& from); + void MergeFrom(const CDOTAClientMsg_Pause& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // @@protoc_insertion_point(class_scope:CDOTAClientMsg_Pause) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[1]; + + friend void protobuf_AddDesc_dota_5fclientmessages_2eproto(); + friend void protobuf_AssignDesc_dota_5fclientmessages_2eproto(); + friend void protobuf_ShutdownFile_dota_5fclientmessages_2eproto(); + + void InitAsDefaultInstance(); + static CDOTAClientMsg_Pause* default_instance_; +}; +// ------------------------------------------------------------------- + +class CDOTAClientMsg_ShopViewMode : public ::google::protobuf::Message { + public: + CDOTAClientMsg_ShopViewMode(); + virtual ~CDOTAClientMsg_ShopViewMode(); + + CDOTAClientMsg_ShopViewMode(const CDOTAClientMsg_ShopViewMode& from); + + inline CDOTAClientMsg_ShopViewMode& operator=(const CDOTAClientMsg_ShopViewMode& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const CDOTAClientMsg_ShopViewMode& default_instance(); + + void Swap(CDOTAClientMsg_ShopViewMode* other); + + // implements Message ---------------------------------------------- + + CDOTAClientMsg_ShopViewMode* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const CDOTAClientMsg_ShopViewMode& from); + void MergeFrom(const CDOTAClientMsg_ShopViewMode& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional uint32 mode = 1; + inline bool has_mode() const; + inline void clear_mode(); + static const int kModeFieldNumber = 1; + inline ::google::protobuf::uint32 mode() const; + inline void set_mode(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:CDOTAClientMsg_ShopViewMode) + private: + inline void set_has_mode(); + inline void clear_has_mode(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 mode_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_dota_5fclientmessages_2eproto(); + friend void protobuf_AssignDesc_dota_5fclientmessages_2eproto(); + friend void protobuf_ShutdownFile_dota_5fclientmessages_2eproto(); + + void InitAsDefaultInstance(); + static CDOTAClientMsg_ShopViewMode* default_instance_; +}; +// ------------------------------------------------------------------- + +class CDOTAClientMsg_SetUnitShareFlag : public ::google::protobuf::Message { + public: + CDOTAClientMsg_SetUnitShareFlag(); + virtual ~CDOTAClientMsg_SetUnitShareFlag(); + + CDOTAClientMsg_SetUnitShareFlag(const CDOTAClientMsg_SetUnitShareFlag& from); + + inline CDOTAClientMsg_SetUnitShareFlag& operator=(const CDOTAClientMsg_SetUnitShareFlag& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const CDOTAClientMsg_SetUnitShareFlag& default_instance(); + + void Swap(CDOTAClientMsg_SetUnitShareFlag* other); + + // implements Message ---------------------------------------------- + + CDOTAClientMsg_SetUnitShareFlag* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const CDOTAClientMsg_SetUnitShareFlag& from); + void MergeFrom(const CDOTAClientMsg_SetUnitShareFlag& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional uint32 playerID = 1; + inline bool has_playerid() const; + inline void clear_playerid(); + static const int kPlayerIDFieldNumber = 1; + inline ::google::protobuf::uint32 playerid() const; + inline void set_playerid(::google::protobuf::uint32 value); + + // optional uint32 flag = 2; + inline bool has_flag() const; + inline void clear_flag(); + static const int kFlagFieldNumber = 2; + inline ::google::protobuf::uint32 flag() const; + inline void set_flag(::google::protobuf::uint32 value); + + // optional bool state = 3; + inline bool has_state() const; + inline void clear_state(); + static const int kStateFieldNumber = 3; + inline bool state() const; + inline void set_state(bool value); + + // @@protoc_insertion_point(class_scope:CDOTAClientMsg_SetUnitShareFlag) + private: + inline void set_has_playerid(); + inline void clear_has_playerid(); + inline void set_has_flag(); + inline void clear_has_flag(); + inline void set_has_state(); + inline void clear_has_state(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 playerid_; + ::google::protobuf::uint32 flag_; + bool state_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; + + friend void protobuf_AddDesc_dota_5fclientmessages_2eproto(); + friend void protobuf_AssignDesc_dota_5fclientmessages_2eproto(); + friend void protobuf_ShutdownFile_dota_5fclientmessages_2eproto(); + + void InitAsDefaultInstance(); + static CDOTAClientMsg_SetUnitShareFlag* default_instance_; +}; +// ------------------------------------------------------------------- + +class CDOTAClientMsg_SwapRequest : public ::google::protobuf::Message { + public: + CDOTAClientMsg_SwapRequest(); + virtual ~CDOTAClientMsg_SwapRequest(); + + CDOTAClientMsg_SwapRequest(const CDOTAClientMsg_SwapRequest& from); + + inline CDOTAClientMsg_SwapRequest& operator=(const CDOTAClientMsg_SwapRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const CDOTAClientMsg_SwapRequest& default_instance(); + + void Swap(CDOTAClientMsg_SwapRequest* other); + + // implements Message ---------------------------------------------- + + CDOTAClientMsg_SwapRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const CDOTAClientMsg_SwapRequest& from); + void MergeFrom(const CDOTAClientMsg_SwapRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional uint32 player_id = 1; + inline bool has_player_id() const; + inline void clear_player_id(); + static const int kPlayerIdFieldNumber = 1; + inline ::google::protobuf::uint32 player_id() const; + inline void set_player_id(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:CDOTAClientMsg_SwapRequest) + private: + inline void set_has_player_id(); + inline void clear_has_player_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 player_id_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_dota_5fclientmessages_2eproto(); + friend void protobuf_AssignDesc_dota_5fclientmessages_2eproto(); + friend void protobuf_ShutdownFile_dota_5fclientmessages_2eproto(); + + void InitAsDefaultInstance(); + static CDOTAClientMsg_SwapRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class CDOTAClientMsg_SwapAccept : public ::google::protobuf::Message { + public: + CDOTAClientMsg_SwapAccept(); + virtual ~CDOTAClientMsg_SwapAccept(); + + CDOTAClientMsg_SwapAccept(const CDOTAClientMsg_SwapAccept& from); + + inline CDOTAClientMsg_SwapAccept& operator=(const CDOTAClientMsg_SwapAccept& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const CDOTAClientMsg_SwapAccept& default_instance(); + + void Swap(CDOTAClientMsg_SwapAccept* other); + + // implements Message ---------------------------------------------- + + CDOTAClientMsg_SwapAccept* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const CDOTAClientMsg_SwapAccept& from); + void MergeFrom(const CDOTAClientMsg_SwapAccept& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional uint32 player_id = 1; + inline bool has_player_id() const; + inline void clear_player_id(); + static const int kPlayerIdFieldNumber = 1; + inline ::google::protobuf::uint32 player_id() const; + inline void set_player_id(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:CDOTAClientMsg_SwapAccept) + private: + inline void set_has_player_id(); + inline void clear_has_player_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 player_id_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_dota_5fclientmessages_2eproto(); + friend void protobuf_AssignDesc_dota_5fclientmessages_2eproto(); + friend void protobuf_ShutdownFile_dota_5fclientmessages_2eproto(); + + void InitAsDefaultInstance(); + static CDOTAClientMsg_SwapAccept* default_instance_; +}; +// ------------------------------------------------------------------- + +class CDOTAClientMsg_WorldLine : public ::google::protobuf::Message { + public: + CDOTAClientMsg_WorldLine(); + virtual ~CDOTAClientMsg_WorldLine(); + + CDOTAClientMsg_WorldLine(const CDOTAClientMsg_WorldLine& from); + + inline CDOTAClientMsg_WorldLine& operator=(const CDOTAClientMsg_WorldLine& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const CDOTAClientMsg_WorldLine& default_instance(); + + void Swap(CDOTAClientMsg_WorldLine* other); + + // implements Message ---------------------------------------------- + + CDOTAClientMsg_WorldLine* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const CDOTAClientMsg_WorldLine& from); + void MergeFrom(const CDOTAClientMsg_WorldLine& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .CDOTAMsg_WorldLine worldline = 1; + inline bool has_worldline() const; + inline void clear_worldline(); + static const int kWorldlineFieldNumber = 1; + inline const ::CDOTAMsg_WorldLine& worldline() const; + inline ::CDOTAMsg_WorldLine* mutable_worldline(); + inline ::CDOTAMsg_WorldLine* release_worldline(); + + // @@protoc_insertion_point(class_scope:CDOTAClientMsg_WorldLine) + private: + inline void set_has_worldline(); + inline void clear_has_worldline(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::CDOTAMsg_WorldLine* worldline_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_dota_5fclientmessages_2eproto(); + friend void protobuf_AssignDesc_dota_5fclientmessages_2eproto(); + friend void protobuf_ShutdownFile_dota_5fclientmessages_2eproto(); + + void InitAsDefaultInstance(); + static CDOTAClientMsg_WorldLine* default_instance_; +}; +// ------------------------------------------------------------------- + +class CDOTAClientMsg_RequestGraphUpdate : public ::google::protobuf::Message { + public: + CDOTAClientMsg_RequestGraphUpdate(); + virtual ~CDOTAClientMsg_RequestGraphUpdate(); + + CDOTAClientMsg_RequestGraphUpdate(const CDOTAClientMsg_RequestGraphUpdate& from); + + inline CDOTAClientMsg_RequestGraphUpdate& operator=(const CDOTAClientMsg_RequestGraphUpdate& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const CDOTAClientMsg_RequestGraphUpdate& default_instance(); + + void Swap(CDOTAClientMsg_RequestGraphUpdate* other); + + // implements Message ---------------------------------------------- + + CDOTAClientMsg_RequestGraphUpdate* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const CDOTAClientMsg_RequestGraphUpdate& from); + void MergeFrom(const CDOTAClientMsg_RequestGraphUpdate& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // @@protoc_insertion_point(class_scope:CDOTAClientMsg_RequestGraphUpdate) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[1]; + + friend void protobuf_AddDesc_dota_5fclientmessages_2eproto(); + friend void protobuf_AssignDesc_dota_5fclientmessages_2eproto(); + friend void protobuf_ShutdownFile_dota_5fclientmessages_2eproto(); + + void InitAsDefaultInstance(); + static CDOTAClientMsg_RequestGraphUpdate* default_instance_; +}; +// ------------------------------------------------------------------- + +class CDOTAClientMsg_ChatWheel : public ::google::protobuf::Message { + public: + CDOTAClientMsg_ChatWheel(); + virtual ~CDOTAClientMsg_ChatWheel(); + + CDOTAClientMsg_ChatWheel(const CDOTAClientMsg_ChatWheel& from); + + inline CDOTAClientMsg_ChatWheel& operator=(const CDOTAClientMsg_ChatWheel& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const CDOTAClientMsg_ChatWheel& default_instance(); + + void Swap(CDOTAClientMsg_ChatWheel* other); + + // implements Message ---------------------------------------------- + + CDOTAClientMsg_ChatWheel* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const CDOTAClientMsg_ChatWheel& from); + void MergeFrom(const CDOTAClientMsg_ChatWheel& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .EDOTAChatWheelMessage chat_message = 1 [default = k_EDOTA_CW_Ok]; + inline bool has_chat_message() const; + inline void clear_chat_message(); + static const int kChatMessageFieldNumber = 1; + inline EDOTAChatWheelMessage chat_message() const; + inline void set_chat_message(EDOTAChatWheelMessage value); + + // @@protoc_insertion_point(class_scope:CDOTAClientMsg_ChatWheel) + private: + inline void set_has_chat_message(); + inline void clear_has_chat_message(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + int chat_message_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_dota_5fclientmessages_2eproto(); + friend void protobuf_AssignDesc_dota_5fclientmessages_2eproto(); + friend void protobuf_ShutdownFile_dota_5fclientmessages_2eproto(); + + void InitAsDefaultInstance(); + static CDOTAClientMsg_ChatWheel* default_instance_; +}; +// =================================================================== + + +// =================================================================== + +// CDOTAClientMsg_MapPing + +// optional .CDOTAMsg_LocationPing location_ping = 1; +inline bool CDOTAClientMsg_MapPing::has_location_ping() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void CDOTAClientMsg_MapPing::set_has_location_ping() { + _has_bits_[0] |= 0x00000001u; +} +inline void CDOTAClientMsg_MapPing::clear_has_location_ping() { + _has_bits_[0] &= ~0x00000001u; +} +inline void CDOTAClientMsg_MapPing::clear_location_ping() { + if (location_ping_ != NULL) location_ping_->::CDOTAMsg_LocationPing::Clear(); + clear_has_location_ping(); +} +inline const ::CDOTAMsg_LocationPing& CDOTAClientMsg_MapPing::location_ping() const { + return location_ping_ != NULL ? *location_ping_ : *default_instance_->location_ping_; +} +inline ::CDOTAMsg_LocationPing* CDOTAClientMsg_MapPing::mutable_location_ping() { + set_has_location_ping(); + if (location_ping_ == NULL) location_ping_ = new ::CDOTAMsg_LocationPing; + return location_ping_; +} +inline ::CDOTAMsg_LocationPing* CDOTAClientMsg_MapPing::release_location_ping() { + clear_has_location_ping(); + ::CDOTAMsg_LocationPing* temp = location_ping_; + location_ping_ = NULL; + return temp; +} + +// ------------------------------------------------------------------- + +// CDOTAClientMsg_ItemAlert + +// optional .CDOTAMsg_ItemAlert item_alert = 1; +inline bool CDOTAClientMsg_ItemAlert::has_item_alert() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void CDOTAClientMsg_ItemAlert::set_has_item_alert() { + _has_bits_[0] |= 0x00000001u; +} +inline void CDOTAClientMsg_ItemAlert::clear_has_item_alert() { + _has_bits_[0] &= ~0x00000001u; +} +inline void CDOTAClientMsg_ItemAlert::clear_item_alert() { + if (item_alert_ != NULL) item_alert_->::CDOTAMsg_ItemAlert::Clear(); + clear_has_item_alert(); +} +inline const ::CDOTAMsg_ItemAlert& CDOTAClientMsg_ItemAlert::item_alert() const { + return item_alert_ != NULL ? *item_alert_ : *default_instance_->item_alert_; +} +inline ::CDOTAMsg_ItemAlert* CDOTAClientMsg_ItemAlert::mutable_item_alert() { + set_has_item_alert(); + if (item_alert_ == NULL) item_alert_ = new ::CDOTAMsg_ItemAlert; + return item_alert_; +} +inline ::CDOTAMsg_ItemAlert* CDOTAClientMsg_ItemAlert::release_item_alert() { + clear_has_item_alert(); + ::CDOTAMsg_ItemAlert* temp = item_alert_; + item_alert_ = NULL; + return temp; +} + +// ------------------------------------------------------------------- + +// CDOTAClientMsg_MapLine + +// optional .CDOTAMsg_MapLine mapline = 1; +inline bool CDOTAClientMsg_MapLine::has_mapline() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void CDOTAClientMsg_MapLine::set_has_mapline() { + _has_bits_[0] |= 0x00000001u; +} +inline void CDOTAClientMsg_MapLine::clear_has_mapline() { + _has_bits_[0] &= ~0x00000001u; +} +inline void CDOTAClientMsg_MapLine::clear_mapline() { + if (mapline_ != NULL) mapline_->::CDOTAMsg_MapLine::Clear(); + clear_has_mapline(); +} +inline const ::CDOTAMsg_MapLine& CDOTAClientMsg_MapLine::mapline() const { + return mapline_ != NULL ? *mapline_ : *default_instance_->mapline_; +} +inline ::CDOTAMsg_MapLine* CDOTAClientMsg_MapLine::mutable_mapline() { + set_has_mapline(); + if (mapline_ == NULL) mapline_ = new ::CDOTAMsg_MapLine; + return mapline_; +} +inline ::CDOTAMsg_MapLine* CDOTAClientMsg_MapLine::release_mapline() { + clear_has_mapline(); + ::CDOTAMsg_MapLine* temp = mapline_; + mapline_ = NULL; + return temp; +} + +// ------------------------------------------------------------------- + +// CDOTAClientMsg_AspectRatio + +// optional float ratio = 1; +inline bool CDOTAClientMsg_AspectRatio::has_ratio() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void CDOTAClientMsg_AspectRatio::set_has_ratio() { + _has_bits_[0] |= 0x00000001u; +} +inline void CDOTAClientMsg_AspectRatio::clear_has_ratio() { + _has_bits_[0] &= ~0x00000001u; +} +inline void CDOTAClientMsg_AspectRatio::clear_ratio() { + ratio_ = 0; + clear_has_ratio(); +} +inline float CDOTAClientMsg_AspectRatio::ratio() const { + return ratio_; +} +inline void CDOTAClientMsg_AspectRatio::set_ratio(float value) { + set_has_ratio(); + ratio_ = value; +} + +// ------------------------------------------------------------------- + +// CDOTAClientMsg_UnitsAutoAttack + +// optional bool enabled = 1; +inline bool CDOTAClientMsg_UnitsAutoAttack::has_enabled() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void CDOTAClientMsg_UnitsAutoAttack::set_has_enabled() { + _has_bits_[0] |= 0x00000001u; +} +inline void CDOTAClientMsg_UnitsAutoAttack::clear_has_enabled() { + _has_bits_[0] &= ~0x00000001u; +} +inline void CDOTAClientMsg_UnitsAutoAttack::clear_enabled() { + enabled_ = false; + clear_has_enabled(); +} +inline bool CDOTAClientMsg_UnitsAutoAttack::enabled() const { + return enabled_; +} +inline void CDOTAClientMsg_UnitsAutoAttack::set_enabled(bool value) { + set_has_enabled(); + enabled_ = value; +} + +// ------------------------------------------------------------------- + +// CDOTAClientMsg_AutoPurchaseItems + +// optional bool enabled = 1; +inline bool CDOTAClientMsg_AutoPurchaseItems::has_enabled() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void CDOTAClientMsg_AutoPurchaseItems::set_has_enabled() { + _has_bits_[0] |= 0x00000001u; +} +inline void CDOTAClientMsg_AutoPurchaseItems::clear_has_enabled() { + _has_bits_[0] &= ~0x00000001u; +} +inline void CDOTAClientMsg_AutoPurchaseItems::clear_enabled() { + enabled_ = false; + clear_has_enabled(); +} +inline bool CDOTAClientMsg_AutoPurchaseItems::enabled() const { + return enabled_; +} +inline void CDOTAClientMsg_AutoPurchaseItems::set_enabled(bool value) { + set_has_enabled(); + enabled_ = value; +} + +// ------------------------------------------------------------------- + +// CDOTAClientMsg_TestItems + +// optional string key_values = 1; +inline bool CDOTAClientMsg_TestItems::has_key_values() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void CDOTAClientMsg_TestItems::set_has_key_values() { + _has_bits_[0] |= 0x00000001u; +} +inline void CDOTAClientMsg_TestItems::clear_has_key_values() { + _has_bits_[0] &= ~0x00000001u; +} +inline void CDOTAClientMsg_TestItems::clear_key_values() { + if (key_values_ != &::google::protobuf::internal::kEmptyString) { + key_values_->clear(); + } + clear_has_key_values(); +} +inline const ::std::string& CDOTAClientMsg_TestItems::key_values() const { + return *key_values_; +} +inline void CDOTAClientMsg_TestItems::set_key_values(const ::std::string& value) { + set_has_key_values(); + if (key_values_ == &::google::protobuf::internal::kEmptyString) { + key_values_ = new ::std::string; + } + key_values_->assign(value); +} +inline void CDOTAClientMsg_TestItems::set_key_values(const char* value) { + set_has_key_values(); + if (key_values_ == &::google::protobuf::internal::kEmptyString) { + key_values_ = new ::std::string; + } + key_values_->assign(value); +} +inline void CDOTAClientMsg_TestItems::set_key_values(const char* value, size_t size) { + set_has_key_values(); + if (key_values_ == &::google::protobuf::internal::kEmptyString) { + key_values_ = new ::std::string; + } + key_values_->assign(reinterpret_cast(value), size); +} +inline ::std::string* CDOTAClientMsg_TestItems::mutable_key_values() { + set_has_key_values(); + if (key_values_ == &::google::protobuf::internal::kEmptyString) { + key_values_ = new ::std::string; + } + return key_values_; +} +inline ::std::string* CDOTAClientMsg_TestItems::release_key_values() { + clear_has_key_values(); + if (key_values_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = key_values_; + key_values_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} + +// ------------------------------------------------------------------- + +// CDOTAClientMsg_SearchString + +// optional string search = 1; +inline bool CDOTAClientMsg_SearchString::has_search() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void CDOTAClientMsg_SearchString::set_has_search() { + _has_bits_[0] |= 0x00000001u; +} +inline void CDOTAClientMsg_SearchString::clear_has_search() { + _has_bits_[0] &= ~0x00000001u; +} +inline void CDOTAClientMsg_SearchString::clear_search() { + if (search_ != &::google::protobuf::internal::kEmptyString) { + search_->clear(); + } + clear_has_search(); +} +inline const ::std::string& CDOTAClientMsg_SearchString::search() const { + return *search_; +} +inline void CDOTAClientMsg_SearchString::set_search(const ::std::string& value) { + set_has_search(); + if (search_ == &::google::protobuf::internal::kEmptyString) { + search_ = new ::std::string; + } + search_->assign(value); +} +inline void CDOTAClientMsg_SearchString::set_search(const char* value) { + set_has_search(); + if (search_ == &::google::protobuf::internal::kEmptyString) { + search_ = new ::std::string; + } + search_->assign(value); +} +inline void CDOTAClientMsg_SearchString::set_search(const char* value, size_t size) { + set_has_search(); + if (search_ == &::google::protobuf::internal::kEmptyString) { + search_ = new ::std::string; + } + search_->assign(reinterpret_cast(value), size); +} +inline ::std::string* CDOTAClientMsg_SearchString::mutable_search() { + set_has_search(); + if (search_ == &::google::protobuf::internal::kEmptyString) { + search_ = new ::std::string; + } + return search_; +} +inline ::std::string* CDOTAClientMsg_SearchString::release_search() { + clear_has_search(); + if (search_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = search_; + search_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} + +// ------------------------------------------------------------------- + +// CDOTAClientMsg_Pause + +// ------------------------------------------------------------------- + +// CDOTAClientMsg_ShopViewMode + +// optional uint32 mode = 1; +inline bool CDOTAClientMsg_ShopViewMode::has_mode() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void CDOTAClientMsg_ShopViewMode::set_has_mode() { + _has_bits_[0] |= 0x00000001u; +} +inline void CDOTAClientMsg_ShopViewMode::clear_has_mode() { + _has_bits_[0] &= ~0x00000001u; +} +inline void CDOTAClientMsg_ShopViewMode::clear_mode() { + mode_ = 0u; + clear_has_mode(); +} +inline ::google::protobuf::uint32 CDOTAClientMsg_ShopViewMode::mode() const { + return mode_; +} +inline void CDOTAClientMsg_ShopViewMode::set_mode(::google::protobuf::uint32 value) { + set_has_mode(); + mode_ = value; +} + +// ------------------------------------------------------------------- + +// CDOTAClientMsg_SetUnitShareFlag + +// optional uint32 playerID = 1; +inline bool CDOTAClientMsg_SetUnitShareFlag::has_playerid() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void CDOTAClientMsg_SetUnitShareFlag::set_has_playerid() { + _has_bits_[0] |= 0x00000001u; +} +inline void CDOTAClientMsg_SetUnitShareFlag::clear_has_playerid() { + _has_bits_[0] &= ~0x00000001u; +} +inline void CDOTAClientMsg_SetUnitShareFlag::clear_playerid() { + playerid_ = 0u; + clear_has_playerid(); +} +inline ::google::protobuf::uint32 CDOTAClientMsg_SetUnitShareFlag::playerid() const { + return playerid_; +} +inline void CDOTAClientMsg_SetUnitShareFlag::set_playerid(::google::protobuf::uint32 value) { + set_has_playerid(); + playerid_ = value; +} + +// optional uint32 flag = 2; +inline bool CDOTAClientMsg_SetUnitShareFlag::has_flag() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void CDOTAClientMsg_SetUnitShareFlag::set_has_flag() { + _has_bits_[0] |= 0x00000002u; +} +inline void CDOTAClientMsg_SetUnitShareFlag::clear_has_flag() { + _has_bits_[0] &= ~0x00000002u; +} +inline void CDOTAClientMsg_SetUnitShareFlag::clear_flag() { + flag_ = 0u; + clear_has_flag(); +} +inline ::google::protobuf::uint32 CDOTAClientMsg_SetUnitShareFlag::flag() const { + return flag_; +} +inline void CDOTAClientMsg_SetUnitShareFlag::set_flag(::google::protobuf::uint32 value) { + set_has_flag(); + flag_ = value; +} + +// optional bool state = 3; +inline bool CDOTAClientMsg_SetUnitShareFlag::has_state() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void CDOTAClientMsg_SetUnitShareFlag::set_has_state() { + _has_bits_[0] |= 0x00000004u; +} +inline void CDOTAClientMsg_SetUnitShareFlag::clear_has_state() { + _has_bits_[0] &= ~0x00000004u; +} +inline void CDOTAClientMsg_SetUnitShareFlag::clear_state() { + state_ = false; + clear_has_state(); +} +inline bool CDOTAClientMsg_SetUnitShareFlag::state() const { + return state_; +} +inline void CDOTAClientMsg_SetUnitShareFlag::set_state(bool value) { + set_has_state(); + state_ = value; +} + +// ------------------------------------------------------------------- + +// CDOTAClientMsg_SwapRequest + +// optional uint32 player_id = 1; +inline bool CDOTAClientMsg_SwapRequest::has_player_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void CDOTAClientMsg_SwapRequest::set_has_player_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void CDOTAClientMsg_SwapRequest::clear_has_player_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void CDOTAClientMsg_SwapRequest::clear_player_id() { + player_id_ = 0u; + clear_has_player_id(); +} +inline ::google::protobuf::uint32 CDOTAClientMsg_SwapRequest::player_id() const { + return player_id_; +} +inline void CDOTAClientMsg_SwapRequest::set_player_id(::google::protobuf::uint32 value) { + set_has_player_id(); + player_id_ = value; +} + +// ------------------------------------------------------------------- + +// CDOTAClientMsg_SwapAccept + +// optional uint32 player_id = 1; +inline bool CDOTAClientMsg_SwapAccept::has_player_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void CDOTAClientMsg_SwapAccept::set_has_player_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void CDOTAClientMsg_SwapAccept::clear_has_player_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void CDOTAClientMsg_SwapAccept::clear_player_id() { + player_id_ = 0u; + clear_has_player_id(); +} +inline ::google::protobuf::uint32 CDOTAClientMsg_SwapAccept::player_id() const { + return player_id_; +} +inline void CDOTAClientMsg_SwapAccept::set_player_id(::google::protobuf::uint32 value) { + set_has_player_id(); + player_id_ = value; +} + +// ------------------------------------------------------------------- + +// CDOTAClientMsg_WorldLine + +// optional .CDOTAMsg_WorldLine worldline = 1; +inline bool CDOTAClientMsg_WorldLine::has_worldline() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void CDOTAClientMsg_WorldLine::set_has_worldline() { + _has_bits_[0] |= 0x00000001u; +} +inline void CDOTAClientMsg_WorldLine::clear_has_worldline() { + _has_bits_[0] &= ~0x00000001u; +} +inline void CDOTAClientMsg_WorldLine::clear_worldline() { + if (worldline_ != NULL) worldline_->::CDOTAMsg_WorldLine::Clear(); + clear_has_worldline(); +} +inline const ::CDOTAMsg_WorldLine& CDOTAClientMsg_WorldLine::worldline() const { + return worldline_ != NULL ? *worldline_ : *default_instance_->worldline_; +} +inline ::CDOTAMsg_WorldLine* CDOTAClientMsg_WorldLine::mutable_worldline() { + set_has_worldline(); + if (worldline_ == NULL) worldline_ = new ::CDOTAMsg_WorldLine; + return worldline_; +} +inline ::CDOTAMsg_WorldLine* CDOTAClientMsg_WorldLine::release_worldline() { + clear_has_worldline(); + ::CDOTAMsg_WorldLine* temp = worldline_; + worldline_ = NULL; + return temp; +} + +// ------------------------------------------------------------------- + +// CDOTAClientMsg_RequestGraphUpdate + +// ------------------------------------------------------------------- + +// CDOTAClientMsg_ChatWheel + +// optional .EDOTAChatWheelMessage chat_message = 1 [default = k_EDOTA_CW_Ok]; +inline bool CDOTAClientMsg_ChatWheel::has_chat_message() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void CDOTAClientMsg_ChatWheel::set_has_chat_message() { + _has_bits_[0] |= 0x00000001u; +} +inline void CDOTAClientMsg_ChatWheel::clear_has_chat_message() { + _has_bits_[0] &= ~0x00000001u; +} +inline void CDOTAClientMsg_ChatWheel::clear_chat_message() { + chat_message_ = 0; + clear_has_chat_message(); +} +inline EDOTAChatWheelMessage CDOTAClientMsg_ChatWheel::chat_message() const { + return static_cast< EDOTAChatWheelMessage >(chat_message_); +} +inline void CDOTAClientMsg_ChatWheel::set_chat_message(EDOTAChatWheelMessage value) { + GOOGLE_DCHECK(EDOTAChatWheelMessage_IsValid(value)); + set_has_chat_message(); + chat_message_ = value; +} + + +// @@protoc_insertion_point(namespace_scope) + +#ifndef SWIG +namespace google { +namespace protobuf { + +template <> +inline const EnumDescriptor* GetEnumDescriptor< EDotaClientMessages>() { + return EDotaClientMessages_descriptor(); +} + +} // namespace google +} // namespace protobuf +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_dota_5fclientmessages_2eproto__INCLUDED diff --git a/public/game/shared/dota/protobuf/dota_clientmessages.proto b/public/game/shared/dota/protobuf/dota_clientmessages.proto new file mode 100644 index 00000000..134128c4 --- /dev/null +++ b/public/game/shared/dota/protobuf/dota_clientmessages.proto @@ -0,0 +1,172 @@ +//====== Copyright (c) 2012, Valve Corporation, All rights reserved. ========// +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF +// THE POSSIBILITY OF SUCH DAMAGE. +//===========================================================================// +// +// Purpose: The file defines our Google Protocol Buffers which are used in over +// the wire messages for the Source engine. +// +//============================================================================= + +// We care more about speed than code size +option optimize_for = SPEED; + +// We don't use the service generation functionality +option cc_generic_services = false; + + +// +// STYLE NOTES: +// +// Use CamelCase CMsgMyMessageName style names for messages. +// +// Use lowercase _ delimited names like my_steam_id for field names, this is non-standard for Steam, +// but plays nice with the Google formatted code generation. +// +// Try not to use required fields ever. Only do so if you are really really sure you'll never want them removed. +// Optional should be preffered as it will make versioning easier and cleaner in the future if someone refactors +// your message and wants to remove or rename fields. +// +// Use fixed64 for JobId_t, GID_t, or SteamID. This is appropriate for any field that is normally +// going to be larger than 2^56. Otherwise use int64 for 64 bit values that are frequently smaller +// than 2^56 as it will safe space on the wire in those cases. +// +// Similar to fixed64, use fixed32 for RTime32 or other 32 bit values that are frequently larger than +// 2^28. It will safe space in those cases, otherwise use int32 which will safe space for smaller values. +// An exception to this rule for RTime32 is if the value will frequently be zero rather than set to an actual +// time. +// + +import "google/protobuf/descriptor.proto"; + +// for CMsgVector, etc. +import "netmessages.proto"; + +// for structures shared between user and client messages +import "dota_commonmessages.proto"; + +//============================================================================= +// Dota Client Messages +//============================================================================= + +enum EDotaClientMessages +{ + DOTA_CM_MapLine = 1; + DOTA_CM_AspectRatio = 2; + DOTA_CM_MapPing = 3; + DOTA_CM_UnitsAutoAttack = 4; + DOTA_CM_AutoPurchaseItems = 5; + DOTA_CM_TestItems = 6; + DOTA_CM_SearchString = 7; + DOTA_CM_Pause = 8; + DOTA_CM_ShopViewMode = 9; + DOTA_CM_SetUnitShareFlag = 10; + DOTA_CM_SwapRequest = 11; + DOTA_CM_SwapAccept = 12; + DOTA_CM_WorldLine = 13; + DOTA_CM_RequestGraphUpdate = 14; + DOTA_CM_ItemAlert = 15; + DOTA_CM_ChatWheel = 16; +} + +//============================================================================= + +message CDOTAClientMsg_MapPing +{ + optional CDOTAMsg_LocationPing location_ping = 1; +} + +message CDOTAClientMsg_ItemAlert +{ + optional CDOTAMsg_ItemAlert item_alert = 1; +} + +message CDOTAClientMsg_MapLine +{ + optional CDOTAMsg_MapLine mapline = 1; +} + +message CDOTAClientMsg_AspectRatio +{ + optional float ratio = 1; +} + +message CDOTAClientMsg_UnitsAutoAttack +{ + optional bool enabled = 1; +} + +message CDOTAClientMsg_AutoPurchaseItems +{ + optional bool enabled = 1; +} + +message CDOTAClientMsg_TestItems +{ + optional string key_values = 1; +} + +message CDOTAClientMsg_SearchString +{ + optional string search = 1; +} + +message CDOTAClientMsg_Pause +{ +} + +message CDOTAClientMsg_ShopViewMode +{ + optional uint32 mode = 1; +} + +message CDOTAClientMsg_SetUnitShareFlag +{ + optional uint32 playerID = 1; + optional uint32 flag = 2; + optional bool state = 3; +} + +message CDOTAClientMsg_SwapRequest +{ + optional uint32 player_id = 1; +} + +message CDOTAClientMsg_SwapAccept +{ + optional uint32 player_id = 1; +} + +message CDOTAClientMsg_WorldLine +{ + optional CDOTAMsg_WorldLine worldline = 1; +} + +message CDOTAClientMsg_RequestGraphUpdate +{ +} + +message CDOTAClientMsg_ChatWheel +{ + optional EDOTAChatWheelMessage chat_message = 1 [default = k_EDOTA_CW_Ok]; +} +