source/hl2sdk
1
0
Fork 0
mirror of https://github.com/alliedmodders/hl2sdk.git synced 2025-12-15 01:58:34 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
409858e4ee
hl2sdk/public/engine/protobuf/netmessages.pb.cc
Nicholas Hastings 409858e4ee Regenerate proto files.
2015-02-20 09:14:02 -05:00

15073 lines
498 KiB
C++
Raw Blame History

// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: netmessages.proto
#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
#include "netmessages.pb.h"
#include <algorithm>
#include <google/protobuf/stubs/common.h>
#include <google/protobuf/stubs/once.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/wire_format_lite_inl.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/reflection_ops.h>
#include <google/protobuf/wire_format.h>
// @@protoc_insertion_point(includes)
namespace {
const ::google::protobuf::Descriptor* CCLCMsg_ClientInfo_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
CCLCMsg_ClientInfo_reflection_ = NULL;
const ::google::protobuf::Descriptor* CCLCMsg_Move_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
CCLCMsg_Move_reflection_ = NULL;
const ::google::protobuf::Descriptor* CCLCMsg_VoiceData_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
CCLCMsg_VoiceData_reflection_ = NULL;
const ::google::protobuf::Descriptor* CCLCMsg_BaselineAck_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
CCLCMsg_BaselineAck_reflection_ = NULL;
const ::google::protobuf::Descriptor* CCLCMsg_ListenEvents_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
CCLCMsg_ListenEvents_reflection_ = NULL;
const ::google::protobuf::Descriptor* CCLCMsg_RespondCvarValue_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
CCLCMsg_RespondCvarValue_reflection_ = NULL;
const ::google::protobuf::Descriptor* CCLCMsg_FileCRCCheck_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
CCLCMsg_FileCRCCheck_reflection_ = NULL;
const ::google::protobuf::Descriptor* CCLCMsg_LoadingProgress_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
CCLCMsg_LoadingProgress_reflection_ = NULL;
const ::google::protobuf::Descriptor* CCLCMsg_SplitPlayerConnect_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
CCLCMsg_SplitPlayerConnect_reflection_ = NULL;
const ::google::protobuf::Descriptor* CCLCMsg_ClientMessage_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
CCLCMsg_ClientMessage_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_ServerInfo_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
CSVCMsg_ServerInfo_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_ClassInfo_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
CSVCMsg_ClassInfo_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_ClassInfo_class_t_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
CSVCMsg_ClassInfo_class_t_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_SetPause_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
CSVCMsg_SetPause_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_VoiceInit_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
CSVCMsg_VoiceInit_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_Print_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
CSVCMsg_Print_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_Sounds_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
CSVCMsg_Sounds_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_Sounds_sounddata_t_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
CSVCMsg_Sounds_sounddata_t_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_Prefetch_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
CSVCMsg_Prefetch_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_SetView_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
CSVCMsg_SetView_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_FixAngle_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
CSVCMsg_FixAngle_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_CrosshairAngle_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
CSVCMsg_CrosshairAngle_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_BSPDecal_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
CSVCMsg_BSPDecal_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_SplitScreen_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
CSVCMsg_SplitScreen_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_GetCvarValue_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
CSVCMsg_GetCvarValue_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_Menu_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
CSVCMsg_Menu_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_SendTable_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
CSVCMsg_SendTable_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_SendTable_sendprop_t_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
CSVCMsg_SendTable_sendprop_t_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_GameEventList_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
CSVCMsg_GameEventList_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_GameEventList_key_t_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
CSVCMsg_GameEventList_key_t_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_GameEventList_descriptor_t_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
CSVCMsg_GameEventList_descriptor_t_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_PacketEntities_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
CSVCMsg_PacketEntities_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_TempEntities_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
CSVCMsg_TempEntities_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_CreateStringTable_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
CSVCMsg_CreateStringTable_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_UpdateStringTable_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
CSVCMsg_UpdateStringTable_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_VoiceData_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
CSVCMsg_VoiceData_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_PacketReliable_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
CSVCMsg_PacketReliable_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_FullFrameSplit_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
CSVCMsg_FullFrameSplit_reflection_ = NULL;
const ::google::protobuf::EnumDescriptor* CLC_Messages_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* VoiceDataFormat_t_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* SVC_Messages_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* ESplitScreenMessageType_descriptor_ = NULL;
} // namespace
void protobuf_AssignDesc_netmessages_2eproto() {
protobuf_AddDesc_netmessages_2eproto();
const ::google::protobuf::FileDescriptor* file =
::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
"netmessages.proto");
GOOGLE_CHECK(file != NULL);
CCLCMsg_ClientInfo_descriptor_ = file->message_type(0);
static const int CCLCMsg_ClientInfo_offsets_[7] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_ClientInfo, send_table_crc_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_ClientInfo, server_count_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_ClientInfo, is_hltv_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_ClientInfo, is_replay_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_ClientInfo, friends_id_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_ClientInfo, friends_name_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_ClientInfo, custom_files_),
};
CCLCMsg_ClientInfo_reflection_ =
new ::google::protobuf::internal::GeneratedMessageReflection(
CCLCMsg_ClientInfo_descriptor_,
CCLCMsg_ClientInfo::default_instance_,
CCLCMsg_ClientInfo_offsets_,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_ClientInfo, _has_bits_[0]),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_ClientInfo, _unknown_fields_),
-1,
::google::protobuf::DescriptorPool::generated_pool(),
::google::protobuf::MessageFactory::generated_factory(),
sizeof(CCLCMsg_ClientInfo));
CCLCMsg_Move_descriptor_ = file->message_type(1);
static const int CCLCMsg_Move_offsets_[3] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_Move, num_backup_commands_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_Move, num_new_commands_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_Move, data_),
};
CCLCMsg_Move_reflection_ =
new ::google::protobuf::internal::GeneratedMessageReflection(
CCLCMsg_Move_descriptor_,
CCLCMsg_Move::default_instance_,
CCLCMsg_Move_offsets_,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_Move, _has_bits_[0]),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_Move, _unknown_fields_),
-1,
::google::protobuf::DescriptorPool::generated_pool(),
::google::protobuf::MessageFactory::generated_factory(),
sizeof(CCLCMsg_Move));
CCLCMsg_VoiceData_descriptor_ = file->message_type(2);
static const int CCLCMsg_VoiceData_offsets_[7] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_VoiceData, data_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_VoiceData, xuid_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_VoiceData, format_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_VoiceData, sequence_bytes_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_VoiceData, section_number_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_VoiceData, uncompressed_sample_offset_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_VoiceData, tick_),
};
CCLCMsg_VoiceData_reflection_ =
new ::google::protobuf::internal::GeneratedMessageReflection(
CCLCMsg_VoiceData_descriptor_,
CCLCMsg_VoiceData::default_instance_,
CCLCMsg_VoiceData_offsets_,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_VoiceData, _has_bits_[0]),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_VoiceData, _unknown_fields_),
-1,
::google::protobuf::DescriptorPool::generated_pool(),
::google::protobuf::MessageFactory::generated_factory(),
sizeof(CCLCMsg_VoiceData));
CCLCMsg_BaselineAck_descriptor_ = file->message_type(3);
static const int CCLCMsg_BaselineAck_offsets_[2] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_BaselineAck, baseline_tick_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_BaselineAck, baseline_nr_),
};
CCLCMsg_BaselineAck_reflection_ =
new ::google::protobuf::internal::GeneratedMessageReflection(
CCLCMsg_BaselineAck_descriptor_,
CCLCMsg_BaselineAck::default_instance_,
CCLCMsg_BaselineAck_offsets_,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_BaselineAck, _has_bits_[0]),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_BaselineAck, _unknown_fields_),
-1,
::google::protobuf::DescriptorPool::generated_pool(),
::google::protobuf::MessageFactory::generated_factory(),
sizeof(CCLCMsg_BaselineAck));
CCLCMsg_ListenEvents_descriptor_ = file->message_type(4);
static const int CCLCMsg_ListenEvents_offsets_[1] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_ListenEvents, event_mask_),
};
CCLCMsg_ListenEvents_reflection_ =
new ::google::protobuf::internal::GeneratedMessageReflection(
CCLCMsg_ListenEvents_descriptor_,
CCLCMsg_ListenEvents::default_instance_,
CCLCMsg_ListenEvents_offsets_,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_ListenEvents, _has_bits_[0]),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_ListenEvents, _unknown_fields_),
-1,
::google::protobuf::DescriptorPool::generated_pool(),
::google::protobuf::MessageFactory::generated_factory(),
sizeof(CCLCMsg_ListenEvents));
CCLCMsg_RespondCvarValue_descriptor_ = file->message_type(5);
static const int CCLCMsg_RespondCvarValue_offsets_[4] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_RespondCvarValue, cookie_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_RespondCvarValue, status_code_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_RespondCvarValue, name_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_RespondCvarValue, value_),
};
CCLCMsg_RespondCvarValue_reflection_ =
new ::google::protobuf::internal::GeneratedMessageReflection(
CCLCMsg_RespondCvarValue_descriptor_,
CCLCMsg_RespondCvarValue::default_instance_,
CCLCMsg_RespondCvarValue_offsets_,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_RespondCvarValue, _has_bits_[0]),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_RespondCvarValue, _unknown_fields_),
-1,
::google::protobuf::DescriptorPool::generated_pool(),
::google::protobuf::MessageFactory::generated_factory(),
sizeof(CCLCMsg_RespondCvarValue));
CCLCMsg_FileCRCCheck_descriptor_ = file->message_type(6);
static const int CCLCMsg_FileCRCCheck_offsets_[5] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_FileCRCCheck, code_path_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_FileCRCCheck, path_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_FileCRCCheck, code_filename_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_FileCRCCheck, filename_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_FileCRCCheck, crc_),
};
CCLCMsg_FileCRCCheck_reflection_ =
new ::google::protobuf::internal::GeneratedMessageReflection(
CCLCMsg_FileCRCCheck_descriptor_,
CCLCMsg_FileCRCCheck::default_instance_,
CCLCMsg_FileCRCCheck_offsets_,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_FileCRCCheck, _has_bits_[0]),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_FileCRCCheck, _unknown_fields_),
-1,
::google::protobuf::DescriptorPool::generated_pool(),
::google::protobuf::MessageFactory::generated_factory(),
sizeof(CCLCMsg_FileCRCCheck));
CCLCMsg_LoadingProgress_descriptor_ = file->message_type(7);
static const int CCLCMsg_LoadingProgress_offsets_[1] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_LoadingProgress, progress_),
};
CCLCMsg_LoadingProgress_reflection_ =
new ::google::protobuf::internal::GeneratedMessageReflection(
CCLCMsg_LoadingProgress_descriptor_,
CCLCMsg_LoadingProgress::default_instance_,
CCLCMsg_LoadingProgress_offsets_,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_LoadingProgress, _has_bits_[0]),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_LoadingProgress, _unknown_fields_),
-1,
::google::protobuf::DescriptorPool::generated_pool(),
::google::protobuf::MessageFactory::generated_factory(),
sizeof(CCLCMsg_LoadingProgress));
CCLCMsg_SplitPlayerConnect_descriptor_ = file->message_type(8);
static const int CCLCMsg_SplitPlayerConnect_offsets_[1] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_SplitPlayerConnect, convars_),
};
CCLCMsg_SplitPlayerConnect_reflection_ =
new ::google::protobuf::internal::GeneratedMessageReflection(
CCLCMsg_SplitPlayerConnect_descriptor_,
CCLCMsg_SplitPlayerConnect::default_instance_,
CCLCMsg_SplitPlayerConnect_offsets_,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_SplitPlayerConnect, _has_bits_[0]),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_SplitPlayerConnect, _unknown_fields_),
-1,
::google::protobuf::DescriptorPool::generated_pool(),
::google::protobuf::MessageFactory::generated_factory(),
sizeof(CCLCMsg_SplitPlayerConnect));
CCLCMsg_ClientMessage_descriptor_ = file->message_type(9);
static const int CCLCMsg_ClientMessage_offsets_[2] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_ClientMessage, msg_type_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_ClientMessage, data_),
};
CCLCMsg_ClientMessage_reflection_ =
new ::google::protobuf::internal::GeneratedMessageReflection(
CCLCMsg_ClientMessage_descriptor_,
CCLCMsg_ClientMessage::default_instance_,
CCLCMsg_ClientMessage_offsets_,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_ClientMessage, _has_bits_[0]),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_ClientMessage, _unknown_fields_),
-1,
::google::protobuf::DescriptorPool::generated_pool(),
::google::protobuf::MessageFactory::generated_factory(),
sizeof(CCLCMsg_ClientMessage));
CSVCMsg_ServerInfo_descriptor_ = file->message_type(10);
static const int CSVCMsg_ServerInfo_offsets_[18] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, protocol_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, server_count_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, is_dedicated_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, is_hltv_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, is_replay_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, c_os_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, map_crc_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, client_crc_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, string_table_crc_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, max_clients_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, max_classes_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, player_slot_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, tick_interval_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, game_dir_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, map_name_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, sky_name_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, host_name_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, addon_name_),
};
CSVCMsg_ServerInfo_reflection_ =
new ::google::protobuf::internal::GeneratedMessageReflection(
CSVCMsg_ServerInfo_descriptor_,
CSVCMsg_ServerInfo::default_instance_,
CSVCMsg_ServerInfo_offsets_,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, _has_bits_[0]),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, _unknown_fields_),
-1,
::google::protobuf::DescriptorPool::generated_pool(),
::google::protobuf::MessageFactory::generated_factory(),
sizeof(CSVCMsg_ServerInfo));
CSVCMsg_ClassInfo_descriptor_ = file->message_type(11);
static const int CSVCMsg_ClassInfo_offsets_[2] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ClassInfo, create_on_client_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ClassInfo, classes_),
};
CSVCMsg_ClassInfo_reflection_ =
new ::google::protobuf::internal::GeneratedMessageReflection(
CSVCMsg_ClassInfo_descriptor_,
CSVCMsg_ClassInfo::default_instance_,
CSVCMsg_ClassInfo_offsets_,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ClassInfo, _has_bits_[0]),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ClassInfo, _unknown_fields_),
-1,
::google::protobuf::DescriptorPool::generated_pool(),
::google::protobuf::MessageFactory::generated_factory(),
sizeof(CSVCMsg_ClassInfo));
CSVCMsg_ClassInfo_class_t_descriptor_ = CSVCMsg_ClassInfo_descriptor_->nested_type(0);
static const int CSVCMsg_ClassInfo_class_t_offsets_[3] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ClassInfo_class_t, class_id_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ClassInfo_class_t, data_table_name_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ClassInfo_class_t, class_name_),
};
CSVCMsg_ClassInfo_class_t_reflection_ =
new ::google::protobuf::internal::GeneratedMessageReflection(
CSVCMsg_ClassInfo_class_t_descriptor_,
CSVCMsg_ClassInfo_class_t::default_instance_,
CSVCMsg_ClassInfo_class_t_offsets_,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ClassInfo_class_t, _has_bits_[0]),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ClassInfo_class_t, _unknown_fields_),
-1,
::google::protobuf::DescriptorPool::generated_pool(),
::google::protobuf::MessageFactory::generated_factory(),
sizeof(CSVCMsg_ClassInfo_class_t));
CSVCMsg_SetPause_descriptor_ = file->message_type(12);
static const int CSVCMsg_SetPause_offsets_[1] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SetPause, paused_),
};
CSVCMsg_SetPause_reflection_ =
new ::google::protobuf::internal::GeneratedMessageReflection(
CSVCMsg_SetPause_descriptor_,
CSVCMsg_SetPause::default_instance_,
CSVCMsg_SetPause_offsets_,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SetPause, _has_bits_[0]),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SetPause, _unknown_fields_),
-1,
::google::protobuf::DescriptorPool::generated_pool(),
::google::protobuf::MessageFactory::generated_factory(),
sizeof(CSVCMsg_SetPause));
CSVCMsg_VoiceInit_descriptor_ = file->message_type(13);
static const int CSVCMsg_VoiceInit_offsets_[3] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_VoiceInit, quality_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_VoiceInit, codec_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_VoiceInit, version_),
};
CSVCMsg_VoiceInit_reflection_ =
new ::google::protobuf::internal::GeneratedMessageReflection(
CSVCMsg_VoiceInit_descriptor_,
CSVCMsg_VoiceInit::default_instance_,
CSVCMsg_VoiceInit_offsets_,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_VoiceInit, _has_bits_[0]),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_VoiceInit, _unknown_fields_),
-1,
::google::protobuf::DescriptorPool::generated_pool(),
::google::protobuf::MessageFactory::generated_factory(),
sizeof(CSVCMsg_VoiceInit));
CSVCMsg_Print_descriptor_ = file->message_type(14);
static const int CSVCMsg_Print_offsets_[1] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Print, text_),
};
CSVCMsg_Print_reflection_ =
new ::google::protobuf::internal::GeneratedMessageReflection(
CSVCMsg_Print_descriptor_,
CSVCMsg_Print::default_instance_,
CSVCMsg_Print_offsets_,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Print, _has_bits_[0]),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Print, _unknown_fields_),
-1,
::google::protobuf::DescriptorPool::generated_pool(),
::google::protobuf::MessageFactory::generated_factory(),
sizeof(CSVCMsg_Print));
CSVCMsg_Sounds_descriptor_ = file->message_type(15);
static const int CSVCMsg_Sounds_offsets_[2] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds, reliable_sound_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds, sounds_),
};
CSVCMsg_Sounds_reflection_ =
new ::google::protobuf::internal::GeneratedMessageReflection(
CSVCMsg_Sounds_descriptor_,
CSVCMsg_Sounds::default_instance_,
CSVCMsg_Sounds_offsets_,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds, _has_bits_[0]),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds, _unknown_fields_),
-1,
::google::protobuf::DescriptorPool::generated_pool(),
::google::protobuf::MessageFactory::generated_factory(),
sizeof(CSVCMsg_Sounds));
CSVCMsg_Sounds_sounddata_t_descriptor_ = CSVCMsg_Sounds_descriptor_->nested_type(0);
static const int CSVCMsg_Sounds_sounddata_t_offsets_[17] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds_sounddata_t, origin_x_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds_sounddata_t, origin_y_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds_sounddata_t, origin_z_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds_sounddata_t, volume_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds_sounddata_t, delay_value_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds_sounddata_t, sequence_number_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds_sounddata_t, entity_index_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds_sounddata_t, channel_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds_sounddata_t, pitch_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds_sounddata_t, flags_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds_sounddata_t, sound_num_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds_sounddata_t, sound_num_handle_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds_sounddata_t, speaker_entity_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds_sounddata_t, random_seed_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds_sounddata_t, sound_level_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds_sounddata_t, is_sentence_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds_sounddata_t, is_ambient_),
};
CSVCMsg_Sounds_sounddata_t_reflection_ =
new ::google::protobuf::internal::GeneratedMessageReflection(
CSVCMsg_Sounds_sounddata_t_descriptor_,
CSVCMsg_Sounds_sounddata_t::default_instance_,
CSVCMsg_Sounds_sounddata_t_offsets_,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds_sounddata_t, _has_bits_[0]),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds_sounddata_t, _unknown_fields_),
-1,
::google::protobuf::DescriptorPool::generated_pool(),
::google::protobuf::MessageFactory::generated_factory(),
sizeof(CSVCMsg_Sounds_sounddata_t));
CSVCMsg_Prefetch_descriptor_ = file->message_type(16);
static const int CSVCMsg_Prefetch_offsets_[1] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Prefetch, sound_index_),
};
CSVCMsg_Prefetch_reflection_ =
new ::google::protobuf::internal::GeneratedMessageReflection(
CSVCMsg_Prefetch_descriptor_,
CSVCMsg_Prefetch::default_instance_,
CSVCMsg_Prefetch_offsets_,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Prefetch, _has_bits_[0]),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Prefetch, _unknown_fields_),
-1,
::google::protobuf::DescriptorPool::generated_pool(),
::google::protobuf::MessageFactory::generated_factory(),
sizeof(CSVCMsg_Prefetch));
CSVCMsg_SetView_descriptor_ = file->message_type(17);
static const int CSVCMsg_SetView_offsets_[1] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SetView, entity_index_),
};
CSVCMsg_SetView_reflection_ =
new ::google::protobuf::internal::GeneratedMessageReflection(
CSVCMsg_SetView_descriptor_,
CSVCMsg_SetView::default_instance_,
CSVCMsg_SetView_offsets_,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SetView, _has_bits_[0]),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SetView, _unknown_fields_),
-1,
::google::protobuf::DescriptorPool::generated_pool(),
::google::protobuf::MessageFactory::generated_factory(),
sizeof(CSVCMsg_SetView));
CSVCMsg_FixAngle_descriptor_ = file->message_type(18);
static const int CSVCMsg_FixAngle_offsets_[2] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_FixAngle, relative_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_FixAngle, angle_),
};
CSVCMsg_FixAngle_reflection_ =
new ::google::protobuf::internal::GeneratedMessageReflection(
CSVCMsg_FixAngle_descriptor_,
CSVCMsg_FixAngle::default_instance_,
CSVCMsg_FixAngle_offsets_,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_FixAngle, _has_bits_[0]),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_FixAngle, _unknown_fields_),
-1,
::google::protobuf::DescriptorPool::generated_pool(),
::google::protobuf::MessageFactory::generated_factory(),
sizeof(CSVCMsg_FixAngle));
CSVCMsg_CrosshairAngle_descriptor_ = file->message_type(19);
static const int CSVCMsg_CrosshairAngle_offsets_[1] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_CrosshairAngle, angle_),
};
CSVCMsg_CrosshairAngle_reflection_ =
new ::google::protobuf::internal::GeneratedMessageReflection(
CSVCMsg_CrosshairAngle_descriptor_,
CSVCMsg_CrosshairAngle::default_instance_,
CSVCMsg_CrosshairAngle_offsets_,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_CrosshairAngle, _has_bits_[0]),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_CrosshairAngle, _unknown_fields_),
-1,
::google::protobuf::DescriptorPool::generated_pool(),
::google::protobuf::MessageFactory::generated_factory(),
sizeof(CSVCMsg_CrosshairAngle));
CSVCMsg_BSPDecal_descriptor_ = file->message_type(20);
static const int CSVCMsg_BSPDecal_offsets_[5] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_BSPDecal, pos_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_BSPDecal, decal_texture_index_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_BSPDecal, entity_index_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_BSPDecal, model_index_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_BSPDecal, low_priority_),
};
CSVCMsg_BSPDecal_reflection_ =
new ::google::protobuf::internal::GeneratedMessageReflection(
CSVCMsg_BSPDecal_descriptor_,
CSVCMsg_BSPDecal::default_instance_,
CSVCMsg_BSPDecal_offsets_,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_BSPDecal, _has_bits_[0]),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_BSPDecal, _unknown_fields_),
-1,
::google::protobuf::DescriptorPool::generated_pool(),
::google::protobuf::MessageFactory::generated_factory(),
sizeof(CSVCMsg_BSPDecal));
CSVCMsg_SplitScreen_descriptor_ = file->message_type(21);
static const int CSVCMsg_SplitScreen_offsets_[3] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SplitScreen, type_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SplitScreen, slot_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SplitScreen, player_index_),
};
CSVCMsg_SplitScreen_reflection_ =
new ::google::protobuf::internal::GeneratedMessageReflection(
CSVCMsg_SplitScreen_descriptor_,
CSVCMsg_SplitScreen::default_instance_,
CSVCMsg_SplitScreen_offsets_,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SplitScreen, _has_bits_[0]),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SplitScreen, _unknown_fields_),
-1,
::google::protobuf::DescriptorPool::generated_pool(),
::google::protobuf::MessageFactory::generated_factory(),
sizeof(CSVCMsg_SplitScreen));
CSVCMsg_GetCvarValue_descriptor_ = file->message_type(22);
static const int CSVCMsg_GetCvarValue_offsets_[2] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GetCvarValue, cookie_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GetCvarValue, cvar_name_),
};
CSVCMsg_GetCvarValue_reflection_ =
new ::google::protobuf::internal::GeneratedMessageReflection(
CSVCMsg_GetCvarValue_descriptor_,
CSVCMsg_GetCvarValue::default_instance_,
CSVCMsg_GetCvarValue_offsets_,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GetCvarValue, _has_bits_[0]),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GetCvarValue, _unknown_fields_),
-1,
::google::protobuf::DescriptorPool::generated_pool(),
::google::protobuf::MessageFactory::generated_factory(),
sizeof(CSVCMsg_GetCvarValue));
CSVCMsg_Menu_descriptor_ = file->message_type(23);
static const int CSVCMsg_Menu_offsets_[2] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Menu, dialog_type_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Menu, menu_key_values_),
};
CSVCMsg_Menu_reflection_ =
new ::google::protobuf::internal::GeneratedMessageReflection(
CSVCMsg_Menu_descriptor_,
CSVCMsg_Menu::default_instance_,
CSVCMsg_Menu_offsets_,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Menu, _has_bits_[0]),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Menu, _unknown_fields_),
-1,
::google::protobuf::DescriptorPool::generated_pool(),
::google::protobuf::MessageFactory::generated_factory(),
sizeof(CSVCMsg_Menu));
CSVCMsg_SendTable_descriptor_ = file->message_type(24);
static const int CSVCMsg_SendTable_offsets_[4] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SendTable, is_end_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SendTable, net_table_name_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SendTable, needs_decoder_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SendTable, props_),
};
CSVCMsg_SendTable_reflection_ =
new ::google::protobuf::internal::GeneratedMessageReflection(
CSVCMsg_SendTable_descriptor_,
CSVCMsg_SendTable::default_instance_,
CSVCMsg_SendTable_offsets_,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SendTable, _has_bits_[0]),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SendTable, _unknown_fields_),
-1,
::google::protobuf::DescriptorPool::generated_pool(),
::google::protobuf::MessageFactory::generated_factory(),
sizeof(CSVCMsg_SendTable));
CSVCMsg_SendTable_sendprop_t_descriptor_ = CSVCMsg_SendTable_descriptor_->nested_type(0);
static const int CSVCMsg_SendTable_sendprop_t_offsets_[9] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SendTable_sendprop_t, type_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SendTable_sendprop_t, var_name_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SendTable_sendprop_t, flags_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SendTable_sendprop_t, priority_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SendTable_sendprop_t, dt_name_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SendTable_sendprop_t, num_elements_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SendTable_sendprop_t, low_value_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SendTable_sendprop_t, high_value_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SendTable_sendprop_t, num_bits_),
};
CSVCMsg_SendTable_sendprop_t_reflection_ =
new ::google::protobuf::internal::GeneratedMessageReflection(
CSVCMsg_SendTable_sendprop_t_descriptor_,
CSVCMsg_SendTable_sendprop_t::default_instance_,
CSVCMsg_SendTable_sendprop_t_offsets_,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SendTable_sendprop_t, _has_bits_[0]),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SendTable_sendprop_t, _unknown_fields_),
-1,
::google::protobuf::DescriptorPool::generated_pool(),
::google::protobuf::MessageFactory::generated_factory(),
sizeof(CSVCMsg_SendTable_sendprop_t));
CSVCMsg_GameEventList_descriptor_ = file->message_type(25);
static const int CSVCMsg_GameEventList_offsets_[1] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GameEventList, descriptors_),
};
CSVCMsg_GameEventList_reflection_ =
new ::google::protobuf::internal::GeneratedMessageReflection(
CSVCMsg_GameEventList_descriptor_,
CSVCMsg_GameEventList::default_instance_,
CSVCMsg_GameEventList_offsets_,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GameEventList, _has_bits_[0]),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GameEventList, _unknown_fields_),
-1,
::google::protobuf::DescriptorPool::generated_pool(),
::google::protobuf::MessageFactory::generated_factory(),
sizeof(CSVCMsg_GameEventList));
CSVCMsg_GameEventList_key_t_descriptor_ = CSVCMsg_GameEventList_descriptor_->nested_type(0);
static const int CSVCMsg_GameEventList_key_t_offsets_[2] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GameEventList_key_t, type_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GameEventList_key_t, name_),
};
CSVCMsg_GameEventList_key_t_reflection_ =
new ::google::protobuf::internal::GeneratedMessageReflection(
CSVCMsg_GameEventList_key_t_descriptor_,
CSVCMsg_GameEventList_key_t::default_instance_,
CSVCMsg_GameEventList_key_t_offsets_,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GameEventList_key_t, _has_bits_[0]),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GameEventList_key_t, _unknown_fields_),
-1,
::google::protobuf::DescriptorPool::generated_pool(),
::google::protobuf::MessageFactory::generated_factory(),
sizeof(CSVCMsg_GameEventList_key_t));
CSVCMsg_GameEventList_descriptor_t_descriptor_ = CSVCMsg_GameEventList_descriptor_->nested_type(1);
static const int CSVCMsg_GameEventList_descriptor_t_offsets_[3] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GameEventList_descriptor_t, eventid_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GameEventList_descriptor_t, name_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GameEventList_descriptor_t, keys_),
};
CSVCMsg_GameEventList_descriptor_t_reflection_ =
new ::google::protobuf::internal::GeneratedMessageReflection(
CSVCMsg_GameEventList_descriptor_t_descriptor_,
CSVCMsg_GameEventList_descriptor_t::default_instance_,
CSVCMsg_GameEventList_descriptor_t_offsets_,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GameEventList_descriptor_t, _has_bits_[0]),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GameEventList_descriptor_t, _unknown_fields_),
-1,
::google::protobuf::DescriptorPool::generated_pool(),
::google::protobuf::MessageFactory::generated_factory(),
sizeof(CSVCMsg_GameEventList_descriptor_t));
CSVCMsg_PacketEntities_descriptor_ = file->message_type(26);
static const int CSVCMsg_PacketEntities_offsets_[8] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_PacketEntities, max_entries_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_PacketEntities, updated_entries_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_PacketEntities, is_delta_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_PacketEntities, update_baseline_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_PacketEntities, baseline_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_PacketEntities, delta_from_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_PacketEntities, entity_data_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_PacketEntities, pending_full_frame_),
};
CSVCMsg_PacketEntities_reflection_ =
new ::google::protobuf::internal::GeneratedMessageReflection(
CSVCMsg_PacketEntities_descriptor_,
CSVCMsg_PacketEntities::default_instance_,
CSVCMsg_PacketEntities_offsets_,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_PacketEntities, _has_bits_[0]),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_PacketEntities, _unknown_fields_),
-1,
::google::protobuf::DescriptorPool::generated_pool(),
::google::protobuf::MessageFactory::generated_factory(),
sizeof(CSVCMsg_PacketEntities));
CSVCMsg_TempEntities_descriptor_ = file->message_type(27);
static const int CSVCMsg_TempEntities_offsets_[3] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_TempEntities, reliable_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_TempEntities, num_entries_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_TempEntities, entity_data_),
};
CSVCMsg_TempEntities_reflection_ =
new ::google::protobuf::internal::GeneratedMessageReflection(
CSVCMsg_TempEntities_descriptor_,
CSVCMsg_TempEntities::default_instance_,
CSVCMsg_TempEntities_offsets_,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_TempEntities, _has_bits_[0]),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_TempEntities, _unknown_fields_),
-1,
::google::protobuf::DescriptorPool::generated_pool(),
::google::protobuf::MessageFactory::generated_factory(),
sizeof(CSVCMsg_TempEntities));
CSVCMsg_CreateStringTable_descriptor_ = file->message_type(28);
static const int CSVCMsg_CreateStringTable_offsets_[8] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_CreateStringTable, name_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_CreateStringTable, max_entries_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_CreateStringTable, num_entries_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_CreateStringTable, user_data_fixed_size_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_CreateStringTable, user_data_size_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_CreateStringTable, user_data_size_bits_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_CreateStringTable, flags_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_CreateStringTable, string_data_),
};
CSVCMsg_CreateStringTable_reflection_ =
new ::google::protobuf::internal::GeneratedMessageReflection(
CSVCMsg_CreateStringTable_descriptor_,
CSVCMsg_CreateStringTable::default_instance_,
CSVCMsg_CreateStringTable_offsets_,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_CreateStringTable, _has_bits_[0]),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_CreateStringTable, _unknown_fields_),
-1,
::google::protobuf::DescriptorPool::generated_pool(),
::google::protobuf::MessageFactory::generated_factory(),
sizeof(CSVCMsg_CreateStringTable));
CSVCMsg_UpdateStringTable_descriptor_ = file->message_type(29);
static const int CSVCMsg_UpdateStringTable_offsets_[3] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_UpdateStringTable, table_id_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_UpdateStringTable, num_changed_entries_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_UpdateStringTable, string_data_),
};
CSVCMsg_UpdateStringTable_reflection_ =
new ::google::protobuf::internal::GeneratedMessageReflection(
CSVCMsg_UpdateStringTable_descriptor_,
CSVCMsg_UpdateStringTable::default_instance_,
CSVCMsg_UpdateStringTable_offsets_,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_UpdateStringTable, _has_bits_[0]),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_UpdateStringTable, _unknown_fields_),
-1,
::google::protobuf::DescriptorPool::generated_pool(),
::google::protobuf::MessageFactory::generated_factory(),
sizeof(CSVCMsg_UpdateStringTable));
CSVCMsg_VoiceData_descriptor_ = file->message_type(30);
static const int CSVCMsg_VoiceData_offsets_[10] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_VoiceData, client_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_VoiceData, proximity_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_VoiceData, xuid_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_VoiceData, audible_mask_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_VoiceData, voice_data_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_VoiceData, format_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_VoiceData, sequence_bytes_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_VoiceData, section_number_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_VoiceData, uncompressed_sample_offset_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_VoiceData, tick_),
};
CSVCMsg_VoiceData_reflection_ =
new ::google::protobuf::internal::GeneratedMessageReflection(
CSVCMsg_VoiceData_descriptor_,
CSVCMsg_VoiceData::default_instance_,
CSVCMsg_VoiceData_offsets_,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_VoiceData, _has_bits_[0]),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_VoiceData, _unknown_fields_),
-1,
::google::protobuf::DescriptorPool::generated_pool(),
::google::protobuf::MessageFactory::generated_factory(),
sizeof(CSVCMsg_VoiceData));
CSVCMsg_PacketReliable_descriptor_ = file->message_type(31);
static const int CSVCMsg_PacketReliable_offsets_[2] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_PacketReliable, tick_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_PacketReliable, messagessize_),
};
CSVCMsg_PacketReliable_reflection_ =
new ::google::protobuf::internal::GeneratedMessageReflection(
CSVCMsg_PacketReliable_descriptor_,
CSVCMsg_PacketReliable::default_instance_,
CSVCMsg_PacketReliable_offsets_,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_PacketReliable, _has_bits_[0]),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_PacketReliable, _unknown_fields_),
-1,
::google::protobuf::DescriptorPool::generated_pool(),
::google::protobuf::MessageFactory::generated_factory(),
sizeof(CSVCMsg_PacketReliable));
CSVCMsg_FullFrameSplit_descriptor_ = file->message_type(32);
static const int CSVCMsg_FullFrameSplit_offsets_[4] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_FullFrameSplit, tick_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_FullFrameSplit, section_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_FullFrameSplit, total_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_FullFrameSplit, data_),
};
CSVCMsg_FullFrameSplit_reflection_ =
new ::google::protobuf::internal::GeneratedMessageReflection(
CSVCMsg_FullFrameSplit_descriptor_,
CSVCMsg_FullFrameSplit::default_instance_,
CSVCMsg_FullFrameSplit_offsets_,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_FullFrameSplit, _has_bits_[0]),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_FullFrameSplit, _unknown_fields_),
-1,
::google::protobuf::DescriptorPool::generated_pool(),
::google::protobuf::MessageFactory::generated_factory(),
sizeof(CSVCMsg_FullFrameSplit));
CLC_Messages_descriptor_ = file->enum_type(0);
VoiceDataFormat_t_descriptor_ = file->enum_type(1);
SVC_Messages_descriptor_ = file->enum_type(2);
ESplitScreenMessageType_descriptor_ = file->enum_type(3);
}
namespace {
GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
inline void protobuf_AssignDescriptorsOnce() {
::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
&protobuf_AssignDesc_netmessages_2eproto);
}
void protobuf_RegisterTypes(const ::std::string&) {
protobuf_AssignDescriptorsOnce();
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
CCLCMsg_ClientInfo_descriptor_, &CCLCMsg_ClientInfo::default_instance());
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
CCLCMsg_Move_descriptor_, &CCLCMsg_Move::default_instance());
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
CCLCMsg_VoiceData_descriptor_, &CCLCMsg_VoiceData::default_instance());
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
CCLCMsg_BaselineAck_descriptor_, &CCLCMsg_BaselineAck::default_instance());
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
CCLCMsg_ListenEvents_descriptor_, &CCLCMsg_ListenEvents::default_instance());
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
CCLCMsg_RespondCvarValue_descriptor_, &CCLCMsg_RespondCvarValue::default_instance());
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
CCLCMsg_FileCRCCheck_descriptor_, &CCLCMsg_FileCRCCheck::default_instance());
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
CCLCMsg_LoadingProgress_descriptor_, &CCLCMsg_LoadingProgress::default_instance());
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
CCLCMsg_SplitPlayerConnect_descriptor_, &CCLCMsg_SplitPlayerConnect::default_instance());
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
CCLCMsg_ClientMessage_descriptor_, &CCLCMsg_ClientMessage::default_instance());
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
CSVCMsg_ServerInfo_descriptor_, &CSVCMsg_ServerInfo::default_instance());
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
CSVCMsg_ClassInfo_descriptor_, &CSVCMsg_ClassInfo::default_instance());
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
CSVCMsg_ClassInfo_class_t_descriptor_, &CSVCMsg_ClassInfo_class_t::default_instance());
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
CSVCMsg_SetPause_descriptor_, &CSVCMsg_SetPause::default_instance());
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
CSVCMsg_VoiceInit_descriptor_, &CSVCMsg_VoiceInit::default_instance());
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
CSVCMsg_Print_descriptor_, &CSVCMsg_Print::default_instance());
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
CSVCMsg_Sounds_descriptor_, &CSVCMsg_Sounds::default_instance());
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
CSVCMsg_Sounds_sounddata_t_descriptor_, &CSVCMsg_Sounds_sounddata_t::default_instance());
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
CSVCMsg_Prefetch_descriptor_, &CSVCMsg_Prefetch::default_instance());
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
CSVCMsg_SetView_descriptor_, &CSVCMsg_SetView::default_instance());
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
CSVCMsg_FixAngle_descriptor_, &CSVCMsg_FixAngle::default_instance());
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
CSVCMsg_CrosshairAngle_descriptor_, &CSVCMsg_CrosshairAngle::default_instance());
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
CSVCMsg_BSPDecal_descriptor_, &CSVCMsg_BSPDecal::default_instance());
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
CSVCMsg_SplitScreen_descriptor_, &CSVCMsg_SplitScreen::default_instance());
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
CSVCMsg_GetCvarValue_descriptor_, &CSVCMsg_GetCvarValue::default_instance());
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
CSVCMsg_Menu_descriptor_, &CSVCMsg_Menu::default_instance());
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
CSVCMsg_SendTable_descriptor_, &CSVCMsg_SendTable::default_instance());
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
CSVCMsg_SendTable_sendprop_t_descriptor_, &CSVCMsg_SendTable_sendprop_t::default_instance());
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
CSVCMsg_GameEventList_descriptor_, &CSVCMsg_GameEventList::default_instance());
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
CSVCMsg_GameEventList_key_t_descriptor_, &CSVCMsg_GameEventList_key_t::default_instance());
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
CSVCMsg_GameEventList_descriptor_t_descriptor_, &CSVCMsg_GameEventList_descriptor_t::default_instance());
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
CSVCMsg_PacketEntities_descriptor_, &CSVCMsg_PacketEntities::default_instance());
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
CSVCMsg_TempEntities_descriptor_, &CSVCMsg_TempEntities::default_instance());
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
CSVCMsg_CreateStringTable_descriptor_, &CSVCMsg_CreateStringTable::default_instance());
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
CSVCMsg_UpdateStringTable_descriptor_, &CSVCMsg_UpdateStringTable::default_instance());
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
CSVCMsg_VoiceData_descriptor_, &CSVCMsg_VoiceData::default_instance());
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
CSVCMsg_PacketReliable_descriptor_, &CSVCMsg_PacketReliable::default_instance());
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
CSVCMsg_FullFrameSplit_descriptor_, &CSVCMsg_FullFrameSplit::default_instance());
}
} // namespace
void protobuf_ShutdownFile_netmessages_2eproto() {
delete CCLCMsg_ClientInfo::default_instance_;
delete CCLCMsg_ClientInfo_reflection_;
delete CCLCMsg_Move::default_instance_;
delete CCLCMsg_Move_reflection_;
delete CCLCMsg_VoiceData::default_instance_;
delete CCLCMsg_VoiceData_reflection_;
delete CCLCMsg_BaselineAck::default_instance_;
delete CCLCMsg_BaselineAck_reflection_;
delete CCLCMsg_ListenEvents::default_instance_;
delete CCLCMsg_ListenEvents_reflection_;
delete CCLCMsg_RespondCvarValue::default_instance_;
delete CCLCMsg_RespondCvarValue_reflection_;
delete CCLCMsg_FileCRCCheck::default_instance_;
delete CCLCMsg_FileCRCCheck_reflection_;
delete CCLCMsg_LoadingProgress::default_instance_;
delete CCLCMsg_LoadingProgress_reflection_;
delete CCLCMsg_SplitPlayerConnect::default_instance_;
delete CCLCMsg_SplitPlayerConnect_reflection_;
delete CCLCMsg_ClientMessage::default_instance_;
delete CCLCMsg_ClientMessage_reflection_;
delete CSVCMsg_ServerInfo::default_instance_;
delete CSVCMsg_ServerInfo_reflection_;
delete CSVCMsg_ClassInfo::default_instance_;
delete CSVCMsg_ClassInfo_reflection_;
delete CSVCMsg_ClassInfo_class_t::default_instance_;
delete CSVCMsg_ClassInfo_class_t_reflection_;
delete CSVCMsg_SetPause::default_instance_;
delete CSVCMsg_SetPause_reflection_;
delete CSVCMsg_VoiceInit::default_instance_;
delete CSVCMsg_VoiceInit_reflection_;
delete CSVCMsg_Print::default_instance_;
delete CSVCMsg_Print_reflection_;
delete CSVCMsg_Sounds::default_instance_;
delete CSVCMsg_Sounds_reflection_;
delete CSVCMsg_Sounds_sounddata_t::default_instance_;
delete CSVCMsg_Sounds_sounddata_t_reflection_;
delete CSVCMsg_Prefetch::default_instance_;
delete CSVCMsg_Prefetch_reflection_;
delete CSVCMsg_SetView::default_instance_;
delete CSVCMsg_SetView_reflection_;
delete CSVCMsg_FixAngle::default_instance_;
delete CSVCMsg_FixAngle_reflection_;
delete CSVCMsg_CrosshairAngle::default_instance_;
delete CSVCMsg_CrosshairAngle_reflection_;
delete CSVCMsg_BSPDecal::default_instance_;
delete CSVCMsg_BSPDecal_reflection_;
delete CSVCMsg_SplitScreen::default_instance_;
delete CSVCMsg_SplitScreen_reflection_;
delete CSVCMsg_GetCvarValue::default_instance_;
delete CSVCMsg_GetCvarValue_reflection_;
delete CSVCMsg_Menu::default_instance_;
delete CSVCMsg_Menu_reflection_;
delete CSVCMsg_SendTable::default_instance_;
delete CSVCMsg_SendTable_reflection_;
delete CSVCMsg_SendTable_sendprop_t::default_instance_;
delete CSVCMsg_SendTable_sendprop_t_reflection_;
delete CSVCMsg_GameEventList::default_instance_;
delete CSVCMsg_GameEventList_reflection_;
delete CSVCMsg_GameEventList_key_t::default_instance_;
delete CSVCMsg_GameEventList_key_t_reflection_;
delete CSVCMsg_GameEventList_descriptor_t::default_instance_;
delete CSVCMsg_GameEventList_descriptor_t_reflection_;
delete CSVCMsg_PacketEntities::default_instance_;
delete CSVCMsg_PacketEntities_reflection_;
delete CSVCMsg_TempEntities::default_instance_;
delete CSVCMsg_TempEntities_reflection_;
delete CSVCMsg_CreateStringTable::default_instance_;
delete CSVCMsg_CreateStringTable_reflection_;
delete CSVCMsg_UpdateStringTable::default_instance_;
delete CSVCMsg_UpdateStringTable_reflection_;
delete CSVCMsg_VoiceData::default_instance_;
delete CSVCMsg_VoiceData_reflection_;
delete CSVCMsg_PacketReliable::default_instance_;
delete CSVCMsg_PacketReliable_reflection_;
delete CSVCMsg_FullFrameSplit::default_instance_;
delete CSVCMsg_FullFrameSplit_reflection_;
}
void protobuf_AddDesc_netmessages_2eproto() {
static bool already_here = false;
if (already_here) return;
already_here = true;
GOOGLE_PROTOBUF_VERIFY_VERSION;
::protobuf_AddDesc_networkbasetypes_2eproto();
::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
"\n\021netmessages.proto\032\026networkbasetypes.pr"
"oto\"\246\001\n\022CCLCMsg_ClientInfo\022\026\n\016send_table"
"_crc\030\001 \001(\007\022\024\n\014server_count\030\002 \001(\r\022\017\n\007is_h"
"ltv\030\003 \001(\010\022\021\n\tis_replay\030\004 \001(\010\022\022\n\nfriends_"
"id\030\005 \001(\r\022\024\n\014friends_name\030\006 \001(\t\022\024\n\014custom"
"_files\030\007 \003(\007\"S\n\014CCLCMsg_Move\022\033\n\023num_back"
"up_commands\030\001 \001(\r\022\030\n\020num_new_commands\030\002 "
"\001(\r\022\014\n\004data\030\003 \001(\014\"\315\001\n\021CCLCMsg_VoiceData\022"
"\014\n\004data\030\001 \001(\014\022\014\n\004xuid\030\002 \001(\006\022:\n\006format\030\003 "
"\001(\0162\022.VoiceDataFormat_t:\026VOICEDATA_FORMA"
"T_STEAM\022\026\n\016sequence_bytes\030\004 \001(\005\022\026\n\016secti"
"on_number\030\005 \001(\r\022\"\n\032uncompressed_sample_o"
"ffset\030\006 \001(\r\022\014\n\004tick\030\007 \001(\r\"A\n\023CCLCMsg_Bas"
"elineAck\022\025\n\rbaseline_tick\030\001 \001(\005\022\023\n\013basel"
"ine_nr\030\002 \001(\005\"*\n\024CCLCMsg_ListenEvents\022\022\n\n"
"event_mask\030\001 \003(\007\"\\\n\030CCLCMsg_RespondCvarV"
"alue\022\016\n\006cookie\030\001 \001(\005\022\023\n\013status_code\030\002 \001("
"\005\022\014\n\004name\030\003 \001(\t\022\r\n\005value\030\004 \001(\t\"m\n\024CCLCMs"
"g_FileCRCCheck\022\021\n\tcode_path\030\001 \001(\005\022\014\n\004pat"
"h\030\002 \001(\t\022\025\n\rcode_filename\030\003 \001(\005\022\020\n\010filena"
"me\030\004 \001(\t\022\013\n\003crc\030\005 \001(\007\"+\n\027CCLCMsg_Loading"
"Progress\022\020\n\010progress\030\001 \001(\005\":\n\032CCLCMsg_Sp"
"litPlayerConnect\022\034\n\007convars\030\001 \001(\0132\013.CMsg"
"_CVars\"7\n\025CCLCMsg_ClientMessage\022\020\n\010msg_t"
"ype\030\001 \001(\005\022\014\n\004data\030\002 \001(\014\"\366\002\n\022CSVCMsg_Serv"
"erInfo\022\020\n\010protocol\030\001 \001(\005\022\024\n\014server_count"
"\030\002 \001(\005\022\024\n\014is_dedicated\030\003 \001(\010\022\017\n\007is_hltv\030"
"\004 \001(\010\022\021\n\tis_replay\030\005 \001(\010\022\014\n\004c_os\030\006 \001(\005\022\017"
"\n\007map_crc\030\007 \001(\007\022\022\n\nclient_crc\030\010 \001(\007\022\030\n\020s"
"tring_table_crc\030\t \001(\007\022\023\n\013max_clients\030\n \001"
"(\005\022\023\n\013max_classes\030\013 \001(\005\022\023\n\013player_slot\030\014"
" \001(\005\022\025\n\rtick_interval\030\r \001(\002\022\020\n\010game_dir\030"
"\016 \001(\t\022\020\n\010map_name\030\017 \001(\t\022\020\n\010sky_name\030\020 \001("
"\t\022\021\n\thost_name\030\021 \001(\t\022\022\n\naddon_name\030\022 \001(\t"
"\"\244\001\n\021CSVCMsg_ClassInfo\022\030\n\020create_on_clie"
"nt\030\001 \001(\010\022+\n\007classes\030\002 \003(\0132\032.CSVCMsg_Clas"
"sInfo.class_t\032H\n\007class_t\022\020\n\010class_id\030\001 \001"
"(\005\022\027\n\017data_table_name\030\002 \001(\t\022\022\n\nclass_nam"
"e\030\003 \001(\t\"\"\n\020CSVCMsg_SetPause\022\016\n\006paused\030\001 "
"\001(\010\"G\n\021CSVCMsg_VoiceInit\022\017\n\007quality\030\001 \001("
"\005\022\r\n\005codec\030\002 \001(\t\022\022\n\007version\030\003 \001(\005:\0010\"\035\n\r"
"CSVCMsg_Print\022\014\n\004text\030\001 \001(\t\"\266\003\n\016CSVCMsg_"
"Sounds\022\026\n\016reliable_sound\030\001 \001(\010\022+\n\006sounds"
"\030\002 \003(\0132\033.CSVCMsg_Sounds.sounddata_t\032\336\002\n\013"
"sounddata_t\022\020\n\010origin_x\030\001 \001(\021\022\020\n\010origin_"
"y\030\002 \001(\021\022\020\n\010origin_z\030\003 \001(\021\022\016\n\006volume\030\004 \001("
"\r\022\023\n\013delay_value\030\005 \001(\002\022\027\n\017sequence_numbe"
"r\030\006 \001(\005\022\024\n\014entity_index\030\007 \001(\005\022\017\n\007channel"
"\030\010 \001(\005\022\r\n\005pitch\030\t \001(\005\022\r\n\005flags\030\n \001(\005\022\021\n\t"
"sound_num\030\013 \001(\r\022\030\n\020sound_num_handle\030\014 \001("
"\007\022\026\n\016speaker_entity\030\r \001(\005\022\023\n\013random_seed"
"\030\016 \001(\005\022\023\n\013sound_level\030\017 \001(\005\022\023\n\013is_senten"
"ce\030\020 \001(\010\022\022\n\nis_ambient\030\021 \001(\010\"\'\n\020CSVCMsg_"
"Prefetch\022\023\n\013sound_index\030\001 \001(\005\"\'\n\017CSVCMsg"
"_SetView\022\024\n\014entity_index\030\001 \001(\005\"@\n\020CSVCMs"
"g_FixAngle\022\020\n\010relative\030\001 \001(\010\022\032\n\005angle\030\002 "
"\001(\0132\013.CMsgQAngle\"4\n\026CSVCMsg_CrosshairAng"
"le\022\032\n\005angle\030\001 \001(\0132\013.CMsgQAngle\"\212\001\n\020CSVCM"
"sg_BSPDecal\022\030\n\003pos\030\001 \001(\0132\013.CMsgVector\022\033\n"
"\023decal_texture_index\030\002 \001(\005\022\024\n\014entity_ind"
"ex\030\003 \001(\005\022\023\n\013model_index\030\004 \001(\005\022\024\n\014low_pri"
"ority\030\005 \001(\010\"z\n\023CSVCMsg_SplitScreen\022\?\n\004ty"
"pe\030\001 \001(\0162\030.ESplitScreenMessageType:\027MSG_"
"SPLITSCREEN_ADDUSER\022\014\n\004slot\030\002 \001(\005\022\024\n\014pla"
"yer_index\030\003 \001(\005\"9\n\024CSVCMsg_GetCvarValue\022"
"\016\n\006cookie\030\001 \001(\005\022\021\n\tcvar_name\030\002 \001(\t\"<\n\014CS"
"VCMsg_Menu\022\023\n\013dialog_type\030\001 \001(\005\022\027\n\017menu_"
"key_values\030\002 \001(\014\"\260\002\n\021CSVCMsg_SendTable\022\016"
"\n\006is_end\030\001 \001(\010\022\026\n\016net_table_name\030\002 \001(\t\022\025"
"\n\rneeds_decoder\030\003 \001(\010\022,\n\005props\030\004 \003(\0132\035.C"
"SVCMsg_SendTable.sendprop_t\032\255\001\n\nsendprop"
"_t\022\014\n\004type\030\001 \001(\005\022\020\n\010var_name\030\002 \001(\t\022\r\n\005fl"
"ags\030\003 \001(\005\022\020\n\010priority\030\004 \001(\005\022\017\n\007dt_name\030\005"
" \001(\t\022\024\n\014num_elements\030\006 \001(\005\022\021\n\tlow_value\030"
"\007 \001(\002\022\022\n\nhigh_value\030\010 \001(\002\022\020\n\010num_bits\030\t "
"\001(\005\"\321\001\n\025CSVCMsg_GameEventList\0228\n\013descrip"
"tors\030\001 \003(\0132#.CSVCMsg_GameEventList.descr"
"iptor_t\032#\n\005key_t\022\014\n\004type\030\001 \001(\005\022\014\n\004name\030\002"
" \001(\t\032Y\n\014descriptor_t\022\017\n\007eventid\030\001 \001(\005\022\014\n"
"\004name\030\002 \001(\t\022*\n\004keys\030\003 \003(\0132\034.CSVCMsg_Game"
"EventList.key_t\"\310\001\n\026CSVCMsg_PacketEntiti"
"es\022\023\n\013max_entries\030\001 \001(\005\022\027\n\017updated_entri"
"es\030\002 \001(\005\022\020\n\010is_delta\030\003 \001(\010\022\027\n\017update_bas"
"eline\030\004 \001(\010\022\020\n\010baseline\030\005 \001(\005\022\022\n\ndelta_f"
"rom\030\006 \001(\005\022\023\n\013entity_data\030\007 \001(\014\022\032\n\022pendin"
"g_full_frame\030\010 \001(\010\"R\n\024CSVCMsg_TempEntiti"
"es\022\020\n\010reliable\030\001 \001(\010\022\023\n\013num_entries\030\002 \001("
"\005\022\023\n\013entity_data\030\003 \001(\014\"\312\001\n\031CSVCMsg_Creat"
"eStringTable\022\014\n\004name\030\001 \001(\t\022\023\n\013max_entrie"
"s\030\002 \001(\005\022\023\n\013num_entries\030\003 \001(\005\022\034\n\024user_dat"
"a_fixed_size\030\004 \001(\010\022\026\n\016user_data_size\030\005 \001"
"(\005\022\033\n\023user_data_size_bits\030\006 \001(\005\022\r\n\005flags"
"\030\007 \001(\005\022\023\n\013string_data\030\010 \001(\014\"_\n\031CSVCMsg_U"
"pdateStringTable\022\020\n\010table_id\030\001 \001(\005\022\033\n\023nu"
"m_changed_entries\030\002 \001(\005\022\023\n\013string_data\030\003"
" \001(\014\"\214\002\n\021CSVCMsg_VoiceData\022\016\n\006client\030\001 \001"
"(\005\022\021\n\tproximity\030\002 \001(\010\022\014\n\004xuid\030\003 \001(\006\022\024\n\014a"
"udible_mask\030\004 \001(\005\022\022\n\nvoice_data\030\005 \001(\014\022:\n"
"\006format\030\006 \001(\0162\022.VoiceDataFormat_t:\026VOICE"
"DATA_FORMAT_STEAM\022\026\n\016sequence_bytes\030\007 \001("
"\005\022\026\n\016section_number\030\010 \001(\r\022\"\n\032uncompresse"
"d_sample_offset\030\t \001(\r\022\014\n\004tick\030\n \001(\r\"<\n\026C"
"SVCMsg_PacketReliable\022\014\n\004tick\030\001 \001(\005\022\024\n\014m"
"essagessize\030\002 \001(\005\"T\n\026CSVCMsg_FullFrameSp"
"lit\022\014\n\004tick\030\001 \001(\005\022\017\n\007section\030\002 \001(\005\022\r\n\005to"
"tal\030\003 \001(\005\022\014\n\004data\030\004 \001(\014*\352\001\n\014CLC_Messages"
"\022\022\n\016clc_ClientInfo\020\010\022\014\n\010clc_Move\020\t\022\021\n\rcl"
"c_VoiceData\020\n\022\023\n\017clc_BaselineAck\020\013\022\024\n\020cl"
"c_ListenEvents\020\014\022\030\n\024clc_RespondCvarValue"
"\020\r\022\024\n\020clc_FileCRCCheck\020\016\022\027\n\023clc_LoadingP"
"rogress\020\017\022\032\n\026clc_SplitPlayerConnect\020\020\022\025\n"
"\021clc_ClientMessage\020\021*L\n\021VoiceDataFormat_"
"t\022\032\n\026VOICEDATA_FORMAT_STEAM\020\000\022\033\n\027VOICEDA"
"TA_FORMAT_ENGINE\020\001*\241\004\n\014SVC_Messages\022\022\n\016s"
"vc_ServerInfo\020\010\022\021\n\rsvc_SendTable\020\t\022\021\n\rsv"
"c_ClassInfo\020\n\022\020\n\014svc_SetPause\020\013\022\031\n\025svc_C"
"reateStringTable\020\014\022\031\n\025svc_UpdateStringTa"
"ble\020\r\022\021\n\rsvc_VoiceInit\020\016\022\021\n\rsvc_VoiceDat"
"a\020\017\022\r\n\tsvc_Print\020\020\022\016\n\nsvc_Sounds\020\021\022\017\n\013sv"
"c_SetView\020\022\022\020\n\014svc_FixAngle\020\023\022\026\n\022svc_Cro"
"sshairAngle\020\024\022\020\n\014svc_BSPDecal\020\025\022\023\n\017svc_S"
"plitScreen\020\026\022\023\n\017svc_UserMessage\020\027\022\025\n\021svc"
"_EntityMessage\020\030\022\021\n\rsvc_GameEvent\020\031\022\026\n\022s"
"vc_PacketEntities\020\032\022\024\n\020svc_TempEntities\020"
"\033\022\020\n\014svc_Prefetch\020\034\022\014\n\010svc_Menu\020\035\022\025\n\021svc"
"_GameEventList\020\036\022\024\n\020svc_GetCvarValue\020\037\022\026"
"\n\022svc_PacketReliable\020 \022\026\n\022svc_FullFrameS"
"plit\020!*V\n\027ESplitScreenMessageType\022\033\n\027MSG"
"_SPLITSCREEN_ADDUSER\020\000\022\036\n\032MSG_SPLITSCREE"
"N_REMOVEUSER\020\001B\003\200\001\000", 5179);
::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
"netmessages.proto", &protobuf_RegisterTypes);
CCLCMsg_ClientInfo::default_instance_ = new CCLCMsg_ClientInfo();
CCLCMsg_Move::default_instance_ = new CCLCMsg_Move();
CCLCMsg_VoiceData::default_instance_ = new CCLCMsg_VoiceData();
CCLCMsg_BaselineAck::default_instance_ = new CCLCMsg_BaselineAck();
CCLCMsg_ListenEvents::default_instance_ = new CCLCMsg_ListenEvents();
CCLCMsg_RespondCvarValue::default_instance_ = new CCLCMsg_RespondCvarValue();
CCLCMsg_FileCRCCheck::default_instance_ = new CCLCMsg_FileCRCCheck();
CCLCMsg_LoadingProgress::default_instance_ = new CCLCMsg_LoadingProgress();
CCLCMsg_SplitPlayerConnect::default_instance_ = new CCLCMsg_SplitPlayerConnect();
CCLCMsg_ClientMessage::default_instance_ = new CCLCMsg_ClientMessage();
CSVCMsg_ServerInfo::default_instance_ = new CSVCMsg_ServerInfo();
CSVCMsg_ClassInfo::default_instance_ = new CSVCMsg_ClassInfo();
CSVCMsg_ClassInfo_class_t::default_instance_ = new CSVCMsg_ClassInfo_class_t();
CSVCMsg_SetPause::default_instance_ = new CSVCMsg_SetPause();
CSVCMsg_VoiceInit::default_instance_ = new CSVCMsg_VoiceInit();
CSVCMsg_Print::default_instance_ = new CSVCMsg_Print();
CSVCMsg_Sounds::default_instance_ = new CSVCMsg_Sounds();
CSVCMsg_Sounds_sounddata_t::default_instance_ = new CSVCMsg_Sounds_sounddata_t();
CSVCMsg_Prefetch::default_instance_ = new CSVCMsg_Prefetch();
CSVCMsg_SetView::default_instance_ = new CSVCMsg_SetView();
CSVCMsg_FixAngle::default_instance_ = new CSVCMsg_FixAngle();
CSVCMsg_CrosshairAngle::default_instance_ = new CSVCMsg_CrosshairAngle();
CSVCMsg_BSPDecal::default_instance_ = new CSVCMsg_BSPDecal();
CSVCMsg_SplitScreen::default_instance_ = new CSVCMsg_SplitScreen();
CSVCMsg_GetCvarValue::default_instance_ = new CSVCMsg_GetCvarValue();
CSVCMsg_Menu::default_instance_ = new CSVCMsg_Menu();
CSVCMsg_SendTable::default_instance_ = new CSVCMsg_SendTable();
CSVCMsg_SendTable_sendprop_t::default_instance_ = new CSVCMsg_SendTable_sendprop_t();
CSVCMsg_GameEventList::default_instance_ = new CSVCMsg_GameEventList();
CSVCMsg_GameEventList_key_t::default_instance_ = new CSVCMsg_GameEventList_key_t();
CSVCMsg_GameEventList_descriptor_t::default_instance_ = new CSVCMsg_GameEventList_descriptor_t();
CSVCMsg_PacketEntities::default_instance_ = new CSVCMsg_PacketEntities();
CSVCMsg_TempEntities::default_instance_ = new CSVCMsg_TempEntities();
CSVCMsg_CreateStringTable::default_instance_ = new CSVCMsg_CreateStringTable();
CSVCMsg_UpdateStringTable::default_instance_ = new CSVCMsg_UpdateStringTable();
CSVCMsg_VoiceData::default_instance_ = new CSVCMsg_VoiceData();
CSVCMsg_PacketReliable::default_instance_ = new CSVCMsg_PacketReliable();
CSVCMsg_FullFrameSplit::default_instance_ = new CSVCMsg_FullFrameSplit();
CCLCMsg_ClientInfo::default_instance_->InitAsDefaultInstance();
CCLCMsg_Move::default_instance_->InitAsDefaultInstance();
CCLCMsg_VoiceData::default_instance_->InitAsDefaultInstance();
CCLCMsg_BaselineAck::default_instance_->InitAsDefaultInstance();
CCLCMsg_ListenEvents::default_instance_->InitAsDefaultInstance();
CCLCMsg_RespondCvarValue::default_instance_->InitAsDefaultInstance();
CCLCMsg_FileCRCCheck::default_instance_->InitAsDefaultInstance();
CCLCMsg_LoadingProgress::default_instance_->InitAsDefaultInstance();
CCLCMsg_SplitPlayerConnect::default_instance_->InitAsDefaultInstance();
CCLCMsg_ClientMessage::default_instance_->InitAsDefaultInstance();
CSVCMsg_ServerInfo::default_instance_->InitAsDefaultInstance();
CSVCMsg_ClassInfo::default_instance_->InitAsDefaultInstance();
CSVCMsg_ClassInfo_class_t::default_instance_->InitAsDefaultInstance();
CSVCMsg_SetPause::default_instance_->InitAsDefaultInstance();
CSVCMsg_VoiceInit::default_instance_->InitAsDefaultInstance();
CSVCMsg_Print::default_instance_->InitAsDefaultInstance();
CSVCMsg_Sounds::default_instance_->InitAsDefaultInstance();
CSVCMsg_Sounds_sounddata_t::default_instance_->InitAsDefaultInstance();
CSVCMsg_Prefetch::default_instance_->InitAsDefaultInstance();
CSVCMsg_SetView::default_instance_->InitAsDefaultInstance();
CSVCMsg_FixAngle::default_instance_->InitAsDefaultInstance();
CSVCMsg_CrosshairAngle::default_instance_->InitAsDefaultInstance();
CSVCMsg_BSPDecal::default_instance_->InitAsDefaultInstance();
CSVCMsg_SplitScreen::default_instance_->InitAsDefaultInstance();
CSVCMsg_GetCvarValue::default_instance_->InitAsDefaultInstance();
CSVCMsg_Menu::default_instance_->InitAsDefaultInstance();
CSVCMsg_SendTable::default_instance_->InitAsDefaultInstance();
CSVCMsg_SendTable_sendprop_t::default_instance_->InitAsDefaultInstance();
CSVCMsg_GameEventList::default_instance_->InitAsDefaultInstance();
CSVCMsg_GameEventList_key_t::default_instance_->InitAsDefaultInstance();
CSVCMsg_GameEventList_descriptor_t::default_instance_->InitAsDefaultInstance();
CSVCMsg_PacketEntities::default_instance_->InitAsDefaultInstance();
CSVCMsg_TempEntities::default_instance_->InitAsDefaultInstance();
CSVCMsg_CreateStringTable::default_instance_->InitAsDefaultInstance();
CSVCMsg_UpdateStringTable::default_instance_->InitAsDefaultInstance();
CSVCMsg_VoiceData::default_instance_->InitAsDefaultInstance();
CSVCMsg_PacketReliable::default_instance_->InitAsDefaultInstance();
CSVCMsg_FullFrameSplit::default_instance_->InitAsDefaultInstance();
::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_netmessages_2eproto);
}
// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_netmessages_2eproto {
StaticDescriptorInitializer_netmessages_2eproto() {
protobuf_AddDesc_netmessages_2eproto();
}
} static_descriptor_initializer_netmessages_2eproto_;
const ::google::protobuf::EnumDescriptor* CLC_Messages_descriptor() {
protobuf_AssignDescriptorsOnce();
return CLC_Messages_descriptor_;
}
bool CLC_Messages_IsValid(int value) {
switch(value) {
case 8:
case 9:
case 10:
case 11:
case 12:
case 13:
case 14:
case 15:
case 16:
case 17:
return true;
default:
return false;
}
}
const ::google::protobuf::EnumDescriptor* VoiceDataFormat_t_descriptor() {
protobuf_AssignDescriptorsOnce();
return VoiceDataFormat_t_descriptor_;
}
bool VoiceDataFormat_t_IsValid(int value) {
switch(value) {
case 0:
case 1:
return true;
default:
return false;
}
}
const ::google::protobuf::EnumDescriptor* SVC_Messages_descriptor() {
protobuf_AssignDescriptorsOnce();
return SVC_Messages_descriptor_;
}
bool SVC_Messages_IsValid(int value) {
switch(value) {
case 8:
case 9:
case 10:
case 11:
case 12:
case 13:
case 14:
case 15:
case 16:
case 17:
case 18:
case 19:
case 20:
case 21:
case 22:
case 23:
case 24:
case 25:
case 26:
case 27:
case 28:
case 29:
case 30:
case 31:
case 32:
case 33:
return true;
default:
return false;
}
}
const ::google::protobuf::EnumDescriptor* ESplitScreenMessageType_descriptor() {
protobuf_AssignDescriptorsOnce();
return ESplitScreenMessageType_descriptor_;
}
bool ESplitScreenMessageType_IsValid(int value) {
switch(value) {
case 0:
case 1:
return true;
default:
return false;
}
}
// ===================================================================
#ifndef _MSC_VER
const int CCLCMsg_ClientInfo::kSendTableCrcFieldNumber;
const int CCLCMsg_ClientInfo::kServerCountFieldNumber;
const int CCLCMsg_ClientInfo::kIsHltvFieldNumber;
const int CCLCMsg_ClientInfo::kIsReplayFieldNumber;
const int CCLCMsg_ClientInfo::kFriendsIdFieldNumber;
const int CCLCMsg_ClientInfo::kFriendsNameFieldNumber;
const int CCLCMsg_ClientInfo::kCustomFilesFieldNumber;
#endif // !_MSC_VER
CCLCMsg_ClientInfo::CCLCMsg_ClientInfo()
: ::google::protobuf::Message() {
SharedCtor();
// @@protoc_insertion_point(constructor:CCLCMsg_ClientInfo)
}
void CCLCMsg_ClientInfo::InitAsDefaultInstance() {
}
CCLCMsg_ClientInfo::CCLCMsg_ClientInfo(const CCLCMsg_ClientInfo& from)
: ::google::protobuf::Message() {
SharedCtor();
MergeFrom(from);
// @@protoc_insertion_point(copy_constructor:CCLCMsg_ClientInfo)
}
void CCLCMsg_ClientInfo::SharedCtor() {
::google::protobuf::internal::GetEmptyString();
_cached_size_ = 0;
send_table_crc_ = 0u;
server_count_ = 0u;
is_hltv_ = false;
is_replay_ = false;
friends_id_ = 0u;
friends_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
CCLCMsg_ClientInfo::~CCLCMsg_ClientInfo() {
// @@protoc_insertion_point(destructor:CCLCMsg_ClientInfo)
SharedDtor();
}
void CCLCMsg_ClientInfo::SharedDtor() {
if (friends_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
delete friends_name_;
}
if (this != default_instance_) {
}
}
void CCLCMsg_ClientInfo::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CCLCMsg_ClientInfo::descriptor() {
protobuf_AssignDescriptorsOnce();
return CCLCMsg_ClientInfo_descriptor_;
}
const CCLCMsg_ClientInfo& CCLCMsg_ClientInfo::default_instance() {
if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
return *default_instance_;
}
CCLCMsg_ClientInfo* CCLCMsg_ClientInfo::default_instance_ = NULL;
CCLCMsg_ClientInfo* CCLCMsg_ClientInfo::New() const {
return new CCLCMsg_ClientInfo;
}
void CCLCMsg_ClientInfo::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>( \
&reinterpret_cast<CCLCMsg_ClientInfo*>(16)->f) - \
reinterpret_cast<char*>(16))
#define ZR_(first, last) do { \
size_t f = OFFSET_OF_FIELD_(first); \
size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \
::memset(&first, 0, n); \
} while (0)
if (_has_bits_[0 / 32] & 63) {
ZR_(send_table_crc_, friends_id_);
if (has_friends_name()) {
if (friends_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
friends_name_->clear();
}
}
}
#undef OFFSET_OF_FIELD_
#undef ZR_
custom_files_.Clear();
::memset(_has_bits_, 0, sizeof(_has_bits_));
mutable_unknown_fields()->Clear();
}
bool CCLCMsg_ClientInfo::MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
::google::protobuf::uint32 tag;
// @@protoc_insertion_point(parse_start:CCLCMsg_ClientInfo)
for (;;) {
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// optional fixed32 send_table_crc = 1;
case 1: {
if (tag == 13) {
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &send_table_crc_)));
set_has_send_table_crc();
} else {
goto handle_unusual;
}
if (input->ExpectTag(16)) goto parse_server_count;
break;
}
// optional uint32 server_count = 2;
case 2: {
if (tag == 16) {
parse_server_count:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
input, &server_count_)));
set_has_server_count();
} else {
goto handle_unusual;
}
if (input->ExpectTag(24)) goto parse_is_hltv;
break;
}
// optional bool is_hltv = 3;
case 3: {
if (tag == 24) {
parse_is_hltv:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
input, &is_hltv_)));
set_has_is_hltv();
} else {
goto handle_unusual;
}
if (input->ExpectTag(32)) goto parse_is_replay;
break;
}
// optional bool is_replay = 4;
case 4: {
if (tag == 32) {
parse_is_replay:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
input, &is_replay_)));
set_has_is_replay();
} else {
goto handle_unusual;
}
if (input->ExpectTag(40)) goto parse_friends_id;
break;
}
// optional uint32 friends_id = 5;
case 5: {
if (tag == 40) {
parse_friends_id:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
input, &friends_id_)));
set_has_friends_id();
} else {
goto handle_unusual;
}
if (input->ExpectTag(50)) goto parse_friends_name;
break;
}
// optional string friends_name = 6;
case 6: {
if (tag == 50) {
parse_friends_name:
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
input, this->mutable_friends_name()));
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->friends_name().data(), this->friends_name().length(),
::google::protobuf::internal::WireFormat::PARSE,
"friends_name");
} else {
goto handle_unusual;
}
if (input->ExpectTag(61)) goto parse_custom_files;
break;
}
// repeated fixed32 custom_files = 7;
case 7: {
if (tag == 61) {
parse_custom_files:
DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
1, 61, input, this->mutable_custom_files())));
} else if (tag == 58) {
DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, this->mutable_custom_files())));
} else {
goto handle_unusual;
}
if (input->ExpectTag(61)) goto parse_custom_files;
if (input->ExpectAtEnd()) goto success;
break;
}
default: {
handle_unusual:
if (tag == 0 ||
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
goto success;
}
DO_(::google::protobuf::internal::WireFormat::SkipField(
input, tag, mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:CCLCMsg_ClientInfo)
return true;
failure:
// @@protoc_insertion_point(parse_failure:CCLCMsg_ClientInfo)
return false;
#undef DO_
}
void CCLCMsg_ClientInfo::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:CCLCMsg_ClientInfo)
// optional fixed32 send_table_crc = 1;
if (has_send_table_crc()) {
::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->send_table_crc(), output);
}
// optional uint32 server_count = 2;
if (has_server_count()) {
::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->server_count(), output);
}
// optional bool is_hltv = 3;
if (has_is_hltv()) {
::google::protobuf::internal::WireFormatLite::WriteBool(3, this->is_hltv(), output);
}
// optional bool is_replay = 4;
if (has_is_replay()) {
::google::protobuf::internal::WireFormatLite::WriteBool(4, this->is_replay(), output);
}
// optional uint32 friends_id = 5;
if (has_friends_id()) {
::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->friends_id(), output);
}
// optional string friends_name = 6;
if (has_friends_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->friends_name().data(), this->friends_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"friends_name");
::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
6, this->friends_name(), output);
}
// repeated fixed32 custom_files = 7;
for (int i = 0; i < this->custom_files_size(); i++) {
::google::protobuf::internal::WireFormatLite::WriteFixed32(
7, this->custom_files(i), output);
}
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
}
// @@protoc_insertion_point(serialize_end:CCLCMsg_ClientInfo)
}
::google::protobuf::uint8* CCLCMsg_ClientInfo::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// @@protoc_insertion_point(serialize_to_array_start:CCLCMsg_ClientInfo)
// optional fixed32 send_table_crc = 1;
if (has_send_table_crc()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->send_table_crc(), target);
}
// optional uint32 server_count = 2;
if (has_server_count()) {
target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->server_count(), target);
}
// optional bool is_hltv = 3;
if (has_is_hltv()) {
target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->is_hltv(), target);
}
// optional bool is_replay = 4;
if (has_is_replay()) {
target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->is_replay(), target);
}
// optional uint32 friends_id = 5;
if (has_friends_id()) {
target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(5, this->friends_id(), target);
}
// optional string friends_name = 6;
if (has_friends_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->friends_name().data(), this->friends_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"friends_name");
target =
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
6, this->friends_name(), target);
}
// repeated fixed32 custom_files = 7;
for (int i = 0; i < this->custom_files_size(); i++) {
target = ::google::protobuf::internal::WireFormatLite::
WriteFixed32ToArray(7, this->custom_files(i), target);
}
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
}
// @@protoc_insertion_point(serialize_to_array_end:CCLCMsg_ClientInfo)
return target;
}
int CCLCMsg_ClientInfo::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// optional fixed32 send_table_crc = 1;
if (has_send_table_crc()) {
total_size += 1 + 4;
}
// optional uint32 server_count = 2;
if (has_server_count()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::UInt32Size(
this->server_count());
}
// optional bool is_hltv = 3;
if (has_is_hltv()) {
total_size += 1 + 1;
}
// optional bool is_replay = 4;
if (has_is_replay()) {
total_size += 1 + 1;
}
// optional uint32 friends_id = 5;
if (has_friends_id()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::UInt32Size(
this->friends_id());
}
// optional string friends_name = 6;
if (has_friends_name()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::StringSize(
this->friends_name());
}
}
// repeated fixed32 custom_files = 7;
{
int data_size = 0;
data_size = 4 * this->custom_files_size();
total_size += 1 * this->custom_files_size() + data_size;
}
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 CCLCMsg_ClientInfo::MergeFrom(const ::google::protobuf::Message& from) {
GOOGLE_CHECK_NE(&from, this);
const CCLCMsg_ClientInfo* source =
::google::protobuf::internal::dynamic_cast_if_available<const CCLCMsg_ClientInfo*>(
&from);
if (source == NULL) {
::google::protobuf::internal::ReflectionOps::Merge(from, this);
} else {
MergeFrom(*source);
}
}
void CCLCMsg_ClientInfo::MergeFrom(const CCLCMsg_ClientInfo& from) {
GOOGLE_CHECK_NE(&from, this);
custom_files_.MergeFrom(from.custom_files_);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
if (from.has_send_table_crc()) {
set_send_table_crc(from.send_table_crc());
}
if (from.has_server_count()) {
set_server_count(from.server_count());
}
if (from.has_is_hltv()) {
set_is_hltv(from.is_hltv());
}
if (from.has_is_replay()) {
set_is_replay(from.is_replay());
}
if (from.has_friends_id()) {
set_friends_id(from.friends_id());
}
if (from.has_friends_name()) {
set_friends_name(from.friends_name());
}
}
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}
void CCLCMsg_ClientInfo::CopyFrom(const ::google::protobuf::Message& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
void CCLCMsg_ClientInfo::CopyFrom(const CCLCMsg_ClientInfo& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool CCLCMsg_ClientInfo::IsInitialized() const {
return true;
}
void CCLCMsg_ClientInfo::Swap(CCLCMsg_ClientInfo* other) {
if (other != this) {
std::swap(send_table_crc_, other->send_table_crc_);
std::swap(server_count_, other->server_count_);
std::swap(is_hltv_, other->is_hltv_);
std::swap(is_replay_, other->is_replay_);
std::swap(friends_id_, other->friends_id_);
std::swap(friends_name_, other->friends_name_);
custom_files_.Swap(&other->custom_files_);
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 CCLCMsg_ClientInfo::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
::google::protobuf::Metadata metadata;
metadata.descriptor = CCLCMsg_ClientInfo_descriptor_;
metadata.reflection = CCLCMsg_ClientInfo_reflection_;
return metadata;
}
// ===================================================================
#ifndef _MSC_VER
const int CCLCMsg_Move::kNumBackupCommandsFieldNumber;
const int CCLCMsg_Move::kNumNewCommandsFieldNumber;
const int CCLCMsg_Move::kDataFieldNumber;
#endif // !_MSC_VER
CCLCMsg_Move::CCLCMsg_Move()
: ::google::protobuf::Message() {
SharedCtor();
// @@protoc_insertion_point(constructor:CCLCMsg_Move)
}
void CCLCMsg_Move::InitAsDefaultInstance() {
}
CCLCMsg_Move::CCLCMsg_Move(const CCLCMsg_Move& from)
: ::google::protobuf::Message() {
SharedCtor();
MergeFrom(from);
// @@protoc_insertion_point(copy_constructor:CCLCMsg_Move)
}
void CCLCMsg_Move::SharedCtor() {
::google::protobuf::internal::GetEmptyString();
_cached_size_ = 0;
num_backup_commands_ = 0u;
num_new_commands_ = 0u;
data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
CCLCMsg_Move::~CCLCMsg_Move() {
// @@protoc_insertion_point(destructor:CCLCMsg_Move)
SharedDtor();
}
void CCLCMsg_Move::SharedDtor() {
if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
delete data_;
}
if (this != default_instance_) {
}
}
void CCLCMsg_Move::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CCLCMsg_Move::descriptor() {
protobuf_AssignDescriptorsOnce();
return CCLCMsg_Move_descriptor_;
}
const CCLCMsg_Move& CCLCMsg_Move::default_instance() {
if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
return *default_instance_;
}
CCLCMsg_Move* CCLCMsg_Move::default_instance_ = NULL;
CCLCMsg_Move* CCLCMsg_Move::New() const {
return new CCLCMsg_Move;
}
void CCLCMsg_Move::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>( \
&reinterpret_cast<CCLCMsg_Move*>(16)->f) - \
reinterpret_cast<char*>(16))
#define ZR_(first, last) do { \
size_t f = OFFSET_OF_FIELD_(first); \
size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \
::memset(&first, 0, n); \
} while (0)
if (_has_bits_[0 / 32] & 7) {
ZR_(num_backup_commands_, num_new_commands_);
if (has_data()) {
if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
data_->clear();
}
}
}
#undef OFFSET_OF_FIELD_
#undef ZR_
::memset(_has_bits_, 0, sizeof(_has_bits_));
mutable_unknown_fields()->Clear();
}
bool CCLCMsg_Move::MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
::google::protobuf::uint32 tag;
// @@protoc_insertion_point(parse_start:CCLCMsg_Move)
for (;;) {
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// optional uint32 num_backup_commands = 1;
case 1: {
if (tag == 8) {
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
input, &num_backup_commands_)));
set_has_num_backup_commands();
} else {
goto handle_unusual;
}
if (input->ExpectTag(16)) goto parse_num_new_commands;
break;
}
// optional uint32 num_new_commands = 2;
case 2: {
if (tag == 16) {
parse_num_new_commands:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
input, &num_new_commands_)));
set_has_num_new_commands();
} else {
goto handle_unusual;
}
if (input->ExpectTag(26)) goto parse_data;
break;
}
// optional bytes data = 3;
case 3: {
if (tag == 26) {
parse_data:
DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
input, this->mutable_data()));
} else {
goto handle_unusual;
}
if (input->ExpectAtEnd()) goto success;
break;
}
default: {
handle_unusual:
if (tag == 0 ||
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
goto success;
}
DO_(::google::protobuf::internal::WireFormat::SkipField(
input, tag, mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:CCLCMsg_Move)
return true;
failure:
// @@protoc_insertion_point(parse_failure:CCLCMsg_Move)
return false;
#undef DO_
}
void CCLCMsg_Move::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:CCLCMsg_Move)
// optional uint32 num_backup_commands = 1;
if (has_num_backup_commands()) {
::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->num_backup_commands(), output);
}
// optional uint32 num_new_commands = 2;
if (has_num_new_commands()) {
::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->num_new_commands(), output);
}
// optional bytes data = 3;
if (has_data()) {
::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
3, this->data(), output);
}
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
}
// @@protoc_insertion_point(serialize_end:CCLCMsg_Move)
}
::google::protobuf::uint8* CCLCMsg_Move::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// @@protoc_insertion_point(serialize_to_array_start:CCLCMsg_Move)
// optional uint32 num_backup_commands = 1;
if (has_num_backup_commands()) {
target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->num_backup_commands(), target);
}
// optional uint32 num_new_commands = 2;
if (has_num_new_commands()) {
target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->num_new_commands(), target);
}
// optional bytes data = 3;
if (has_data()) {
target =
::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
3, this->data(), target);
}
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
}
// @@protoc_insertion_point(serialize_to_array_end:CCLCMsg_Move)
return target;
}
int CCLCMsg_Move::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// optional uint32 num_backup_commands = 1;
if (has_num_backup_commands()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::UInt32Size(
this->num_backup_commands());
}
// optional uint32 num_new_commands = 2;
if (has_num_new_commands()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::UInt32Size(
this->num_new_commands());
}
// optional bytes data = 3;
if (has_data()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::BytesSize(
this->data());
}
}
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 CCLCMsg_Move::MergeFrom(const ::google::protobuf::Message& from) {
GOOGLE_CHECK_NE(&from, this);
const CCLCMsg_Move* source =
::google::protobuf::internal::dynamic_cast_if_available<const CCLCMsg_Move*>(
&from);
if (source == NULL) {
::google::protobuf::internal::ReflectionOps::Merge(from, this);
} else {
MergeFrom(*source);
}
}
void CCLCMsg_Move::MergeFrom(const CCLCMsg_Move& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
if (from.has_num_backup_commands()) {
set_num_backup_commands(from.num_backup_commands());
}
if (from.has_num_new_commands()) {
set_num_new_commands(from.num_new_commands());
}
if (from.has_data()) {
set_data(from.data());
}
}
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}
void CCLCMsg_Move::CopyFrom(const ::google::protobuf::Message& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
void CCLCMsg_Move::CopyFrom(const CCLCMsg_Move& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool CCLCMsg_Move::IsInitialized() const {
return true;
}
void CCLCMsg_Move::Swap(CCLCMsg_Move* other) {
if (other != this) {
std::swap(num_backup_commands_, other->num_backup_commands_);
std::swap(num_new_commands_, other->num_new_commands_);
std::swap(data_, other->data_);
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 CCLCMsg_Move::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
::google::protobuf::Metadata metadata;
metadata.descriptor = CCLCMsg_Move_descriptor_;
metadata.reflection = CCLCMsg_Move_reflection_;
return metadata;
}
// ===================================================================
#ifndef _MSC_VER
const int CCLCMsg_VoiceData::kDataFieldNumber;
const int CCLCMsg_VoiceData::kXuidFieldNumber;
const int CCLCMsg_VoiceData::kFormatFieldNumber;
const int CCLCMsg_VoiceData::kSequenceBytesFieldNumber;
const int CCLCMsg_VoiceData::kSectionNumberFieldNumber;
const int CCLCMsg_VoiceData::kUncompressedSampleOffsetFieldNumber;
const int CCLCMsg_VoiceData::kTickFieldNumber;
#endif // !_MSC_VER
CCLCMsg_VoiceData::CCLCMsg_VoiceData()
: ::google::protobuf::Message() {
SharedCtor();
// @@protoc_insertion_point(constructor:CCLCMsg_VoiceData)
}
void CCLCMsg_VoiceData::InitAsDefaultInstance() {
}
CCLCMsg_VoiceData::CCLCMsg_VoiceData(const CCLCMsg_VoiceData& from)
: ::google::protobuf::Message() {
SharedCtor();
MergeFrom(from);
// @@protoc_insertion_point(copy_constructor:CCLCMsg_VoiceData)
}
void CCLCMsg_VoiceData::SharedCtor() {
::google::protobuf::internal::GetEmptyString();
_cached_size_ = 0;
data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
xuid_ = GOOGLE_ULONGLONG(0);
format_ = 0;
sequence_bytes_ = 0;
section_number_ = 0u;
uncompressed_sample_offset_ = 0u;
tick_ = 0u;
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
CCLCMsg_VoiceData::~CCLCMsg_VoiceData() {
// @@protoc_insertion_point(destructor:CCLCMsg_VoiceData)
SharedDtor();
}
void CCLCMsg_VoiceData::SharedDtor() {
if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
delete data_;
}
if (this != default_instance_) {
}
}
void CCLCMsg_VoiceData::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CCLCMsg_VoiceData::descriptor() {
protobuf_AssignDescriptorsOnce();
return CCLCMsg_VoiceData_descriptor_;
}
const CCLCMsg_VoiceData& CCLCMsg_VoiceData::default_instance() {
if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
return *default_instance_;
}
CCLCMsg_VoiceData* CCLCMsg_VoiceData::default_instance_ = NULL;
CCLCMsg_VoiceData* CCLCMsg_VoiceData::New() const {
return new CCLCMsg_VoiceData;
}
void CCLCMsg_VoiceData::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>( \
&reinterpret_cast<CCLCMsg_VoiceData*>(16)->f) - \
reinterpret_cast<char*>(16))
#define ZR_(first, last) do { \
size_t f = OFFSET_OF_FIELD_(first); \
size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \
::memset(&first, 0, n); \
} while (0)
if (_has_bits_[0 / 32] & 127) {
ZR_(xuid_, tick_);
if (has_data()) {
if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
data_->clear();
}
}
}
#undef OFFSET_OF_FIELD_
#undef ZR_
::memset(_has_bits_, 0, sizeof(_has_bits_));
mutable_unknown_fields()->Clear();
}
bool CCLCMsg_VoiceData::MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
::google::protobuf::uint32 tag;
// @@protoc_insertion_point(parse_start:CCLCMsg_VoiceData)
for (;;) {
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// optional bytes data = 1;
case 1: {
if (tag == 10) {
DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
input, this->mutable_data()));
} else {
goto handle_unusual;
}
if (input->ExpectTag(17)) goto parse_xuid;
break;
}
// optional fixed64 xuid = 2;
case 2: {
if (tag == 17) {
parse_xuid:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
input, &xuid_)));
set_has_xuid();
} else {
goto handle_unusual;
}
if (input->ExpectTag(24)) goto parse_format;
break;
}
// optional .VoiceDataFormat_t format = 3 [default = VOICEDATA_FORMAT_STEAM];
case 3: {
if (tag == 24) {
parse_format:
int value;
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
input, &value)));
if (::VoiceDataFormat_t_IsValid(value)) {
set_format(static_cast< ::VoiceDataFormat_t >(value));
} else {
mutable_unknown_fields()->AddVarint(3, value);
}
} else {
goto handle_unusual;
}
if (input->ExpectTag(32)) goto parse_sequence_bytes;
break;
}
// optional int32 sequence_bytes = 4;
case 4: {
if (tag == 32) {
parse_sequence_bytes:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &sequence_bytes_)));
set_has_sequence_bytes();
} else {
goto handle_unusual;
}
if (input->ExpectTag(40)) goto parse_section_number;
break;
}
// optional uint32 section_number = 5;
case 5: {
if (tag == 40) {
parse_section_number:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
input, &section_number_)));
set_has_section_number();
} else {
goto handle_unusual;
}
if (input->ExpectTag(48)) goto parse_uncompressed_sample_offset;
break;
}
// optional uint32 uncompressed_sample_offset = 6;
case 6: {
if (tag == 48) {
parse_uncompressed_sample_offset:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
input, &uncompressed_sample_offset_)));
set_has_uncompressed_sample_offset();
} else {
goto handle_unusual;
}
if (input->ExpectTag(56)) goto parse_tick;
break;
}
// optional uint32 tick = 7;
case 7: {
if (tag == 56) {
parse_tick:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
input, &tick_)));
set_has_tick();
} else {
goto handle_unusual;
}
if (input->ExpectAtEnd()) goto success;
break;
}
default: {
handle_unusual:
if (tag == 0 ||
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
goto success;
}
DO_(::google::protobuf::internal::WireFormat::SkipField(
input, tag, mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:CCLCMsg_VoiceData)
return true;
failure:
// @@protoc_insertion_point(parse_failure:CCLCMsg_VoiceData)
return false;
#undef DO_
}
void CCLCMsg_VoiceData::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:CCLCMsg_VoiceData)
// optional bytes data = 1;
if (has_data()) {
::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
1, this->data(), output);
}
// optional fixed64 xuid = 2;
if (has_xuid()) {
::google::protobuf::internal::WireFormatLite::WriteFixed64(2, this->xuid(), output);
}
// optional .VoiceDataFormat_t format = 3 [default = VOICEDATA_FORMAT_STEAM];
if (has_format()) {
::google::protobuf::internal::WireFormatLite::WriteEnum(
3, this->format(), output);
}
// optional int32 sequence_bytes = 4;
if (has_sequence_bytes()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->sequence_bytes(), output);
}
// optional uint32 section_number = 5;
if (has_section_number()) {
::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->section_number(), output);
}
// optional uint32 uncompressed_sample_offset = 6;
if (has_uncompressed_sample_offset()) {
::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->uncompressed_sample_offset(), output);
}
// optional uint32 tick = 7;
if (has_tick()) {
::google::protobuf::internal::WireFormatLite::WriteUInt32(7, this->tick(), output);
}
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
}
// @@protoc_insertion_point(serialize_end:CCLCMsg_VoiceData)
}
::google::protobuf::uint8* CCLCMsg_VoiceData::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// @@protoc_insertion_point(serialize_to_array_start:CCLCMsg_VoiceData)
// optional bytes data = 1;
if (has_data()) {
target =
::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
1, this->data(), target);
}
// optional fixed64 xuid = 2;
if (has_xuid()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(2, this->xuid(), target);
}
// optional .VoiceDataFormat_t format = 3 [default = VOICEDATA_FORMAT_STEAM];
if (has_format()) {
target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
3, this->format(), target);
}
// optional int32 sequence_bytes = 4;
if (has_sequence_bytes()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->sequence_bytes(), target);
}
// optional uint32 section_number = 5;
if (has_section_number()) {
target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(5, this->section_number(), target);
}
// optional uint32 uncompressed_sample_offset = 6;
if (has_uncompressed_sample_offset()) {
target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(6, this->uncompressed_sample_offset(), target);
}
// optional uint32 tick = 7;
if (has_tick()) {
target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(7, this->tick(), target);
}
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
}
// @@protoc_insertion_point(serialize_to_array_end:CCLCMsg_VoiceData)
return target;
}
int CCLCMsg_VoiceData::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// optional bytes data = 1;
if (has_data()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::BytesSize(
this->data());
}
// optional fixed64 xuid = 2;
if (has_xuid()) {
total_size += 1 + 8;
}
// optional .VoiceDataFormat_t format = 3 [default = VOICEDATA_FORMAT_STEAM];
if (has_format()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::EnumSize(this->format());
}
// optional int32 sequence_bytes = 4;
if (has_sequence_bytes()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->sequence_bytes());
}
// optional uint32 section_number = 5;
if (has_section_number()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::UInt32Size(
this->section_number());
}
// optional uint32 uncompressed_sample_offset = 6;
if (has_uncompressed_sample_offset()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::UInt32Size(
this->uncompressed_sample_offset());
}
// optional uint32 tick = 7;
if (has_tick()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::UInt32Size(
this->tick());
}
}
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 CCLCMsg_VoiceData::MergeFrom(const ::google::protobuf::Message& from) {
GOOGLE_CHECK_NE(&from, this);
const CCLCMsg_VoiceData* source =
::google::protobuf::internal::dynamic_cast_if_available<const CCLCMsg_VoiceData*>(
&from);
if (source == NULL) {
::google::protobuf::internal::ReflectionOps::Merge(from, this);
} else {
MergeFrom(*source);
}
}
void CCLCMsg_VoiceData::MergeFrom(const CCLCMsg_VoiceData& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
if (from.has_data()) {
set_data(from.data());
}
if (from.has_xuid()) {
set_xuid(from.xuid());
}
if (from.has_format()) {
set_format(from.format());
}
if (from.has_sequence_bytes()) {
set_sequence_bytes(from.sequence_bytes());
}
if (from.has_section_number()) {
set_section_number(from.section_number());
}
if (from.has_uncompressed_sample_offset()) {
set_uncompressed_sample_offset(from.uncompressed_sample_offset());
}
if (from.has_tick()) {
set_tick(from.tick());
}
}
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}
void CCLCMsg_VoiceData::CopyFrom(const ::google::protobuf::Message& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
void CCLCMsg_VoiceData::CopyFrom(const CCLCMsg_VoiceData& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool CCLCMsg_VoiceData::IsInitialized() const {
return true;
}
void CCLCMsg_VoiceData::Swap(CCLCMsg_VoiceData* other) {
if (other != this) {
std::swap(data_, other->data_);
std::swap(xuid_, other->xuid_);
std::swap(format_, other->format_);
std::swap(sequence_bytes_, other->sequence_bytes_);
std::swap(section_number_, other->section_number_);
std::swap(uncompressed_sample_offset_, other->uncompressed_sample_offset_);
std::swap(tick_, other->tick_);
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 CCLCMsg_VoiceData::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
::google::protobuf::Metadata metadata;
metadata.descriptor = CCLCMsg_VoiceData_descriptor_;
metadata.reflection = CCLCMsg_VoiceData_reflection_;
return metadata;
}
// ===================================================================
#ifndef _MSC_VER
const int CCLCMsg_BaselineAck::kBaselineTickFieldNumber;
const int CCLCMsg_BaselineAck::kBaselineNrFieldNumber;
#endif // !_MSC_VER
CCLCMsg_BaselineAck::CCLCMsg_BaselineAck()
: ::google::protobuf::Message() {
SharedCtor();
// @@protoc_insertion_point(constructor:CCLCMsg_BaselineAck)
}
void CCLCMsg_BaselineAck::InitAsDefaultInstance() {
}
CCLCMsg_BaselineAck::CCLCMsg_BaselineAck(const CCLCMsg_BaselineAck& from)
: ::google::protobuf::Message() {
SharedCtor();
MergeFrom(from);
// @@protoc_insertion_point(copy_constructor:CCLCMsg_BaselineAck)
}
void CCLCMsg_BaselineAck::SharedCtor() {
_cached_size_ = 0;
baseline_tick_ = 0;
baseline_nr_ = 0;
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
CCLCMsg_BaselineAck::~CCLCMsg_BaselineAck() {
// @@protoc_insertion_point(destructor:CCLCMsg_BaselineAck)
SharedDtor();
}
void CCLCMsg_BaselineAck::SharedDtor() {
if (this != default_instance_) {
}
}
void CCLCMsg_BaselineAck::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CCLCMsg_BaselineAck::descriptor() {
protobuf_AssignDescriptorsOnce();
return CCLCMsg_BaselineAck_descriptor_;
}
const CCLCMsg_BaselineAck& CCLCMsg_BaselineAck::default_instance() {
if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
return *default_instance_;
}
CCLCMsg_BaselineAck* CCLCMsg_BaselineAck::default_instance_ = NULL;
CCLCMsg_BaselineAck* CCLCMsg_BaselineAck::New() const {
return new CCLCMsg_BaselineAck;
}
void CCLCMsg_BaselineAck::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>( \
&reinterpret_cast<CCLCMsg_BaselineAck*>(16)->f) - \
reinterpret_cast<char*>(16))
#define ZR_(first, last) do { \
size_t f = OFFSET_OF_FIELD_(first); \
size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \
::memset(&first, 0, n); \
} while (0)
ZR_(baseline_tick_, baseline_nr_);
#undef OFFSET_OF_FIELD_
#undef ZR_
::memset(_has_bits_, 0, sizeof(_has_bits_));
mutable_unknown_fields()->Clear();
}
bool CCLCMsg_BaselineAck::MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
::google::protobuf::uint32 tag;
// @@protoc_insertion_point(parse_start:CCLCMsg_BaselineAck)
for (;;) {
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// optional int32 baseline_tick = 1;
case 1: {
if (tag == 8) {
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &baseline_tick_)));
set_has_baseline_tick();
} else {
goto handle_unusual;
}
if (input->ExpectTag(16)) goto parse_baseline_nr;
break;
}
// optional int32 baseline_nr = 2;
case 2: {
if (tag == 16) {
parse_baseline_nr:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &baseline_nr_)));
set_has_baseline_nr();
} else {
goto handle_unusual;
}
if (input->ExpectAtEnd()) goto success;
break;
}
default: {
handle_unusual:
if (tag == 0 ||
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
goto success;
}
DO_(::google::protobuf::internal::WireFormat::SkipField(
input, tag, mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:CCLCMsg_BaselineAck)
return true;
failure:
// @@protoc_insertion_point(parse_failure:CCLCMsg_BaselineAck)
return false;
#undef DO_
}
void CCLCMsg_BaselineAck::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:CCLCMsg_BaselineAck)
// optional int32 baseline_tick = 1;
if (has_baseline_tick()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->baseline_tick(), output);
}
// optional int32 baseline_nr = 2;
if (has_baseline_nr()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->baseline_nr(), output);
}
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
}
// @@protoc_insertion_point(serialize_end:CCLCMsg_BaselineAck)
}
::google::protobuf::uint8* CCLCMsg_BaselineAck::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// @@protoc_insertion_point(serialize_to_array_start:CCLCMsg_BaselineAck)
// optional int32 baseline_tick = 1;
if (has_baseline_tick()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->baseline_tick(), target);
}
// optional int32 baseline_nr = 2;
if (has_baseline_nr()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->baseline_nr(), target);
}
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
}
// @@protoc_insertion_point(serialize_to_array_end:CCLCMsg_BaselineAck)
return target;
}
int CCLCMsg_BaselineAck::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// optional int32 baseline_tick = 1;
if (has_baseline_tick()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->baseline_tick());
}
// optional int32 baseline_nr = 2;
if (has_baseline_nr()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->baseline_nr());
}
}
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 CCLCMsg_BaselineAck::MergeFrom(const ::google::protobuf::Message& from) {
GOOGLE_CHECK_NE(&from, this);
const CCLCMsg_BaselineAck* source =
::google::protobuf::internal::dynamic_cast_if_available<const CCLCMsg_BaselineAck*>(
&from);
if (source == NULL) {
::google::protobuf::internal::ReflectionOps::Merge(from, this);
} else {
MergeFrom(*source);
}
}
void CCLCMsg_BaselineAck::MergeFrom(const CCLCMsg_BaselineAck& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
if (from.has_baseline_tick()) {
set_baseline_tick(from.baseline_tick());
}
if (from.has_baseline_nr()) {
set_baseline_nr(from.baseline_nr());
}
}
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}
void CCLCMsg_BaselineAck::CopyFrom(const ::google::protobuf::Message& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
void CCLCMsg_BaselineAck::CopyFrom(const CCLCMsg_BaselineAck& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool CCLCMsg_BaselineAck::IsInitialized() const {
return true;
}
void CCLCMsg_BaselineAck::Swap(CCLCMsg_BaselineAck* other) {
if (other != this) {
std::swap(baseline_tick_, other->baseline_tick_);
std::swap(baseline_nr_, other->baseline_nr_);
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 CCLCMsg_BaselineAck::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
::google::protobuf::Metadata metadata;
metadata.descriptor = CCLCMsg_BaselineAck_descriptor_;
metadata.reflection = CCLCMsg_BaselineAck_reflection_;
return metadata;
}
// ===================================================================
#ifndef _MSC_VER
const int CCLCMsg_ListenEvents::kEventMaskFieldNumber;
#endif // !_MSC_VER
CCLCMsg_ListenEvents::CCLCMsg_ListenEvents()
: ::google::protobuf::Message() {
SharedCtor();
// @@protoc_insertion_point(constructor:CCLCMsg_ListenEvents)
}
void CCLCMsg_ListenEvents::InitAsDefaultInstance() {
}
CCLCMsg_ListenEvents::CCLCMsg_ListenEvents(const CCLCMsg_ListenEvents& from)
: ::google::protobuf::Message() {
SharedCtor();
MergeFrom(from);
// @@protoc_insertion_point(copy_constructor:CCLCMsg_ListenEvents)
}
void CCLCMsg_ListenEvents::SharedCtor() {
_cached_size_ = 0;
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
CCLCMsg_ListenEvents::~CCLCMsg_ListenEvents() {
// @@protoc_insertion_point(destructor:CCLCMsg_ListenEvents)
SharedDtor();
}
void CCLCMsg_ListenEvents::SharedDtor() {
if (this != default_instance_) {
}
}
void CCLCMsg_ListenEvents::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CCLCMsg_ListenEvents::descriptor() {
protobuf_AssignDescriptorsOnce();
return CCLCMsg_ListenEvents_descriptor_;
}
const CCLCMsg_ListenEvents& CCLCMsg_ListenEvents::default_instance() {
if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
return *default_instance_;
}
CCLCMsg_ListenEvents* CCLCMsg_ListenEvents::default_instance_ = NULL;
CCLCMsg_ListenEvents* CCLCMsg_ListenEvents::New() const {
return new CCLCMsg_ListenEvents;
}
void CCLCMsg_ListenEvents::Clear() {
event_mask_.Clear();
::memset(_has_bits_, 0, sizeof(_has_bits_));
mutable_unknown_fields()->Clear();
}
bool CCLCMsg_ListenEvents::MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
::google::protobuf::uint32 tag;
// @@protoc_insertion_point(parse_start:CCLCMsg_ListenEvents)
for (;;) {
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// repeated fixed32 event_mask = 1;
case 1: {
if (tag == 13) {
parse_event_mask:
DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
1, 13, input, this->mutable_event_mask())));
} else if (tag == 10) {
DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, this->mutable_event_mask())));
} else {
goto handle_unusual;
}
if (input->ExpectTag(13)) goto parse_event_mask;
if (input->ExpectAtEnd()) goto success;
break;
}
default: {
handle_unusual:
if (tag == 0 ||
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
goto success;
}
DO_(::google::protobuf::internal::WireFormat::SkipField(
input, tag, mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:CCLCMsg_ListenEvents)
return true;
failure:
// @@protoc_insertion_point(parse_failure:CCLCMsg_ListenEvents)
return false;
#undef DO_
}
void CCLCMsg_ListenEvents::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:CCLCMsg_ListenEvents)
// repeated fixed32 event_mask = 1;
for (int i = 0; i < this->event_mask_size(); i++) {
::google::protobuf::internal::WireFormatLite::WriteFixed32(
1, this->event_mask(i), output);
}
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
}
// @@protoc_insertion_point(serialize_end:CCLCMsg_ListenEvents)
}
::google::protobuf::uint8* CCLCMsg_ListenEvents::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// @@protoc_insertion_point(serialize_to_array_start:CCLCMsg_ListenEvents)
// repeated fixed32 event_mask = 1;
for (int i = 0; i < this->event_mask_size(); i++) {
target = ::google::protobuf::internal::WireFormatLite::
WriteFixed32ToArray(1, this->event_mask(i), target);
}
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
}
// @@protoc_insertion_point(serialize_to_array_end:CCLCMsg_ListenEvents)
return target;
}
int CCLCMsg_ListenEvents::ByteSize() const {
int total_size = 0;
// repeated fixed32 event_mask = 1;
{
int data_size = 0;
data_size = 4 * this->event_mask_size();
total_size += 1 * this->event_mask_size() + data_size;
}
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 CCLCMsg_ListenEvents::MergeFrom(const ::google::protobuf::Message& from) {
GOOGLE_CHECK_NE(&from, this);
const CCLCMsg_ListenEvents* source =
::google::protobuf::internal::dynamic_cast_if_available<const CCLCMsg_ListenEvents*>(
&from);
if (source == NULL) {
::google::protobuf::internal::ReflectionOps::Merge(from, this);
} else {
MergeFrom(*source);
}
}
void CCLCMsg_ListenEvents::MergeFrom(const CCLCMsg_ListenEvents& from) {
GOOGLE_CHECK_NE(&from, this);
event_mask_.MergeFrom(from.event_mask_);
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}
void CCLCMsg_ListenEvents::CopyFrom(const ::google::protobuf::Message& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
void CCLCMsg_ListenEvents::CopyFrom(const CCLCMsg_ListenEvents& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool CCLCMsg_ListenEvents::IsInitialized() const {
return true;
}
void CCLCMsg_ListenEvents::Swap(CCLCMsg_ListenEvents* other) {
if (other != this) {
event_mask_.Swap(&other->event_mask_);
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 CCLCMsg_ListenEvents::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
::google::protobuf::Metadata metadata;
metadata.descriptor = CCLCMsg_ListenEvents_descriptor_;
metadata.reflection = CCLCMsg_ListenEvents_reflection_;
return metadata;
}
// ===================================================================
#ifndef _MSC_VER
const int CCLCMsg_RespondCvarValue::kCookieFieldNumber;
const int CCLCMsg_RespondCvarValue::kStatusCodeFieldNumber;
const int CCLCMsg_RespondCvarValue::kNameFieldNumber;
const int CCLCMsg_RespondCvarValue::kValueFieldNumber;
#endif // !_MSC_VER
CCLCMsg_RespondCvarValue::CCLCMsg_RespondCvarValue()
: ::google::protobuf::Message() {
SharedCtor();
// @@protoc_insertion_point(constructor:CCLCMsg_RespondCvarValue)
}
void CCLCMsg_RespondCvarValue::InitAsDefaultInstance() {
}
CCLCMsg_RespondCvarValue::CCLCMsg_RespondCvarValue(const CCLCMsg_RespondCvarValue& from)
: ::google::protobuf::Message() {
SharedCtor();
MergeFrom(from);
// @@protoc_insertion_point(copy_constructor:CCLCMsg_RespondCvarValue)
}
void CCLCMsg_RespondCvarValue::SharedCtor() {
::google::protobuf::internal::GetEmptyString();
_cached_size_ = 0;
cookie_ = 0;
status_code_ = 0;
name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
CCLCMsg_RespondCvarValue::~CCLCMsg_RespondCvarValue() {
// @@protoc_insertion_point(destructor:CCLCMsg_RespondCvarValue)
SharedDtor();
}
void CCLCMsg_RespondCvarValue::SharedDtor() {
if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
delete name_;
}
if (value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
delete value_;
}
if (this != default_instance_) {
}
}
void CCLCMsg_RespondCvarValue::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CCLCMsg_RespondCvarValue::descriptor() {
protobuf_AssignDescriptorsOnce();
return CCLCMsg_RespondCvarValue_descriptor_;
}
const CCLCMsg_RespondCvarValue& CCLCMsg_RespondCvarValue::default_instance() {
if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
return *default_instance_;
}
CCLCMsg_RespondCvarValue* CCLCMsg_RespondCvarValue::default_instance_ = NULL;
CCLCMsg_RespondCvarValue* CCLCMsg_RespondCvarValue::New() const {
return new CCLCMsg_RespondCvarValue;
}
void CCLCMsg_RespondCvarValue::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>( \
&reinterpret_cast<CCLCMsg_RespondCvarValue*>(16)->f) - \
reinterpret_cast<char*>(16))
#define ZR_(first, last) do { \
size_t f = OFFSET_OF_FIELD_(first); \
size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \
::memset(&first, 0, n); \
} while (0)
if (_has_bits_[0 / 32] & 15) {
ZR_(cookie_, status_code_);
if (has_name()) {
if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
name_->clear();
}
}
if (has_value()) {
if (value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
value_->clear();
}
}
}
#undef OFFSET_OF_FIELD_
#undef ZR_
::memset(_has_bits_, 0, sizeof(_has_bits_));
mutable_unknown_fields()->Clear();
}
bool CCLCMsg_RespondCvarValue::MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
::google::protobuf::uint32 tag;
// @@protoc_insertion_point(parse_start:CCLCMsg_RespondCvarValue)
for (;;) {
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// optional int32 cookie = 1;
case 1: {
if (tag == 8) {
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &cookie_)));
set_has_cookie();
} else {
goto handle_unusual;
}
if (input->ExpectTag(16)) goto parse_status_code;
break;
}
// optional int32 status_code = 2;
case 2: {
if (tag == 16) {
parse_status_code:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &status_code_)));
set_has_status_code();
} else {
goto handle_unusual;
}
if (input->ExpectTag(26)) goto parse_name;
break;
}
// optional string name = 3;
case 3: {
if (tag == 26) {
parse_name:
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
input, this->mutable_name()));
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->name().data(), this->name().length(),
::google::protobuf::internal::WireFormat::PARSE,
"name");
} else {
goto handle_unusual;
}
if (input->ExpectTag(34)) goto parse_value;
break;
}
// optional string value = 4;
case 4: {
if (tag == 34) {
parse_value:
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
input, this->mutable_value()));
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->value().data(), this->value().length(),
::google::protobuf::internal::WireFormat::PARSE,
"value");
} else {
goto handle_unusual;
}
if (input->ExpectAtEnd()) goto success;
break;
}
default: {
handle_unusual:
if (tag == 0 ||
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
goto success;
}
DO_(::google::protobuf::internal::WireFormat::SkipField(
input, tag, mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:CCLCMsg_RespondCvarValue)
return true;
failure:
// @@protoc_insertion_point(parse_failure:CCLCMsg_RespondCvarValue)
return false;
#undef DO_
}
void CCLCMsg_RespondCvarValue::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:CCLCMsg_RespondCvarValue)
// optional int32 cookie = 1;
if (has_cookie()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->cookie(), output);
}
// optional int32 status_code = 2;
if (has_status_code()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->status_code(), output);
}
// optional string name = 3;
if (has_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->name().data(), this->name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"name");
::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
3, this->name(), output);
}
// optional string value = 4;
if (has_value()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->value().data(), this->value().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"value");
::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
4, this->value(), output);
}
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
}
// @@protoc_insertion_point(serialize_end:CCLCMsg_RespondCvarValue)
}
::google::protobuf::uint8* CCLCMsg_RespondCvarValue::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// @@protoc_insertion_point(serialize_to_array_start:CCLCMsg_RespondCvarValue)
// optional int32 cookie = 1;
if (has_cookie()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->cookie(), target);
}
// optional int32 status_code = 2;
if (has_status_code()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->status_code(), target);
}
// optional string name = 3;
if (has_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->name().data(), this->name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"name");
target =
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
3, this->name(), target);
}
// optional string value = 4;
if (has_value()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->value().data(), this->value().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"value");
target =
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
4, this->value(), target);
}
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
}
// @@protoc_insertion_point(serialize_to_array_end:CCLCMsg_RespondCvarValue)
return target;
}
int CCLCMsg_RespondCvarValue::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// optional int32 cookie = 1;
if (has_cookie()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->cookie());
}
// optional int32 status_code = 2;
if (has_status_code()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->status_code());
}
// optional string name = 3;
if (has_name()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::StringSize(
this->name());
}
// optional string value = 4;
if (has_value()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::StringSize(
this->value());
}
}
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 CCLCMsg_RespondCvarValue::MergeFrom(const ::google::protobuf::Message& from) {
GOOGLE_CHECK_NE(&from, this);
const CCLCMsg_RespondCvarValue* source =
::google::protobuf::internal::dynamic_cast_if_available<const CCLCMsg_RespondCvarValue*>(
&from);
if (source == NULL) {
::google::protobuf::internal::ReflectionOps::Merge(from, this);
} else {
MergeFrom(*source);
}
}
void CCLCMsg_RespondCvarValue::MergeFrom(const CCLCMsg_RespondCvarValue& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
if (from.has_cookie()) {
set_cookie(from.cookie());
}
if (from.has_status_code()) {
set_status_code(from.status_code());
}
if (from.has_name()) {
set_name(from.name());
}
if (from.has_value()) {
set_value(from.value());
}
}
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}
void CCLCMsg_RespondCvarValue::CopyFrom(const ::google::protobuf::Message& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
void CCLCMsg_RespondCvarValue::CopyFrom(const CCLCMsg_RespondCvarValue& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool CCLCMsg_RespondCvarValue::IsInitialized() const {
return true;
}
void CCLCMsg_RespondCvarValue::Swap(CCLCMsg_RespondCvarValue* other) {
if (other != this) {
std::swap(cookie_, other->cookie_);
std::swap(status_code_, other->status_code_);
std::swap(name_, other->name_);
std::swap(value_, other->value_);
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 CCLCMsg_RespondCvarValue::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
::google::protobuf::Metadata metadata;
metadata.descriptor = CCLCMsg_RespondCvarValue_descriptor_;
metadata.reflection = CCLCMsg_RespondCvarValue_reflection_;
return metadata;
}
// ===================================================================
#ifndef _MSC_VER
const int CCLCMsg_FileCRCCheck::kCodePathFieldNumber;
const int CCLCMsg_FileCRCCheck::kPathFieldNumber;
const int CCLCMsg_FileCRCCheck::kCodeFilenameFieldNumber;
const int CCLCMsg_FileCRCCheck::kFilenameFieldNumber;
const int CCLCMsg_FileCRCCheck::kCrcFieldNumber;
#endif // !_MSC_VER
CCLCMsg_FileCRCCheck::CCLCMsg_FileCRCCheck()
: ::google::protobuf::Message() {
SharedCtor();
// @@protoc_insertion_point(constructor:CCLCMsg_FileCRCCheck)
}
void CCLCMsg_FileCRCCheck::InitAsDefaultInstance() {
}
CCLCMsg_FileCRCCheck::CCLCMsg_FileCRCCheck(const CCLCMsg_FileCRCCheck& from)
: ::google::protobuf::Message() {
SharedCtor();
MergeFrom(from);
// @@protoc_insertion_point(copy_constructor:CCLCMsg_FileCRCCheck)
}
void CCLCMsg_FileCRCCheck::SharedCtor() {
::google::protobuf::internal::GetEmptyString();
_cached_size_ = 0;
code_path_ = 0;
path_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
code_filename_ = 0;
filename_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
crc_ = 0u;
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
CCLCMsg_FileCRCCheck::~CCLCMsg_FileCRCCheck() {
// @@protoc_insertion_point(destructor:CCLCMsg_FileCRCCheck)
SharedDtor();
}
void CCLCMsg_FileCRCCheck::SharedDtor() {
if (path_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
delete path_;
}
if (filename_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
delete filename_;
}
if (this != default_instance_) {
}
}
void CCLCMsg_FileCRCCheck::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CCLCMsg_FileCRCCheck::descriptor() {
protobuf_AssignDescriptorsOnce();
return CCLCMsg_FileCRCCheck_descriptor_;
}
const CCLCMsg_FileCRCCheck& CCLCMsg_FileCRCCheck::default_instance() {
if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
return *default_instance_;
}
CCLCMsg_FileCRCCheck* CCLCMsg_FileCRCCheck::default_instance_ = NULL;
CCLCMsg_FileCRCCheck* CCLCMsg_FileCRCCheck::New() const {
return new CCLCMsg_FileCRCCheck;
}
void CCLCMsg_FileCRCCheck::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>( \
&reinterpret_cast<CCLCMsg_FileCRCCheck*>(16)->f) - \
reinterpret_cast<char*>(16))
#define ZR_(first, last) do { \
size_t f = OFFSET_OF_FIELD_(first); \
size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \
::memset(&first, 0, n); \
} while (0)
if (_has_bits_[0 / 32] & 31) {
ZR_(code_path_, code_filename_);
if (has_path()) {
if (path_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
path_->clear();
}
}
if (has_filename()) {
if (filename_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
filename_->clear();
}
}
crc_ = 0u;
}
#undef OFFSET_OF_FIELD_
#undef ZR_
::memset(_has_bits_, 0, sizeof(_has_bits_));
mutable_unknown_fields()->Clear();
}
bool CCLCMsg_FileCRCCheck::MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
::google::protobuf::uint32 tag;
// @@protoc_insertion_point(parse_start:CCLCMsg_FileCRCCheck)
for (;;) {
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// optional int32 code_path = 1;
case 1: {
if (tag == 8) {
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &code_path_)));
set_has_code_path();
} else {
goto handle_unusual;
}
if (input->ExpectTag(18)) goto parse_path;
break;
}
// optional string path = 2;
case 2: {
if (tag == 18) {
parse_path:
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
input, this->mutable_path()));
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->path().data(), this->path().length(),
::google::protobuf::internal::WireFormat::PARSE,
"path");
} else {
goto handle_unusual;
}
if (input->ExpectTag(24)) goto parse_code_filename;
break;
}
// optional int32 code_filename = 3;
case 3: {
if (tag == 24) {
parse_code_filename:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &code_filename_)));
set_has_code_filename();
} else {
goto handle_unusual;
}
if (input->ExpectTag(34)) goto parse_filename;
break;
}
// optional string filename = 4;
case 4: {
if (tag == 34) {
parse_filename:
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
input, this->mutable_filename()));
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->filename().data(), this->filename().length(),
::google::protobuf::internal::WireFormat::PARSE,
"filename");
} else {
goto handle_unusual;
}
if (input->ExpectTag(45)) goto parse_crc;
break;
}
// optional fixed32 crc = 5;
case 5: {
if (tag == 45) {
parse_crc:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &crc_)));
set_has_crc();
} else {
goto handle_unusual;
}
if (input->ExpectAtEnd()) goto success;
break;
}
default: {
handle_unusual:
if (tag == 0 ||
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
goto success;
}
DO_(::google::protobuf::internal::WireFormat::SkipField(
input, tag, mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:CCLCMsg_FileCRCCheck)
return true;
failure:
// @@protoc_insertion_point(parse_failure:CCLCMsg_FileCRCCheck)
return false;
#undef DO_
}
void CCLCMsg_FileCRCCheck::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:CCLCMsg_FileCRCCheck)
// optional int32 code_path = 1;
if (has_code_path()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->code_path(), output);
}
// optional string path = 2;
if (has_path()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->path().data(), this->path().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"path");
::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
2, this->path(), output);
}
// optional int32 code_filename = 3;
if (has_code_filename()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->code_filename(), output);
}
// optional string filename = 4;
if (has_filename()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->filename().data(), this->filename().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"filename");
::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
4, this->filename(), output);
}
// optional fixed32 crc = 5;
if (has_crc()) {
::google::protobuf::internal::WireFormatLite::WriteFixed32(5, this->crc(), output);
}
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
}
// @@protoc_insertion_point(serialize_end:CCLCMsg_FileCRCCheck)
}
::google::protobuf::uint8* CCLCMsg_FileCRCCheck::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// @@protoc_insertion_point(serialize_to_array_start:CCLCMsg_FileCRCCheck)
// optional int32 code_path = 1;
if (has_code_path()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->code_path(), target);
}
// optional string path = 2;
if (has_path()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->path().data(), this->path().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"path");
target =
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2, this->path(), target);
}
// optional int32 code_filename = 3;
if (has_code_filename()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->code_filename(), target);
}
// optional string filename = 4;
if (has_filename()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->filename().data(), this->filename().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"filename");
target =
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
4, this->filename(), target);
}
// optional fixed32 crc = 5;
if (has_crc()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(5, this->crc(), target);
}
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
}
// @@protoc_insertion_point(serialize_to_array_end:CCLCMsg_FileCRCCheck)
return target;
}
int CCLCMsg_FileCRCCheck::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// optional int32 code_path = 1;
if (has_code_path()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->code_path());
}
// optional string path = 2;
if (has_path()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::StringSize(
this->path());
}
// optional int32 code_filename = 3;
if (has_code_filename()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->code_filename());
}
// optional string filename = 4;
if (has_filename()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::StringSize(
this->filename());
}
// optional fixed32 crc = 5;
if (has_crc()) {
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 CCLCMsg_FileCRCCheck::MergeFrom(const ::google::protobuf::Message& from) {
GOOGLE_CHECK_NE(&from, this);
const CCLCMsg_FileCRCCheck* source =
::google::protobuf::internal::dynamic_cast_if_available<const CCLCMsg_FileCRCCheck*>(
&from);
if (source == NULL) {
::google::protobuf::internal::ReflectionOps::Merge(from, this);
} else {
MergeFrom(*source);
}
}
void CCLCMsg_FileCRCCheck::MergeFrom(const CCLCMsg_FileCRCCheck& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
if (from.has_code_path()) {
set_code_path(from.code_path());
}
if (from.has_path()) {
set_path(from.path());
}
if (from.has_code_filename()) {
set_code_filename(from.code_filename());
}
if (from.has_filename()) {
set_filename(from.filename());
}
if (from.has_crc()) {
set_crc(from.crc());
}
}
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}
void CCLCMsg_FileCRCCheck::CopyFrom(const ::google::protobuf::Message& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
void CCLCMsg_FileCRCCheck::CopyFrom(const CCLCMsg_FileCRCCheck& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool CCLCMsg_FileCRCCheck::IsInitialized() const {
return true;
}
void CCLCMsg_FileCRCCheck::Swap(CCLCMsg_FileCRCCheck* other) {
if (other != this) {
std::swap(code_path_, other->code_path_);
std::swap(path_, other->path_);
std::swap(code_filename_, other->code_filename_);
std::swap(filename_, other->filename_);
std::swap(crc_, other->crc_);
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 CCLCMsg_FileCRCCheck::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
::google::protobuf::Metadata metadata;
metadata.descriptor = CCLCMsg_FileCRCCheck_descriptor_;
metadata.reflection = CCLCMsg_FileCRCCheck_reflection_;
return metadata;
}
// ===================================================================
#ifndef _MSC_VER
const int CCLCMsg_LoadingProgress::kProgressFieldNumber;
#endif // !_MSC_VER
CCLCMsg_LoadingProgress::CCLCMsg_LoadingProgress()
: ::google::protobuf::Message() {
SharedCtor();
// @@protoc_insertion_point(constructor:CCLCMsg_LoadingProgress)
}
void CCLCMsg_LoadingProgress::InitAsDefaultInstance() {
}
CCLCMsg_LoadingProgress::CCLCMsg_LoadingProgress(const CCLCMsg_LoadingProgress& from)
: ::google::protobuf::Message() {
SharedCtor();
MergeFrom(from);
// @@protoc_insertion_point(copy_constructor:CCLCMsg_LoadingProgress)
}
void CCLCMsg_LoadingProgress::SharedCtor() {
_cached_size_ = 0;
progress_ = 0;
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
CCLCMsg_LoadingProgress::~CCLCMsg_LoadingProgress() {
// @@protoc_insertion_point(destructor:CCLCMsg_LoadingProgress)
SharedDtor();
}
void CCLCMsg_LoadingProgress::SharedDtor() {
if (this != default_instance_) {
}
}
void CCLCMsg_LoadingProgress::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CCLCMsg_LoadingProgress::descriptor() {
protobuf_AssignDescriptorsOnce();
return CCLCMsg_LoadingProgress_descriptor_;
}
const CCLCMsg_LoadingProgress& CCLCMsg_LoadingProgress::default_instance() {
if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
return *default_instance_;
}
CCLCMsg_LoadingProgress* CCLCMsg_LoadingProgress::default_instance_ = NULL;
CCLCMsg_LoadingProgress* CCLCMsg_LoadingProgress::New() const {
return new CCLCMsg_LoadingProgress;
}
void CCLCMsg_LoadingProgress::Clear() {
progress_ = 0;
::memset(_has_bits_, 0, sizeof(_has_bits_));
mutable_unknown_fields()->Clear();
}
bool CCLCMsg_LoadingProgress::MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
::google::protobuf::uint32 tag;
// @@protoc_insertion_point(parse_start:CCLCMsg_LoadingProgress)
for (;;) {
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// optional int32 progress = 1;
case 1: {
if (tag == 8) {
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &progress_)));
set_has_progress();
} else {
goto handle_unusual;
}
if (input->ExpectAtEnd()) goto success;
break;
}
default: {
handle_unusual:
if (tag == 0 ||
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
goto success;
}
DO_(::google::protobuf::internal::WireFormat::SkipField(
input, tag, mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:CCLCMsg_LoadingProgress)
return true;
failure:
// @@protoc_insertion_point(parse_failure:CCLCMsg_LoadingProgress)
return false;
#undef DO_
}
void CCLCMsg_LoadingProgress::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:CCLCMsg_LoadingProgress)
// optional int32 progress = 1;
if (has_progress()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->progress(), output);
}
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
}
// @@protoc_insertion_point(serialize_end:CCLCMsg_LoadingProgress)
}
::google::protobuf::uint8* CCLCMsg_LoadingProgress::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// @@protoc_insertion_point(serialize_to_array_start:CCLCMsg_LoadingProgress)
// optional int32 progress = 1;
if (has_progress()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->progress(), target);
}
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
}
// @@protoc_insertion_point(serialize_to_array_end:CCLCMsg_LoadingProgress)
return target;
}
int CCLCMsg_LoadingProgress::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// optional int32 progress = 1;
if (has_progress()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->progress());
}
}
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 CCLCMsg_LoadingProgress::MergeFrom(const ::google::protobuf::Message& from) {
GOOGLE_CHECK_NE(&from, this);
const CCLCMsg_LoadingProgress* source =
::google::protobuf::internal::dynamic_cast_if_available<const CCLCMsg_LoadingProgress*>(
&from);
if (source == NULL) {
::google::protobuf::internal::ReflectionOps::Merge(from, this);
} else {
MergeFrom(*source);
}
}
void CCLCMsg_LoadingProgress::MergeFrom(const CCLCMsg_LoadingProgress& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
if (from.has_progress()) {
set_progress(from.progress());
}
}
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}
void CCLCMsg_LoadingProgress::CopyFrom(const ::google::protobuf::Message& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
void CCLCMsg_LoadingProgress::CopyFrom(const CCLCMsg_LoadingProgress& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool CCLCMsg_LoadingProgress::IsInitialized() const {
return true;
}
void CCLCMsg_LoadingProgress::Swap(CCLCMsg_LoadingProgress* other) {
if (other != this) {
std::swap(progress_, other->progress_);
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 CCLCMsg_LoadingProgress::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
::google::protobuf::Metadata metadata;
metadata.descriptor = CCLCMsg_LoadingProgress_descriptor_;
metadata.reflection = CCLCMsg_LoadingProgress_reflection_;
return metadata;
}
// ===================================================================
#ifndef _MSC_VER
const int CCLCMsg_SplitPlayerConnect::kConvarsFieldNumber;
#endif // !_MSC_VER
CCLCMsg_SplitPlayerConnect::CCLCMsg_SplitPlayerConnect()
: ::google::protobuf::Message() {
SharedCtor();
// @@protoc_insertion_point(constructor:CCLCMsg_SplitPlayerConnect)
}
void CCLCMsg_SplitPlayerConnect::InitAsDefaultInstance() {
convars_ = const_cast< ::CMsg_CVars*>(&::CMsg_CVars::default_instance());
}
CCLCMsg_SplitPlayerConnect::CCLCMsg_SplitPlayerConnect(const CCLCMsg_SplitPlayerConnect& from)
: ::google::protobuf::Message() {
SharedCtor();
MergeFrom(from);
// @@protoc_insertion_point(copy_constructor:CCLCMsg_SplitPlayerConnect)
}
void CCLCMsg_SplitPlayerConnect::SharedCtor() {
_cached_size_ = 0;
convars_ = NULL;
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
CCLCMsg_SplitPlayerConnect::~CCLCMsg_SplitPlayerConnect() {
// @@protoc_insertion_point(destructor:CCLCMsg_SplitPlayerConnect)
SharedDtor();
}
void CCLCMsg_SplitPlayerConnect::SharedDtor() {
if (this != default_instance_) {
delete convars_;
}
}
void CCLCMsg_SplitPlayerConnect::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CCLCMsg_SplitPlayerConnect::descriptor() {
protobuf_AssignDescriptorsOnce();
return CCLCMsg_SplitPlayerConnect_descriptor_;
}
const CCLCMsg_SplitPlayerConnect& CCLCMsg_SplitPlayerConnect::default_instance() {
if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
return *default_instance_;
}
CCLCMsg_SplitPlayerConnect* CCLCMsg_SplitPlayerConnect::default_instance_ = NULL;
CCLCMsg_SplitPlayerConnect* CCLCMsg_SplitPlayerConnect::New() const {
return new CCLCMsg_SplitPlayerConnect;
}
void CCLCMsg_SplitPlayerConnect::Clear() {
if (has_convars()) {
if (convars_ != NULL) convars_->::CMsg_CVars::Clear();
}
::memset(_has_bits_, 0, sizeof(_has_bits_));
mutable_unknown_fields()->Clear();
}
bool CCLCMsg_SplitPlayerConnect::MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
::google::protobuf::uint32 tag;
// @@protoc_insertion_point(parse_start:CCLCMsg_SplitPlayerConnect)
for (;;) {
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// optional .CMsg_CVars convars = 1;
case 1: {
if (tag == 10) {
DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
input, mutable_convars()));
} else {
goto handle_unusual;
}
if (input->ExpectAtEnd()) goto success;
break;
}
default: {
handle_unusual:
if (tag == 0 ||
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
goto success;
}
DO_(::google::protobuf::internal::WireFormat::SkipField(
input, tag, mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:CCLCMsg_SplitPlayerConnect)
return true;
failure:
// @@protoc_insertion_point(parse_failure:CCLCMsg_SplitPlayerConnect)
return false;
#undef DO_
}
void CCLCMsg_SplitPlayerConnect::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:CCLCMsg_SplitPlayerConnect)
// optional .CMsg_CVars convars = 1;
if (has_convars()) {
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1, this->convars(), output);
}
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
}
// @@protoc_insertion_point(serialize_end:CCLCMsg_SplitPlayerConnect)
}
::google::protobuf::uint8* CCLCMsg_SplitPlayerConnect::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// @@protoc_insertion_point(serialize_to_array_start:CCLCMsg_SplitPlayerConnect)
// optional .CMsg_CVars convars = 1;
if (has_convars()) {
target = ::google::protobuf::internal::WireFormatLite::
WriteMessageNoVirtualToArray(
1, this->convars(), target);
}
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
}
// @@protoc_insertion_point(serialize_to_array_end:CCLCMsg_SplitPlayerConnect)
return target;
}
int CCLCMsg_SplitPlayerConnect::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// optional .CMsg_CVars convars = 1;
if (has_convars()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
this->convars());
}
}
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 CCLCMsg_SplitPlayerConnect::MergeFrom(const ::google::protobuf::Message& from) {
GOOGLE_CHECK_NE(&from, this);
const CCLCMsg_SplitPlayerConnect* source =
::google::protobuf::internal::dynamic_cast_if_available<const CCLCMsg_SplitPlayerConnect*>(
&from);
if (source == NULL) {
::google::protobuf::internal::ReflectionOps::Merge(from, this);
} else {
MergeFrom(*source);
}
}
void CCLCMsg_SplitPlayerConnect::MergeFrom(const CCLCMsg_SplitPlayerConnect& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
if (from.has_convars()) {
mutable_convars()->::CMsg_CVars::MergeFrom(from.convars());
}
}
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}
void CCLCMsg_SplitPlayerConnect::CopyFrom(const ::google::protobuf::Message& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
void CCLCMsg_SplitPlayerConnect::CopyFrom(const CCLCMsg_SplitPlayerConnect& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool CCLCMsg_SplitPlayerConnect::IsInitialized() const {
return true;
}
void CCLCMsg_SplitPlayerConnect::Swap(CCLCMsg_SplitPlayerConnect* other) {
if (other != this) {
std::swap(convars_, other->convars_);
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 CCLCMsg_SplitPlayerConnect::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
::google::protobuf::Metadata metadata;
metadata.descriptor = CCLCMsg_SplitPlayerConnect_descriptor_;
metadata.reflection = CCLCMsg_SplitPlayerConnect_reflection_;
return metadata;
}
// ===================================================================
#ifndef _MSC_VER
const int CCLCMsg_ClientMessage::kMsgTypeFieldNumber;
const int CCLCMsg_ClientMessage::kDataFieldNumber;
#endif // !_MSC_VER
CCLCMsg_ClientMessage::CCLCMsg_ClientMessage()
: ::google::protobuf::Message() {
SharedCtor();
// @@protoc_insertion_point(constructor:CCLCMsg_ClientMessage)
}
void CCLCMsg_ClientMessage::InitAsDefaultInstance() {
}
CCLCMsg_ClientMessage::CCLCMsg_ClientMessage(const CCLCMsg_ClientMessage& from)
: ::google::protobuf::Message() {
SharedCtor();
MergeFrom(from);
// @@protoc_insertion_point(copy_constructor:CCLCMsg_ClientMessage)
}
void CCLCMsg_ClientMessage::SharedCtor() {
::google::protobuf::internal::GetEmptyString();
_cached_size_ = 0;
msg_type_ = 0;
data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
CCLCMsg_ClientMessage::~CCLCMsg_ClientMessage() {
// @@protoc_insertion_point(destructor:CCLCMsg_ClientMessage)
SharedDtor();
}
void CCLCMsg_ClientMessage::SharedDtor() {
if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
delete data_;
}
if (this != default_instance_) {
}
}
void CCLCMsg_ClientMessage::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CCLCMsg_ClientMessage::descriptor() {
protobuf_AssignDescriptorsOnce();
return CCLCMsg_ClientMessage_descriptor_;
}
const CCLCMsg_ClientMessage& CCLCMsg_ClientMessage::default_instance() {
if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
return *default_instance_;
}
CCLCMsg_ClientMessage* CCLCMsg_ClientMessage::default_instance_ = NULL;
CCLCMsg_ClientMessage* CCLCMsg_ClientMessage::New() const {
return new CCLCMsg_ClientMessage;
}
void CCLCMsg_ClientMessage::Clear() {
if (_has_bits_[0 / 32] & 3) {
msg_type_ = 0;
if (has_data()) {
if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
data_->clear();
}
}
}
::memset(_has_bits_, 0, sizeof(_has_bits_));
mutable_unknown_fields()->Clear();
}
bool CCLCMsg_ClientMessage::MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
::google::protobuf::uint32 tag;
// @@protoc_insertion_point(parse_start:CCLCMsg_ClientMessage)
for (;;) {
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// optional int32 msg_type = 1;
case 1: {
if (tag == 8) {
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &msg_type_)));
set_has_msg_type();
} else {
goto handle_unusual;
}
if (input->ExpectTag(18)) goto parse_data;
break;
}
// optional bytes data = 2;
case 2: {
if (tag == 18) {
parse_data:
DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
input, this->mutable_data()));
} else {
goto handle_unusual;
}
if (input->ExpectAtEnd()) goto success;
break;
}
default: {
handle_unusual:
if (tag == 0 ||
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
goto success;
}
DO_(::google::protobuf::internal::WireFormat::SkipField(
input, tag, mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:CCLCMsg_ClientMessage)
return true;
failure:
// @@protoc_insertion_point(parse_failure:CCLCMsg_ClientMessage)
return false;
#undef DO_
}
void CCLCMsg_ClientMessage::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:CCLCMsg_ClientMessage)
// optional int32 msg_type = 1;
if (has_msg_type()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->msg_type(), output);
}
// optional bytes data = 2;
if (has_data()) {
::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
2, this->data(), output);
}
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
}
// @@protoc_insertion_point(serialize_end:CCLCMsg_ClientMessage)
}
::google::protobuf::uint8* CCLCMsg_ClientMessage::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// @@protoc_insertion_point(serialize_to_array_start:CCLCMsg_ClientMessage)
// optional int32 msg_type = 1;
if (has_msg_type()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->msg_type(), target);
}
// optional bytes data = 2;
if (has_data()) {
target =
::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
2, this->data(), target);
}
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
}
// @@protoc_insertion_point(serialize_to_array_end:CCLCMsg_ClientMessage)
return target;
}
int CCLCMsg_ClientMessage::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// optional int32 msg_type = 1;
if (has_msg_type()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->msg_type());
}
// optional bytes data = 2;
if (has_data()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::BytesSize(
this->data());
}
}
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 CCLCMsg_ClientMessage::MergeFrom(const ::google::protobuf::Message& from) {
GOOGLE_CHECK_NE(&from, this);
const CCLCMsg_ClientMessage* source =
::google::protobuf::internal::dynamic_cast_if_available<const CCLCMsg_ClientMessage*>(
&from);
if (source == NULL) {
::google::protobuf::internal::ReflectionOps::Merge(from, this);
} else {
MergeFrom(*source);
}
}
void CCLCMsg_ClientMessage::MergeFrom(const CCLCMsg_ClientMessage& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
if (from.has_msg_type()) {
set_msg_type(from.msg_type());
}
if (from.has_data()) {
set_data(from.data());
}
}
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}
void CCLCMsg_ClientMessage::CopyFrom(const ::google::protobuf::Message& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
void CCLCMsg_ClientMessage::CopyFrom(const CCLCMsg_ClientMessage& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool CCLCMsg_ClientMessage::IsInitialized() const {
return true;
}
void CCLCMsg_ClientMessage::Swap(CCLCMsg_ClientMessage* other) {
if (other != this) {
std::swap(msg_type_, other->msg_type_);
std::swap(data_, other->data_);
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 CCLCMsg_ClientMessage::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
::google::protobuf::Metadata metadata;
metadata.descriptor = CCLCMsg_ClientMessage_descriptor_;
metadata.reflection = CCLCMsg_ClientMessage_reflection_;
return metadata;
}
// ===================================================================
#ifndef _MSC_VER
const int CSVCMsg_ServerInfo::kProtocolFieldNumber;
const int CSVCMsg_ServerInfo::kServerCountFieldNumber;
const int CSVCMsg_ServerInfo::kIsDedicatedFieldNumber;
const int CSVCMsg_ServerInfo::kIsHltvFieldNumber;
const int CSVCMsg_ServerInfo::kIsReplayFieldNumber;
const int CSVCMsg_ServerInfo::kCOsFieldNumber;
const int CSVCMsg_ServerInfo::kMapCrcFieldNumber;
const int CSVCMsg_ServerInfo::kClientCrcFieldNumber;
const int CSVCMsg_ServerInfo::kStringTableCrcFieldNumber;
const int CSVCMsg_ServerInfo::kMaxClientsFieldNumber;
const int CSVCMsg_ServerInfo::kMaxClassesFieldNumber;
const int CSVCMsg_ServerInfo::kPlayerSlotFieldNumber;
const int CSVCMsg_ServerInfo::kTickIntervalFieldNumber;
const int CSVCMsg_ServerInfo::kGameDirFieldNumber;
const int CSVCMsg_ServerInfo::kMapNameFieldNumber;
const int CSVCMsg_ServerInfo::kSkyNameFieldNumber;
const int CSVCMsg_ServerInfo::kHostNameFieldNumber;
const int CSVCMsg_ServerInfo::kAddonNameFieldNumber;
#endif // !_MSC_VER
CSVCMsg_ServerInfo::CSVCMsg_ServerInfo()
: ::google::protobuf::Message() {
SharedCtor();
// @@protoc_insertion_point(constructor:CSVCMsg_ServerInfo)
}
void CSVCMsg_ServerInfo::InitAsDefaultInstance() {
}
CSVCMsg_ServerInfo::CSVCMsg_ServerInfo(const CSVCMsg_ServerInfo& from)
: ::google::protobuf::Message() {
SharedCtor();
MergeFrom(from);
// @@protoc_insertion_point(copy_constructor:CSVCMsg_ServerInfo)
}
void CSVCMsg_ServerInfo::SharedCtor() {
::google::protobuf::internal::GetEmptyString();
_cached_size_ = 0;
protocol_ = 0;
server_count_ = 0;
is_dedicated_ = false;
is_hltv_ = false;
is_replay_ = false;
c_os_ = 0;
map_crc_ = 0u;
client_crc_ = 0u;
string_table_crc_ = 0u;
max_clients_ = 0;
max_classes_ = 0;
player_slot_ = 0;
tick_interval_ = 0;
game_dir_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
map_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
sky_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
host_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
addon_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
CSVCMsg_ServerInfo::~CSVCMsg_ServerInfo() {
// @@protoc_insertion_point(destructor:CSVCMsg_ServerInfo)
SharedDtor();
}
void CSVCMsg_ServerInfo::SharedDtor() {
if (game_dir_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
delete game_dir_;
}
if (map_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
delete map_name_;
}
if (sky_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
delete sky_name_;
}
if (host_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
delete host_name_;
}
if (addon_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
delete addon_name_;
}
if (this != default_instance_) {
}
}
void CSVCMsg_ServerInfo::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_ServerInfo::descriptor() {
protobuf_AssignDescriptorsOnce();
return CSVCMsg_ServerInfo_descriptor_;
}
const CSVCMsg_ServerInfo& CSVCMsg_ServerInfo::default_instance() {
if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
return *default_instance_;
}
CSVCMsg_ServerInfo* CSVCMsg_ServerInfo::default_instance_ = NULL;
CSVCMsg_ServerInfo* CSVCMsg_ServerInfo::New() const {
return new CSVCMsg_ServerInfo;
}
void CSVCMsg_ServerInfo::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>( \
&reinterpret_cast<CSVCMsg_ServerInfo*>(16)->f) - \
reinterpret_cast<char*>(16))
#define ZR_(first, last) do { \
size_t f = OFFSET_OF_FIELD_(first); \
size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \
::memset(&first, 0, n); \
} while (0)
if (_has_bits_[0 / 32] & 255) {
ZR_(protocol_, client_crc_);
}
if (_has_bits_[8 / 32] & 65280) {
ZR_(string_table_crc_, player_slot_);
tick_interval_ = 0;
if (has_game_dir()) {
if (game_dir_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
game_dir_->clear();
}
}
if (has_map_name()) {
if (map_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
map_name_->clear();
}
}
if (has_sky_name()) {
if (sky_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
sky_name_->clear();
}
}
}
if (_has_bits_[16 / 32] & 196608) {
if (has_host_name()) {
if (host_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
host_name_->clear();
}
}
if (has_addon_name()) {
if (addon_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
addon_name_->clear();
}
}
}
#undef OFFSET_OF_FIELD_
#undef ZR_
::memset(_has_bits_, 0, sizeof(_has_bits_));
mutable_unknown_fields()->Clear();
}
bool CSVCMsg_ServerInfo::MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
::google::protobuf::uint32 tag;
// @@protoc_insertion_point(parse_start:CSVCMsg_ServerInfo)
for (;;) {
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(16383);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// optional int32 protocol = 1;
case 1: {
if (tag == 8) {
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &protocol_)));
set_has_protocol();
} else {
goto handle_unusual;
}
if (input->ExpectTag(16)) goto parse_server_count;
break;
}
// optional int32 server_count = 2;
case 2: {
if (tag == 16) {
parse_server_count:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &server_count_)));
set_has_server_count();
} else {
goto handle_unusual;
}
if (input->ExpectTag(24)) goto parse_is_dedicated;
break;
}
// optional bool is_dedicated = 3;
case 3: {
if (tag == 24) {
parse_is_dedicated:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
input, &is_dedicated_)));
set_has_is_dedicated();
} else {
goto handle_unusual;
}
if (input->ExpectTag(32)) goto parse_is_hltv;
break;
}
// optional bool is_hltv = 4;
case 4: {
if (tag == 32) {
parse_is_hltv:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
input, &is_hltv_)));
set_has_is_hltv();
} else {
goto handle_unusual;
}
if (input->ExpectTag(40)) goto parse_is_replay;
break;
}
// optional bool is_replay = 5;
case 5: {
if (tag == 40) {
parse_is_replay:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
input, &is_replay_)));
set_has_is_replay();
} else {
goto handle_unusual;
}
if (input->ExpectTag(48)) goto parse_c_os;
break;
}
// optional int32 c_os = 6;
case 6: {
if (tag == 48) {
parse_c_os:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &c_os_)));
set_has_c_os();
} else {
goto handle_unusual;
}
if (input->ExpectTag(61)) goto parse_map_crc;
break;
}
// optional fixed32 map_crc = 7;
case 7: {
if (tag == 61) {
parse_map_crc:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &map_crc_)));
set_has_map_crc();
} else {
goto handle_unusual;
}
if (input->ExpectTag(69)) goto parse_client_crc;
break;
}
// optional fixed32 client_crc = 8;
case 8: {
if (tag == 69) {
parse_client_crc:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &client_crc_)));
set_has_client_crc();
} else {
goto handle_unusual;
}
if (input->ExpectTag(77)) goto parse_string_table_crc;
break;
}
// optional fixed32 string_table_crc = 9;
case 9: {
if (tag == 77) {
parse_string_table_crc:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &string_table_crc_)));
set_has_string_table_crc();
} else {
goto handle_unusual;
}
if (input->ExpectTag(80)) goto parse_max_clients;
break;
}
// optional int32 max_clients = 10;
case 10: {
if (tag == 80) {
parse_max_clients:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &max_clients_)));
set_has_max_clients();
} else {
goto handle_unusual;
}
if (input->ExpectTag(88)) goto parse_max_classes;
break;
}
// optional int32 max_classes = 11;
case 11: {
if (tag == 88) {
parse_max_classes:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &max_classes_)));
set_has_max_classes();
} else {
goto handle_unusual;
}
if (input->ExpectTag(96)) goto parse_player_slot;
break;
}
// optional int32 player_slot = 12;
case 12: {
if (tag == 96) {
parse_player_slot:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &player_slot_)));
set_has_player_slot();
} else {
goto handle_unusual;
}
if (input->ExpectTag(109)) goto parse_tick_interval;
break;
}
// optional float tick_interval = 13;
case 13: {
if (tag == 109) {
parse_tick_interval:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
input, &tick_interval_)));
set_has_tick_interval();
} else {
goto handle_unusual;
}
if (input->ExpectTag(114)) goto parse_game_dir;
break;
}
// optional string game_dir = 14;
case 14: {
if (tag == 114) {
parse_game_dir:
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
input, this->mutable_game_dir()));
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->game_dir().data(), this->game_dir().length(),
::google::protobuf::internal::WireFormat::PARSE,
"game_dir");
} else {
goto handle_unusual;
}
if (input->ExpectTag(122)) goto parse_map_name;
break;
}
// optional string map_name = 15;
case 15: {
if (tag == 122) {
parse_map_name:
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
input, this->mutable_map_name()));
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->map_name().data(), this->map_name().length(),
::google::protobuf::internal::WireFormat::PARSE,
"map_name");
} else {
goto handle_unusual;
}
if (input->ExpectTag(130)) goto parse_sky_name;
break;
}
// optional string sky_name = 16;
case 16: {
if (tag == 130) {
parse_sky_name:
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
input, this->mutable_sky_name()));
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->sky_name().data(), this->sky_name().length(),
::google::protobuf::internal::WireFormat::PARSE,
"sky_name");
} else {
goto handle_unusual;
}
if (input->ExpectTag(138)) goto parse_host_name;
break;
}
// optional string host_name = 17;
case 17: {
if (tag == 138) {
parse_host_name:
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
input, this->mutable_host_name()));
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->host_name().data(), this->host_name().length(),
::google::protobuf::internal::WireFormat::PARSE,
"host_name");
} else {
goto handle_unusual;
}
if (input->ExpectTag(146)) goto parse_addon_name;
break;
}
// optional string addon_name = 18;
case 18: {
if (tag == 146) {
parse_addon_name:
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
input, this->mutable_addon_name()));
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->addon_name().data(), this->addon_name().length(),
::google::protobuf::internal::WireFormat::PARSE,
"addon_name");
} else {
goto handle_unusual;
}
if (input->ExpectAtEnd()) goto success;
break;
}
default: {
handle_unusual:
if (tag == 0 ||
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
goto success;
}
DO_(::google::protobuf::internal::WireFormat::SkipField(
input, tag, mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:CSVCMsg_ServerInfo)
return true;
failure:
// @@protoc_insertion_point(parse_failure:CSVCMsg_ServerInfo)
return false;
#undef DO_
}
void CSVCMsg_ServerInfo::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:CSVCMsg_ServerInfo)
// optional int32 protocol = 1;
if (has_protocol()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->protocol(), output);
}
// optional int32 server_count = 2;
if (has_server_count()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->server_count(), output);
}
// optional bool is_dedicated = 3;
if (has_is_dedicated()) {
::google::protobuf::internal::WireFormatLite::WriteBool(3, this->is_dedicated(), output);
}
// optional bool is_hltv = 4;
if (has_is_hltv()) {
::google::protobuf::internal::WireFormatLite::WriteBool(4, this->is_hltv(), output);
}
// optional bool is_replay = 5;
if (has_is_replay()) {
::google::protobuf::internal::WireFormatLite::WriteBool(5, this->is_replay(), output);
}
// optional int32 c_os = 6;
if (has_c_os()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->c_os(), output);
}
// optional fixed32 map_crc = 7;
if (has_map_crc()) {
::google::protobuf::internal::WireFormatLite::WriteFixed32(7, this->map_crc(), output);
}
// optional fixed32 client_crc = 8;
if (has_client_crc()) {
::google::protobuf::internal::WireFormatLite::WriteFixed32(8, this->client_crc(), output);
}
// optional fixed32 string_table_crc = 9;
if (has_string_table_crc()) {
::google::protobuf::internal::WireFormatLite::WriteFixed32(9, this->string_table_crc(), output);
}
// optional int32 max_clients = 10;
if (has_max_clients()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(10, this->max_clients(), output);
}
// optional int32 max_classes = 11;
if (has_max_classes()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(11, this->max_classes(), output);
}
// optional int32 player_slot = 12;
if (has_player_slot()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(12, this->player_slot(), output);
}
// optional float tick_interval = 13;
if (has_tick_interval()) {
::google::protobuf::internal::WireFormatLite::WriteFloat(13, this->tick_interval(), output);
}
// optional string game_dir = 14;
if (has_game_dir()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->game_dir().data(), this->game_dir().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"game_dir");
::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
14, this->game_dir(), output);
}
// optional string map_name = 15;
if (has_map_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->map_name().data(), this->map_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"map_name");
::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
15, this->map_name(), output);
}
// optional string sky_name = 16;
if (has_sky_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->sky_name().data(), this->sky_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"sky_name");
::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
16, this->sky_name(), output);
}
// optional string host_name = 17;
if (has_host_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->host_name().data(), this->host_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"host_name");
::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
17, this->host_name(), output);
}
// optional string addon_name = 18;
if (has_addon_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->addon_name().data(), this->addon_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"addon_name");
::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
18, this->addon_name(), output);
}
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
}
// @@protoc_insertion_point(serialize_end:CSVCMsg_ServerInfo)
}
::google::protobuf::uint8* CSVCMsg_ServerInfo::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_ServerInfo)
// optional int32 protocol = 1;
if (has_protocol()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->protocol(), target);
}
// optional int32 server_count = 2;
if (has_server_count()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->server_count(), target);
}
// optional bool is_dedicated = 3;
if (has_is_dedicated()) {
target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->is_dedicated(), target);
}
// optional bool is_hltv = 4;
if (has_is_hltv()) {
target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->is_hltv(), target);
}
// optional bool is_replay = 5;
if (has_is_replay()) {
target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->is_replay(), target);
}
// optional int32 c_os = 6;
if (has_c_os()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(6, this->c_os(), target);
}
// optional fixed32 map_crc = 7;
if (has_map_crc()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(7, this->map_crc(), target);
}
// optional fixed32 client_crc = 8;
if (has_client_crc()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(8, this->client_crc(), target);
}
// optional fixed32 string_table_crc = 9;
if (has_string_table_crc()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(9, this->string_table_crc(), target);
}
// optional int32 max_clients = 10;
if (has_max_clients()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(10, this->max_clients(), target);
}
// optional int32 max_classes = 11;
if (has_max_classes()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(11, this->max_classes(), target);
}
// optional int32 player_slot = 12;
if (has_player_slot()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(12, this->player_slot(), target);
}
// optional float tick_interval = 13;
if (has_tick_interval()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(13, this->tick_interval(), target);
}
// optional string game_dir = 14;
if (has_game_dir()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->game_dir().data(), this->game_dir().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"game_dir");
target =
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
14, this->game_dir(), target);
}
// optional string map_name = 15;
if (has_map_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->map_name().data(), this->map_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"map_name");
target =
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
15, this->map_name(), target);
}
// optional string sky_name = 16;
if (has_sky_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->sky_name().data(), this->sky_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"sky_name");
target =
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
16, this->sky_name(), target);
}
// optional string host_name = 17;
if (has_host_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->host_name().data(), this->host_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"host_name");
target =
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
17, this->host_name(), target);
}
// optional string addon_name = 18;
if (has_addon_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->addon_name().data(), this->addon_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"addon_name");
target =
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
18, this->addon_name(), target);
}
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
}
// @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_ServerInfo)
return target;
}
int CSVCMsg_ServerInfo::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// optional int32 protocol = 1;
if (has_protocol()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->protocol());
}
// optional int32 server_count = 2;
if (has_server_count()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->server_count());
}
// optional bool is_dedicated = 3;
if (has_is_dedicated()) {
total_size += 1 + 1;
}
// optional bool is_hltv = 4;
if (has_is_hltv()) {
total_size += 1 + 1;
}
// optional bool is_replay = 5;
if (has_is_replay()) {
total_size += 1 + 1;
}
// optional int32 c_os = 6;
if (has_c_os()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->c_os());
}
// optional fixed32 map_crc = 7;
if (has_map_crc()) {
total_size += 1 + 4;
}
// optional fixed32 client_crc = 8;
if (has_client_crc()) {
total_size += 1 + 4;
}
}
if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
// optional fixed32 string_table_crc = 9;
if (has_string_table_crc()) {
total_size += 1 + 4;
}
// optional int32 max_clients = 10;
if (has_max_clients()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->max_clients());
}
// optional int32 max_classes = 11;
if (has_max_classes()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->max_classes());
}
// optional int32 player_slot = 12;
if (has_player_slot()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->player_slot());
}
// optional float tick_interval = 13;
if (has_tick_interval()) {
total_size += 1 + 4;
}
// optional string game_dir = 14;
if (has_game_dir()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::StringSize(
this->game_dir());
}
// optional string map_name = 15;
if (has_map_name()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::StringSize(
this->map_name());
}
// optional string sky_name = 16;
if (has_sky_name()) {
total_size += 2 +
::google::protobuf::internal::WireFormatLite::StringSize(
this->sky_name());
}
}
if (_has_bits_[16 / 32] & (0xffu << (16 % 32))) {
// optional string host_name = 17;
if (has_host_name()) {
total_size += 2 +
::google::protobuf::internal::WireFormatLite::StringSize(
this->host_name());
}
// optional string addon_name = 18;
if (has_addon_name()) {
total_size += 2 +
::google::protobuf::internal::WireFormatLite::StringSize(
this->addon_name());
}
}
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 CSVCMsg_ServerInfo::MergeFrom(const ::google::protobuf::Message& from) {
GOOGLE_CHECK_NE(&from, this);
const CSVCMsg_ServerInfo* source =
::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_ServerInfo*>(
&from);
if (source == NULL) {
::google::protobuf::internal::ReflectionOps::Merge(from, this);
} else {
MergeFrom(*source);
}
}
void CSVCMsg_ServerInfo::MergeFrom(const CSVCMsg_ServerInfo& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
if (from.has_protocol()) {
set_protocol(from.protocol());
}
if (from.has_server_count()) {
set_server_count(from.server_count());
}
if (from.has_is_dedicated()) {
set_is_dedicated(from.is_dedicated());
}
if (from.has_is_hltv()) {
set_is_hltv(from.is_hltv());
}
if (from.has_is_replay()) {
set_is_replay(from.is_replay());
}
if (from.has_c_os()) {
set_c_os(from.c_os());
}
if (from.has_map_crc()) {
set_map_crc(from.map_crc());
}
if (from.has_client_crc()) {
set_client_crc(from.client_crc());
}
}
if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
if (from.has_string_table_crc()) {
set_string_table_crc(from.string_table_crc());
}
if (from.has_max_clients()) {
set_max_clients(from.max_clients());
}
if (from.has_max_classes()) {
set_max_classes(from.max_classes());
}
if (from.has_player_slot()) {
set_player_slot(from.player_slot());
}
if (from.has_tick_interval()) {
set_tick_interval(from.tick_interval());
}
if (from.has_game_dir()) {
set_game_dir(from.game_dir());
}
if (from.has_map_name()) {
set_map_name(from.map_name());
}
if (from.has_sky_name()) {
set_sky_name(from.sky_name());
}
}
if (from._has_bits_[16 / 32] & (0xffu << (16 % 32))) {
if (from.has_host_name()) {
set_host_name(from.host_name());
}
if (from.has_addon_name()) {
set_addon_name(from.addon_name());
}
}
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}
void CSVCMsg_ServerInfo::CopyFrom(const ::google::protobuf::Message& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
void CSVCMsg_ServerInfo::CopyFrom(const CSVCMsg_ServerInfo& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool CSVCMsg_ServerInfo::IsInitialized() const {
return true;
}
void CSVCMsg_ServerInfo::Swap(CSVCMsg_ServerInfo* other) {
if (other != this) {
std::swap(protocol_, other->protocol_);
std::swap(server_count_, other->server_count_);
std::swap(is_dedicated_, other->is_dedicated_);
std::swap(is_hltv_, other->is_hltv_);
std::swap(is_replay_, other->is_replay_);
std::swap(c_os_, other->c_os_);
std::swap(map_crc_, other->map_crc_);
std::swap(client_crc_, other->client_crc_);
std::swap(string_table_crc_, other->string_table_crc_);
std::swap(max_clients_, other->max_clients_);
std::swap(max_classes_, other->max_classes_);
std::swap(player_slot_, other->player_slot_);
std::swap(tick_interval_, other->tick_interval_);
std::swap(game_dir_, other->game_dir_);
std::swap(map_name_, other->map_name_);
std::swap(sky_name_, other->sky_name_);
std::swap(host_name_, other->host_name_);
std::swap(addon_name_, other->addon_name_);
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 CSVCMsg_ServerInfo::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
::google::protobuf::Metadata metadata;
metadata.descriptor = CSVCMsg_ServerInfo_descriptor_;
metadata.reflection = CSVCMsg_ServerInfo_reflection_;
return metadata;
}
// ===================================================================
#ifndef _MSC_VER
const int CSVCMsg_ClassInfo_class_t::kClassIdFieldNumber;
const int CSVCMsg_ClassInfo_class_t::kDataTableNameFieldNumber;
const int CSVCMsg_ClassInfo_class_t::kClassNameFieldNumber;
#endif // !_MSC_VER
CSVCMsg_ClassInfo_class_t::CSVCMsg_ClassInfo_class_t()
: ::google::protobuf::Message() {
SharedCtor();
// @@protoc_insertion_point(constructor:CSVCMsg_ClassInfo.class_t)
}
void CSVCMsg_ClassInfo_class_t::InitAsDefaultInstance() {
}
CSVCMsg_ClassInfo_class_t::CSVCMsg_ClassInfo_class_t(const CSVCMsg_ClassInfo_class_t& from)
: ::google::protobuf::Message() {
SharedCtor();
MergeFrom(from);
// @@protoc_insertion_point(copy_constructor:CSVCMsg_ClassInfo.class_t)
}
void CSVCMsg_ClassInfo_class_t::SharedCtor() {
::google::protobuf::internal::GetEmptyString();
_cached_size_ = 0;
class_id_ = 0;
data_table_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
class_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
CSVCMsg_ClassInfo_class_t::~CSVCMsg_ClassInfo_class_t() {
// @@protoc_insertion_point(destructor:CSVCMsg_ClassInfo.class_t)
SharedDtor();
}
void CSVCMsg_ClassInfo_class_t::SharedDtor() {
if (data_table_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
delete data_table_name_;
}
if (class_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
delete class_name_;
}
if (this != default_instance_) {
}
}
void CSVCMsg_ClassInfo_class_t::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_ClassInfo_class_t::descriptor() {
protobuf_AssignDescriptorsOnce();
return CSVCMsg_ClassInfo_class_t_descriptor_;
}
const CSVCMsg_ClassInfo_class_t& CSVCMsg_ClassInfo_class_t::default_instance() {
if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
return *default_instance_;
}
CSVCMsg_ClassInfo_class_t* CSVCMsg_ClassInfo_class_t::default_instance_ = NULL;
CSVCMsg_ClassInfo_class_t* CSVCMsg_ClassInfo_class_t::New() const {
return new CSVCMsg_ClassInfo_class_t;
}
void CSVCMsg_ClassInfo_class_t::Clear() {
if (_has_bits_[0 / 32] & 7) {
class_id_ = 0;
if (has_data_table_name()) {
if (data_table_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
data_table_name_->clear();
}
}
if (has_class_name()) {
if (class_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
class_name_->clear();
}
}
}
::memset(_has_bits_, 0, sizeof(_has_bits_));
mutable_unknown_fields()->Clear();
}
bool CSVCMsg_ClassInfo_class_t::MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
::google::protobuf::uint32 tag;
// @@protoc_insertion_point(parse_start:CSVCMsg_ClassInfo.class_t)
for (;;) {
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// optional int32 class_id = 1;
case 1: {
if (tag == 8) {
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &class_id_)));
set_has_class_id();
} else {
goto handle_unusual;
}
if (input->ExpectTag(18)) goto parse_data_table_name;
break;
}
// optional string data_table_name = 2;
case 2: {
if (tag == 18) {
parse_data_table_name:
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
input, this->mutable_data_table_name()));
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->data_table_name().data(), this->data_table_name().length(),
::google::protobuf::internal::WireFormat::PARSE,
"data_table_name");
} else {
goto handle_unusual;
}
if (input->ExpectTag(26)) goto parse_class_name;
break;
}
// optional string class_name = 3;
case 3: {
if (tag == 26) {
parse_class_name:
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
input, this->mutable_class_name()));
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->class_name().data(), this->class_name().length(),
::google::protobuf::internal::WireFormat::PARSE,
"class_name");
} else {
goto handle_unusual;
}
if (input->ExpectAtEnd()) goto success;
break;
}
default: {
handle_unusual:
if (tag == 0 ||
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
goto success;
}
DO_(::google::protobuf::internal::WireFormat::SkipField(
input, tag, mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:CSVCMsg_ClassInfo.class_t)
return true;
failure:
// @@protoc_insertion_point(parse_failure:CSVCMsg_ClassInfo.class_t)
return false;
#undef DO_
}
void CSVCMsg_ClassInfo_class_t::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:CSVCMsg_ClassInfo.class_t)
// optional int32 class_id = 1;
if (has_class_id()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->class_id(), output);
}
// optional string data_table_name = 2;
if (has_data_table_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->data_table_name().data(), this->data_table_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"data_table_name");
::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
2, this->data_table_name(), output);
}
// optional string class_name = 3;
if (has_class_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->class_name().data(), this->class_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"class_name");
::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
3, this->class_name(), output);
}
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
}
// @@protoc_insertion_point(serialize_end:CSVCMsg_ClassInfo.class_t)
}
::google::protobuf::uint8* CSVCMsg_ClassInfo_class_t::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_ClassInfo.class_t)
// optional int32 class_id = 1;
if (has_class_id()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->class_id(), target);
}
// optional string data_table_name = 2;
if (has_data_table_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->data_table_name().data(), this->data_table_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"data_table_name");
target =
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2, this->data_table_name(), target);
}
// optional string class_name = 3;
if (has_class_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->class_name().data(), this->class_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"class_name");
target =
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
3, this->class_name(), target);
}
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
}
// @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_ClassInfo.class_t)
return target;
}
int CSVCMsg_ClassInfo_class_t::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// optional int32 class_id = 1;
if (has_class_id()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->class_id());
}
// optional string data_table_name = 2;
if (has_data_table_name()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::StringSize(
this->data_table_name());
}
// optional string class_name = 3;
if (has_class_name()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::StringSize(
this->class_name());
}
}
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 CSVCMsg_ClassInfo_class_t::MergeFrom(const ::google::protobuf::Message& from) {
GOOGLE_CHECK_NE(&from, this);
const CSVCMsg_ClassInfo_class_t* source =
::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_ClassInfo_class_t*>(
&from);
if (source == NULL) {
::google::protobuf::internal::ReflectionOps::Merge(from, this);
} else {
MergeFrom(*source);
}
}
void CSVCMsg_ClassInfo_class_t::MergeFrom(const CSVCMsg_ClassInfo_class_t& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
if (from.has_class_id()) {
set_class_id(from.class_id());
}
if (from.has_data_table_name()) {
set_data_table_name(from.data_table_name());
}
if (from.has_class_name()) {
set_class_name(from.class_name());
}
}
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}
void CSVCMsg_ClassInfo_class_t::CopyFrom(const ::google::protobuf::Message& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
void CSVCMsg_ClassInfo_class_t::CopyFrom(const CSVCMsg_ClassInfo_class_t& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool CSVCMsg_ClassInfo_class_t::IsInitialized() const {
return true;
}
void CSVCMsg_ClassInfo_class_t::Swap(CSVCMsg_ClassInfo_class_t* other) {
if (other != this) {
std::swap(class_id_, other->class_id_);
std::swap(data_table_name_, other->data_table_name_);
std::swap(class_name_, other->class_name_);
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 CSVCMsg_ClassInfo_class_t::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
::google::protobuf::Metadata metadata;
metadata.descriptor = CSVCMsg_ClassInfo_class_t_descriptor_;
metadata.reflection = CSVCMsg_ClassInfo_class_t_reflection_;
return metadata;
}
// -------------------------------------------------------------------
#ifndef _MSC_VER
const int CSVCMsg_ClassInfo::kCreateOnClientFieldNumber;
const int CSVCMsg_ClassInfo::kClassesFieldNumber;
#endif // !_MSC_VER
CSVCMsg_ClassInfo::CSVCMsg_ClassInfo()
: ::google::protobuf::Message() {
SharedCtor();
// @@protoc_insertion_point(constructor:CSVCMsg_ClassInfo)
}
void CSVCMsg_ClassInfo::InitAsDefaultInstance() {
}
CSVCMsg_ClassInfo::CSVCMsg_ClassInfo(const CSVCMsg_ClassInfo& from)
: ::google::protobuf::Message() {
SharedCtor();
MergeFrom(from);
// @@protoc_insertion_point(copy_constructor:CSVCMsg_ClassInfo)
}
void CSVCMsg_ClassInfo::SharedCtor() {
_cached_size_ = 0;
create_on_client_ = false;
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
CSVCMsg_ClassInfo::~CSVCMsg_ClassInfo() {
// @@protoc_insertion_point(destructor:CSVCMsg_ClassInfo)
SharedDtor();
}
void CSVCMsg_ClassInfo::SharedDtor() {
if (this != default_instance_) {
}
}
void CSVCMsg_ClassInfo::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_ClassInfo::descriptor() {
protobuf_AssignDescriptorsOnce();
return CSVCMsg_ClassInfo_descriptor_;
}
const CSVCMsg_ClassInfo& CSVCMsg_ClassInfo::default_instance() {
if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
return *default_instance_;
}
CSVCMsg_ClassInfo* CSVCMsg_ClassInfo::default_instance_ = NULL;
CSVCMsg_ClassInfo* CSVCMsg_ClassInfo::New() const {
return new CSVCMsg_ClassInfo;
}
void CSVCMsg_ClassInfo::Clear() {
create_on_client_ = false;
classes_.Clear();
::memset(_has_bits_, 0, sizeof(_has_bits_));
mutable_unknown_fields()->Clear();
}
bool CSVCMsg_ClassInfo::MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
::google::protobuf::uint32 tag;
// @@protoc_insertion_point(parse_start:CSVCMsg_ClassInfo)
for (;;) {
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// optional bool create_on_client = 1;
case 1: {
if (tag == 8) {
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
input, &create_on_client_)));
set_has_create_on_client();
} else {
goto handle_unusual;
}
if (input->ExpectTag(18)) goto parse_classes;
break;
}
// repeated .CSVCMsg_ClassInfo.class_t classes = 2;
case 2: {
if (tag == 18) {
parse_classes:
DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
input, add_classes()));
} else {
goto handle_unusual;
}
if (input->ExpectTag(18)) goto parse_classes;
if (input->ExpectAtEnd()) goto success;
break;
}
default: {
handle_unusual:
if (tag == 0 ||
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
goto success;
}
DO_(::google::protobuf::internal::WireFormat::SkipField(
input, tag, mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:CSVCMsg_ClassInfo)
return true;
failure:
// @@protoc_insertion_point(parse_failure:CSVCMsg_ClassInfo)
return false;
#undef DO_
}
void CSVCMsg_ClassInfo::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:CSVCMsg_ClassInfo)
// optional bool create_on_client = 1;
if (has_create_on_client()) {
::google::protobuf::internal::WireFormatLite::WriteBool(1, this->create_on_client(), output);
}
// repeated .CSVCMsg_ClassInfo.class_t classes = 2;
for (int i = 0; i < this->classes_size(); i++) {
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
2, this->classes(i), output);
}
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
}
// @@protoc_insertion_point(serialize_end:CSVCMsg_ClassInfo)
}
::google::protobuf::uint8* CSVCMsg_ClassInfo::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_ClassInfo)
// optional bool create_on_client = 1;
if (has_create_on_client()) {
target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->create_on_client(), target);
}
// repeated .CSVCMsg_ClassInfo.class_t classes = 2;
for (int i = 0; i < this->classes_size(); i++) {
target = ::google::protobuf::internal::WireFormatLite::
WriteMessageNoVirtualToArray(
2, this->classes(i), target);
}
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
}
// @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_ClassInfo)
return target;
}
int CSVCMsg_ClassInfo::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// optional bool create_on_client = 1;
if (has_create_on_client()) {
total_size += 1 + 1;
}
}
// repeated .CSVCMsg_ClassInfo.class_t classes = 2;
total_size += 1 * this->classes_size();
for (int i = 0; i < this->classes_size(); i++) {
total_size +=
::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
this->classes(i));
}
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 CSVCMsg_ClassInfo::MergeFrom(const ::google::protobuf::Message& from) {
GOOGLE_CHECK_NE(&from, this);
const CSVCMsg_ClassInfo* source =
::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_ClassInfo*>(
&from);
if (source == NULL) {
::google::protobuf::internal::ReflectionOps::Merge(from, this);
} else {
MergeFrom(*source);
}
}
void CSVCMsg_ClassInfo::MergeFrom(const CSVCMsg_ClassInfo& from) {
GOOGLE_CHECK_NE(&from, this);
classes_.MergeFrom(from.classes_);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
if (from.has_create_on_client()) {
set_create_on_client(from.create_on_client());
}
}
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}
void CSVCMsg_ClassInfo::CopyFrom(const ::google::protobuf::Message& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
void CSVCMsg_ClassInfo::CopyFrom(const CSVCMsg_ClassInfo& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool CSVCMsg_ClassInfo::IsInitialized() const {
return true;
}
void CSVCMsg_ClassInfo::Swap(CSVCMsg_ClassInfo* other) {
if (other != this) {
std::swap(create_on_client_, other->create_on_client_);
classes_.Swap(&other->classes_);
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 CSVCMsg_ClassInfo::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
::google::protobuf::Metadata metadata;
metadata.descriptor = CSVCMsg_ClassInfo_descriptor_;
metadata.reflection = CSVCMsg_ClassInfo_reflection_;
return metadata;
}
// ===================================================================
#ifndef _MSC_VER
const int CSVCMsg_SetPause::kPausedFieldNumber;
#endif // !_MSC_VER
CSVCMsg_SetPause::CSVCMsg_SetPause()
: ::google::protobuf::Message() {
SharedCtor();
// @@protoc_insertion_point(constructor:CSVCMsg_SetPause)
}
void CSVCMsg_SetPause::InitAsDefaultInstance() {
}
CSVCMsg_SetPause::CSVCMsg_SetPause(const CSVCMsg_SetPause& from)
: ::google::protobuf::Message() {
SharedCtor();
MergeFrom(from);
// @@protoc_insertion_point(copy_constructor:CSVCMsg_SetPause)
}
void CSVCMsg_SetPause::SharedCtor() {
_cached_size_ = 0;
paused_ = false;
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
CSVCMsg_SetPause::~CSVCMsg_SetPause() {
// @@protoc_insertion_point(destructor:CSVCMsg_SetPause)
SharedDtor();
}
void CSVCMsg_SetPause::SharedDtor() {
if (this != default_instance_) {
}
}
void CSVCMsg_SetPause::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_SetPause::descriptor() {
protobuf_AssignDescriptorsOnce();
return CSVCMsg_SetPause_descriptor_;
}
const CSVCMsg_SetPause& CSVCMsg_SetPause::default_instance() {
if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
return *default_instance_;
}
CSVCMsg_SetPause* CSVCMsg_SetPause::default_instance_ = NULL;
CSVCMsg_SetPause* CSVCMsg_SetPause::New() const {
return new CSVCMsg_SetPause;
}
void CSVCMsg_SetPause::Clear() {
paused_ = false;
::memset(_has_bits_, 0, sizeof(_has_bits_));
mutable_unknown_fields()->Clear();
}
bool CSVCMsg_SetPause::MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
::google::protobuf::uint32 tag;
// @@protoc_insertion_point(parse_start:CSVCMsg_SetPause)
for (;;) {
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// optional bool paused = 1;
case 1: {
if (tag == 8) {
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
input, &paused_)));
set_has_paused();
} else {
goto handle_unusual;
}
if (input->ExpectAtEnd()) goto success;
break;
}
default: {
handle_unusual:
if (tag == 0 ||
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
goto success;
}
DO_(::google::protobuf::internal::WireFormat::SkipField(
input, tag, mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:CSVCMsg_SetPause)
return true;
failure:
// @@protoc_insertion_point(parse_failure:CSVCMsg_SetPause)
return false;
#undef DO_
}
void CSVCMsg_SetPause::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:CSVCMsg_SetPause)
// optional bool paused = 1;
if (has_paused()) {
::google::protobuf::internal::WireFormatLite::WriteBool(1, this->paused(), output);
}
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
}
// @@protoc_insertion_point(serialize_end:CSVCMsg_SetPause)
}
::google::protobuf::uint8* CSVCMsg_SetPause::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_SetPause)
// optional bool paused = 1;
if (has_paused()) {
target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->paused(), target);
}
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
}
// @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_SetPause)
return target;
}
int CSVCMsg_SetPause::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// optional bool paused = 1;
if (has_paused()) {
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 CSVCMsg_SetPause::MergeFrom(const ::google::protobuf::Message& from) {
GOOGLE_CHECK_NE(&from, this);
const CSVCMsg_SetPause* source =
::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_SetPause*>(
&from);
if (source == NULL) {
::google::protobuf::internal::ReflectionOps::Merge(from, this);
} else {
MergeFrom(*source);
}
}
void CSVCMsg_SetPause::MergeFrom(const CSVCMsg_SetPause& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
if (from.has_paused()) {
set_paused(from.paused());
}
}
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}
void CSVCMsg_SetPause::CopyFrom(const ::google::protobuf::Message& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
void CSVCMsg_SetPause::CopyFrom(const CSVCMsg_SetPause& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool CSVCMsg_SetPause::IsInitialized() const {
return true;
}
void CSVCMsg_SetPause::Swap(CSVCMsg_SetPause* other) {
if (other != this) {
std::swap(paused_, other->paused_);
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 CSVCMsg_SetPause::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
::google::protobuf::Metadata metadata;
metadata.descriptor = CSVCMsg_SetPause_descriptor_;
metadata.reflection = CSVCMsg_SetPause_reflection_;
return metadata;
}
// ===================================================================
#ifndef _MSC_VER
const int CSVCMsg_VoiceInit::kQualityFieldNumber;
const int CSVCMsg_VoiceInit::kCodecFieldNumber;
const int CSVCMsg_VoiceInit::kVersionFieldNumber;
#endif // !_MSC_VER
CSVCMsg_VoiceInit::CSVCMsg_VoiceInit()
: ::google::protobuf::Message() {
SharedCtor();
// @@protoc_insertion_point(constructor:CSVCMsg_VoiceInit)
}
void CSVCMsg_VoiceInit::InitAsDefaultInstance() {
}
CSVCMsg_VoiceInit::CSVCMsg_VoiceInit(const CSVCMsg_VoiceInit& from)
: ::google::protobuf::Message() {
SharedCtor();
MergeFrom(from);
// @@protoc_insertion_point(copy_constructor:CSVCMsg_VoiceInit)
}
void CSVCMsg_VoiceInit::SharedCtor() {
::google::protobuf::internal::GetEmptyString();
_cached_size_ = 0;
quality_ = 0;
codec_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
version_ = 0;
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
CSVCMsg_VoiceInit::~CSVCMsg_VoiceInit() {
// @@protoc_insertion_point(destructor:CSVCMsg_VoiceInit)
SharedDtor();
}
void CSVCMsg_VoiceInit::SharedDtor() {
if (codec_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
delete codec_;
}
if (this != default_instance_) {
}
}
void CSVCMsg_VoiceInit::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_VoiceInit::descriptor() {
protobuf_AssignDescriptorsOnce();
return CSVCMsg_VoiceInit_descriptor_;
}
const CSVCMsg_VoiceInit& CSVCMsg_VoiceInit::default_instance() {
if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
return *default_instance_;
}
CSVCMsg_VoiceInit* CSVCMsg_VoiceInit::default_instance_ = NULL;
CSVCMsg_VoiceInit* CSVCMsg_VoiceInit::New() const {
return new CSVCMsg_VoiceInit;
}
void CSVCMsg_VoiceInit::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>( \
&reinterpret_cast<CSVCMsg_VoiceInit*>(16)->f) - \
reinterpret_cast<char*>(16))
#define ZR_(first, last) do { \
size_t f = OFFSET_OF_FIELD_(first); \
size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \
::memset(&first, 0, n); \
} while (0)
if (_has_bits_[0 / 32] & 7) {
ZR_(quality_, version_);
if (has_codec()) {
if (codec_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
codec_->clear();
}
}
}
#undef OFFSET_OF_FIELD_
#undef ZR_
::memset(_has_bits_, 0, sizeof(_has_bits_));
mutable_unknown_fields()->Clear();
}
bool CSVCMsg_VoiceInit::MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
::google::protobuf::uint32 tag;
// @@protoc_insertion_point(parse_start:CSVCMsg_VoiceInit)
for (;;) {
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// optional int32 quality = 1;
case 1: {
if (tag == 8) {
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &quality_)));
set_has_quality();
} else {
goto handle_unusual;
}
if (input->ExpectTag(18)) goto parse_codec;
break;
}
// optional string codec = 2;
case 2: {
if (tag == 18) {
parse_codec:
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
input, this->mutable_codec()));
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->codec().data(), this->codec().length(),
::google::protobuf::internal::WireFormat::PARSE,
"codec");
} else {
goto handle_unusual;
}
if (input->ExpectTag(24)) goto parse_version;
break;
}
// optional int32 version = 3 [default = 0];
case 3: {
if (tag == 24) {
parse_version:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &version_)));
set_has_version();
} else {
goto handle_unusual;
}
if (input->ExpectAtEnd()) goto success;
break;
}
default: {
handle_unusual:
if (tag == 0 ||
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
goto success;
}
DO_(::google::protobuf::internal::WireFormat::SkipField(
input, tag, mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:CSVCMsg_VoiceInit)
return true;
failure:
// @@protoc_insertion_point(parse_failure:CSVCMsg_VoiceInit)
return false;
#undef DO_
}
void CSVCMsg_VoiceInit::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:CSVCMsg_VoiceInit)
// optional int32 quality = 1;
if (has_quality()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->quality(), output);
}
// optional string codec = 2;
if (has_codec()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->codec().data(), this->codec().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"codec");
::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
2, this->codec(), output);
}
// optional int32 version = 3 [default = 0];
if (has_version()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->version(), output);
}
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
}
// @@protoc_insertion_point(serialize_end:CSVCMsg_VoiceInit)
}
::google::protobuf::uint8* CSVCMsg_VoiceInit::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_VoiceInit)
// optional int32 quality = 1;
if (has_quality()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->quality(), target);
}
// optional string codec = 2;
if (has_codec()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->codec().data(), this->codec().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"codec");
target =
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2, this->codec(), target);
}
// optional int32 version = 3 [default = 0];
if (has_version()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->version(), target);
}
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
}
// @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_VoiceInit)
return target;
}
int CSVCMsg_VoiceInit::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// optional int32 quality = 1;
if (has_quality()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->quality());
}
// optional string codec = 2;
if (has_codec()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::StringSize(
this->codec());
}
// optional int32 version = 3 [default = 0];
if (has_version()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->version());
}
}
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 CSVCMsg_VoiceInit::MergeFrom(const ::google::protobuf::Message& from) {
GOOGLE_CHECK_NE(&from, this);
const CSVCMsg_VoiceInit* source =
::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_VoiceInit*>(
&from);
if (source == NULL) {
::google::protobuf::internal::ReflectionOps::Merge(from, this);
} else {
MergeFrom(*source);
}
}
void CSVCMsg_VoiceInit::MergeFrom(const CSVCMsg_VoiceInit& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
if (from.has_quality()) {
set_quality(from.quality());
}
if (from.has_codec()) {
set_codec(from.codec());
}
if (from.has_version()) {
set_version(from.version());
}
}
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}
void CSVCMsg_VoiceInit::CopyFrom(const ::google::protobuf::Message& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
void CSVCMsg_VoiceInit::CopyFrom(const CSVCMsg_VoiceInit& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool CSVCMsg_VoiceInit::IsInitialized() const {
return true;
}
void CSVCMsg_VoiceInit::Swap(CSVCMsg_VoiceInit* other) {
if (other != this) {
std::swap(quality_, other->quality_);
std::swap(codec_, other->codec_);
std::swap(version_, other->version_);
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 CSVCMsg_VoiceInit::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
::google::protobuf::Metadata metadata;
metadata.descriptor = CSVCMsg_VoiceInit_descriptor_;
metadata.reflection = CSVCMsg_VoiceInit_reflection_;
return metadata;
}
// ===================================================================
#ifndef _MSC_VER
const int CSVCMsg_Print::kTextFieldNumber;
#endif // !_MSC_VER
CSVCMsg_Print::CSVCMsg_Print()
: ::google::protobuf::Message() {
SharedCtor();
// @@protoc_insertion_point(constructor:CSVCMsg_Print)
}
void CSVCMsg_Print::InitAsDefaultInstance() {
}
CSVCMsg_Print::CSVCMsg_Print(const CSVCMsg_Print& from)
: ::google::protobuf::Message() {
SharedCtor();
MergeFrom(from);
// @@protoc_insertion_point(copy_constructor:CSVCMsg_Print)
}
void CSVCMsg_Print::SharedCtor() {
::google::protobuf::internal::GetEmptyString();
_cached_size_ = 0;
text_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
CSVCMsg_Print::~CSVCMsg_Print() {
// @@protoc_insertion_point(destructor:CSVCMsg_Print)
SharedDtor();
}
void CSVCMsg_Print::SharedDtor() {
if (text_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
delete text_;
}
if (this != default_instance_) {
}
}
void CSVCMsg_Print::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_Print::descriptor() {
protobuf_AssignDescriptorsOnce();
return CSVCMsg_Print_descriptor_;
}
const CSVCMsg_Print& CSVCMsg_Print::default_instance() {
if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
return *default_instance_;
}
CSVCMsg_Print* CSVCMsg_Print::default_instance_ = NULL;
CSVCMsg_Print* CSVCMsg_Print::New() const {
return new CSVCMsg_Print;
}
void CSVCMsg_Print::Clear() {
if (has_text()) {
if (text_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
text_->clear();
}
}
::memset(_has_bits_, 0, sizeof(_has_bits_));
mutable_unknown_fields()->Clear();
}
bool CSVCMsg_Print::MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
::google::protobuf::uint32 tag;
// @@protoc_insertion_point(parse_start:CSVCMsg_Print)
for (;;) {
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// optional string text = 1;
case 1: {
if (tag == 10) {
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
input, this->mutable_text()));
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->text().data(), this->text().length(),
::google::protobuf::internal::WireFormat::PARSE,
"text");
} else {
goto handle_unusual;
}
if (input->ExpectAtEnd()) goto success;
break;
}
default: {
handle_unusual:
if (tag == 0 ||
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
goto success;
}
DO_(::google::protobuf::internal::WireFormat::SkipField(
input, tag, mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:CSVCMsg_Print)
return true;
failure:
// @@protoc_insertion_point(parse_failure:CSVCMsg_Print)
return false;
#undef DO_
}
void CSVCMsg_Print::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:CSVCMsg_Print)
// optional string text = 1;
if (has_text()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->text().data(), this->text().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"text");
::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
1, this->text(), output);
}
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
}
// @@protoc_insertion_point(serialize_end:CSVCMsg_Print)
}
::google::protobuf::uint8* CSVCMsg_Print::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_Print)
// optional string text = 1;
if (has_text()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->text().data(), this->text().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"text");
target =
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->text(), target);
}
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
}
// @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_Print)
return target;
}
int CSVCMsg_Print::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// optional string text = 1;
if (has_text()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::StringSize(
this->text());
}
}
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 CSVCMsg_Print::MergeFrom(const ::google::protobuf::Message& from) {
GOOGLE_CHECK_NE(&from, this);
const CSVCMsg_Print* source =
::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_Print*>(
&from);
if (source == NULL) {
::google::protobuf::internal::ReflectionOps::Merge(from, this);
} else {
MergeFrom(*source);
}
}
void CSVCMsg_Print::MergeFrom(const CSVCMsg_Print& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
if (from.has_text()) {
set_text(from.text());
}
}
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}
void CSVCMsg_Print::CopyFrom(const ::google::protobuf::Message& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
void CSVCMsg_Print::CopyFrom(const CSVCMsg_Print& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool CSVCMsg_Print::IsInitialized() const {
return true;
}
void CSVCMsg_Print::Swap(CSVCMsg_Print* other) {
if (other != this) {
std::swap(text_, other->text_);
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 CSVCMsg_Print::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
::google::protobuf::Metadata metadata;
metadata.descriptor = CSVCMsg_Print_descriptor_;
metadata.reflection = CSVCMsg_Print_reflection_;
return metadata;
}
// ===================================================================
#ifndef _MSC_VER
const int CSVCMsg_Sounds_sounddata_t::kOriginXFieldNumber;
const int CSVCMsg_Sounds_sounddata_t::kOriginYFieldNumber;
const int CSVCMsg_Sounds_sounddata_t::kOriginZFieldNumber;
const int CSVCMsg_Sounds_sounddata_t::kVolumeFieldNumber;
const int CSVCMsg_Sounds_sounddata_t::kDelayValueFieldNumber;
const int CSVCMsg_Sounds_sounddata_t::kSequenceNumberFieldNumber;
const int CSVCMsg_Sounds_sounddata_t::kEntityIndexFieldNumber;
const int CSVCMsg_Sounds_sounddata_t::kChannelFieldNumber;
const int CSVCMsg_Sounds_sounddata_t::kPitchFieldNumber;
const int CSVCMsg_Sounds_sounddata_t::kFlagsFieldNumber;
const int CSVCMsg_Sounds_sounddata_t::kSoundNumFieldNumber;
const int CSVCMsg_Sounds_sounddata_t::kSoundNumHandleFieldNumber;
const int CSVCMsg_Sounds_sounddata_t::kSpeakerEntityFieldNumber;
const int CSVCMsg_Sounds_sounddata_t::kRandomSeedFieldNumber;
const int CSVCMsg_Sounds_sounddata_t::kSoundLevelFieldNumber;
const int CSVCMsg_Sounds_sounddata_t::kIsSentenceFieldNumber;
const int CSVCMsg_Sounds_sounddata_t::kIsAmbientFieldNumber;
#endif // !_MSC_VER
CSVCMsg_Sounds_sounddata_t::CSVCMsg_Sounds_sounddata_t()
: ::google::protobuf::Message() {
SharedCtor();
// @@protoc_insertion_point(constructor:CSVCMsg_Sounds.sounddata_t)
}
void CSVCMsg_Sounds_sounddata_t::InitAsDefaultInstance() {
}
CSVCMsg_Sounds_sounddata_t::CSVCMsg_Sounds_sounddata_t(const CSVCMsg_Sounds_sounddata_t& from)
: ::google::protobuf::Message() {
SharedCtor();
MergeFrom(from);
// @@protoc_insertion_point(copy_constructor:CSVCMsg_Sounds.sounddata_t)
}
void CSVCMsg_Sounds_sounddata_t::SharedCtor() {
_cached_size_ = 0;
origin_x_ = 0;
origin_y_ = 0;
origin_z_ = 0;
volume_ = 0u;
delay_value_ = 0;
sequence_number_ = 0;
entity_index_ = 0;
channel_ = 0;
pitch_ = 0;
flags_ = 0;
sound_num_ = 0u;
sound_num_handle_ = 0u;
speaker_entity_ = 0;
random_seed_ = 0;
sound_level_ = 0;
is_sentence_ = false;
is_ambient_ = false;
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
CSVCMsg_Sounds_sounddata_t::~CSVCMsg_Sounds_sounddata_t() {
// @@protoc_insertion_point(destructor:CSVCMsg_Sounds.sounddata_t)
SharedDtor();
}
void CSVCMsg_Sounds_sounddata_t::SharedDtor() {
if (this != default_instance_) {
}
}
void CSVCMsg_Sounds_sounddata_t::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_Sounds_sounddata_t::descriptor() {
protobuf_AssignDescriptorsOnce();
return CSVCMsg_Sounds_sounddata_t_descriptor_;
}
const CSVCMsg_Sounds_sounddata_t& CSVCMsg_Sounds_sounddata_t::default_instance() {
if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
return *default_instance_;
}
CSVCMsg_Sounds_sounddata_t* CSVCMsg_Sounds_sounddata_t::default_instance_ = NULL;
CSVCMsg_Sounds_sounddata_t* CSVCMsg_Sounds_sounddata_t::New() const {
return new CSVCMsg_Sounds_sounddata_t;
}
void CSVCMsg_Sounds_sounddata_t::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>( \
&reinterpret_cast<CSVCMsg_Sounds_sounddata_t*>(16)->f) - \
reinterpret_cast<char*>(16))
#define ZR_(first, last) do { \
size_t f = OFFSET_OF_FIELD_(first); \
size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \
::memset(&first, 0, n); \
} while (0)
if (_has_bits_[0 / 32] & 255) {
ZR_(origin_x_, channel_);
}
if (_has_bits_[8 / 32] & 65280) {
ZR_(pitch_, is_sentence_);
}
is_ambient_ = false;
#undef OFFSET_OF_FIELD_
#undef ZR_
::memset(_has_bits_, 0, sizeof(_has_bits_));
mutable_unknown_fields()->Clear();
}
bool CSVCMsg_Sounds_sounddata_t::MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
::google::protobuf::uint32 tag;
// @@protoc_insertion_point(parse_start:CSVCMsg_Sounds.sounddata_t)
for (;;) {
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(16383);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// optional sint32 origin_x = 1;
case 1: {
if (tag == 8) {
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_SINT32>(
input, &origin_x_)));
set_has_origin_x();
} else {
goto handle_unusual;
}
if (input->ExpectTag(16)) goto parse_origin_y;
break;
}
// optional sint32 origin_y = 2;
case 2: {
if (tag == 16) {
parse_origin_y:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_SINT32>(
input, &origin_y_)));
set_has_origin_y();
} else {
goto handle_unusual;
}
if (input->ExpectTag(24)) goto parse_origin_z;
break;
}
// optional sint32 origin_z = 3;
case 3: {
if (tag == 24) {
parse_origin_z:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_SINT32>(
input, &origin_z_)));
set_has_origin_z();
} else {
goto handle_unusual;
}
if (input->ExpectTag(32)) goto parse_volume;
break;
}
// optional uint32 volume = 4;
case 4: {
if (tag == 32) {
parse_volume:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
input, &volume_)));
set_has_volume();
} else {
goto handle_unusual;
}
if (input->ExpectTag(45)) goto parse_delay_value;
break;
}
// optional float delay_value = 5;
case 5: {
if (tag == 45) {
parse_delay_value:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
input, &delay_value_)));
set_has_delay_value();
} else {
goto handle_unusual;
}
if (input->ExpectTag(48)) goto parse_sequence_number;
break;
}
// optional int32 sequence_number = 6;
case 6: {
if (tag == 48) {
parse_sequence_number:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &sequence_number_)));
set_has_sequence_number();
} else {
goto handle_unusual;
}
if (input->ExpectTag(56)) goto parse_entity_index;
break;
}
// optional int32 entity_index = 7;
case 7: {
if (tag == 56) {
parse_entity_index:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &entity_index_)));
set_has_entity_index();
} else {
goto handle_unusual;
}
if (input->ExpectTag(64)) goto parse_channel;
break;
}
// optional int32 channel = 8;
case 8: {
if (tag == 64) {
parse_channel:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &channel_)));
set_has_channel();
} else {
goto handle_unusual;
}
if (input->ExpectTag(72)) goto parse_pitch;
break;
}
// optional int32 pitch = 9;
case 9: {
if (tag == 72) {
parse_pitch:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &pitch_)));
set_has_pitch();
} else {
goto handle_unusual;
}
if (input->ExpectTag(80)) goto parse_flags;
break;
}
// optional int32 flags = 10;
case 10: {
if (tag == 80) {
parse_flags:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &flags_)));
set_has_flags();
} else {
goto handle_unusual;
}
if (input->ExpectTag(88)) goto parse_sound_num;
break;
}
// optional uint32 sound_num = 11;
case 11: {
if (tag == 88) {
parse_sound_num:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
input, &sound_num_)));
set_has_sound_num();
} else {
goto handle_unusual;
}
if (input->ExpectTag(101)) goto parse_sound_num_handle;
break;
}
// optional fixed32 sound_num_handle = 12;
case 12: {
if (tag == 101) {
parse_sound_num_handle:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &sound_num_handle_)));
set_has_sound_num_handle();
} else {
goto handle_unusual;
}
if (input->ExpectTag(104)) goto parse_speaker_entity;
break;
}
// optional int32 speaker_entity = 13;
case 13: {
if (tag == 104) {
parse_speaker_entity:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &speaker_entity_)));
set_has_speaker_entity();
} else {
goto handle_unusual;
}
if (input->ExpectTag(112)) goto parse_random_seed;
break;
}
// optional int32 random_seed = 14;
case 14: {
if (tag == 112) {
parse_random_seed:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &random_seed_)));
set_has_random_seed();
} else {
goto handle_unusual;
}
if (input->ExpectTag(120)) goto parse_sound_level;
break;
}
// optional int32 sound_level = 15;
case 15: {
if (tag == 120) {
parse_sound_level:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &sound_level_)));
set_has_sound_level();
} else {
goto handle_unusual;
}
if (input->ExpectTag(128)) goto parse_is_sentence;
break;
}
// optional bool is_sentence = 16;
case 16: {
if (tag == 128) {
parse_is_sentence:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
input, &is_sentence_)));
set_has_is_sentence();
} else {
goto handle_unusual;
}
if (input->ExpectTag(136)) goto parse_is_ambient;
break;
}
// optional bool is_ambient = 17;
case 17: {
if (tag == 136) {
parse_is_ambient:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
input, &is_ambient_)));
set_has_is_ambient();
} else {
goto handle_unusual;
}
if (input->ExpectAtEnd()) goto success;
break;
}
default: {
handle_unusual:
if (tag == 0 ||
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
goto success;
}
DO_(::google::protobuf::internal::WireFormat::SkipField(
input, tag, mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:CSVCMsg_Sounds.sounddata_t)
return true;
failure:
// @@protoc_insertion_point(parse_failure:CSVCMsg_Sounds.sounddata_t)
return false;
#undef DO_
}
void CSVCMsg_Sounds_sounddata_t::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:CSVCMsg_Sounds.sounddata_t)
// optional sint32 origin_x = 1;
if (has_origin_x()) {
::google::protobuf::internal::WireFormatLite::WriteSInt32(1, this->origin_x(), output);
}
// optional sint32 origin_y = 2;
if (has_origin_y()) {
::google::protobuf::internal::WireFormatLite::WriteSInt32(2, this->origin_y(), output);
}
// optional sint32 origin_z = 3;
if (has_origin_z()) {
::google::protobuf::internal::WireFormatLite::WriteSInt32(3, this->origin_z(), output);
}
// optional uint32 volume = 4;
if (has_volume()) {
::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->volume(), output);
}
// optional float delay_value = 5;
if (has_delay_value()) {
::google::protobuf::internal::WireFormatLite::WriteFloat(5, this->delay_value(), output);
}
// optional int32 sequence_number = 6;
if (has_sequence_number()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->sequence_number(), output);
}
// optional int32 entity_index = 7;
if (has_entity_index()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(7, this->entity_index(), output);
}
// optional int32 channel = 8;
if (has_channel()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(8, this->channel(), output);
}
// optional int32 pitch = 9;
if (has_pitch()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(9, this->pitch(), output);
}
// optional int32 flags = 10;
if (has_flags()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(10, this->flags(), output);
}
// optional uint32 sound_num = 11;
if (has_sound_num()) {
::google::protobuf::internal::WireFormatLite::WriteUInt32(11, this->sound_num(), output);
}
// optional fixed32 sound_num_handle = 12;
if (has_sound_num_handle()) {
::google::protobuf::internal::WireFormatLite::WriteFixed32(12, this->sound_num_handle(), output);
}
// optional int32 speaker_entity = 13;
if (has_speaker_entity()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(13, this->speaker_entity(), output);
}
// optional int32 random_seed = 14;
if (has_random_seed()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(14, this->random_seed(), output);
}
// optional int32 sound_level = 15;
if (has_sound_level()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(15, this->sound_level(), output);
}
// optional bool is_sentence = 16;
if (has_is_sentence()) {
::google::protobuf::internal::WireFormatLite::WriteBool(16, this->is_sentence(), output);
}
// optional bool is_ambient = 17;
if (has_is_ambient()) {
::google::protobuf::internal::WireFormatLite::WriteBool(17, this->is_ambient(), output);
}
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
}
// @@protoc_insertion_point(serialize_end:CSVCMsg_Sounds.sounddata_t)
}
::google::protobuf::uint8* CSVCMsg_Sounds_sounddata_t::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_Sounds.sounddata_t)
// optional sint32 origin_x = 1;
if (has_origin_x()) {
target = ::google::protobuf::internal::WireFormatLite::WriteSInt32ToArray(1, this->origin_x(), target);
}
// optional sint32 origin_y = 2;
if (has_origin_y()) {
target = ::google::protobuf::internal::WireFormatLite::WriteSInt32ToArray(2, this->origin_y(), target);
}
// optional sint32 origin_z = 3;
if (has_origin_z()) {
target = ::google::protobuf::internal::WireFormatLite::WriteSInt32ToArray(3, this->origin_z(), target);
}
// optional uint32 volume = 4;
if (has_volume()) {
target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->volume(), target);
}
// optional float delay_value = 5;
if (has_delay_value()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(5, this->delay_value(), target);
}
// optional int32 sequence_number = 6;
if (has_sequence_number()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(6, this->sequence_number(), target);
}
// optional int32 entity_index = 7;
if (has_entity_index()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(7, this->entity_index(), target);
}
// optional int32 channel = 8;
if (has_channel()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(8, this->channel(), target);
}
// optional int32 pitch = 9;
if (has_pitch()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(9, this->pitch(), target);
}
// optional int32 flags = 10;
if (has_flags()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(10, this->flags(), target);
}
// optional uint32 sound_num = 11;
if (has_sound_num()) {
target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(11, this->sound_num(), target);
}
// optional fixed32 sound_num_handle = 12;
if (has_sound_num_handle()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(12, this->sound_num_handle(), target);
}
// optional int32 speaker_entity = 13;
if (has_speaker_entity()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(13, this->speaker_entity(), target);
}
// optional int32 random_seed = 14;
if (has_random_seed()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(14, this->random_seed(), target);
}
// optional int32 sound_level = 15;
if (has_sound_level()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(15, this->sound_level(), target);
}
// optional bool is_sentence = 16;
if (has_is_sentence()) {
target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(16, this->is_sentence(), target);
}
// optional bool is_ambient = 17;
if (has_is_ambient()) {
target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(17, this->is_ambient(), target);
}
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
}
// @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_Sounds.sounddata_t)
return target;
}
int CSVCMsg_Sounds_sounddata_t::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// optional sint32 origin_x = 1;
if (has_origin_x()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::SInt32Size(
this->origin_x());
}
// optional sint32 origin_y = 2;
if (has_origin_y()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::SInt32Size(
this->origin_y());
}
// optional sint32 origin_z = 3;
if (has_origin_z()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::SInt32Size(
this->origin_z());
}
// optional uint32 volume = 4;
if (has_volume()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::UInt32Size(
this->volume());
}
// optional float delay_value = 5;
if (has_delay_value()) {
total_size += 1 + 4;
}
// optional int32 sequence_number = 6;
if (has_sequence_number()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->sequence_number());
}
// optional int32 entity_index = 7;
if (has_entity_index()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->entity_index());
}
// optional int32 channel = 8;
if (has_channel()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->channel());
}
}
if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
// optional int32 pitch = 9;
if (has_pitch()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->pitch());
}
// optional int32 flags = 10;
if (has_flags()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->flags());
}
// optional uint32 sound_num = 11;
if (has_sound_num()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::UInt32Size(
this->sound_num());
}
// optional fixed32 sound_num_handle = 12;
if (has_sound_num_handle()) {
total_size += 1 + 4;
}
// optional int32 speaker_entity = 13;
if (has_speaker_entity()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->speaker_entity());
}
// optional int32 random_seed = 14;
if (has_random_seed()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->random_seed());
}
// optional int32 sound_level = 15;
if (has_sound_level()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->sound_level());
}
// optional bool is_sentence = 16;
if (has_is_sentence()) {
total_size += 2 + 1;
}
}
if (_has_bits_[16 / 32] & (0xffu << (16 % 32))) {
// optional bool is_ambient = 17;
if (has_is_ambient()) {
total_size += 2 + 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 CSVCMsg_Sounds_sounddata_t::MergeFrom(const ::google::protobuf::Message& from) {
GOOGLE_CHECK_NE(&from, this);
const CSVCMsg_Sounds_sounddata_t* source =
::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_Sounds_sounddata_t*>(
&from);
if (source == NULL) {
::google::protobuf::internal::ReflectionOps::Merge(from, this);
} else {
MergeFrom(*source);
}
}
void CSVCMsg_Sounds_sounddata_t::MergeFrom(const CSVCMsg_Sounds_sounddata_t& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
if (from.has_origin_x()) {
set_origin_x(from.origin_x());
}
if (from.has_origin_y()) {
set_origin_y(from.origin_y());
}
if (from.has_origin_z()) {
set_origin_z(from.origin_z());
}
if (from.has_volume()) {
set_volume(from.volume());
}
if (from.has_delay_value()) {
set_delay_value(from.delay_value());
}
if (from.has_sequence_number()) {
set_sequence_number(from.sequence_number());
}
if (from.has_entity_index()) {
set_entity_index(from.entity_index());
}
if (from.has_channel()) {
set_channel(from.channel());
}
}
if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
if (from.has_pitch()) {
set_pitch(from.pitch());
}
if (from.has_flags()) {
set_flags(from.flags());
}
if (from.has_sound_num()) {
set_sound_num(from.sound_num());
}
if (from.has_sound_num_handle()) {
set_sound_num_handle(from.sound_num_handle());
}
if (from.has_speaker_entity()) {
set_speaker_entity(from.speaker_entity());
}
if (from.has_random_seed()) {
set_random_seed(from.random_seed());
}
if (from.has_sound_level()) {
set_sound_level(from.sound_level());
}
if (from.has_is_sentence()) {
set_is_sentence(from.is_sentence());
}
}
if (from._has_bits_[16 / 32] & (0xffu << (16 % 32))) {
if (from.has_is_ambient()) {
set_is_ambient(from.is_ambient());
}
}
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}
void CSVCMsg_Sounds_sounddata_t::CopyFrom(const ::google::protobuf::Message& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
void CSVCMsg_Sounds_sounddata_t::CopyFrom(const CSVCMsg_Sounds_sounddata_t& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool CSVCMsg_Sounds_sounddata_t::IsInitialized() const {
return true;
}
void CSVCMsg_Sounds_sounddata_t::Swap(CSVCMsg_Sounds_sounddata_t* other) {
if (other != this) {
std::swap(origin_x_, other->origin_x_);
std::swap(origin_y_, other->origin_y_);
std::swap(origin_z_, other->origin_z_);
std::swap(volume_, other->volume_);
std::swap(delay_value_, other->delay_value_);
std::swap(sequence_number_, other->sequence_number_);
std::swap(entity_index_, other->entity_index_);
std::swap(channel_, other->channel_);
std::swap(pitch_, other->pitch_);
std::swap(flags_, other->flags_);
std::swap(sound_num_, other->sound_num_);
std::swap(sound_num_handle_, other->sound_num_handle_);
std::swap(speaker_entity_, other->speaker_entity_);
std::swap(random_seed_, other->random_seed_);
std::swap(sound_level_, other->sound_level_);
std::swap(is_sentence_, other->is_sentence_);
std::swap(is_ambient_, other->is_ambient_);
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 CSVCMsg_Sounds_sounddata_t::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
::google::protobuf::Metadata metadata;
metadata.descriptor = CSVCMsg_Sounds_sounddata_t_descriptor_;
metadata.reflection = CSVCMsg_Sounds_sounddata_t_reflection_;
return metadata;
}
// -------------------------------------------------------------------
#ifndef _MSC_VER
const int CSVCMsg_Sounds::kReliableSoundFieldNumber;
const int CSVCMsg_Sounds::kSoundsFieldNumber;
#endif // !_MSC_VER
CSVCMsg_Sounds::CSVCMsg_Sounds()
: ::google::protobuf::Message() {
SharedCtor();
// @@protoc_insertion_point(constructor:CSVCMsg_Sounds)
}
void CSVCMsg_Sounds::InitAsDefaultInstance() {
}
CSVCMsg_Sounds::CSVCMsg_Sounds(const CSVCMsg_Sounds& from)
: ::google::protobuf::Message() {
SharedCtor();
MergeFrom(from);
// @@protoc_insertion_point(copy_constructor:CSVCMsg_Sounds)
}
void CSVCMsg_Sounds::SharedCtor() {
_cached_size_ = 0;
reliable_sound_ = false;
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
CSVCMsg_Sounds::~CSVCMsg_Sounds() {
// @@protoc_insertion_point(destructor:CSVCMsg_Sounds)
SharedDtor();
}
void CSVCMsg_Sounds::SharedDtor() {
if (this != default_instance_) {
}
}
void CSVCMsg_Sounds::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_Sounds::descriptor() {
protobuf_AssignDescriptorsOnce();
return CSVCMsg_Sounds_descriptor_;
}
const CSVCMsg_Sounds& CSVCMsg_Sounds::default_instance() {
if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
return *default_instance_;
}
CSVCMsg_Sounds* CSVCMsg_Sounds::default_instance_ = NULL;
CSVCMsg_Sounds* CSVCMsg_Sounds::New() const {
return new CSVCMsg_Sounds;
}
void CSVCMsg_Sounds::Clear() {
reliable_sound_ = false;
sounds_.Clear();
::memset(_has_bits_, 0, sizeof(_has_bits_));
mutable_unknown_fields()->Clear();
}
bool CSVCMsg_Sounds::MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
::google::protobuf::uint32 tag;
// @@protoc_insertion_point(parse_start:CSVCMsg_Sounds)
for (;;) {
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// optional bool reliable_sound = 1;
case 1: {
if (tag == 8) {
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
input, &reliable_sound_)));
set_has_reliable_sound();
} else {
goto handle_unusual;
}
if (input->ExpectTag(18)) goto parse_sounds;
break;
}
// repeated .CSVCMsg_Sounds.sounddata_t sounds = 2;
case 2: {
if (tag == 18) {
parse_sounds:
DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
input, add_sounds()));
} else {
goto handle_unusual;
}
if (input->ExpectTag(18)) goto parse_sounds;
if (input->ExpectAtEnd()) goto success;
break;
}
default: {
handle_unusual:
if (tag == 0 ||
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
goto success;
}
DO_(::google::protobuf::internal::WireFormat::SkipField(
input, tag, mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:CSVCMsg_Sounds)
return true;
failure:
// @@protoc_insertion_point(parse_failure:CSVCMsg_Sounds)
return false;
#undef DO_
}
void CSVCMsg_Sounds::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:CSVCMsg_Sounds)
// optional bool reliable_sound = 1;
if (has_reliable_sound()) {
::google::protobuf::internal::WireFormatLite::WriteBool(1, this->reliable_sound(), output);
}
// repeated .CSVCMsg_Sounds.sounddata_t sounds = 2;
for (int i = 0; i < this->sounds_size(); i++) {
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
2, this->sounds(i), output);
}
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
}
// @@protoc_insertion_point(serialize_end:CSVCMsg_Sounds)
}
::google::protobuf::uint8* CSVCMsg_Sounds::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_Sounds)
// optional bool reliable_sound = 1;
if (has_reliable_sound()) {
target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->reliable_sound(), target);
}
// repeated .CSVCMsg_Sounds.sounddata_t sounds = 2;
for (int i = 0; i < this->sounds_size(); i++) {
target = ::google::protobuf::internal::WireFormatLite::
WriteMessageNoVirtualToArray(
2, this->sounds(i), target);
}
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
}
// @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_Sounds)
return target;
}
int CSVCMsg_Sounds::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// optional bool reliable_sound = 1;
if (has_reliable_sound()) {
total_size += 1 + 1;
}
}
// repeated .CSVCMsg_Sounds.sounddata_t sounds = 2;
total_size += 1 * this->sounds_size();
for (int i = 0; i < this->sounds_size(); i++) {
total_size +=
::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
this->sounds(i));
}
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 CSVCMsg_Sounds::MergeFrom(const ::google::protobuf::Message& from) {
GOOGLE_CHECK_NE(&from, this);
const CSVCMsg_Sounds* source =
::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_Sounds*>(
&from);
if (source == NULL) {
::google::protobuf::internal::ReflectionOps::Merge(from, this);
} else {
MergeFrom(*source);
}
}
void CSVCMsg_Sounds::MergeFrom(const CSVCMsg_Sounds& from) {
GOOGLE_CHECK_NE(&from, this);
sounds_.MergeFrom(from.sounds_);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
if (from.has_reliable_sound()) {
set_reliable_sound(from.reliable_sound());
}
}
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}
void CSVCMsg_Sounds::CopyFrom(const ::google::protobuf::Message& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
void CSVCMsg_Sounds::CopyFrom(const CSVCMsg_Sounds& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool CSVCMsg_Sounds::IsInitialized() const {
return true;
}
void CSVCMsg_Sounds::Swap(CSVCMsg_Sounds* other) {
if (other != this) {
std::swap(reliable_sound_, other->reliable_sound_);
sounds_.Swap(&other->sounds_);
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 CSVCMsg_Sounds::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
::google::protobuf::Metadata metadata;
metadata.descriptor = CSVCMsg_Sounds_descriptor_;
metadata.reflection = CSVCMsg_Sounds_reflection_;
return metadata;
}
// ===================================================================
#ifndef _MSC_VER
const int CSVCMsg_Prefetch::kSoundIndexFieldNumber;
#endif // !_MSC_VER
CSVCMsg_Prefetch::CSVCMsg_Prefetch()
: ::google::protobuf::Message() {
SharedCtor();
// @@protoc_insertion_point(constructor:CSVCMsg_Prefetch)
}
void CSVCMsg_Prefetch::InitAsDefaultInstance() {
}
CSVCMsg_Prefetch::CSVCMsg_Prefetch(const CSVCMsg_Prefetch& from)
: ::google::protobuf::Message() {
SharedCtor();
MergeFrom(from);
// @@protoc_insertion_point(copy_constructor:CSVCMsg_Prefetch)
}
void CSVCMsg_Prefetch::SharedCtor() {
_cached_size_ = 0;
sound_index_ = 0;
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
CSVCMsg_Prefetch::~CSVCMsg_Prefetch() {
// @@protoc_insertion_point(destructor:CSVCMsg_Prefetch)
SharedDtor();
}
void CSVCMsg_Prefetch::SharedDtor() {
if (this != default_instance_) {
}
}
void CSVCMsg_Prefetch::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_Prefetch::descriptor() {
protobuf_AssignDescriptorsOnce();
return CSVCMsg_Prefetch_descriptor_;
}
const CSVCMsg_Prefetch& CSVCMsg_Prefetch::default_instance() {
if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
return *default_instance_;
}
CSVCMsg_Prefetch* CSVCMsg_Prefetch::default_instance_ = NULL;
CSVCMsg_Prefetch* CSVCMsg_Prefetch::New() const {
return new CSVCMsg_Prefetch;
}
void CSVCMsg_Prefetch::Clear() {
sound_index_ = 0;
::memset(_has_bits_, 0, sizeof(_has_bits_));
mutable_unknown_fields()->Clear();
}
bool CSVCMsg_Prefetch::MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
::google::protobuf::uint32 tag;
// @@protoc_insertion_point(parse_start:CSVCMsg_Prefetch)
for (;;) {
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// optional int32 sound_index = 1;
case 1: {
if (tag == 8) {
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &sound_index_)));
set_has_sound_index();
} else {
goto handle_unusual;
}
if (input->ExpectAtEnd()) goto success;
break;
}
default: {
handle_unusual:
if (tag == 0 ||
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
goto success;
}
DO_(::google::protobuf::internal::WireFormat::SkipField(
input, tag, mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:CSVCMsg_Prefetch)
return true;
failure:
// @@protoc_insertion_point(parse_failure:CSVCMsg_Prefetch)
return false;
#undef DO_
}
void CSVCMsg_Prefetch::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:CSVCMsg_Prefetch)
// optional int32 sound_index = 1;
if (has_sound_index()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->sound_index(), output);
}
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
}
// @@protoc_insertion_point(serialize_end:CSVCMsg_Prefetch)
}
::google::protobuf::uint8* CSVCMsg_Prefetch::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_Prefetch)
// optional int32 sound_index = 1;
if (has_sound_index()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->sound_index(), target);
}
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
}
// @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_Prefetch)
return target;
}
int CSVCMsg_Prefetch::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// optional int32 sound_index = 1;
if (has_sound_index()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->sound_index());
}
}
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 CSVCMsg_Prefetch::MergeFrom(const ::google::protobuf::Message& from) {
GOOGLE_CHECK_NE(&from, this);
const CSVCMsg_Prefetch* source =
::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_Prefetch*>(
&from);
if (source == NULL) {
::google::protobuf::internal::ReflectionOps::Merge(from, this);
} else {
MergeFrom(*source);
}
}
void CSVCMsg_Prefetch::MergeFrom(const CSVCMsg_Prefetch& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
if (from.has_sound_index()) {
set_sound_index(from.sound_index());
}
}
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}
void CSVCMsg_Prefetch::CopyFrom(const ::google::protobuf::Message& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
void CSVCMsg_Prefetch::CopyFrom(const CSVCMsg_Prefetch& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool CSVCMsg_Prefetch::IsInitialized() const {
return true;
}
void CSVCMsg_Prefetch::Swap(CSVCMsg_Prefetch* other) {
if (other != this) {
std::swap(sound_index_, other->sound_index_);
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 CSVCMsg_Prefetch::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
::google::protobuf::Metadata metadata;
metadata.descriptor = CSVCMsg_Prefetch_descriptor_;
metadata.reflection = CSVCMsg_Prefetch_reflection_;
return metadata;
}
// ===================================================================
#ifndef _MSC_VER
const int CSVCMsg_SetView::kEntityIndexFieldNumber;
#endif // !_MSC_VER
CSVCMsg_SetView::CSVCMsg_SetView()
: ::google::protobuf::Message() {
SharedCtor();
// @@protoc_insertion_point(constructor:CSVCMsg_SetView)
}
void CSVCMsg_SetView::InitAsDefaultInstance() {
}
CSVCMsg_SetView::CSVCMsg_SetView(const CSVCMsg_SetView& from)
: ::google::protobuf::Message() {
SharedCtor();
MergeFrom(from);
// @@protoc_insertion_point(copy_constructor:CSVCMsg_SetView)
}
void CSVCMsg_SetView::SharedCtor() {
_cached_size_ = 0;
entity_index_ = 0;
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
CSVCMsg_SetView::~CSVCMsg_SetView() {
// @@protoc_insertion_point(destructor:CSVCMsg_SetView)
SharedDtor();
}
void CSVCMsg_SetView::SharedDtor() {
if (this != default_instance_) {
}
}
void CSVCMsg_SetView::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_SetView::descriptor() {
protobuf_AssignDescriptorsOnce();
return CSVCMsg_SetView_descriptor_;
}
const CSVCMsg_SetView& CSVCMsg_SetView::default_instance() {
if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
return *default_instance_;
}
CSVCMsg_SetView* CSVCMsg_SetView::default_instance_ = NULL;
CSVCMsg_SetView* CSVCMsg_SetView::New() const {
return new CSVCMsg_SetView;
}
void CSVCMsg_SetView::Clear() {
entity_index_ = 0;
::memset(_has_bits_, 0, sizeof(_has_bits_));
mutable_unknown_fields()->Clear();
}
bool CSVCMsg_SetView::MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
::google::protobuf::uint32 tag;
// @@protoc_insertion_point(parse_start:CSVCMsg_SetView)
for (;;) {
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// optional int32 entity_index = 1;
case 1: {
if (tag == 8) {
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &entity_index_)));
set_has_entity_index();
} else {
goto handle_unusual;
}
if (input->ExpectAtEnd()) goto success;
break;
}
default: {
handle_unusual:
if (tag == 0 ||
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
goto success;
}
DO_(::google::protobuf::internal::WireFormat::SkipField(
input, tag, mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:CSVCMsg_SetView)
return true;
failure:
// @@protoc_insertion_point(parse_failure:CSVCMsg_SetView)
return false;
#undef DO_
}
void CSVCMsg_SetView::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:CSVCMsg_SetView)
// optional int32 entity_index = 1;
if (has_entity_index()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->entity_index(), output);
}
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
}
// @@protoc_insertion_point(serialize_end:CSVCMsg_SetView)
}
::google::protobuf::uint8* CSVCMsg_SetView::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_SetView)
// optional int32 entity_index = 1;
if (has_entity_index()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->entity_index(), target);
}
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
}
// @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_SetView)
return target;
}
int CSVCMsg_SetView::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// optional int32 entity_index = 1;
if (has_entity_index()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->entity_index());
}
}
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 CSVCMsg_SetView::MergeFrom(const ::google::protobuf::Message& from) {
GOOGLE_CHECK_NE(&from, this);
const CSVCMsg_SetView* source =
::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_SetView*>(
&from);
if (source == NULL) {
::google::protobuf::internal::ReflectionOps::Merge(from, this);
} else {
MergeFrom(*source);
}
}
void CSVCMsg_SetView::MergeFrom(const CSVCMsg_SetView& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
if (from.has_entity_index()) {
set_entity_index(from.entity_index());
}
}
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}
void CSVCMsg_SetView::CopyFrom(const ::google::protobuf::Message& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
void CSVCMsg_SetView::CopyFrom(const CSVCMsg_SetView& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool CSVCMsg_SetView::IsInitialized() const {
return true;
}
void CSVCMsg_SetView::Swap(CSVCMsg_SetView* other) {
if (other != this) {
std::swap(entity_index_, other->entity_index_);
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 CSVCMsg_SetView::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
::google::protobuf::Metadata metadata;
metadata.descriptor = CSVCMsg_SetView_descriptor_;
metadata.reflection = CSVCMsg_SetView_reflection_;
return metadata;
}
// ===================================================================
#ifndef _MSC_VER
const int CSVCMsg_FixAngle::kRelativeFieldNumber;
const int CSVCMsg_FixAngle::kAngleFieldNumber;
#endif // !_MSC_VER
CSVCMsg_FixAngle::CSVCMsg_FixAngle()
: ::google::protobuf::Message() {
SharedCtor();
// @@protoc_insertion_point(constructor:CSVCMsg_FixAngle)
}
void CSVCMsg_FixAngle::InitAsDefaultInstance() {
angle_ = const_cast< ::CMsgQAngle*>(&::CMsgQAngle::default_instance());
}
CSVCMsg_FixAngle::CSVCMsg_FixAngle(const CSVCMsg_FixAngle& from)
: ::google::protobuf::Message() {
SharedCtor();
MergeFrom(from);
// @@protoc_insertion_point(copy_constructor:CSVCMsg_FixAngle)
}
void CSVCMsg_FixAngle::SharedCtor() {
_cached_size_ = 0;
relative_ = false;
angle_ = NULL;
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
CSVCMsg_FixAngle::~CSVCMsg_FixAngle() {
// @@protoc_insertion_point(destructor:CSVCMsg_FixAngle)
SharedDtor();
}
void CSVCMsg_FixAngle::SharedDtor() {
if (this != default_instance_) {
delete angle_;
}
}
void CSVCMsg_FixAngle::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_FixAngle::descriptor() {
protobuf_AssignDescriptorsOnce();
return CSVCMsg_FixAngle_descriptor_;
}
const CSVCMsg_FixAngle& CSVCMsg_FixAngle::default_instance() {
if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
return *default_instance_;
}
CSVCMsg_FixAngle* CSVCMsg_FixAngle::default_instance_ = NULL;
CSVCMsg_FixAngle* CSVCMsg_FixAngle::New() const {
return new CSVCMsg_FixAngle;
}
void CSVCMsg_FixAngle::Clear() {
if (_has_bits_[0 / 32] & 3) {
relative_ = false;
if (has_angle()) {
if (angle_ != NULL) angle_->::CMsgQAngle::Clear();
}
}
::memset(_has_bits_, 0, sizeof(_has_bits_));
mutable_unknown_fields()->Clear();
}
bool CSVCMsg_FixAngle::MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
::google::protobuf::uint32 tag;
// @@protoc_insertion_point(parse_start:CSVCMsg_FixAngle)
for (;;) {
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// optional bool relative = 1;
case 1: {
if (tag == 8) {
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
input, &relative_)));
set_has_relative();
} else {
goto handle_unusual;
}
if (input->ExpectTag(18)) goto parse_angle;
break;
}
// optional .CMsgQAngle angle = 2;
case 2: {
if (tag == 18) {
parse_angle:
DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
input, mutable_angle()));
} else {
goto handle_unusual;
}
if (input->ExpectAtEnd()) goto success;
break;
}
default: {
handle_unusual:
if (tag == 0 ||
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
goto success;
}
DO_(::google::protobuf::internal::WireFormat::SkipField(
input, tag, mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:CSVCMsg_FixAngle)
return true;
failure:
// @@protoc_insertion_point(parse_failure:CSVCMsg_FixAngle)
return false;
#undef DO_
}
void CSVCMsg_FixAngle::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:CSVCMsg_FixAngle)
// optional bool relative = 1;
if (has_relative()) {
::google::protobuf::internal::WireFormatLite::WriteBool(1, this->relative(), output);
}
// optional .CMsgQAngle angle = 2;
if (has_angle()) {
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
2, this->angle(), output);
}
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
}
// @@protoc_insertion_point(serialize_end:CSVCMsg_FixAngle)
}
::google::protobuf::uint8* CSVCMsg_FixAngle::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_FixAngle)
// optional bool relative = 1;
if (has_relative()) {
target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->relative(), target);
}
// optional .CMsgQAngle angle = 2;
if (has_angle()) {
target = ::google::protobuf::internal::WireFormatLite::
WriteMessageNoVirtualToArray(
2, this->angle(), target);
}
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
}
// @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_FixAngle)
return target;
}
int CSVCMsg_FixAngle::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// optional bool relative = 1;
if (has_relative()) {
total_size += 1 + 1;
}
// optional .CMsgQAngle angle = 2;
if (has_angle()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
this->angle());
}
}
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 CSVCMsg_FixAngle::MergeFrom(const ::google::protobuf::Message& from) {
GOOGLE_CHECK_NE(&from, this);
const CSVCMsg_FixAngle* source =
::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_FixAngle*>(
&from);
if (source == NULL) {
::google::protobuf::internal::ReflectionOps::Merge(from, this);
} else {
MergeFrom(*source);
}
}
void CSVCMsg_FixAngle::MergeFrom(const CSVCMsg_FixAngle& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
if (from.has_relative()) {
set_relative(from.relative());
}
if (from.has_angle()) {
mutable_angle()->::CMsgQAngle::MergeFrom(from.angle());
}
}
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}
void CSVCMsg_FixAngle::CopyFrom(const ::google::protobuf::Message& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
void CSVCMsg_FixAngle::CopyFrom(const CSVCMsg_FixAngle& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool CSVCMsg_FixAngle::IsInitialized() const {
return true;
}
void CSVCMsg_FixAngle::Swap(CSVCMsg_FixAngle* other) {
if (other != this) {
std::swap(relative_, other->relative_);
std::swap(angle_, other->angle_);
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 CSVCMsg_FixAngle::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
::google::protobuf::Metadata metadata;
metadata.descriptor = CSVCMsg_FixAngle_descriptor_;
metadata.reflection = CSVCMsg_FixAngle_reflection_;
return metadata;
}
// ===================================================================
#ifndef _MSC_VER
const int CSVCMsg_CrosshairAngle::kAngleFieldNumber;
#endif // !_MSC_VER
CSVCMsg_CrosshairAngle::CSVCMsg_CrosshairAngle()
: ::google::protobuf::Message() {
SharedCtor();
// @@protoc_insertion_point(constructor:CSVCMsg_CrosshairAngle)
}
void CSVCMsg_CrosshairAngle::InitAsDefaultInstance() {
angle_ = const_cast< ::CMsgQAngle*>(&::CMsgQAngle::default_instance());
}
CSVCMsg_CrosshairAngle::CSVCMsg_CrosshairAngle(const CSVCMsg_CrosshairAngle& from)
: ::google::protobuf::Message() {
SharedCtor();
MergeFrom(from);
// @@protoc_insertion_point(copy_constructor:CSVCMsg_CrosshairAngle)
}
void CSVCMsg_CrosshairAngle::SharedCtor() {
_cached_size_ = 0;
angle_ = NULL;
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
CSVCMsg_CrosshairAngle::~CSVCMsg_CrosshairAngle() {
// @@protoc_insertion_point(destructor:CSVCMsg_CrosshairAngle)
SharedDtor();
}
void CSVCMsg_CrosshairAngle::SharedDtor() {
if (this != default_instance_) {
delete angle_;
}
}
void CSVCMsg_CrosshairAngle::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_CrosshairAngle::descriptor() {
protobuf_AssignDescriptorsOnce();
return CSVCMsg_CrosshairAngle_descriptor_;
}
const CSVCMsg_CrosshairAngle& CSVCMsg_CrosshairAngle::default_instance() {
if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
return *default_instance_;
}
CSVCMsg_CrosshairAngle* CSVCMsg_CrosshairAngle::default_instance_ = NULL;
CSVCMsg_CrosshairAngle* CSVCMsg_CrosshairAngle::New() const {
return new CSVCMsg_CrosshairAngle;
}
void CSVCMsg_CrosshairAngle::Clear() {
if (has_angle()) {
if (angle_ != NULL) angle_->::CMsgQAngle::Clear();
}
::memset(_has_bits_, 0, sizeof(_has_bits_));
mutable_unknown_fields()->Clear();
}
bool CSVCMsg_CrosshairAngle::MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
::google::protobuf::uint32 tag;
// @@protoc_insertion_point(parse_start:CSVCMsg_CrosshairAngle)
for (;;) {
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// optional .CMsgQAngle angle = 1;
case 1: {
if (tag == 10) {
DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
input, mutable_angle()));
} else {
goto handle_unusual;
}
if (input->ExpectAtEnd()) goto success;
break;
}
default: {
handle_unusual:
if (tag == 0 ||
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
goto success;
}
DO_(::google::protobuf::internal::WireFormat::SkipField(
input, tag, mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:CSVCMsg_CrosshairAngle)
return true;
failure:
// @@protoc_insertion_point(parse_failure:CSVCMsg_CrosshairAngle)
return false;
#undef DO_
}
void CSVCMsg_CrosshairAngle::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:CSVCMsg_CrosshairAngle)
// optional .CMsgQAngle angle = 1;
if (has_angle()) {
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1, this->angle(), output);
}
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
}
// @@protoc_insertion_point(serialize_end:CSVCMsg_CrosshairAngle)
}
::google::protobuf::uint8* CSVCMsg_CrosshairAngle::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_CrosshairAngle)
// optional .CMsgQAngle angle = 1;
if (has_angle()) {
target = ::google::protobuf::internal::WireFormatLite::
WriteMessageNoVirtualToArray(
1, this->angle(), target);
}
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
}
// @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_CrosshairAngle)
return target;
}
int CSVCMsg_CrosshairAngle::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// optional .CMsgQAngle angle = 1;
if (has_angle()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
this->angle());
}
}
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 CSVCMsg_CrosshairAngle::MergeFrom(const ::google::protobuf::Message& from) {
GOOGLE_CHECK_NE(&from, this);
const CSVCMsg_CrosshairAngle* source =
::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_CrosshairAngle*>(
&from);
if (source == NULL) {
::google::protobuf::internal::ReflectionOps::Merge(from, this);
} else {
MergeFrom(*source);
}
}
void CSVCMsg_CrosshairAngle::MergeFrom(const CSVCMsg_CrosshairAngle& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
if (from.has_angle()) {
mutable_angle()->::CMsgQAngle::MergeFrom(from.angle());
}
}
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}
void CSVCMsg_CrosshairAngle::CopyFrom(const ::google::protobuf::Message& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
void CSVCMsg_CrosshairAngle::CopyFrom(const CSVCMsg_CrosshairAngle& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool CSVCMsg_CrosshairAngle::IsInitialized() const {
return true;
}
void CSVCMsg_CrosshairAngle::Swap(CSVCMsg_CrosshairAngle* other) {
if (other != this) {
std::swap(angle_, other->angle_);
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 CSVCMsg_CrosshairAngle::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
::google::protobuf::Metadata metadata;
metadata.descriptor = CSVCMsg_CrosshairAngle_descriptor_;
metadata.reflection = CSVCMsg_CrosshairAngle_reflection_;
return metadata;
}
// ===================================================================
#ifndef _MSC_VER
const int CSVCMsg_BSPDecal::kPosFieldNumber;
const int CSVCMsg_BSPDecal::kDecalTextureIndexFieldNumber;
const int CSVCMsg_BSPDecal::kEntityIndexFieldNumber;
const int CSVCMsg_BSPDecal::kModelIndexFieldNumber;
const int CSVCMsg_BSPDecal::kLowPriorityFieldNumber;
#endif // !_MSC_VER
CSVCMsg_BSPDecal::CSVCMsg_BSPDecal()
: ::google::protobuf::Message() {
SharedCtor();
// @@protoc_insertion_point(constructor:CSVCMsg_BSPDecal)
}
void CSVCMsg_BSPDecal::InitAsDefaultInstance() {
pos_ = const_cast< ::CMsgVector*>(&::CMsgVector::default_instance());
}
CSVCMsg_BSPDecal::CSVCMsg_BSPDecal(const CSVCMsg_BSPDecal& from)
: ::google::protobuf::Message() {
SharedCtor();
MergeFrom(from);
// @@protoc_insertion_point(copy_constructor:CSVCMsg_BSPDecal)
}
void CSVCMsg_BSPDecal::SharedCtor() {
_cached_size_ = 0;
pos_ = NULL;
decal_texture_index_ = 0;
entity_index_ = 0;
model_index_ = 0;
low_priority_ = false;
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
CSVCMsg_BSPDecal::~CSVCMsg_BSPDecal() {
// @@protoc_insertion_point(destructor:CSVCMsg_BSPDecal)
SharedDtor();
}
void CSVCMsg_BSPDecal::SharedDtor() {
if (this != default_instance_) {
delete pos_;
}
}
void CSVCMsg_BSPDecal::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_BSPDecal::descriptor() {
protobuf_AssignDescriptorsOnce();
return CSVCMsg_BSPDecal_descriptor_;
}
const CSVCMsg_BSPDecal& CSVCMsg_BSPDecal::default_instance() {
if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
return *default_instance_;
}
CSVCMsg_BSPDecal* CSVCMsg_BSPDecal::default_instance_ = NULL;
CSVCMsg_BSPDecal* CSVCMsg_BSPDecal::New() const {
return new CSVCMsg_BSPDecal;
}
void CSVCMsg_BSPDecal::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>( \
&reinterpret_cast<CSVCMsg_BSPDecal*>(16)->f) - \
reinterpret_cast<char*>(16))
#define ZR_(first, last) do { \
size_t f = OFFSET_OF_FIELD_(first); \
size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \
::memset(&first, 0, n); \
} while (0)
if (_has_bits_[0 / 32] & 31) {
ZR_(decal_texture_index_, low_priority_);
if (has_pos()) {
if (pos_ != NULL) pos_->::CMsgVector::Clear();
}
}
#undef OFFSET_OF_FIELD_
#undef ZR_
::memset(_has_bits_, 0, sizeof(_has_bits_));
mutable_unknown_fields()->Clear();
}
bool CSVCMsg_BSPDecal::MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
::google::protobuf::uint32 tag;
// @@protoc_insertion_point(parse_start:CSVCMsg_BSPDecal)
for (;;) {
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// optional .CMsgVector pos = 1;
case 1: {
if (tag == 10) {
DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
input, mutable_pos()));
} else {
goto handle_unusual;
}
if (input->ExpectTag(16)) goto parse_decal_texture_index;
break;
}
// optional int32 decal_texture_index = 2;
case 2: {
if (tag == 16) {
parse_decal_texture_index:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &decal_texture_index_)));
set_has_decal_texture_index();
} else {
goto handle_unusual;
}
if (input->ExpectTag(24)) goto parse_entity_index;
break;
}
// optional int32 entity_index = 3;
case 3: {
if (tag == 24) {
parse_entity_index:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &entity_index_)));
set_has_entity_index();
} else {
goto handle_unusual;
}
if (input->ExpectTag(32)) goto parse_model_index;
break;
}
// optional int32 model_index = 4;
case 4: {
if (tag == 32) {
parse_model_index:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &model_index_)));
set_has_model_index();
} else {
goto handle_unusual;
}
if (input->ExpectTag(40)) goto parse_low_priority;
break;
}
// optional bool low_priority = 5;
case 5: {
if (tag == 40) {
parse_low_priority:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
input, &low_priority_)));
set_has_low_priority();
} else {
goto handle_unusual;
}
if (input->ExpectAtEnd()) goto success;
break;
}
default: {
handle_unusual:
if (tag == 0 ||
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
goto success;
}
DO_(::google::protobuf::internal::WireFormat::SkipField(
input, tag, mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:CSVCMsg_BSPDecal)
return true;
failure:
// @@protoc_insertion_point(parse_failure:CSVCMsg_BSPDecal)
return false;
#undef DO_
}
void CSVCMsg_BSPDecal::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:CSVCMsg_BSPDecal)
// optional .CMsgVector pos = 1;
if (has_pos()) {
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1, this->pos(), output);
}
// optional int32 decal_texture_index = 2;
if (has_decal_texture_index()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->decal_texture_index(), output);
}
// optional int32 entity_index = 3;
if (has_entity_index()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->entity_index(), output);
}
// optional int32 model_index = 4;
if (has_model_index()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->model_index(), output);
}
// optional bool low_priority = 5;
if (has_low_priority()) {
::google::protobuf::internal::WireFormatLite::WriteBool(5, this->low_priority(), output);
}
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
}
// @@protoc_insertion_point(serialize_end:CSVCMsg_BSPDecal)
}
::google::protobuf::uint8* CSVCMsg_BSPDecal::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_BSPDecal)
// optional .CMsgVector pos = 1;
if (has_pos()) {
target = ::google::protobuf::internal::WireFormatLite::
WriteMessageNoVirtualToArray(
1, this->pos(), target);
}
// optional int32 decal_texture_index = 2;
if (has_decal_texture_index()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->decal_texture_index(), target);
}
// optional int32 entity_index = 3;
if (has_entity_index()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->entity_index(), target);
}
// optional int32 model_index = 4;
if (has_model_index()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->model_index(), target);
}
// optional bool low_priority = 5;
if (has_low_priority()) {
target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->low_priority(), target);
}
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
}
// @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_BSPDecal)
return target;
}
int CSVCMsg_BSPDecal::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// optional .CMsgVector pos = 1;
if (has_pos()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
this->pos());
}
// optional int32 decal_texture_index = 2;
if (has_decal_texture_index()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->decal_texture_index());
}
// optional int32 entity_index = 3;
if (has_entity_index()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->entity_index());
}
// optional int32 model_index = 4;
if (has_model_index()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->model_index());
}
// optional bool low_priority = 5;
if (has_low_priority()) {
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 CSVCMsg_BSPDecal::MergeFrom(const ::google::protobuf::Message& from) {
GOOGLE_CHECK_NE(&from, this);
const CSVCMsg_BSPDecal* source =
::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_BSPDecal*>(
&from);
if (source == NULL) {
::google::protobuf::internal::ReflectionOps::Merge(from, this);
} else {
MergeFrom(*source);
}
}
void CSVCMsg_BSPDecal::MergeFrom(const CSVCMsg_BSPDecal& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
if (from.has_pos()) {
mutable_pos()->::CMsgVector::MergeFrom(from.pos());
}
if (from.has_decal_texture_index()) {
set_decal_texture_index(from.decal_texture_index());
}
if (from.has_entity_index()) {
set_entity_index(from.entity_index());
}
if (from.has_model_index()) {
set_model_index(from.model_index());
}
if (from.has_low_priority()) {
set_low_priority(from.low_priority());
}
}
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}
void CSVCMsg_BSPDecal::CopyFrom(const ::google::protobuf::Message& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
void CSVCMsg_BSPDecal::CopyFrom(const CSVCMsg_BSPDecal& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool CSVCMsg_BSPDecal::IsInitialized() const {
return true;
}
void CSVCMsg_BSPDecal::Swap(CSVCMsg_BSPDecal* other) {
if (other != this) {
std::swap(pos_, other->pos_);
std::swap(decal_texture_index_, other->decal_texture_index_);
std::swap(entity_index_, other->entity_index_);
std::swap(model_index_, other->model_index_);
std::swap(low_priority_, other->low_priority_);
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 CSVCMsg_BSPDecal::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
::google::protobuf::Metadata metadata;
metadata.descriptor = CSVCMsg_BSPDecal_descriptor_;
metadata.reflection = CSVCMsg_BSPDecal_reflection_;
return metadata;
}
// ===================================================================
#ifndef _MSC_VER
const int CSVCMsg_SplitScreen::kTypeFieldNumber;
const int CSVCMsg_SplitScreen::kSlotFieldNumber;
const int CSVCMsg_SplitScreen::kPlayerIndexFieldNumber;
#endif // !_MSC_VER
CSVCMsg_SplitScreen::CSVCMsg_SplitScreen()
: ::google::protobuf::Message() {
SharedCtor();
// @@protoc_insertion_point(constructor:CSVCMsg_SplitScreen)
}
void CSVCMsg_SplitScreen::InitAsDefaultInstance() {
}
CSVCMsg_SplitScreen::CSVCMsg_SplitScreen(const CSVCMsg_SplitScreen& from)
: ::google::protobuf::Message() {
SharedCtor();
MergeFrom(from);
// @@protoc_insertion_point(copy_constructor:CSVCMsg_SplitScreen)
}
void CSVCMsg_SplitScreen::SharedCtor() {
_cached_size_ = 0;
type_ = 0;
slot_ = 0;
player_index_ = 0;
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
CSVCMsg_SplitScreen::~CSVCMsg_SplitScreen() {
// @@protoc_insertion_point(destructor:CSVCMsg_SplitScreen)
SharedDtor();
}
void CSVCMsg_SplitScreen::SharedDtor() {
if (this != default_instance_) {
}
}
void CSVCMsg_SplitScreen::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_SplitScreen::descriptor() {
protobuf_AssignDescriptorsOnce();
return CSVCMsg_SplitScreen_descriptor_;
}
const CSVCMsg_SplitScreen& CSVCMsg_SplitScreen::default_instance() {
if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
return *default_instance_;
}
CSVCMsg_SplitScreen* CSVCMsg_SplitScreen::default_instance_ = NULL;
CSVCMsg_SplitScreen* CSVCMsg_SplitScreen::New() const {
return new CSVCMsg_SplitScreen;
}
void CSVCMsg_SplitScreen::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>( \
&reinterpret_cast<CSVCMsg_SplitScreen*>(16)->f) - \
reinterpret_cast<char*>(16))
#define ZR_(first, last) do { \
size_t f = OFFSET_OF_FIELD_(first); \
size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \
::memset(&first, 0, n); \
} while (0)
ZR_(type_, player_index_);
#undef OFFSET_OF_FIELD_
#undef ZR_
::memset(_has_bits_, 0, sizeof(_has_bits_));
mutable_unknown_fields()->Clear();
}
bool CSVCMsg_SplitScreen::MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
::google::protobuf::uint32 tag;
// @@protoc_insertion_point(parse_start:CSVCMsg_SplitScreen)
for (;;) {
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// optional .ESplitScreenMessageType type = 1 [default = MSG_SPLITSCREEN_ADDUSER];
case 1: {
if (tag == 8) {
int value;
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
input, &value)));
if (::ESplitScreenMessageType_IsValid(value)) {
set_type(static_cast< ::ESplitScreenMessageType >(value));
} else {
mutable_unknown_fields()->AddVarint(1, value);
}
} else {
goto handle_unusual;
}
if (input->ExpectTag(16)) goto parse_slot;
break;
}
// optional int32 slot = 2;
case 2: {
if (tag == 16) {
parse_slot:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &slot_)));
set_has_slot();
} else {
goto handle_unusual;
}
if (input->ExpectTag(24)) goto parse_player_index;
break;
}
// optional int32 player_index = 3;
case 3: {
if (tag == 24) {
parse_player_index:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &player_index_)));
set_has_player_index();
} else {
goto handle_unusual;
}
if (input->ExpectAtEnd()) goto success;
break;
}
default: {
handle_unusual:
if (tag == 0 ||
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
goto success;
}
DO_(::google::protobuf::internal::WireFormat::SkipField(
input, tag, mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:CSVCMsg_SplitScreen)
return true;
failure:
// @@protoc_insertion_point(parse_failure:CSVCMsg_SplitScreen)
return false;
#undef DO_
}
void CSVCMsg_SplitScreen::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:CSVCMsg_SplitScreen)
// optional .ESplitScreenMessageType type = 1 [default = MSG_SPLITSCREEN_ADDUSER];
if (has_type()) {
::google::protobuf::internal::WireFormatLite::WriteEnum(
1, this->type(), output);
}
// optional int32 slot = 2;
if (has_slot()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->slot(), output);
}
// optional int32 player_index = 3;
if (has_player_index()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->player_index(), output);
}
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
}
// @@protoc_insertion_point(serialize_end:CSVCMsg_SplitScreen)
}
::google::protobuf::uint8* CSVCMsg_SplitScreen::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_SplitScreen)
// optional .ESplitScreenMessageType type = 1 [default = MSG_SPLITSCREEN_ADDUSER];
if (has_type()) {
target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
1, this->type(), target);
}
// optional int32 slot = 2;
if (has_slot()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->slot(), target);
}
// optional int32 player_index = 3;
if (has_player_index()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->player_index(), target);
}
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
}
// @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_SplitScreen)
return target;
}
int CSVCMsg_SplitScreen::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// optional .ESplitScreenMessageType type = 1 [default = MSG_SPLITSCREEN_ADDUSER];
if (has_type()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
}
// optional int32 slot = 2;
if (has_slot()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->slot());
}
// optional int32 player_index = 3;
if (has_player_index()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->player_index());
}
}
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 CSVCMsg_SplitScreen::MergeFrom(const ::google::protobuf::Message& from) {
GOOGLE_CHECK_NE(&from, this);
const CSVCMsg_SplitScreen* source =
::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_SplitScreen*>(
&from);
if (source == NULL) {
::google::protobuf::internal::ReflectionOps::Merge(from, this);
} else {
MergeFrom(*source);
}
}
void CSVCMsg_SplitScreen::MergeFrom(const CSVCMsg_SplitScreen& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
if (from.has_type()) {
set_type(from.type());
}
if (from.has_slot()) {
set_slot(from.slot());
}
if (from.has_player_index()) {
set_player_index(from.player_index());
}
}
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}
void CSVCMsg_SplitScreen::CopyFrom(const ::google::protobuf::Message& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
void CSVCMsg_SplitScreen::CopyFrom(const CSVCMsg_SplitScreen& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool CSVCMsg_SplitScreen::IsInitialized() const {
return true;
}
void CSVCMsg_SplitScreen::Swap(CSVCMsg_SplitScreen* other) {
if (other != this) {
std::swap(type_, other->type_);
std::swap(slot_, other->slot_);
std::swap(player_index_, other->player_index_);
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 CSVCMsg_SplitScreen::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
::google::protobuf::Metadata metadata;
metadata.descriptor = CSVCMsg_SplitScreen_descriptor_;
metadata.reflection = CSVCMsg_SplitScreen_reflection_;
return metadata;
}
// ===================================================================
#ifndef _MSC_VER
const int CSVCMsg_GetCvarValue::kCookieFieldNumber;
const int CSVCMsg_GetCvarValue::kCvarNameFieldNumber;
#endif // !_MSC_VER
CSVCMsg_GetCvarValue::CSVCMsg_GetCvarValue()
: ::google::protobuf::Message() {
SharedCtor();
// @@protoc_insertion_point(constructor:CSVCMsg_GetCvarValue)
}
void CSVCMsg_GetCvarValue::InitAsDefaultInstance() {
}
CSVCMsg_GetCvarValue::CSVCMsg_GetCvarValue(const CSVCMsg_GetCvarValue& from)
: ::google::protobuf::Message() {
SharedCtor();
MergeFrom(from);
// @@protoc_insertion_point(copy_constructor:CSVCMsg_GetCvarValue)
}
void CSVCMsg_GetCvarValue::SharedCtor() {
::google::protobuf::internal::GetEmptyString();
_cached_size_ = 0;
cookie_ = 0;
cvar_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
CSVCMsg_GetCvarValue::~CSVCMsg_GetCvarValue() {
// @@protoc_insertion_point(destructor:CSVCMsg_GetCvarValue)
SharedDtor();
}
void CSVCMsg_GetCvarValue::SharedDtor() {
if (cvar_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
delete cvar_name_;
}
if (this != default_instance_) {
}
}
void CSVCMsg_GetCvarValue::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_GetCvarValue::descriptor() {
protobuf_AssignDescriptorsOnce();
return CSVCMsg_GetCvarValue_descriptor_;
}
const CSVCMsg_GetCvarValue& CSVCMsg_GetCvarValue::default_instance() {
if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
return *default_instance_;
}
CSVCMsg_GetCvarValue* CSVCMsg_GetCvarValue::default_instance_ = NULL;
CSVCMsg_GetCvarValue* CSVCMsg_GetCvarValue::New() const {
return new CSVCMsg_GetCvarValue;
}
void CSVCMsg_GetCvarValue::Clear() {
if (_has_bits_[0 / 32] & 3) {
cookie_ = 0;
if (has_cvar_name()) {
if (cvar_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
cvar_name_->clear();
}
}
}
::memset(_has_bits_, 0, sizeof(_has_bits_));
mutable_unknown_fields()->Clear();
}
bool CSVCMsg_GetCvarValue::MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
::google::protobuf::uint32 tag;
// @@protoc_insertion_point(parse_start:CSVCMsg_GetCvarValue)
for (;;) {
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// optional int32 cookie = 1;
case 1: {
if (tag == 8) {
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &cookie_)));
set_has_cookie();
} else {
goto handle_unusual;
}
if (input->ExpectTag(18)) goto parse_cvar_name;
break;
}
// optional string cvar_name = 2;
case 2: {
if (tag == 18) {
parse_cvar_name:
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
input, this->mutable_cvar_name()));
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->cvar_name().data(), this->cvar_name().length(),
::google::protobuf::internal::WireFormat::PARSE,
"cvar_name");
} else {
goto handle_unusual;
}
if (input->ExpectAtEnd()) goto success;
break;
}
default: {
handle_unusual:
if (tag == 0 ||
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
goto success;
}
DO_(::google::protobuf::internal::WireFormat::SkipField(
input, tag, mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:CSVCMsg_GetCvarValue)
return true;
failure:
// @@protoc_insertion_point(parse_failure:CSVCMsg_GetCvarValue)
return false;
#undef DO_
}
void CSVCMsg_GetCvarValue::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:CSVCMsg_GetCvarValue)
// optional int32 cookie = 1;
if (has_cookie()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->cookie(), output);
}
// optional string cvar_name = 2;
if (has_cvar_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->cvar_name().data(), this->cvar_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"cvar_name");
::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
2, this->cvar_name(), output);
}
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
}
// @@protoc_insertion_point(serialize_end:CSVCMsg_GetCvarValue)
}
::google::protobuf::uint8* CSVCMsg_GetCvarValue::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_GetCvarValue)
// optional int32 cookie = 1;
if (has_cookie()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->cookie(), target);
}
// optional string cvar_name = 2;
if (has_cvar_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->cvar_name().data(), this->cvar_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"cvar_name");
target =
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2, this->cvar_name(), target);
}
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
}
// @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_GetCvarValue)
return target;
}
int CSVCMsg_GetCvarValue::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// optional int32 cookie = 1;
if (has_cookie()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->cookie());
}
// optional string cvar_name = 2;
if (has_cvar_name()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::StringSize(
this->cvar_name());
}
}
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 CSVCMsg_GetCvarValue::MergeFrom(const ::google::protobuf::Message& from) {
GOOGLE_CHECK_NE(&from, this);
const CSVCMsg_GetCvarValue* source =
::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_GetCvarValue*>(
&from);
if (source == NULL) {
::google::protobuf::internal::ReflectionOps::Merge(from, this);
} else {
MergeFrom(*source);
}
}
void CSVCMsg_GetCvarValue::MergeFrom(const CSVCMsg_GetCvarValue& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
if (from.has_cookie()) {
set_cookie(from.cookie());
}
if (from.has_cvar_name()) {
set_cvar_name(from.cvar_name());
}
}
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}
void CSVCMsg_GetCvarValue::CopyFrom(const ::google::protobuf::Message& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
void CSVCMsg_GetCvarValue::CopyFrom(const CSVCMsg_GetCvarValue& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool CSVCMsg_GetCvarValue::IsInitialized() const {
return true;
}
void CSVCMsg_GetCvarValue::Swap(CSVCMsg_GetCvarValue* other) {
if (other != this) {
std::swap(cookie_, other->cookie_);
std::swap(cvar_name_, other->cvar_name_);
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 CSVCMsg_GetCvarValue::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
::google::protobuf::Metadata metadata;
metadata.descriptor = CSVCMsg_GetCvarValue_descriptor_;
metadata.reflection = CSVCMsg_GetCvarValue_reflection_;
return metadata;
}
// ===================================================================
#ifndef _MSC_VER
const int CSVCMsg_Menu::kDialogTypeFieldNumber;
const int CSVCMsg_Menu::kMenuKeyValuesFieldNumber;
#endif // !_MSC_VER
CSVCMsg_Menu::CSVCMsg_Menu()
: ::google::protobuf::Message() {
SharedCtor();
// @@protoc_insertion_point(constructor:CSVCMsg_Menu)
}
void CSVCMsg_Menu::InitAsDefaultInstance() {
}
CSVCMsg_Menu::CSVCMsg_Menu(const CSVCMsg_Menu& from)
: ::google::protobuf::Message() {
SharedCtor();
MergeFrom(from);
// @@protoc_insertion_point(copy_constructor:CSVCMsg_Menu)
}
void CSVCMsg_Menu::SharedCtor() {
::google::protobuf::internal::GetEmptyString();
_cached_size_ = 0;
dialog_type_ = 0;
menu_key_values_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
CSVCMsg_Menu::~CSVCMsg_Menu() {
// @@protoc_insertion_point(destructor:CSVCMsg_Menu)
SharedDtor();
}
void CSVCMsg_Menu::SharedDtor() {
if (menu_key_values_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
delete menu_key_values_;
}
if (this != default_instance_) {
}
}
void CSVCMsg_Menu::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_Menu::descriptor() {
protobuf_AssignDescriptorsOnce();
return CSVCMsg_Menu_descriptor_;
}
const CSVCMsg_Menu& CSVCMsg_Menu::default_instance() {
if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
return *default_instance_;
}
CSVCMsg_Menu* CSVCMsg_Menu::default_instance_ = NULL;
CSVCMsg_Menu* CSVCMsg_Menu::New() const {
return new CSVCMsg_Menu;
}
void CSVCMsg_Menu::Clear() {
if (_has_bits_[0 / 32] & 3) {
dialog_type_ = 0;
if (has_menu_key_values()) {
if (menu_key_values_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
menu_key_values_->clear();
}
}
}
::memset(_has_bits_, 0, sizeof(_has_bits_));
mutable_unknown_fields()->Clear();
}
bool CSVCMsg_Menu::MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
::google::protobuf::uint32 tag;
// @@protoc_insertion_point(parse_start:CSVCMsg_Menu)
for (;;) {
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// optional int32 dialog_type = 1;
case 1: {
if (tag == 8) {
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &dialog_type_)));
set_has_dialog_type();
} else {
goto handle_unusual;
}
if (input->ExpectTag(18)) goto parse_menu_key_values;
break;
}
// optional bytes menu_key_values = 2;
case 2: {
if (tag == 18) {
parse_menu_key_values:
DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
input, this->mutable_menu_key_values()));
} else {
goto handle_unusual;
}
if (input->ExpectAtEnd()) goto success;
break;
}
default: {
handle_unusual:
if (tag == 0 ||
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
goto success;
}
DO_(::google::protobuf::internal::WireFormat::SkipField(
input, tag, mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:CSVCMsg_Menu)
return true;
failure:
// @@protoc_insertion_point(parse_failure:CSVCMsg_Menu)
return false;
#undef DO_
}
void CSVCMsg_Menu::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:CSVCMsg_Menu)
// optional int32 dialog_type = 1;
if (has_dialog_type()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->dialog_type(), output);
}
// optional bytes menu_key_values = 2;
if (has_menu_key_values()) {
::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
2, this->menu_key_values(), output);
}
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
}
// @@protoc_insertion_point(serialize_end:CSVCMsg_Menu)
}
::google::protobuf::uint8* CSVCMsg_Menu::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_Menu)
// optional int32 dialog_type = 1;
if (has_dialog_type()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->dialog_type(), target);
}
// optional bytes menu_key_values = 2;
if (has_menu_key_values()) {
target =
::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
2, this->menu_key_values(), target);
}
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
}
// @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_Menu)
return target;
}
int CSVCMsg_Menu::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// optional int32 dialog_type = 1;
if (has_dialog_type()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->dialog_type());
}
// optional bytes menu_key_values = 2;
if (has_menu_key_values()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::BytesSize(
this->menu_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 CSVCMsg_Menu::MergeFrom(const ::google::protobuf::Message& from) {
GOOGLE_CHECK_NE(&from, this);
const CSVCMsg_Menu* source =
::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_Menu*>(
&from);
if (source == NULL) {
::google::protobuf::internal::ReflectionOps::Merge(from, this);
} else {
MergeFrom(*source);
}
}
void CSVCMsg_Menu::MergeFrom(const CSVCMsg_Menu& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
if (from.has_dialog_type()) {
set_dialog_type(from.dialog_type());
}
if (from.has_menu_key_values()) {
set_menu_key_values(from.menu_key_values());
}
}
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}
void CSVCMsg_Menu::CopyFrom(const ::google::protobuf::Message& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
void CSVCMsg_Menu::CopyFrom(const CSVCMsg_Menu& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool CSVCMsg_Menu::IsInitialized() const {
return true;
}
void CSVCMsg_Menu::Swap(CSVCMsg_Menu* other) {
if (other != this) {
std::swap(dialog_type_, other->dialog_type_);
std::swap(menu_key_values_, other->menu_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 CSVCMsg_Menu::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
::google::protobuf::Metadata metadata;
metadata.descriptor = CSVCMsg_Menu_descriptor_;
metadata.reflection = CSVCMsg_Menu_reflection_;
return metadata;
}
// ===================================================================
#ifndef _MSC_VER
const int CSVCMsg_SendTable_sendprop_t::kTypeFieldNumber;
const int CSVCMsg_SendTable_sendprop_t::kVarNameFieldNumber;
const int CSVCMsg_SendTable_sendprop_t::kFlagsFieldNumber;
const int CSVCMsg_SendTable_sendprop_t::kPriorityFieldNumber;
const int CSVCMsg_SendTable_sendprop_t::kDtNameFieldNumber;
const int CSVCMsg_SendTable_sendprop_t::kNumElementsFieldNumber;
const int CSVCMsg_SendTable_sendprop_t::kLowValueFieldNumber;
const int CSVCMsg_SendTable_sendprop_t::kHighValueFieldNumber;
const int CSVCMsg_SendTable_sendprop_t::kNumBitsFieldNumber;
#endif // !_MSC_VER
CSVCMsg_SendTable_sendprop_t::CSVCMsg_SendTable_sendprop_t()
: ::google::protobuf::Message() {
SharedCtor();
// @@protoc_insertion_point(constructor:CSVCMsg_SendTable.sendprop_t)
}
void CSVCMsg_SendTable_sendprop_t::InitAsDefaultInstance() {
}
CSVCMsg_SendTable_sendprop_t::CSVCMsg_SendTable_sendprop_t(const CSVCMsg_SendTable_sendprop_t& from)
: ::google::protobuf::Message() {
SharedCtor();
MergeFrom(from);
// @@protoc_insertion_point(copy_constructor:CSVCMsg_SendTable.sendprop_t)
}
void CSVCMsg_SendTable_sendprop_t::SharedCtor() {
::google::protobuf::internal::GetEmptyString();
_cached_size_ = 0;
type_ = 0;
var_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
flags_ = 0;
priority_ = 0;
dt_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
num_elements_ = 0;
low_value_ = 0;
high_value_ = 0;
num_bits_ = 0;
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
CSVCMsg_SendTable_sendprop_t::~CSVCMsg_SendTable_sendprop_t() {
// @@protoc_insertion_point(destructor:CSVCMsg_SendTable.sendprop_t)
SharedDtor();
}
void CSVCMsg_SendTable_sendprop_t::SharedDtor() {
if (var_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
delete var_name_;
}
if (dt_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
delete dt_name_;
}
if (this != default_instance_) {
}
}
void CSVCMsg_SendTable_sendprop_t::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_SendTable_sendprop_t::descriptor() {
protobuf_AssignDescriptorsOnce();
return CSVCMsg_SendTable_sendprop_t_descriptor_;
}
const CSVCMsg_SendTable_sendprop_t& CSVCMsg_SendTable_sendprop_t::default_instance() {
if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
return *default_instance_;
}
CSVCMsg_SendTable_sendprop_t* CSVCMsg_SendTable_sendprop_t::default_instance_ = NULL;
CSVCMsg_SendTable_sendprop_t* CSVCMsg_SendTable_sendprop_t::New() const {
return new CSVCMsg_SendTable_sendprop_t;
}
void CSVCMsg_SendTable_sendprop_t::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>( \
&reinterpret_cast<CSVCMsg_SendTable_sendprop_t*>(16)->f) - \
reinterpret_cast<char*>(16))
#define ZR_(first, last) do { \
size_t f = OFFSET_OF_FIELD_(first); \
size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \
::memset(&first, 0, n); \
} while (0)
if (_has_bits_[0 / 32] & 255) {
ZR_(type_, flags_);
ZR_(priority_, high_value_);
if (has_var_name()) {
if (var_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
var_name_->clear();
}
}
if (has_dt_name()) {
if (dt_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
dt_name_->clear();
}
}
}
num_bits_ = 0;
#undef OFFSET_OF_FIELD_
#undef ZR_
::memset(_has_bits_, 0, sizeof(_has_bits_));
mutable_unknown_fields()->Clear();
}
bool CSVCMsg_SendTable_sendprop_t::MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
::google::protobuf::uint32 tag;
// @@protoc_insertion_point(parse_start:CSVCMsg_SendTable.sendprop_t)
for (;;) {
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// optional int32 type = 1;
case 1: {
if (tag == 8) {
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &type_)));
set_has_type();
} else {
goto handle_unusual;
}
if (input->ExpectTag(18)) goto parse_var_name;
break;
}
// optional string var_name = 2;
case 2: {
if (tag == 18) {
parse_var_name:
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
input, this->mutable_var_name()));
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->var_name().data(), this->var_name().length(),
::google::protobuf::internal::WireFormat::PARSE,
"var_name");
} else {
goto handle_unusual;
}
if (input->ExpectTag(24)) goto parse_flags;
break;
}
// optional int32 flags = 3;
case 3: {
if (tag == 24) {
parse_flags:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &flags_)));
set_has_flags();
} else {
goto handle_unusual;
}
if (input->ExpectTag(32)) goto parse_priority;
break;
}
// optional int32 priority = 4;
case 4: {
if (tag == 32) {
parse_priority:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &priority_)));
set_has_priority();
} else {
goto handle_unusual;
}
if (input->ExpectTag(42)) goto parse_dt_name;
break;
}
// optional string dt_name = 5;
case 5: {
if (tag == 42) {
parse_dt_name:
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
input, this->mutable_dt_name()));
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->dt_name().data(), this->dt_name().length(),
::google::protobuf::internal::WireFormat::PARSE,
"dt_name");
} else {
goto handle_unusual;
}
if (input->ExpectTag(48)) goto parse_num_elements;
break;
}
// optional int32 num_elements = 6;
case 6: {
if (tag == 48) {
parse_num_elements:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &num_elements_)));
set_has_num_elements();
} else {
goto handle_unusual;
}
if (input->ExpectTag(61)) goto parse_low_value;
break;
}
// optional float low_value = 7;
case 7: {
if (tag == 61) {
parse_low_value:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
input, &low_value_)));
set_has_low_value();
} else {
goto handle_unusual;
}
if (input->ExpectTag(69)) goto parse_high_value;
break;
}
// optional float high_value = 8;
case 8: {
if (tag == 69) {
parse_high_value:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
input, &high_value_)));
set_has_high_value();
} else {
goto handle_unusual;
}
if (input->ExpectTag(72)) goto parse_num_bits;
break;
}
// optional int32 num_bits = 9;
case 9: {
if (tag == 72) {
parse_num_bits:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &num_bits_)));
set_has_num_bits();
} else {
goto handle_unusual;
}
if (input->ExpectAtEnd()) goto success;
break;
}
default: {
handle_unusual:
if (tag == 0 ||
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
goto success;
}
DO_(::google::protobuf::internal::WireFormat::SkipField(
input, tag, mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:CSVCMsg_SendTable.sendprop_t)
return true;
failure:
// @@protoc_insertion_point(parse_failure:CSVCMsg_SendTable.sendprop_t)
return false;
#undef DO_
}
void CSVCMsg_SendTable_sendprop_t::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:CSVCMsg_SendTable.sendprop_t)
// optional int32 type = 1;
if (has_type()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->type(), output);
}
// optional string var_name = 2;
if (has_var_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->var_name().data(), this->var_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"var_name");
::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
2, this->var_name(), output);
}
// optional int32 flags = 3;
if (has_flags()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->flags(), output);
}
// optional int32 priority = 4;
if (has_priority()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->priority(), output);
}
// optional string dt_name = 5;
if (has_dt_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->dt_name().data(), this->dt_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"dt_name");
::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
5, this->dt_name(), output);
}
// optional int32 num_elements = 6;
if (has_num_elements()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->num_elements(), output);
}
// optional float low_value = 7;
if (has_low_value()) {
::google::protobuf::internal::WireFormatLite::WriteFloat(7, this->low_value(), output);
}
// optional float high_value = 8;
if (has_high_value()) {
::google::protobuf::internal::WireFormatLite::WriteFloat(8, this->high_value(), output);
}
// optional int32 num_bits = 9;
if (has_num_bits()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(9, this->num_bits(), output);
}
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
}
// @@protoc_insertion_point(serialize_end:CSVCMsg_SendTable.sendprop_t)
}
::google::protobuf::uint8* CSVCMsg_SendTable_sendprop_t::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_SendTable.sendprop_t)
// optional int32 type = 1;
if (has_type()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->type(), target);
}
// optional string var_name = 2;
if (has_var_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->var_name().data(), this->var_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"var_name");
target =
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2, this->var_name(), target);
}
// optional int32 flags = 3;
if (has_flags()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->flags(), target);
}
// optional int32 priority = 4;
if (has_priority()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->priority(), target);
}
// optional string dt_name = 5;
if (has_dt_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->dt_name().data(), this->dt_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"dt_name");
target =
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
5, this->dt_name(), target);
}
// optional int32 num_elements = 6;
if (has_num_elements()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(6, this->num_elements(), target);
}
// optional float low_value = 7;
if (has_low_value()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(7, this->low_value(), target);
}
// optional float high_value = 8;
if (has_high_value()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(8, this->high_value(), target);
}
// optional int32 num_bits = 9;
if (has_num_bits()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(9, this->num_bits(), target);
}
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
}
// @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_SendTable.sendprop_t)
return target;
}
int CSVCMsg_SendTable_sendprop_t::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// optional int32 type = 1;
if (has_type()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->type());
}
// optional string var_name = 2;
if (has_var_name()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::StringSize(
this->var_name());
}
// optional int32 flags = 3;
if (has_flags()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->flags());
}
// optional int32 priority = 4;
if (has_priority()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->priority());
}
// optional string dt_name = 5;
if (has_dt_name()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::StringSize(
this->dt_name());
}
// optional int32 num_elements = 6;
if (has_num_elements()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->num_elements());
}
// optional float low_value = 7;
if (has_low_value()) {
total_size += 1 + 4;
}
// optional float high_value = 8;
if (has_high_value()) {
total_size += 1 + 4;
}
}
if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
// optional int32 num_bits = 9;
if (has_num_bits()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->num_bits());
}
}
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 CSVCMsg_SendTable_sendprop_t::MergeFrom(const ::google::protobuf::Message& from) {
GOOGLE_CHECK_NE(&from, this);
const CSVCMsg_SendTable_sendprop_t* source =
::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_SendTable_sendprop_t*>(
&from);
if (source == NULL) {
::google::protobuf::internal::ReflectionOps::Merge(from, this);
} else {
MergeFrom(*source);
}
}
void CSVCMsg_SendTable_sendprop_t::MergeFrom(const CSVCMsg_SendTable_sendprop_t& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
if (from.has_type()) {
set_type(from.type());
}
if (from.has_var_name()) {
set_var_name(from.var_name());
}
if (from.has_flags()) {
set_flags(from.flags());
}
if (from.has_priority()) {
set_priority(from.priority());
}
if (from.has_dt_name()) {
set_dt_name(from.dt_name());
}
if (from.has_num_elements()) {
set_num_elements(from.num_elements());
}
if (from.has_low_value()) {
set_low_value(from.low_value());
}
if (from.has_high_value()) {
set_high_value(from.high_value());
}
}
if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
if (from.has_num_bits()) {
set_num_bits(from.num_bits());
}
}
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}
void CSVCMsg_SendTable_sendprop_t::CopyFrom(const ::google::protobuf::Message& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
void CSVCMsg_SendTable_sendprop_t::CopyFrom(const CSVCMsg_SendTable_sendprop_t& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool CSVCMsg_SendTable_sendprop_t::IsInitialized() const {
return true;
}
void CSVCMsg_SendTable_sendprop_t::Swap(CSVCMsg_SendTable_sendprop_t* other) {
if (other != this) {
std::swap(type_, other->type_);
std::swap(var_name_, other->var_name_);
std::swap(flags_, other->flags_);
std::swap(priority_, other->priority_);
std::swap(dt_name_, other->dt_name_);
std::swap(num_elements_, other->num_elements_);
std::swap(low_value_, other->low_value_);
std::swap(high_value_, other->high_value_);
std::swap(num_bits_, other->num_bits_);
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 CSVCMsg_SendTable_sendprop_t::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
::google::protobuf::Metadata metadata;
metadata.descriptor = CSVCMsg_SendTable_sendprop_t_descriptor_;
metadata.reflection = CSVCMsg_SendTable_sendprop_t_reflection_;
return metadata;
}
// -------------------------------------------------------------------
#ifndef _MSC_VER
const int CSVCMsg_SendTable::kIsEndFieldNumber;
const int CSVCMsg_SendTable::kNetTableNameFieldNumber;
const int CSVCMsg_SendTable::kNeedsDecoderFieldNumber;
const int CSVCMsg_SendTable::kPropsFieldNumber;
#endif // !_MSC_VER
CSVCMsg_SendTable::CSVCMsg_SendTable()
: ::google::protobuf::Message() {
SharedCtor();
// @@protoc_insertion_point(constructor:CSVCMsg_SendTable)
}
void CSVCMsg_SendTable::InitAsDefaultInstance() {
}
CSVCMsg_SendTable::CSVCMsg_SendTable(const CSVCMsg_SendTable& from)
: ::google::protobuf::Message() {
SharedCtor();
MergeFrom(from);
// @@protoc_insertion_point(copy_constructor:CSVCMsg_SendTable)
}
void CSVCMsg_SendTable::SharedCtor() {
::google::protobuf::internal::GetEmptyString();
_cached_size_ = 0;
is_end_ = false;
net_table_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
needs_decoder_ = false;
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
CSVCMsg_SendTable::~CSVCMsg_SendTable() {
// @@protoc_insertion_point(destructor:CSVCMsg_SendTable)
SharedDtor();
}
void CSVCMsg_SendTable::SharedDtor() {
if (net_table_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
delete net_table_name_;
}
if (this != default_instance_) {
}
}
void CSVCMsg_SendTable::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_SendTable::descriptor() {
protobuf_AssignDescriptorsOnce();
return CSVCMsg_SendTable_descriptor_;
}
const CSVCMsg_SendTable& CSVCMsg_SendTable::default_instance() {
if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
return *default_instance_;
}
CSVCMsg_SendTable* CSVCMsg_SendTable::default_instance_ = NULL;
CSVCMsg_SendTable* CSVCMsg_SendTable::New() const {
return new CSVCMsg_SendTable;
}
void CSVCMsg_SendTable::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>( \
&reinterpret_cast<CSVCMsg_SendTable*>(16)->f) - \
reinterpret_cast<char*>(16))
#define ZR_(first, last) do { \
size_t f = OFFSET_OF_FIELD_(first); \
size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \
::memset(&first, 0, n); \
} while (0)
if (_has_bits_[0 / 32] & 7) {
ZR_(is_end_, needs_decoder_);
if (has_net_table_name()) {
if (net_table_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
net_table_name_->clear();
}
}
}
#undef OFFSET_OF_FIELD_
#undef ZR_
props_.Clear();
::memset(_has_bits_, 0, sizeof(_has_bits_));
mutable_unknown_fields()->Clear();
}
bool CSVCMsg_SendTable::MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
::google::protobuf::uint32 tag;
// @@protoc_insertion_point(parse_start:CSVCMsg_SendTable)
for (;;) {
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// optional bool is_end = 1;
case 1: {
if (tag == 8) {
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
input, &is_end_)));
set_has_is_end();
} else {
goto handle_unusual;
}
if (input->ExpectTag(18)) goto parse_net_table_name;
break;
}
// optional string net_table_name = 2;
case 2: {
if (tag == 18) {
parse_net_table_name:
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
input, this->mutable_net_table_name()));
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->net_table_name().data(), this->net_table_name().length(),
::google::protobuf::internal::WireFormat::PARSE,
"net_table_name");
} else {
goto handle_unusual;
}
if (input->ExpectTag(24)) goto parse_needs_decoder;
break;
}
// optional bool needs_decoder = 3;
case 3: {
if (tag == 24) {
parse_needs_decoder:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
input, &needs_decoder_)));
set_has_needs_decoder();
} else {
goto handle_unusual;
}
if (input->ExpectTag(34)) goto parse_props;
break;
}
// repeated .CSVCMsg_SendTable.sendprop_t props = 4;
case 4: {
if (tag == 34) {
parse_props:
DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
input, add_props()));
} else {
goto handle_unusual;
}
if (input->ExpectTag(34)) goto parse_props;
if (input->ExpectAtEnd()) goto success;
break;
}
default: {
handle_unusual:
if (tag == 0 ||
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
goto success;
}
DO_(::google::protobuf::internal::WireFormat::SkipField(
input, tag, mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:CSVCMsg_SendTable)
return true;
failure:
// @@protoc_insertion_point(parse_failure:CSVCMsg_SendTable)
return false;
#undef DO_
}
void CSVCMsg_SendTable::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:CSVCMsg_SendTable)
// optional bool is_end = 1;
if (has_is_end()) {
::google::protobuf::internal::WireFormatLite::WriteBool(1, this->is_end(), output);
}
// optional string net_table_name = 2;
if (has_net_table_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->net_table_name().data(), this->net_table_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"net_table_name");
::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
2, this->net_table_name(), output);
}
// optional bool needs_decoder = 3;
if (has_needs_decoder()) {
::google::protobuf::internal::WireFormatLite::WriteBool(3, this->needs_decoder(), output);
}
// repeated .CSVCMsg_SendTable.sendprop_t props = 4;
for (int i = 0; i < this->props_size(); i++) {
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
4, this->props(i), output);
}
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
}
// @@protoc_insertion_point(serialize_end:CSVCMsg_SendTable)
}
::google::protobuf::uint8* CSVCMsg_SendTable::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_SendTable)
// optional bool is_end = 1;
if (has_is_end()) {
target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->is_end(), target);
}
// optional string net_table_name = 2;
if (has_net_table_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->net_table_name().data(), this->net_table_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"net_table_name");
target =
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2, this->net_table_name(), target);
}
// optional bool needs_decoder = 3;
if (has_needs_decoder()) {
target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->needs_decoder(), target);
}
// repeated .CSVCMsg_SendTable.sendprop_t props = 4;
for (int i = 0; i < this->props_size(); i++) {
target = ::google::protobuf::internal::WireFormatLite::
WriteMessageNoVirtualToArray(
4, this->props(i), target);
}
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
}
// @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_SendTable)
return target;
}
int CSVCMsg_SendTable::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// optional bool is_end = 1;
if (has_is_end()) {
total_size += 1 + 1;
}
// optional string net_table_name = 2;
if (has_net_table_name()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::StringSize(
this->net_table_name());
}
// optional bool needs_decoder = 3;
if (has_needs_decoder()) {
total_size += 1 + 1;
}
}
// repeated .CSVCMsg_SendTable.sendprop_t props = 4;
total_size += 1 * this->props_size();
for (int i = 0; i < this->props_size(); i++) {
total_size +=
::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
this->props(i));
}
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 CSVCMsg_SendTable::MergeFrom(const ::google::protobuf::Message& from) {
GOOGLE_CHECK_NE(&from, this);
const CSVCMsg_SendTable* source =
::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_SendTable*>(
&from);
if (source == NULL) {
::google::protobuf::internal::ReflectionOps::Merge(from, this);
} else {
MergeFrom(*source);
}
}
void CSVCMsg_SendTable::MergeFrom(const CSVCMsg_SendTable& from) {
GOOGLE_CHECK_NE(&from, this);
props_.MergeFrom(from.props_);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
if (from.has_is_end()) {
set_is_end(from.is_end());
}
if (from.has_net_table_name()) {
set_net_table_name(from.net_table_name());
}
if (from.has_needs_decoder()) {
set_needs_decoder(from.needs_decoder());
}
}
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}
void CSVCMsg_SendTable::CopyFrom(const ::google::protobuf::Message& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
void CSVCMsg_SendTable::CopyFrom(const CSVCMsg_SendTable& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool CSVCMsg_SendTable::IsInitialized() const {
return true;
}
void CSVCMsg_SendTable::Swap(CSVCMsg_SendTable* other) {
if (other != this) {
std::swap(is_end_, other->is_end_);
std::swap(net_table_name_, other->net_table_name_);
std::swap(needs_decoder_, other->needs_decoder_);
props_.Swap(&other->props_);
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 CSVCMsg_SendTable::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
::google::protobuf::Metadata metadata;
metadata.descriptor = CSVCMsg_SendTable_descriptor_;
metadata.reflection = CSVCMsg_SendTable_reflection_;
return metadata;
}
// ===================================================================
#ifndef _MSC_VER
const int CSVCMsg_GameEventList_key_t::kTypeFieldNumber;
const int CSVCMsg_GameEventList_key_t::kNameFieldNumber;
#endif // !_MSC_VER
CSVCMsg_GameEventList_key_t::CSVCMsg_GameEventList_key_t()
: ::google::protobuf::Message() {
SharedCtor();
// @@protoc_insertion_point(constructor:CSVCMsg_GameEventList.key_t)
}
void CSVCMsg_GameEventList_key_t::InitAsDefaultInstance() {
}
CSVCMsg_GameEventList_key_t::CSVCMsg_GameEventList_key_t(const CSVCMsg_GameEventList_key_t& from)
: ::google::protobuf::Message() {
SharedCtor();
MergeFrom(from);
// @@protoc_insertion_point(copy_constructor:CSVCMsg_GameEventList.key_t)
}
void CSVCMsg_GameEventList_key_t::SharedCtor() {
::google::protobuf::internal::GetEmptyString();
_cached_size_ = 0;
type_ = 0;
name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
CSVCMsg_GameEventList_key_t::~CSVCMsg_GameEventList_key_t() {
// @@protoc_insertion_point(destructor:CSVCMsg_GameEventList.key_t)
SharedDtor();
}
void CSVCMsg_GameEventList_key_t::SharedDtor() {
if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
delete name_;
}
if (this != default_instance_) {
}
}
void CSVCMsg_GameEventList_key_t::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_GameEventList_key_t::descriptor() {
protobuf_AssignDescriptorsOnce();
return CSVCMsg_GameEventList_key_t_descriptor_;
}
const CSVCMsg_GameEventList_key_t& CSVCMsg_GameEventList_key_t::default_instance() {
if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
return *default_instance_;
}
CSVCMsg_GameEventList_key_t* CSVCMsg_GameEventList_key_t::default_instance_ = NULL;
CSVCMsg_GameEventList_key_t* CSVCMsg_GameEventList_key_t::New() const {
return new CSVCMsg_GameEventList_key_t;
}
void CSVCMsg_GameEventList_key_t::Clear() {
if (_has_bits_[0 / 32] & 3) {
type_ = 0;
if (has_name()) {
if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
name_->clear();
}
}
}
::memset(_has_bits_, 0, sizeof(_has_bits_));
mutable_unknown_fields()->Clear();
}
bool CSVCMsg_GameEventList_key_t::MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
::google::protobuf::uint32 tag;
// @@protoc_insertion_point(parse_start:CSVCMsg_GameEventList.key_t)
for (;;) {
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// optional int32 type = 1;
case 1: {
if (tag == 8) {
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &type_)));
set_has_type();
} else {
goto handle_unusual;
}
if (input->ExpectTag(18)) goto parse_name;
break;
}
// optional string name = 2;
case 2: {
if (tag == 18) {
parse_name:
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
input, this->mutable_name()));
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->name().data(), this->name().length(),
::google::protobuf::internal::WireFormat::PARSE,
"name");
} else {
goto handle_unusual;
}
if (input->ExpectAtEnd()) goto success;
break;
}
default: {
handle_unusual:
if (tag == 0 ||
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
goto success;
}
DO_(::google::protobuf::internal::WireFormat::SkipField(
input, tag, mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:CSVCMsg_GameEventList.key_t)
return true;
failure:
// @@protoc_insertion_point(parse_failure:CSVCMsg_GameEventList.key_t)
return false;
#undef DO_
}
void CSVCMsg_GameEventList_key_t::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:CSVCMsg_GameEventList.key_t)
// optional int32 type = 1;
if (has_type()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->type(), output);
}
// optional string name = 2;
if (has_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->name().data(), this->name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"name");
::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
2, this->name(), output);
}
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
}
// @@protoc_insertion_point(serialize_end:CSVCMsg_GameEventList.key_t)
}
::google::protobuf::uint8* CSVCMsg_GameEventList_key_t::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_GameEventList.key_t)
// optional int32 type = 1;
if (has_type()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->type(), target);
}
// optional string name = 2;
if (has_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->name().data(), this->name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"name");
target =
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2, this->name(), target);
}
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
}
// @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_GameEventList.key_t)
return target;
}
int CSVCMsg_GameEventList_key_t::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// optional int32 type = 1;
if (has_type()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->type());
}
// optional string name = 2;
if (has_name()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::StringSize(
this->name());
}
}
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 CSVCMsg_GameEventList_key_t::MergeFrom(const ::google::protobuf::Message& from) {
GOOGLE_CHECK_NE(&from, this);
const CSVCMsg_GameEventList_key_t* source =
::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_GameEventList_key_t*>(
&from);
if (source == NULL) {
::google::protobuf::internal::ReflectionOps::Merge(from, this);
} else {
MergeFrom(*source);
}
}
void CSVCMsg_GameEventList_key_t::MergeFrom(const CSVCMsg_GameEventList_key_t& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
if (from.has_type()) {
set_type(from.type());
}
if (from.has_name()) {
set_name(from.name());
}
}
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}
void CSVCMsg_GameEventList_key_t::CopyFrom(const ::google::protobuf::Message& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
void CSVCMsg_GameEventList_key_t::CopyFrom(const CSVCMsg_GameEventList_key_t& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool CSVCMsg_GameEventList_key_t::IsInitialized() const {
return true;
}
void CSVCMsg_GameEventList_key_t::Swap(CSVCMsg_GameEventList_key_t* other) {
if (other != this) {
std::swap(type_, other->type_);
std::swap(name_, other->name_);
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 CSVCMsg_GameEventList_key_t::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
::google::protobuf::Metadata metadata;
metadata.descriptor = CSVCMsg_GameEventList_key_t_descriptor_;
metadata.reflection = CSVCMsg_GameEventList_key_t_reflection_;
return metadata;
}
// -------------------------------------------------------------------
#ifndef _MSC_VER
const int CSVCMsg_GameEventList_descriptor_t::kEventidFieldNumber;
const int CSVCMsg_GameEventList_descriptor_t::kNameFieldNumber;
const int CSVCMsg_GameEventList_descriptor_t::kKeysFieldNumber;
#endif // !_MSC_VER
CSVCMsg_GameEventList_descriptor_t::CSVCMsg_GameEventList_descriptor_t()
: ::google::protobuf::Message() {
SharedCtor();
// @@protoc_insertion_point(constructor:CSVCMsg_GameEventList.descriptor_t)
}
void CSVCMsg_GameEventList_descriptor_t::InitAsDefaultInstance() {
}
CSVCMsg_GameEventList_descriptor_t::CSVCMsg_GameEventList_descriptor_t(const CSVCMsg_GameEventList_descriptor_t& from)
: ::google::protobuf::Message() {
SharedCtor();
MergeFrom(from);
// @@protoc_insertion_point(copy_constructor:CSVCMsg_GameEventList.descriptor_t)
}
void CSVCMsg_GameEventList_descriptor_t::SharedCtor() {
::google::protobuf::internal::GetEmptyString();
_cached_size_ = 0;
eventid_ = 0;
name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
CSVCMsg_GameEventList_descriptor_t::~CSVCMsg_GameEventList_descriptor_t() {
// @@protoc_insertion_point(destructor:CSVCMsg_GameEventList.descriptor_t)
SharedDtor();
}
void CSVCMsg_GameEventList_descriptor_t::SharedDtor() {
if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
delete name_;
}
if (this != default_instance_) {
}
}
void CSVCMsg_GameEventList_descriptor_t::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_GameEventList_descriptor_t::descriptor() {
protobuf_AssignDescriptorsOnce();
return CSVCMsg_GameEventList_descriptor_t_descriptor_;
}
const CSVCMsg_GameEventList_descriptor_t& CSVCMsg_GameEventList_descriptor_t::default_instance() {
if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
return *default_instance_;
}
CSVCMsg_GameEventList_descriptor_t* CSVCMsg_GameEventList_descriptor_t::default_instance_ = NULL;
CSVCMsg_GameEventList_descriptor_t* CSVCMsg_GameEventList_descriptor_t::New() const {
return new CSVCMsg_GameEventList_descriptor_t;
}
void CSVCMsg_GameEventList_descriptor_t::Clear() {
if (_has_bits_[0 / 32] & 3) {
eventid_ = 0;
if (has_name()) {
if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
name_->clear();
}
}
}
keys_.Clear();
::memset(_has_bits_, 0, sizeof(_has_bits_));
mutable_unknown_fields()->Clear();
}
bool CSVCMsg_GameEventList_descriptor_t::MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
::google::protobuf::uint32 tag;
// @@protoc_insertion_point(parse_start:CSVCMsg_GameEventList.descriptor_t)
for (;;) {
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// optional int32 eventid = 1;
case 1: {
if (tag == 8) {
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &eventid_)));
set_has_eventid();
} else {
goto handle_unusual;
}
if (input->ExpectTag(18)) goto parse_name;
break;
}
// optional string name = 2;
case 2: {
if (tag == 18) {
parse_name:
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
input, this->mutable_name()));
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->name().data(), this->name().length(),
::google::protobuf::internal::WireFormat::PARSE,
"name");
} else {
goto handle_unusual;
}
if (input->ExpectTag(26)) goto parse_keys;
break;
}
// repeated .CSVCMsg_GameEventList.key_t keys = 3;
case 3: {
if (tag == 26) {
parse_keys:
DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
input, add_keys()));
} else {
goto handle_unusual;
}
if (input->ExpectTag(26)) goto parse_keys;
if (input->ExpectAtEnd()) goto success;
break;
}
default: {
handle_unusual:
if (tag == 0 ||
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
goto success;
}
DO_(::google::protobuf::internal::WireFormat::SkipField(
input, tag, mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:CSVCMsg_GameEventList.descriptor_t)
return true;
failure:
// @@protoc_insertion_point(parse_failure:CSVCMsg_GameEventList.descriptor_t)
return false;
#undef DO_
}
void CSVCMsg_GameEventList_descriptor_t::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:CSVCMsg_GameEventList.descriptor_t)
// optional int32 eventid = 1;
if (has_eventid()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->eventid(), output);
}
// optional string name = 2;
if (has_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->name().data(), this->name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"name");
::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
2, this->name(), output);
}
// repeated .CSVCMsg_GameEventList.key_t keys = 3;
for (int i = 0; i < this->keys_size(); i++) {
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
3, this->keys(i), output);
}
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
}
// @@protoc_insertion_point(serialize_end:CSVCMsg_GameEventList.descriptor_t)
}
::google::protobuf::uint8* CSVCMsg_GameEventList_descriptor_t::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_GameEventList.descriptor_t)
// optional int32 eventid = 1;
if (has_eventid()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->eventid(), target);
}
// optional string name = 2;
if (has_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->name().data(), this->name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"name");
target =
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2, this->name(), target);
}
// repeated .CSVCMsg_GameEventList.key_t keys = 3;
for (int i = 0; i < this->keys_size(); i++) {
target = ::google::protobuf::internal::WireFormatLite::
WriteMessageNoVirtualToArray(
3, this->keys(i), target);
}
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
}
// @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_GameEventList.descriptor_t)
return target;
}
int CSVCMsg_GameEventList_descriptor_t::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// optional int32 eventid = 1;
if (has_eventid()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->eventid());
}
// optional string name = 2;
if (has_name()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::StringSize(
this->name());
}
}
// repeated .CSVCMsg_GameEventList.key_t keys = 3;
total_size += 1 * this->keys_size();
for (int i = 0; i < this->keys_size(); i++) {
total_size +=
::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
this->keys(i));
}
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 CSVCMsg_GameEventList_descriptor_t::MergeFrom(const ::google::protobuf::Message& from) {
GOOGLE_CHECK_NE(&from, this);
const CSVCMsg_GameEventList_descriptor_t* source =
::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_GameEventList_descriptor_t*>(
&from);
if (source == NULL) {
::google::protobuf::internal::ReflectionOps::Merge(from, this);
} else {
MergeFrom(*source);
}
}
void CSVCMsg_GameEventList_descriptor_t::MergeFrom(const CSVCMsg_GameEventList_descriptor_t& from) {
GOOGLE_CHECK_NE(&from, this);
keys_.MergeFrom(from.keys_);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
if (from.has_eventid()) {
set_eventid(from.eventid());
}
if (from.has_name()) {
set_name(from.name());
}
}
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}
void CSVCMsg_GameEventList_descriptor_t::CopyFrom(const ::google::protobuf::Message& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
void CSVCMsg_GameEventList_descriptor_t::CopyFrom(const CSVCMsg_GameEventList_descriptor_t& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool CSVCMsg_GameEventList_descriptor_t::IsInitialized() const {
return true;
}
void CSVCMsg_GameEventList_descriptor_t::Swap(CSVCMsg_GameEventList_descriptor_t* other) {
if (other != this) {
std::swap(eventid_, other->eventid_);
std::swap(name_, other->name_);
keys_.Swap(&other->keys_);
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 CSVCMsg_GameEventList_descriptor_t::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
::google::protobuf::Metadata metadata;
metadata.descriptor = CSVCMsg_GameEventList_descriptor_t_descriptor_;
metadata.reflection = CSVCMsg_GameEventList_descriptor_t_reflection_;
return metadata;
}
// -------------------------------------------------------------------
#ifndef _MSC_VER
const int CSVCMsg_GameEventList::kDescriptorsFieldNumber;
#endif // !_MSC_VER
CSVCMsg_GameEventList::CSVCMsg_GameEventList()
: ::google::protobuf::Message() {
SharedCtor();
// @@protoc_insertion_point(constructor:CSVCMsg_GameEventList)
}
void CSVCMsg_GameEventList::InitAsDefaultInstance() {
}
CSVCMsg_GameEventList::CSVCMsg_GameEventList(const CSVCMsg_GameEventList& from)
: ::google::protobuf::Message() {
SharedCtor();
MergeFrom(from);
// @@protoc_insertion_point(copy_constructor:CSVCMsg_GameEventList)
}
void CSVCMsg_GameEventList::SharedCtor() {
_cached_size_ = 0;
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
CSVCMsg_GameEventList::~CSVCMsg_GameEventList() {
// @@protoc_insertion_point(destructor:CSVCMsg_GameEventList)
SharedDtor();
}
void CSVCMsg_GameEventList::SharedDtor() {
if (this != default_instance_) {
}
}
void CSVCMsg_GameEventList::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_GameEventList::descriptor() {
protobuf_AssignDescriptorsOnce();
return CSVCMsg_GameEventList_descriptor_;
}
const CSVCMsg_GameEventList& CSVCMsg_GameEventList::default_instance() {
if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
return *default_instance_;
}
CSVCMsg_GameEventList* CSVCMsg_GameEventList::default_instance_ = NULL;
CSVCMsg_GameEventList* CSVCMsg_GameEventList::New() const {
return new CSVCMsg_GameEventList;
}
void CSVCMsg_GameEventList::Clear() {
descriptors_.Clear();
::memset(_has_bits_, 0, sizeof(_has_bits_));
mutable_unknown_fields()->Clear();
}
bool CSVCMsg_GameEventList::MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
::google::protobuf::uint32 tag;
// @@protoc_insertion_point(parse_start:CSVCMsg_GameEventList)
for (;;) {
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// repeated .CSVCMsg_GameEventList.descriptor_t descriptors = 1;
case 1: {
if (tag == 10) {
parse_descriptors:
DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
input, add_descriptors()));
} else {
goto handle_unusual;
}
if (input->ExpectTag(10)) goto parse_descriptors;
if (input->ExpectAtEnd()) goto success;
break;
}
default: {
handle_unusual:
if (tag == 0 ||
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
goto success;
}
DO_(::google::protobuf::internal::WireFormat::SkipField(
input, tag, mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:CSVCMsg_GameEventList)
return true;
failure:
// @@protoc_insertion_point(parse_failure:CSVCMsg_GameEventList)
return false;
#undef DO_
}
void CSVCMsg_GameEventList::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:CSVCMsg_GameEventList)
// repeated .CSVCMsg_GameEventList.descriptor_t descriptors = 1;
for (int i = 0; i < this->descriptors_size(); i++) {
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1, this->descriptors(i), output);
}
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
}
// @@protoc_insertion_point(serialize_end:CSVCMsg_GameEventList)
}
::google::protobuf::uint8* CSVCMsg_GameEventList::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_GameEventList)
// repeated .CSVCMsg_GameEventList.descriptor_t descriptors = 1;
for (int i = 0; i < this->descriptors_size(); i++) {
target = ::google::protobuf::internal::WireFormatLite::
WriteMessageNoVirtualToArray(
1, this->descriptors(i), target);
}
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
}
// @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_GameEventList)
return target;
}
int CSVCMsg_GameEventList::ByteSize() const {
int total_size = 0;
// repeated .CSVCMsg_GameEventList.descriptor_t descriptors = 1;
total_size += 1 * this->descriptors_size();
for (int i = 0; i < this->descriptors_size(); i++) {
total_size +=
::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
this->descriptors(i));
}
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 CSVCMsg_GameEventList::MergeFrom(const ::google::protobuf::Message& from) {
GOOGLE_CHECK_NE(&from, this);
const CSVCMsg_GameEventList* source =
::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_GameEventList*>(
&from);
if (source == NULL) {
::google::protobuf::internal::ReflectionOps::Merge(from, this);
} else {
MergeFrom(*source);
}
}
void CSVCMsg_GameEventList::MergeFrom(const CSVCMsg_GameEventList& from) {
GOOGLE_CHECK_NE(&from, this);
descriptors_.MergeFrom(from.descriptors_);
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}
void CSVCMsg_GameEventList::CopyFrom(const ::google::protobuf::Message& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
void CSVCMsg_GameEventList::CopyFrom(const CSVCMsg_GameEventList& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool CSVCMsg_GameEventList::IsInitialized() const {
return true;
}
void CSVCMsg_GameEventList::Swap(CSVCMsg_GameEventList* other) {
if (other != this) {
descriptors_.Swap(&other->descriptors_);
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 CSVCMsg_GameEventList::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
::google::protobuf::Metadata metadata;
metadata.descriptor = CSVCMsg_GameEventList_descriptor_;
metadata.reflection = CSVCMsg_GameEventList_reflection_;
return metadata;
}
// ===================================================================
#ifndef _MSC_VER
const int CSVCMsg_PacketEntities::kMaxEntriesFieldNumber;
const int CSVCMsg_PacketEntities::kUpdatedEntriesFieldNumber;
const int CSVCMsg_PacketEntities::kIsDeltaFieldNumber;
const int CSVCMsg_PacketEntities::kUpdateBaselineFieldNumber;
const int CSVCMsg_PacketEntities::kBaselineFieldNumber;
const int CSVCMsg_PacketEntities::kDeltaFromFieldNumber;
const int CSVCMsg_PacketEntities::kEntityDataFieldNumber;
const int CSVCMsg_PacketEntities::kPendingFullFrameFieldNumber;
#endif // !_MSC_VER
CSVCMsg_PacketEntities::CSVCMsg_PacketEntities()
: ::google::protobuf::Message() {
SharedCtor();
// @@protoc_insertion_point(constructor:CSVCMsg_PacketEntities)
}
void CSVCMsg_PacketEntities::InitAsDefaultInstance() {
}
CSVCMsg_PacketEntities::CSVCMsg_PacketEntities(const CSVCMsg_PacketEntities& from)
: ::google::protobuf::Message() {
SharedCtor();
MergeFrom(from);
// @@protoc_insertion_point(copy_constructor:CSVCMsg_PacketEntities)
}
void CSVCMsg_PacketEntities::SharedCtor() {
::google::protobuf::internal::GetEmptyString();
_cached_size_ = 0;
max_entries_ = 0;
updated_entries_ = 0;
is_delta_ = false;
update_baseline_ = false;
baseline_ = 0;
delta_from_ = 0;
entity_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
pending_full_frame_ = false;
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
CSVCMsg_PacketEntities::~CSVCMsg_PacketEntities() {
// @@protoc_insertion_point(destructor:CSVCMsg_PacketEntities)
SharedDtor();
}
void CSVCMsg_PacketEntities::SharedDtor() {
if (entity_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
delete entity_data_;
}
if (this != default_instance_) {
}
}
void CSVCMsg_PacketEntities::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_PacketEntities::descriptor() {
protobuf_AssignDescriptorsOnce();
return CSVCMsg_PacketEntities_descriptor_;
}
const CSVCMsg_PacketEntities& CSVCMsg_PacketEntities::default_instance() {
if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
return *default_instance_;
}
CSVCMsg_PacketEntities* CSVCMsg_PacketEntities::default_instance_ = NULL;
CSVCMsg_PacketEntities* CSVCMsg_PacketEntities::New() const {
return new CSVCMsg_PacketEntities;
}
void CSVCMsg_PacketEntities::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>( \
&reinterpret_cast<CSVCMsg_PacketEntities*>(16)->f) - \
reinterpret_cast<char*>(16))
#define ZR_(first, last) do { \
size_t f = OFFSET_OF_FIELD_(first); \
size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \
::memset(&first, 0, n); \
} while (0)
if (_has_bits_[0 / 32] & 255) {
ZR_(max_entries_, pending_full_frame_);
delta_from_ = 0;
if (has_entity_data()) {
if (entity_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
entity_data_->clear();
}
}
}
#undef OFFSET_OF_FIELD_
#undef ZR_
::memset(_has_bits_, 0, sizeof(_has_bits_));
mutable_unknown_fields()->Clear();
}
bool CSVCMsg_PacketEntities::MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
::google::protobuf::uint32 tag;
// @@protoc_insertion_point(parse_start:CSVCMsg_PacketEntities)
for (;;) {
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// optional int32 max_entries = 1;
case 1: {
if (tag == 8) {
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &max_entries_)));
set_has_max_entries();
} else {
goto handle_unusual;
}
if (input->ExpectTag(16)) goto parse_updated_entries;
break;
}
// optional int32 updated_entries = 2;
case 2: {
if (tag == 16) {
parse_updated_entries:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &updated_entries_)));
set_has_updated_entries();
} else {
goto handle_unusual;
}
if (input->ExpectTag(24)) goto parse_is_delta;
break;
}
// optional bool is_delta = 3;
case 3: {
if (tag == 24) {
parse_is_delta:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
input, &is_delta_)));
set_has_is_delta();
} else {
goto handle_unusual;
}
if (input->ExpectTag(32)) goto parse_update_baseline;
break;
}
// optional bool update_baseline = 4;
case 4: {
if (tag == 32) {
parse_update_baseline:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
input, &update_baseline_)));
set_has_update_baseline();
} else {
goto handle_unusual;
}
if (input->ExpectTag(40)) goto parse_baseline;
break;
}
// optional int32 baseline = 5;
case 5: {
if (tag == 40) {
parse_baseline:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &baseline_)));
set_has_baseline();
} else {
goto handle_unusual;
}
if (input->ExpectTag(48)) goto parse_delta_from;
break;
}
// optional int32 delta_from = 6;
case 6: {
if (tag == 48) {
parse_delta_from:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &delta_from_)));
set_has_delta_from();
} else {
goto handle_unusual;
}
if (input->ExpectTag(58)) goto parse_entity_data;
break;
}
// optional bytes entity_data = 7;
case 7: {
if (tag == 58) {
parse_entity_data:
DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
input, this->mutable_entity_data()));
} else {
goto handle_unusual;
}
if (input->ExpectTag(64)) goto parse_pending_full_frame;
break;
}
// optional bool pending_full_frame = 8;
case 8: {
if (tag == 64) {
parse_pending_full_frame:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
input, &pending_full_frame_)));
set_has_pending_full_frame();
} else {
goto handle_unusual;
}
if (input->ExpectAtEnd()) goto success;
break;
}
default: {
handle_unusual:
if (tag == 0 ||
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
goto success;
}
DO_(::google::protobuf::internal::WireFormat::SkipField(
input, tag, mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:CSVCMsg_PacketEntities)
return true;
failure:
// @@protoc_insertion_point(parse_failure:CSVCMsg_PacketEntities)
return false;
#undef DO_
}
void CSVCMsg_PacketEntities::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:CSVCMsg_PacketEntities)
// optional int32 max_entries = 1;
if (has_max_entries()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->max_entries(), output);
}
// optional int32 updated_entries = 2;
if (has_updated_entries()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->updated_entries(), output);
}
// optional bool is_delta = 3;
if (has_is_delta()) {
::google::protobuf::internal::WireFormatLite::WriteBool(3, this->is_delta(), output);
}
// optional bool update_baseline = 4;
if (has_update_baseline()) {
::google::protobuf::internal::WireFormatLite::WriteBool(4, this->update_baseline(), output);
}
// optional int32 baseline = 5;
if (has_baseline()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->baseline(), output);
}
// optional int32 delta_from = 6;
if (has_delta_from()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->delta_from(), output);
}
// optional bytes entity_data = 7;
if (has_entity_data()) {
::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
7, this->entity_data(), output);
}
// optional bool pending_full_frame = 8;
if (has_pending_full_frame()) {
::google::protobuf::internal::WireFormatLite::WriteBool(8, this->pending_full_frame(), output);
}
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
}
// @@protoc_insertion_point(serialize_end:CSVCMsg_PacketEntities)
}
::google::protobuf::uint8* CSVCMsg_PacketEntities::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_PacketEntities)
// optional int32 max_entries = 1;
if (has_max_entries()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->max_entries(), target);
}
// optional int32 updated_entries = 2;
if (has_updated_entries()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->updated_entries(), target);
}
// optional bool is_delta = 3;
if (has_is_delta()) {
target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->is_delta(), target);
}
// optional bool update_baseline = 4;
if (has_update_baseline()) {
target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->update_baseline(), target);
}
// optional int32 baseline = 5;
if (has_baseline()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->baseline(), target);
}
// optional int32 delta_from = 6;
if (has_delta_from()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(6, this->delta_from(), target);
}
// optional bytes entity_data = 7;
if (has_entity_data()) {
target =
::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
7, this->entity_data(), target);
}
// optional bool pending_full_frame = 8;
if (has_pending_full_frame()) {
target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(8, this->pending_full_frame(), target);
}
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
}
// @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_PacketEntities)
return target;
}
int CSVCMsg_PacketEntities::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// optional int32 max_entries = 1;
if (has_max_entries()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->max_entries());
}
// optional int32 updated_entries = 2;
if (has_updated_entries()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->updated_entries());
}
// optional bool is_delta = 3;
if (has_is_delta()) {
total_size += 1 + 1;
}
// optional bool update_baseline = 4;
if (has_update_baseline()) {
total_size += 1 + 1;
}
// optional int32 baseline = 5;
if (has_baseline()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->baseline());
}
// optional int32 delta_from = 6;
if (has_delta_from()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->delta_from());
}
// optional bytes entity_data = 7;
if (has_entity_data()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::BytesSize(
this->entity_data());
}
// optional bool pending_full_frame = 8;
if (has_pending_full_frame()) {
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 CSVCMsg_PacketEntities::MergeFrom(const ::google::protobuf::Message& from) {
GOOGLE_CHECK_NE(&from, this);
const CSVCMsg_PacketEntities* source =
::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_PacketEntities*>(
&from);
if (source == NULL) {
::google::protobuf::internal::ReflectionOps::Merge(from, this);
} else {
MergeFrom(*source);
}
}
void CSVCMsg_PacketEntities::MergeFrom(const CSVCMsg_PacketEntities& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
if (from.has_max_entries()) {
set_max_entries(from.max_entries());
}
if (from.has_updated_entries()) {
set_updated_entries(from.updated_entries());
}
if (from.has_is_delta()) {
set_is_delta(from.is_delta());
}
if (from.has_update_baseline()) {
set_update_baseline(from.update_baseline());
}
if (from.has_baseline()) {
set_baseline(from.baseline());
}
if (from.has_delta_from()) {
set_delta_from(from.delta_from());
}
if (from.has_entity_data()) {
set_entity_data(from.entity_data());
}
if (from.has_pending_full_frame()) {
set_pending_full_frame(from.pending_full_frame());
}
}
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}
void CSVCMsg_PacketEntities::CopyFrom(const ::google::protobuf::Message& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
void CSVCMsg_PacketEntities::CopyFrom(const CSVCMsg_PacketEntities& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool CSVCMsg_PacketEntities::IsInitialized() const {
return true;
}
void CSVCMsg_PacketEntities::Swap(CSVCMsg_PacketEntities* other) {
if (other != this) {
std::swap(max_entries_, other->max_entries_);
std::swap(updated_entries_, other->updated_entries_);
std::swap(is_delta_, other->is_delta_);
std::swap(update_baseline_, other->update_baseline_);
std::swap(baseline_, other->baseline_);
std::swap(delta_from_, other->delta_from_);
std::swap(entity_data_, other->entity_data_);
std::swap(pending_full_frame_, other->pending_full_frame_);
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 CSVCMsg_PacketEntities::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
::google::protobuf::Metadata metadata;
metadata.descriptor = CSVCMsg_PacketEntities_descriptor_;
metadata.reflection = CSVCMsg_PacketEntities_reflection_;
return metadata;
}
// ===================================================================
#ifndef _MSC_VER
const int CSVCMsg_TempEntities::kReliableFieldNumber;
const int CSVCMsg_TempEntities::kNumEntriesFieldNumber;
const int CSVCMsg_TempEntities::kEntityDataFieldNumber;
#endif // !_MSC_VER
CSVCMsg_TempEntities::CSVCMsg_TempEntities()
: ::google::protobuf::Message() {
SharedCtor();
// @@protoc_insertion_point(constructor:CSVCMsg_TempEntities)
}
void CSVCMsg_TempEntities::InitAsDefaultInstance() {
}
CSVCMsg_TempEntities::CSVCMsg_TempEntities(const CSVCMsg_TempEntities& from)
: ::google::protobuf::Message() {
SharedCtor();
MergeFrom(from);
// @@protoc_insertion_point(copy_constructor:CSVCMsg_TempEntities)
}
void CSVCMsg_TempEntities::SharedCtor() {
::google::protobuf::internal::GetEmptyString();
_cached_size_ = 0;
reliable_ = false;
num_entries_ = 0;
entity_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
CSVCMsg_TempEntities::~CSVCMsg_TempEntities() {
// @@protoc_insertion_point(destructor:CSVCMsg_TempEntities)
SharedDtor();
}
void CSVCMsg_TempEntities::SharedDtor() {
if (entity_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
delete entity_data_;
}
if (this != default_instance_) {
}
}
void CSVCMsg_TempEntities::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_TempEntities::descriptor() {
protobuf_AssignDescriptorsOnce();
return CSVCMsg_TempEntities_descriptor_;
}
const CSVCMsg_TempEntities& CSVCMsg_TempEntities::default_instance() {
if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
return *default_instance_;
}
CSVCMsg_TempEntities* CSVCMsg_TempEntities::default_instance_ = NULL;
CSVCMsg_TempEntities* CSVCMsg_TempEntities::New() const {
return new CSVCMsg_TempEntities;
}
void CSVCMsg_TempEntities::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>( \
&reinterpret_cast<CSVCMsg_TempEntities*>(16)->f) - \
reinterpret_cast<char*>(16))
#define ZR_(first, last) do { \
size_t f = OFFSET_OF_FIELD_(first); \
size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \
::memset(&first, 0, n); \
} while (0)
if (_has_bits_[0 / 32] & 7) {
ZR_(reliable_, num_entries_);
if (has_entity_data()) {
if (entity_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
entity_data_->clear();
}
}
}
#undef OFFSET_OF_FIELD_
#undef ZR_
::memset(_has_bits_, 0, sizeof(_has_bits_));
mutable_unknown_fields()->Clear();
}
bool CSVCMsg_TempEntities::MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
::google::protobuf::uint32 tag;
// @@protoc_insertion_point(parse_start:CSVCMsg_TempEntities)
for (;;) {
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// optional bool reliable = 1;
case 1: {
if (tag == 8) {
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
input, &reliable_)));
set_has_reliable();
} else {
goto handle_unusual;
}
if (input->ExpectTag(16)) goto parse_num_entries;
break;
}
// optional int32 num_entries = 2;
case 2: {
if (tag == 16) {
parse_num_entries:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &num_entries_)));
set_has_num_entries();
} else {
goto handle_unusual;
}
if (input->ExpectTag(26)) goto parse_entity_data;
break;
}
// optional bytes entity_data = 3;
case 3: {
if (tag == 26) {
parse_entity_data:
DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
input, this->mutable_entity_data()));
} else {
goto handle_unusual;
}
if (input->ExpectAtEnd()) goto success;
break;
}
default: {
handle_unusual:
if (tag == 0 ||
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
goto success;
}
DO_(::google::protobuf::internal::WireFormat::SkipField(
input, tag, mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:CSVCMsg_TempEntities)
return true;
failure:
// @@protoc_insertion_point(parse_failure:CSVCMsg_TempEntities)
return false;
#undef DO_
}
void CSVCMsg_TempEntities::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:CSVCMsg_TempEntities)
// optional bool reliable = 1;
if (has_reliable()) {
::google::protobuf::internal::WireFormatLite::WriteBool(1, this->reliable(), output);
}
// optional int32 num_entries = 2;
if (has_num_entries()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->num_entries(), output);
}
// optional bytes entity_data = 3;
if (has_entity_data()) {
::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
3, this->entity_data(), output);
}
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
}
// @@protoc_insertion_point(serialize_end:CSVCMsg_TempEntities)
}
::google::protobuf::uint8* CSVCMsg_TempEntities::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_TempEntities)
// optional bool reliable = 1;
if (has_reliable()) {
target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->reliable(), target);
}
// optional int32 num_entries = 2;
if (has_num_entries()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->num_entries(), target);
}
// optional bytes entity_data = 3;
if (has_entity_data()) {
target =
::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
3, this->entity_data(), target);
}
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
}
// @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_TempEntities)
return target;
}
int CSVCMsg_TempEntities::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// optional bool reliable = 1;
if (has_reliable()) {
total_size += 1 + 1;
}
// optional int32 num_entries = 2;
if (has_num_entries()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->num_entries());
}
// optional bytes entity_data = 3;
if (has_entity_data()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::BytesSize(
this->entity_data());
}
}
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 CSVCMsg_TempEntities::MergeFrom(const ::google::protobuf::Message& from) {
GOOGLE_CHECK_NE(&from, this);
const CSVCMsg_TempEntities* source =
::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_TempEntities*>(
&from);
if (source == NULL) {
::google::protobuf::internal::ReflectionOps::Merge(from, this);
} else {
MergeFrom(*source);
}
}
void CSVCMsg_TempEntities::MergeFrom(const CSVCMsg_TempEntities& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
if (from.has_reliable()) {
set_reliable(from.reliable());
}
if (from.has_num_entries()) {
set_num_entries(from.num_entries());
}
if (from.has_entity_data()) {
set_entity_data(from.entity_data());
}
}
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}
void CSVCMsg_TempEntities::CopyFrom(const ::google::protobuf::Message& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
void CSVCMsg_TempEntities::CopyFrom(const CSVCMsg_TempEntities& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool CSVCMsg_TempEntities::IsInitialized() const {
return true;
}
void CSVCMsg_TempEntities::Swap(CSVCMsg_TempEntities* other) {
if (other != this) {
std::swap(reliable_, other->reliable_);
std::swap(num_entries_, other->num_entries_);
std::swap(entity_data_, other->entity_data_);
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 CSVCMsg_TempEntities::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
::google::protobuf::Metadata metadata;
metadata.descriptor = CSVCMsg_TempEntities_descriptor_;
metadata.reflection = CSVCMsg_TempEntities_reflection_;
return metadata;
}
// ===================================================================
#ifndef _MSC_VER
const int CSVCMsg_CreateStringTable::kNameFieldNumber;
const int CSVCMsg_CreateStringTable::kMaxEntriesFieldNumber;
const int CSVCMsg_CreateStringTable::kNumEntriesFieldNumber;
const int CSVCMsg_CreateStringTable::kUserDataFixedSizeFieldNumber;
const int CSVCMsg_CreateStringTable::kUserDataSizeFieldNumber;
const int CSVCMsg_CreateStringTable::kUserDataSizeBitsFieldNumber;
const int CSVCMsg_CreateStringTable::kFlagsFieldNumber;
const int CSVCMsg_CreateStringTable::kStringDataFieldNumber;
#endif // !_MSC_VER
CSVCMsg_CreateStringTable::CSVCMsg_CreateStringTable()
: ::google::protobuf::Message() {
SharedCtor();
// @@protoc_insertion_point(constructor:CSVCMsg_CreateStringTable)
}
void CSVCMsg_CreateStringTable::InitAsDefaultInstance() {
}
CSVCMsg_CreateStringTable::CSVCMsg_CreateStringTable(const CSVCMsg_CreateStringTable& from)
: ::google::protobuf::Message() {
SharedCtor();
MergeFrom(from);
// @@protoc_insertion_point(copy_constructor:CSVCMsg_CreateStringTable)
}
void CSVCMsg_CreateStringTable::SharedCtor() {
::google::protobuf::internal::GetEmptyString();
_cached_size_ = 0;
name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
max_entries_ = 0;
num_entries_ = 0;
user_data_fixed_size_ = false;
user_data_size_ = 0;
user_data_size_bits_ = 0;
flags_ = 0;
string_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
CSVCMsg_CreateStringTable::~CSVCMsg_CreateStringTable() {
// @@protoc_insertion_point(destructor:CSVCMsg_CreateStringTable)
SharedDtor();
}
void CSVCMsg_CreateStringTable::SharedDtor() {
if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
delete name_;
}
if (string_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
delete string_data_;
}
if (this != default_instance_) {
}
}
void CSVCMsg_CreateStringTable::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_CreateStringTable::descriptor() {
protobuf_AssignDescriptorsOnce();
return CSVCMsg_CreateStringTable_descriptor_;
}
const CSVCMsg_CreateStringTable& CSVCMsg_CreateStringTable::default_instance() {
if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
return *default_instance_;
}
CSVCMsg_CreateStringTable* CSVCMsg_CreateStringTable::default_instance_ = NULL;
CSVCMsg_CreateStringTable* CSVCMsg_CreateStringTable::New() const {
return new CSVCMsg_CreateStringTable;
}
void CSVCMsg_CreateStringTable::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>( \
&reinterpret_cast<CSVCMsg_CreateStringTable*>(16)->f) - \
reinterpret_cast<char*>(16))
#define ZR_(first, last) do { \
size_t f = OFFSET_OF_FIELD_(first); \
size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \
::memset(&first, 0, n); \
} while (0)
if (_has_bits_[0 / 32] & 255) {
ZR_(max_entries_, flags_);
if (has_name()) {
if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
name_->clear();
}
}
if (has_string_data()) {
if (string_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
string_data_->clear();
}
}
}
#undef OFFSET_OF_FIELD_
#undef ZR_
::memset(_has_bits_, 0, sizeof(_has_bits_));
mutable_unknown_fields()->Clear();
}
bool CSVCMsg_CreateStringTable::MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
::google::protobuf::uint32 tag;
// @@protoc_insertion_point(parse_start:CSVCMsg_CreateStringTable)
for (;;) {
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// optional string name = 1;
case 1: {
if (tag == 10) {
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
input, this->mutable_name()));
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->name().data(), this->name().length(),
::google::protobuf::internal::WireFormat::PARSE,
"name");
} else {
goto handle_unusual;
}
if (input->ExpectTag(16)) goto parse_max_entries;
break;
}
// optional int32 max_entries = 2;
case 2: {
if (tag == 16) {
parse_max_entries:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &max_entries_)));
set_has_max_entries();
} else {
goto handle_unusual;
}
if (input->ExpectTag(24)) goto parse_num_entries;
break;
}
// optional int32 num_entries = 3;
case 3: {
if (tag == 24) {
parse_num_entries:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &num_entries_)));
set_has_num_entries();
} else {
goto handle_unusual;
}
if (input->ExpectTag(32)) goto parse_user_data_fixed_size;
break;
}
// optional bool user_data_fixed_size = 4;
case 4: {
if (tag == 32) {
parse_user_data_fixed_size:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
input, &user_data_fixed_size_)));
set_has_user_data_fixed_size();
} else {
goto handle_unusual;
}
if (input->ExpectTag(40)) goto parse_user_data_size;
break;
}
// optional int32 user_data_size = 5;
case 5: {
if (tag == 40) {
parse_user_data_size:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &user_data_size_)));
set_has_user_data_size();
} else {
goto handle_unusual;
}
if (input->ExpectTag(48)) goto parse_user_data_size_bits;
break;
}
// optional int32 user_data_size_bits = 6;
case 6: {
if (tag == 48) {
parse_user_data_size_bits:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &user_data_size_bits_)));
set_has_user_data_size_bits();
} else {
goto handle_unusual;
}
if (input->ExpectTag(56)) goto parse_flags;
break;
}
// optional int32 flags = 7;
case 7: {
if (tag == 56) {
parse_flags:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &flags_)));
set_has_flags();
} else {
goto handle_unusual;
}
if (input->ExpectTag(66)) goto parse_string_data;
break;
}
// optional bytes string_data = 8;
case 8: {
if (tag == 66) {
parse_string_data:
DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
input, this->mutable_string_data()));
} else {
goto handle_unusual;
}
if (input->ExpectAtEnd()) goto success;
break;
}
default: {
handle_unusual:
if (tag == 0 ||
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
goto success;
}
DO_(::google::protobuf::internal::WireFormat::SkipField(
input, tag, mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:CSVCMsg_CreateStringTable)
return true;
failure:
// @@protoc_insertion_point(parse_failure:CSVCMsg_CreateStringTable)
return false;
#undef DO_
}
void CSVCMsg_CreateStringTable::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:CSVCMsg_CreateStringTable)
// optional string name = 1;
if (has_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->name().data(), this->name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"name");
::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
1, this->name(), output);
}
// optional int32 max_entries = 2;
if (has_max_entries()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->max_entries(), output);
}
// optional int32 num_entries = 3;
if (has_num_entries()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->num_entries(), output);
}
// optional bool user_data_fixed_size = 4;
if (has_user_data_fixed_size()) {
::google::protobuf::internal::WireFormatLite::WriteBool(4, this->user_data_fixed_size(), output);
}
// optional int32 user_data_size = 5;
if (has_user_data_size()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->user_data_size(), output);
}
// optional int32 user_data_size_bits = 6;
if (has_user_data_size_bits()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->user_data_size_bits(), output);
}
// optional int32 flags = 7;
if (has_flags()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(7, this->flags(), output);
}
// optional bytes string_data = 8;
if (has_string_data()) {
::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
8, this->string_data(), output);
}
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
}
// @@protoc_insertion_point(serialize_end:CSVCMsg_CreateStringTable)
}
::google::protobuf::uint8* CSVCMsg_CreateStringTable::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_CreateStringTable)
// optional string name = 1;
if (has_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
this->name().data(), this->name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE,
"name");
target =
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->name(), target);
}
// optional int32 max_entries = 2;
if (has_max_entries()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->max_entries(), target);
}
// optional int32 num_entries = 3;
if (has_num_entries()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->num_entries(), target);
}
// optional bool user_data_fixed_size = 4;
if (has_user_data_fixed_size()) {
target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->user_data_fixed_size(), target);
}
// optional int32 user_data_size = 5;
if (has_user_data_size()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->user_data_size(), target);
}
// optional int32 user_data_size_bits = 6;
if (has_user_data_size_bits()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(6, this->user_data_size_bits(), target);
}
// optional int32 flags = 7;
if (has_flags()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(7, this->flags(), target);
}
// optional bytes string_data = 8;
if (has_string_data()) {
target =
::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
8, this->string_data(), target);
}
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
}
// @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_CreateStringTable)
return target;
}
int CSVCMsg_CreateStringTable::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// optional string name = 1;
if (has_name()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::StringSize(
this->name());
}
// optional int32 max_entries = 2;
if (has_max_entries()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->max_entries());
}
// optional int32 num_entries = 3;
if (has_num_entries()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->num_entries());
}
// optional bool user_data_fixed_size = 4;
if (has_user_data_fixed_size()) {
total_size += 1 + 1;
}
// optional int32 user_data_size = 5;
if (has_user_data_size()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->user_data_size());
}
// optional int32 user_data_size_bits = 6;
if (has_user_data_size_bits()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->user_data_size_bits());
}
// optional int32 flags = 7;
if (has_flags()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->flags());
}
// optional bytes string_data = 8;
if (has_string_data()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::BytesSize(
this->string_data());
}
}
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 CSVCMsg_CreateStringTable::MergeFrom(const ::google::protobuf::Message& from) {
GOOGLE_CHECK_NE(&from, this);
const CSVCMsg_CreateStringTable* source =
::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_CreateStringTable*>(
&from);
if (source == NULL) {
::google::protobuf::internal::ReflectionOps::Merge(from, this);
} else {
MergeFrom(*source);
}
}
void CSVCMsg_CreateStringTable::MergeFrom(const CSVCMsg_CreateStringTable& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
if (from.has_name()) {
set_name(from.name());
}
if (from.has_max_entries()) {
set_max_entries(from.max_entries());
}
if (from.has_num_entries()) {
set_num_entries(from.num_entries());
}
if (from.has_user_data_fixed_size()) {
set_user_data_fixed_size(from.user_data_fixed_size());
}
if (from.has_user_data_size()) {
set_user_data_size(from.user_data_size());
}
if (from.has_user_data_size_bits()) {
set_user_data_size_bits(from.user_data_size_bits());
}
if (from.has_flags()) {
set_flags(from.flags());
}
if (from.has_string_data()) {
set_string_data(from.string_data());
}
}
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}
void CSVCMsg_CreateStringTable::CopyFrom(const ::google::protobuf::Message& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
void CSVCMsg_CreateStringTable::CopyFrom(const CSVCMsg_CreateStringTable& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool CSVCMsg_CreateStringTable::IsInitialized() const {
return true;
}
void CSVCMsg_CreateStringTable::Swap(CSVCMsg_CreateStringTable* other) {
if (other != this) {
std::swap(name_, other->name_);
std::swap(max_entries_, other->max_entries_);
std::swap(num_entries_, other->num_entries_);
std::swap(user_data_fixed_size_, other->user_data_fixed_size_);
std::swap(user_data_size_, other->user_data_size_);
std::swap(user_data_size_bits_, other->user_data_size_bits_);
std::swap(flags_, other->flags_);
std::swap(string_data_, other->string_data_);
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 CSVCMsg_CreateStringTable::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
::google::protobuf::Metadata metadata;
metadata.descriptor = CSVCMsg_CreateStringTable_descriptor_;
metadata.reflection = CSVCMsg_CreateStringTable_reflection_;
return metadata;
}
// ===================================================================
#ifndef _MSC_VER
const int CSVCMsg_UpdateStringTable::kTableIdFieldNumber;
const int CSVCMsg_UpdateStringTable::kNumChangedEntriesFieldNumber;
const int CSVCMsg_UpdateStringTable::kStringDataFieldNumber;
#endif // !_MSC_VER
CSVCMsg_UpdateStringTable::CSVCMsg_UpdateStringTable()
: ::google::protobuf::Message() {
SharedCtor();
// @@protoc_insertion_point(constructor:CSVCMsg_UpdateStringTable)
}
void CSVCMsg_UpdateStringTable::InitAsDefaultInstance() {
}
CSVCMsg_UpdateStringTable::CSVCMsg_UpdateStringTable(const CSVCMsg_UpdateStringTable& from)
: ::google::protobuf::Message() {
SharedCtor();
MergeFrom(from);
// @@protoc_insertion_point(copy_constructor:CSVCMsg_UpdateStringTable)
}
void CSVCMsg_UpdateStringTable::SharedCtor() {
::google::protobuf::internal::GetEmptyString();
_cached_size_ = 0;
table_id_ = 0;
num_changed_entries_ = 0;
string_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
CSVCMsg_UpdateStringTable::~CSVCMsg_UpdateStringTable() {
// @@protoc_insertion_point(destructor:CSVCMsg_UpdateStringTable)
SharedDtor();
}
void CSVCMsg_UpdateStringTable::SharedDtor() {
if (string_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
delete string_data_;
}
if (this != default_instance_) {
}
}
void CSVCMsg_UpdateStringTable::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_UpdateStringTable::descriptor() {
protobuf_AssignDescriptorsOnce();
return CSVCMsg_UpdateStringTable_descriptor_;
}
const CSVCMsg_UpdateStringTable& CSVCMsg_UpdateStringTable::default_instance() {
if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
return *default_instance_;
}
CSVCMsg_UpdateStringTable* CSVCMsg_UpdateStringTable::default_instance_ = NULL;
CSVCMsg_UpdateStringTable* CSVCMsg_UpdateStringTable::New() const {
return new CSVCMsg_UpdateStringTable;
}
void CSVCMsg_UpdateStringTable::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>( \
&reinterpret_cast<CSVCMsg_UpdateStringTable*>(16)->f) - \
reinterpret_cast<char*>(16))
#define ZR_(first, last) do { \
size_t f = OFFSET_OF_FIELD_(first); \
size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \
::memset(&first, 0, n); \
} while (0)
if (_has_bits_[0 / 32] & 7) {
ZR_(table_id_, num_changed_entries_);
if (has_string_data()) {
if (string_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
string_data_->clear();
}
}
}
#undef OFFSET_OF_FIELD_
#undef ZR_
::memset(_has_bits_, 0, sizeof(_has_bits_));
mutable_unknown_fields()->Clear();
}
bool CSVCMsg_UpdateStringTable::MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
::google::protobuf::uint32 tag;
// @@protoc_insertion_point(parse_start:CSVCMsg_UpdateStringTable)
for (;;) {
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// optional int32 table_id = 1;
case 1: {
if (tag == 8) {
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &table_id_)));
set_has_table_id();
} else {
goto handle_unusual;
}
if (input->ExpectTag(16)) goto parse_num_changed_entries;
break;
}
// optional int32 num_changed_entries = 2;
case 2: {
if (tag == 16) {
parse_num_changed_entries:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &num_changed_entries_)));
set_has_num_changed_entries();
} else {
goto handle_unusual;
}
if (input->ExpectTag(26)) goto parse_string_data;
break;
}
// optional bytes string_data = 3;
case 3: {
if (tag == 26) {
parse_string_data:
DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
input, this->mutable_string_data()));
} else {
goto handle_unusual;
}
if (input->ExpectAtEnd()) goto success;
break;
}
default: {
handle_unusual:
if (tag == 0 ||
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
goto success;
}
DO_(::google::protobuf::internal::WireFormat::SkipField(
input, tag, mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:CSVCMsg_UpdateStringTable)
return true;
failure:
// @@protoc_insertion_point(parse_failure:CSVCMsg_UpdateStringTable)
return false;
#undef DO_
}
void CSVCMsg_UpdateStringTable::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:CSVCMsg_UpdateStringTable)
// optional int32 table_id = 1;
if (has_table_id()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->table_id(), output);
}
// optional int32 num_changed_entries = 2;
if (has_num_changed_entries()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->num_changed_entries(), output);
}
// optional bytes string_data = 3;
if (has_string_data()) {
::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
3, this->string_data(), output);
}
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
}
// @@protoc_insertion_point(serialize_end:CSVCMsg_UpdateStringTable)
}
::google::protobuf::uint8* CSVCMsg_UpdateStringTable::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_UpdateStringTable)
// optional int32 table_id = 1;
if (has_table_id()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->table_id(), target);
}
// optional int32 num_changed_entries = 2;
if (has_num_changed_entries()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->num_changed_entries(), target);
}
// optional bytes string_data = 3;
if (has_string_data()) {
target =
::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
3, this->string_data(), target);
}
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
}
// @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_UpdateStringTable)
return target;
}
int CSVCMsg_UpdateStringTable::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// optional int32 table_id = 1;
if (has_table_id()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->table_id());
}
// optional int32 num_changed_entries = 2;
if (has_num_changed_entries()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->num_changed_entries());
}
// optional bytes string_data = 3;
if (has_string_data()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::BytesSize(
this->string_data());
}
}
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 CSVCMsg_UpdateStringTable::MergeFrom(const ::google::protobuf::Message& from) {
GOOGLE_CHECK_NE(&from, this);
const CSVCMsg_UpdateStringTable* source =
::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_UpdateStringTable*>(
&from);
if (source == NULL) {
::google::protobuf::internal::ReflectionOps::Merge(from, this);
} else {
MergeFrom(*source);
}
}
void CSVCMsg_UpdateStringTable::MergeFrom(const CSVCMsg_UpdateStringTable& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
if (from.has_table_id()) {
set_table_id(from.table_id());
}
if (from.has_num_changed_entries()) {
set_num_changed_entries(from.num_changed_entries());
}
if (from.has_string_data()) {
set_string_data(from.string_data());
}
}
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}
void CSVCMsg_UpdateStringTable::CopyFrom(const ::google::protobuf::Message& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
void CSVCMsg_UpdateStringTable::CopyFrom(const CSVCMsg_UpdateStringTable& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool CSVCMsg_UpdateStringTable::IsInitialized() const {
return true;
}
void CSVCMsg_UpdateStringTable::Swap(CSVCMsg_UpdateStringTable* other) {
if (other != this) {
std::swap(table_id_, other->table_id_);
std::swap(num_changed_entries_, other->num_changed_entries_);
std::swap(string_data_, other->string_data_);
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 CSVCMsg_UpdateStringTable::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
::google::protobuf::Metadata metadata;
metadata.descriptor = CSVCMsg_UpdateStringTable_descriptor_;
metadata.reflection = CSVCMsg_UpdateStringTable_reflection_;
return metadata;
}
// ===================================================================
#ifndef _MSC_VER
const int CSVCMsg_VoiceData::kClientFieldNumber;
const int CSVCMsg_VoiceData::kProximityFieldNumber;
const int CSVCMsg_VoiceData::kXuidFieldNumber;
const int CSVCMsg_VoiceData::kAudibleMaskFieldNumber;
const int CSVCMsg_VoiceData::kVoiceDataFieldNumber;
const int CSVCMsg_VoiceData::kFormatFieldNumber;
const int CSVCMsg_VoiceData::kSequenceBytesFieldNumber;
const int CSVCMsg_VoiceData::kSectionNumberFieldNumber;
const int CSVCMsg_VoiceData::kUncompressedSampleOffsetFieldNumber;
const int CSVCMsg_VoiceData::kTickFieldNumber;
#endif // !_MSC_VER
CSVCMsg_VoiceData::CSVCMsg_VoiceData()
: ::google::protobuf::Message() {
SharedCtor();
// @@protoc_insertion_point(constructor:CSVCMsg_VoiceData)
}
void CSVCMsg_VoiceData::InitAsDefaultInstance() {
}
CSVCMsg_VoiceData::CSVCMsg_VoiceData(const CSVCMsg_VoiceData& from)
: ::google::protobuf::Message() {
SharedCtor();
MergeFrom(from);
// @@protoc_insertion_point(copy_constructor:CSVCMsg_VoiceData)
}
void CSVCMsg_VoiceData::SharedCtor() {
::google::protobuf::internal::GetEmptyString();
_cached_size_ = 0;
client_ = 0;
proximity_ = false;
xuid_ = GOOGLE_ULONGLONG(0);
audible_mask_ = 0;
voice_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
format_ = 0;
sequence_bytes_ = 0;
section_number_ = 0u;
uncompressed_sample_offset_ = 0u;
tick_ = 0u;
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
CSVCMsg_VoiceData::~CSVCMsg_VoiceData() {
// @@protoc_insertion_point(destructor:CSVCMsg_VoiceData)
SharedDtor();
}
void CSVCMsg_VoiceData::SharedDtor() {
if (voice_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
delete voice_data_;
}
if (this != default_instance_) {
}
}
void CSVCMsg_VoiceData::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_VoiceData::descriptor() {
protobuf_AssignDescriptorsOnce();
return CSVCMsg_VoiceData_descriptor_;
}
const CSVCMsg_VoiceData& CSVCMsg_VoiceData::default_instance() {
if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
return *default_instance_;
}
CSVCMsg_VoiceData* CSVCMsg_VoiceData::default_instance_ = NULL;
CSVCMsg_VoiceData* CSVCMsg_VoiceData::New() const {
return new CSVCMsg_VoiceData;
}
void CSVCMsg_VoiceData::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>( \
&reinterpret_cast<CSVCMsg_VoiceData*>(16)->f) - \
reinterpret_cast<char*>(16))
#define ZR_(first, last) do { \
size_t f = OFFSET_OF_FIELD_(first); \
size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \
::memset(&first, 0, n); \
} while (0)
if (_has_bits_[0 / 32] & 255) {
ZR_(client_, xuid_);
ZR_(audible_mask_, section_number_);
if (has_voice_data()) {
if (voice_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
voice_data_->clear();
}
}
}
ZR_(uncompressed_sample_offset_, tick_);
#undef OFFSET_OF_FIELD_
#undef ZR_
::memset(_has_bits_, 0, sizeof(_has_bits_));
mutable_unknown_fields()->Clear();
}
bool CSVCMsg_VoiceData::MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
::google::protobuf::uint32 tag;
// @@protoc_insertion_point(parse_start:CSVCMsg_VoiceData)
for (;;) {
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// optional int32 client = 1;
case 1: {
if (tag == 8) {
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &client_)));
set_has_client();
} else {
goto handle_unusual;
}
if (input->ExpectTag(16)) goto parse_proximity;
break;
}
// optional bool proximity = 2;
case 2: {
if (tag == 16) {
parse_proximity:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
input, &proximity_)));
set_has_proximity();
} else {
goto handle_unusual;
}
if (input->ExpectTag(25)) goto parse_xuid;
break;
}
// optional fixed64 xuid = 3;
case 3: {
if (tag == 25) {
parse_xuid:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
input, &xuid_)));
set_has_xuid();
} else {
goto handle_unusual;
}
if (input->ExpectTag(32)) goto parse_audible_mask;
break;
}
// optional int32 audible_mask = 4;
case 4: {
if (tag == 32) {
parse_audible_mask:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &audible_mask_)));
set_has_audible_mask();
} else {
goto handle_unusual;
}
if (input->ExpectTag(42)) goto parse_voice_data;
break;
}
// optional bytes voice_data = 5;
case 5: {
if (tag == 42) {
parse_voice_data:
DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
input, this->mutable_voice_data()));
} else {
goto handle_unusual;
}
if (input->ExpectTag(48)) goto parse_format;
break;
}
// optional .VoiceDataFormat_t format = 6 [default = VOICEDATA_FORMAT_STEAM];
case 6: {
if (tag == 48) {
parse_format:
int value;
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
input, &value)));
if (::VoiceDataFormat_t_IsValid(value)) {
set_format(static_cast< ::VoiceDataFormat_t >(value));
} else {
mutable_unknown_fields()->AddVarint(6, value);
}
} else {
goto handle_unusual;
}
if (input->ExpectTag(56)) goto parse_sequence_bytes;
break;
}
// optional int32 sequence_bytes = 7;
case 7: {
if (tag == 56) {
parse_sequence_bytes:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &sequence_bytes_)));
set_has_sequence_bytes();
} else {
goto handle_unusual;
}
if (input->ExpectTag(64)) goto parse_section_number;
break;
}
// optional uint32 section_number = 8;
case 8: {
if (tag == 64) {
parse_section_number:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
input, &section_number_)));
set_has_section_number();
} else {
goto handle_unusual;
}
if (input->ExpectTag(72)) goto parse_uncompressed_sample_offset;
break;
}
// optional uint32 uncompressed_sample_offset = 9;
case 9: {
if (tag == 72) {
parse_uncompressed_sample_offset:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
input, &uncompressed_sample_offset_)));
set_has_uncompressed_sample_offset();
} else {
goto handle_unusual;
}
if (input->ExpectTag(80)) goto parse_tick;
break;
}
// optional uint32 tick = 10;
case 10: {
if (tag == 80) {
parse_tick:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
input, &tick_)));
set_has_tick();
} else {
goto handle_unusual;
}
if (input->ExpectAtEnd()) goto success;
break;
}
default: {
handle_unusual:
if (tag == 0 ||
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
goto success;
}
DO_(::google::protobuf::internal::WireFormat::SkipField(
input, tag, mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:CSVCMsg_VoiceData)
return true;
failure:
// @@protoc_insertion_point(parse_failure:CSVCMsg_VoiceData)
return false;
#undef DO_
}
void CSVCMsg_VoiceData::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:CSVCMsg_VoiceData)
// optional int32 client = 1;
if (has_client()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->client(), output);
}
// optional bool proximity = 2;
if (has_proximity()) {
::google::protobuf::internal::WireFormatLite::WriteBool(2, this->proximity(), output);
}
// optional fixed64 xuid = 3;
if (has_xuid()) {
::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->xuid(), output);
}
// optional int32 audible_mask = 4;
if (has_audible_mask()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->audible_mask(), output);
}
// optional bytes voice_data = 5;
if (has_voice_data()) {
::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
5, this->voice_data(), output);
}
// optional .VoiceDataFormat_t format = 6 [default = VOICEDATA_FORMAT_STEAM];
if (has_format()) {
::google::protobuf::internal::WireFormatLite::WriteEnum(
6, this->format(), output);
}
// optional int32 sequence_bytes = 7;
if (has_sequence_bytes()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(7, this->sequence_bytes(), output);
}
// optional uint32 section_number = 8;
if (has_section_number()) {
::google::protobuf::internal::WireFormatLite::WriteUInt32(8, this->section_number(), output);
}
// optional uint32 uncompressed_sample_offset = 9;
if (has_uncompressed_sample_offset()) {
::google::protobuf::internal::WireFormatLite::WriteUInt32(9, this->uncompressed_sample_offset(), output);
}
// optional uint32 tick = 10;
if (has_tick()) {
::google::protobuf::internal::WireFormatLite::WriteUInt32(10, this->tick(), output);
}
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
}
// @@protoc_insertion_point(serialize_end:CSVCMsg_VoiceData)
}
::google::protobuf::uint8* CSVCMsg_VoiceData::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_VoiceData)
// optional int32 client = 1;
if (has_client()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->client(), target);
}
// optional bool proximity = 2;
if (has_proximity()) {
target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->proximity(), target);
}
// optional fixed64 xuid = 3;
if (has_xuid()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->xuid(), target);
}
// optional int32 audible_mask = 4;
if (has_audible_mask()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->audible_mask(), target);
}
// optional bytes voice_data = 5;
if (has_voice_data()) {
target =
::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
5, this->voice_data(), target);
}
// optional .VoiceDataFormat_t format = 6 [default = VOICEDATA_FORMAT_STEAM];
if (has_format()) {
target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
6, this->format(), target);
}
// optional int32 sequence_bytes = 7;
if (has_sequence_bytes()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(7, this->sequence_bytes(), target);
}
// optional uint32 section_number = 8;
if (has_section_number()) {
target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(8, this->section_number(), target);
}
// optional uint32 uncompressed_sample_offset = 9;
if (has_uncompressed_sample_offset()) {
target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(9, this->uncompressed_sample_offset(), target);
}
// optional uint32 tick = 10;
if (has_tick()) {
target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(10, this->tick(), target);
}
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
}
// @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_VoiceData)
return target;
}
int CSVCMsg_VoiceData::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// optional int32 client = 1;
if (has_client()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->client());
}
// optional bool proximity = 2;
if (has_proximity()) {
total_size += 1 + 1;
}
// optional fixed64 xuid = 3;
if (has_xuid()) {
total_size += 1 + 8;
}
// optional int32 audible_mask = 4;
if (has_audible_mask()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->audible_mask());
}
// optional bytes voice_data = 5;
if (has_voice_data()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::BytesSize(
this->voice_data());
}
// optional .VoiceDataFormat_t format = 6 [default = VOICEDATA_FORMAT_STEAM];
if (has_format()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::EnumSize(this->format());
}
// optional int32 sequence_bytes = 7;
if (has_sequence_bytes()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->sequence_bytes());
}
// optional uint32 section_number = 8;
if (has_section_number()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::UInt32Size(
this->section_number());
}
}
if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
// optional uint32 uncompressed_sample_offset = 9;
if (has_uncompressed_sample_offset()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::UInt32Size(
this->uncompressed_sample_offset());
}
// optional uint32 tick = 10;
if (has_tick()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::UInt32Size(
this->tick());
}
}
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 CSVCMsg_VoiceData::MergeFrom(const ::google::protobuf::Message& from) {
GOOGLE_CHECK_NE(&from, this);
const CSVCMsg_VoiceData* source =
::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_VoiceData*>(
&from);
if (source == NULL) {
::google::protobuf::internal::ReflectionOps::Merge(from, this);
} else {
MergeFrom(*source);
}
}
void CSVCMsg_VoiceData::MergeFrom(const CSVCMsg_VoiceData& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
if (from.has_client()) {
set_client(from.client());
}
if (from.has_proximity()) {
set_proximity(from.proximity());
}
if (from.has_xuid()) {
set_xuid(from.xuid());
}
if (from.has_audible_mask()) {
set_audible_mask(from.audible_mask());
}
if (from.has_voice_data()) {
set_voice_data(from.voice_data());
}
if (from.has_format()) {
set_format(from.format());
}
if (from.has_sequence_bytes()) {
set_sequence_bytes(from.sequence_bytes());
}
if (from.has_section_number()) {
set_section_number(from.section_number());
}
}
if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
if (from.has_uncompressed_sample_offset()) {
set_uncompressed_sample_offset(from.uncompressed_sample_offset());
}
if (from.has_tick()) {
set_tick(from.tick());
}
}
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}
void CSVCMsg_VoiceData::CopyFrom(const ::google::protobuf::Message& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
void CSVCMsg_VoiceData::CopyFrom(const CSVCMsg_VoiceData& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool CSVCMsg_VoiceData::IsInitialized() const {
return true;
}
void CSVCMsg_VoiceData::Swap(CSVCMsg_VoiceData* other) {
if (other != this) {
std::swap(client_, other->client_);
std::swap(proximity_, other->proximity_);
std::swap(xuid_, other->xuid_);
std::swap(audible_mask_, other->audible_mask_);
std::swap(voice_data_, other->voice_data_);
std::swap(format_, other->format_);
std::swap(sequence_bytes_, other->sequence_bytes_);
std::swap(section_number_, other->section_number_);
std::swap(uncompressed_sample_offset_, other->uncompressed_sample_offset_);
std::swap(tick_, other->tick_);
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 CSVCMsg_VoiceData::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
::google::protobuf::Metadata metadata;
metadata.descriptor = CSVCMsg_VoiceData_descriptor_;
metadata.reflection = CSVCMsg_VoiceData_reflection_;
return metadata;
}
// ===================================================================
#ifndef _MSC_VER
const int CSVCMsg_PacketReliable::kTickFieldNumber;
const int CSVCMsg_PacketReliable::kMessagessizeFieldNumber;
#endif // !_MSC_VER
CSVCMsg_PacketReliable::CSVCMsg_PacketReliable()
: ::google::protobuf::Message() {
SharedCtor();
// @@protoc_insertion_point(constructor:CSVCMsg_PacketReliable)
}
void CSVCMsg_PacketReliable::InitAsDefaultInstance() {
}
CSVCMsg_PacketReliable::CSVCMsg_PacketReliable(const CSVCMsg_PacketReliable& from)
: ::google::protobuf::Message() {
SharedCtor();
MergeFrom(from);
// @@protoc_insertion_point(copy_constructor:CSVCMsg_PacketReliable)
}
void CSVCMsg_PacketReliable::SharedCtor() {
_cached_size_ = 0;
tick_ = 0;
messagessize_ = 0;
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
CSVCMsg_PacketReliable::~CSVCMsg_PacketReliable() {
// @@protoc_insertion_point(destructor:CSVCMsg_PacketReliable)
SharedDtor();
}
void CSVCMsg_PacketReliable::SharedDtor() {
if (this != default_instance_) {
}
}
void CSVCMsg_PacketReliable::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_PacketReliable::descriptor() {
protobuf_AssignDescriptorsOnce();
return CSVCMsg_PacketReliable_descriptor_;
}
const CSVCMsg_PacketReliable& CSVCMsg_PacketReliable::default_instance() {
if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
return *default_instance_;
}
CSVCMsg_PacketReliable* CSVCMsg_PacketReliable::default_instance_ = NULL;
CSVCMsg_PacketReliable* CSVCMsg_PacketReliable::New() const {
return new CSVCMsg_PacketReliable;
}
void CSVCMsg_PacketReliable::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>( \
&reinterpret_cast<CSVCMsg_PacketReliable*>(16)->f) - \
reinterpret_cast<char*>(16))
#define ZR_(first, last) do { \
size_t f = OFFSET_OF_FIELD_(first); \
size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \
::memset(&first, 0, n); \
} while (0)
ZR_(tick_, messagessize_);
#undef OFFSET_OF_FIELD_
#undef ZR_
::memset(_has_bits_, 0, sizeof(_has_bits_));
mutable_unknown_fields()->Clear();
}
bool CSVCMsg_PacketReliable::MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
::google::protobuf::uint32 tag;
// @@protoc_insertion_point(parse_start:CSVCMsg_PacketReliable)
for (;;) {
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// optional int32 tick = 1;
case 1: {
if (tag == 8) {
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &tick_)));
set_has_tick();
} else {
goto handle_unusual;
}
if (input->ExpectTag(16)) goto parse_messagessize;
break;
}
// optional int32 messagessize = 2;
case 2: {
if (tag == 16) {
parse_messagessize:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &messagessize_)));
set_has_messagessize();
} else {
goto handle_unusual;
}
if (input->ExpectAtEnd()) goto success;
break;
}
default: {
handle_unusual:
if (tag == 0 ||
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
goto success;
}
DO_(::google::protobuf::internal::WireFormat::SkipField(
input, tag, mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:CSVCMsg_PacketReliable)
return true;
failure:
// @@protoc_insertion_point(parse_failure:CSVCMsg_PacketReliable)
return false;
#undef DO_
}
void CSVCMsg_PacketReliable::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:CSVCMsg_PacketReliable)
// optional int32 tick = 1;
if (has_tick()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->tick(), output);
}
// optional int32 messagessize = 2;
if (has_messagessize()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->messagessize(), output);
}
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
}
// @@protoc_insertion_point(serialize_end:CSVCMsg_PacketReliable)
}
::google::protobuf::uint8* CSVCMsg_PacketReliable::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_PacketReliable)
// optional int32 tick = 1;
if (has_tick()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->tick(), target);
}
// optional int32 messagessize = 2;
if (has_messagessize()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->messagessize(), target);
}
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
}
// @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_PacketReliable)
return target;
}
int CSVCMsg_PacketReliable::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// optional int32 tick = 1;
if (has_tick()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->tick());
}
// optional int32 messagessize = 2;
if (has_messagessize()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->messagessize());
}
}
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 CSVCMsg_PacketReliable::MergeFrom(const ::google::protobuf::Message& from) {
GOOGLE_CHECK_NE(&from, this);
const CSVCMsg_PacketReliable* source =
::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_PacketReliable*>(
&from);
if (source == NULL) {
::google::protobuf::internal::ReflectionOps::Merge(from, this);
} else {
MergeFrom(*source);
}
}
void CSVCMsg_PacketReliable::MergeFrom(const CSVCMsg_PacketReliable& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
if (from.has_tick()) {
set_tick(from.tick());
}
if (from.has_messagessize()) {
set_messagessize(from.messagessize());
}
}
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}
void CSVCMsg_PacketReliable::CopyFrom(const ::google::protobuf::Message& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
void CSVCMsg_PacketReliable::CopyFrom(const CSVCMsg_PacketReliable& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool CSVCMsg_PacketReliable::IsInitialized() const {
return true;
}
void CSVCMsg_PacketReliable::Swap(CSVCMsg_PacketReliable* other) {
if (other != this) {
std::swap(tick_, other->tick_);
std::swap(messagessize_, other->messagessize_);
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 CSVCMsg_PacketReliable::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
::google::protobuf::Metadata metadata;
metadata.descriptor = CSVCMsg_PacketReliable_descriptor_;
metadata.reflection = CSVCMsg_PacketReliable_reflection_;
return metadata;
}
// ===================================================================
#ifndef _MSC_VER
const int CSVCMsg_FullFrameSplit::kTickFieldNumber;
const int CSVCMsg_FullFrameSplit::kSectionFieldNumber;
const int CSVCMsg_FullFrameSplit::kTotalFieldNumber;
const int CSVCMsg_FullFrameSplit::kDataFieldNumber;
#endif // !_MSC_VER
CSVCMsg_FullFrameSplit::CSVCMsg_FullFrameSplit()
: ::google::protobuf::Message() {
SharedCtor();
// @@protoc_insertion_point(constructor:CSVCMsg_FullFrameSplit)
}
void CSVCMsg_FullFrameSplit::InitAsDefaultInstance() {
}
CSVCMsg_FullFrameSplit::CSVCMsg_FullFrameSplit(const CSVCMsg_FullFrameSplit& from)
: ::google::protobuf::Message() {
SharedCtor();
MergeFrom(from);
// @@protoc_insertion_point(copy_constructor:CSVCMsg_FullFrameSplit)
}
void CSVCMsg_FullFrameSplit::SharedCtor() {
::google::protobuf::internal::GetEmptyString();
_cached_size_ = 0;
tick_ = 0;
section_ = 0;
total_ = 0;
data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
CSVCMsg_FullFrameSplit::~CSVCMsg_FullFrameSplit() {
// @@protoc_insertion_point(destructor:CSVCMsg_FullFrameSplit)
SharedDtor();
}
void CSVCMsg_FullFrameSplit::SharedDtor() {
if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
delete data_;
}
if (this != default_instance_) {
}
}
void CSVCMsg_FullFrameSplit::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_FullFrameSplit::descriptor() {
protobuf_AssignDescriptorsOnce();
return CSVCMsg_FullFrameSplit_descriptor_;
}
const CSVCMsg_FullFrameSplit& CSVCMsg_FullFrameSplit::default_instance() {
if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
return *default_instance_;
}
CSVCMsg_FullFrameSplit* CSVCMsg_FullFrameSplit::default_instance_ = NULL;
CSVCMsg_FullFrameSplit* CSVCMsg_FullFrameSplit::New() const {
return new CSVCMsg_FullFrameSplit;
}
void CSVCMsg_FullFrameSplit::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>( \
&reinterpret_cast<CSVCMsg_FullFrameSplit*>(16)->f) - \
reinterpret_cast<char*>(16))
#define ZR_(first, last) do { \
size_t f = OFFSET_OF_FIELD_(first); \
size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \
::memset(&first, 0, n); \
} while (0)
if (_has_bits_[0 / 32] & 15) {
ZR_(tick_, section_);
total_ = 0;
if (has_data()) {
if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
data_->clear();
}
}
}
#undef OFFSET_OF_FIELD_
#undef ZR_
::memset(_has_bits_, 0, sizeof(_has_bits_));
mutable_unknown_fields()->Clear();
}
bool CSVCMsg_FullFrameSplit::MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
::google::protobuf::uint32 tag;
// @@protoc_insertion_point(parse_start:CSVCMsg_FullFrameSplit)
for (;;) {
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// optional int32 tick = 1;
case 1: {
if (tag == 8) {
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &tick_)));
set_has_tick();
} else {
goto handle_unusual;
}
if (input->ExpectTag(16)) goto parse_section;
break;
}
// optional int32 section = 2;
case 2: {
if (tag == 16) {
parse_section:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &section_)));
set_has_section();
} else {
goto handle_unusual;
}
if (input->ExpectTag(24)) goto parse_total;
break;
}
// optional int32 total = 3;
case 3: {
if (tag == 24) {
parse_total:
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &total_)));
set_has_total();
} else {
goto handle_unusual;
}
if (input->ExpectTag(34)) goto parse_data;
break;
}
// optional bytes data = 4;
case 4: {
if (tag == 34) {
parse_data:
DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
input, this->mutable_data()));
} else {
goto handle_unusual;
}
if (input->ExpectAtEnd()) goto success;
break;
}
default: {
handle_unusual:
if (tag == 0 ||
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
goto success;
}
DO_(::google::protobuf::internal::WireFormat::SkipField(
input, tag, mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:CSVCMsg_FullFrameSplit)
return true;
failure:
// @@protoc_insertion_point(parse_failure:CSVCMsg_FullFrameSplit)
return false;
#undef DO_
}
void CSVCMsg_FullFrameSplit::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:CSVCMsg_FullFrameSplit)
// optional int32 tick = 1;
if (has_tick()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->tick(), output);
}
// optional int32 section = 2;
if (has_section()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->section(), output);
}
// optional int32 total = 3;
if (has_total()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->total(), output);
}
// optional bytes data = 4;
if (has_data()) {
::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
4, this->data(), output);
}
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
}
// @@protoc_insertion_point(serialize_end:CSVCMsg_FullFrameSplit)
}
::google::protobuf::uint8* CSVCMsg_FullFrameSplit::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_FullFrameSplit)
// optional int32 tick = 1;
if (has_tick()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->tick(), target);
}
// optional int32 section = 2;
if (has_section()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->section(), target);
}
// optional int32 total = 3;
if (has_total()) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->total(), target);
}
// optional bytes data = 4;
if (has_data()) {
target =
::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
4, this->data(), target);
}
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
}
// @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_FullFrameSplit)
return target;
}
int CSVCMsg_FullFrameSplit::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// optional int32 tick = 1;
if (has_tick()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->tick());
}
// optional int32 section = 2;
if (has_section()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->section());
}
// optional int32 total = 3;
if (has_total()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->total());
}
// optional bytes data = 4;
if (has_data()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::BytesSize(
this->data());
}
}
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 CSVCMsg_FullFrameSplit::MergeFrom(const ::google::protobuf::Message& from) {
GOOGLE_CHECK_NE(&from, this);
const CSVCMsg_FullFrameSplit* source =
::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_FullFrameSplit*>(
&from);
if (source == NULL) {
::google::protobuf::internal::ReflectionOps::Merge(from, this);
} else {
MergeFrom(*source);
}
}
void CSVCMsg_FullFrameSplit::MergeFrom(const CSVCMsg_FullFrameSplit& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
if (from.has_tick()) {
set_tick(from.tick());
}
if (from.has_section()) {
set_section(from.section());
}
if (from.has_total()) {
set_total(from.total());
}
if (from.has_data()) {
set_data(from.data());
}
}
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}
void CSVCMsg_FullFrameSplit::CopyFrom(const ::google::protobuf::Message& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
void CSVCMsg_FullFrameSplit::CopyFrom(const CSVCMsg_FullFrameSplit& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool CSVCMsg_FullFrameSplit::IsInitialized() const {
return true;
}
void CSVCMsg_FullFrameSplit::Swap(CSVCMsg_FullFrameSplit* other) {
if (other != this) {
std::swap(tick_, other->tick_);
std::swap(section_, other->section_);
std::swap(total_, other->total_);
std::swap(data_, other->data_);
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 CSVCMsg_FullFrameSplit::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
::google::protobuf::Metadata metadata;
metadata.descriptor = CSVCMsg_FullFrameSplit_descriptor_;
metadata.reflection = CSVCMsg_FullFrameSplit_reflection_;
return metadata;
}
// @@protoc_insertion_point(namespace_scope)
// @@protoc_insertion_point(global_scope)
Reference in New Issue View Git Blame Copy Permalink